2003-01-01 01:19:48 +03:00
|
|
|
//------------------------------------------------------------------------------
|
2004-09-21 02:50:02 +04:00
|
|
|
// Copyright (c) 2001-2002, Haiku, Inc.
|
2003-01-01 01:19:48 +03:00
|
|
|
//
|
|
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
// copy of this software and associated documentation files (the "Software"),
|
|
|
|
// to deal in the Software without restriction, including without limitation
|
|
|
|
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
|
// and/or sell copies of the Software, and to permit persons to whom the
|
|
|
|
// Software is furnished to do so, subject to the following conditions:
|
|
|
|
//
|
|
|
|
// The above copyright notice and this permission notice shall be included in
|
|
|
|
// all copies or substantial portions of the Software.
|
|
|
|
//
|
|
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
|
|
// DEALINGS IN THE SOFTWARE.
|
|
|
|
//
|
|
|
|
// File Name: FontFamily.cpp
|
|
|
|
// Author: DarkWyrm <bpmagic@columbus.rr.com>
|
|
|
|
// Description: classes to represent font styles and families
|
|
|
|
//
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
#include "FontFamily.h"
|
|
|
|
#include "ServerFont.h"
|
|
|
|
#include FT_CACHE_H
|
|
|
|
|
2003-07-24 23:38:24 +04:00
|
|
|
FTC_Manager ftmanager;
|
2003-01-01 01:19:48 +03:00
|
|
|
|
|
|
|
/*!
|
2003-01-18 23:32:45 +03:00
|
|
|
\brief Constructor
|
2003-01-20 02:04:58 +03:00
|
|
|
\param filepath path to a font file
|
2005-03-26 00:02:40 +03:00
|
|
|
\param face FreeType handle for the font file after it is loaded - it will be kept open until the FontStyle is destroied
|
2003-01-01 01:19:48 +03:00
|
|
|
*/
|
|
|
|
FontStyle::FontStyle(const char *filepath, FT_Face face)
|
|
|
|
{
|
2005-03-26 00:02:40 +03:00
|
|
|
fFTFace = face;
|
2005-01-17 05:05:50 +03:00
|
|
|
fName=face->style_name;
|
2003-01-01 01:19:48 +03:00
|
|
|
cachedface=new CachedFaceRec;
|
|
|
|
cachedface->file_path=filepath;
|
|
|
|
family=NULL;
|
|
|
|
has_bitmaps=(face->num_fixed_sizes>0)?true:false;
|
|
|
|
is_fixedwidth=(face->face_flags & FT_FACE_FLAG_FIXED_WIDTH)?true:false;
|
|
|
|
is_scalable=(face->face_flags & FT_FACE_FLAG_SCALABLE)?true:false;
|
|
|
|
has_kerning=(face->face_flags & FT_FACE_FLAG_KERNING)?true:false;
|
|
|
|
glyphcount=face->num_glyphs;
|
|
|
|
charmapcount=face->num_charmaps;
|
|
|
|
tunedcount=face->num_fixed_sizes;
|
2005-01-17 05:05:50 +03:00
|
|
|
fPath=filepath;
|
2003-01-01 01:19:48 +03:00
|
|
|
fbounds.Set(0,0,0,0);
|
2005-01-17 05:05:50 +03:00
|
|
|
fFace=TranslateStyleToFace(face->style_name);
|
|
|
|
fID=0;
|
2005-05-07 21:32:43 +04:00
|
|
|
fHeight.ascent = face->ascender;
|
|
|
|
|
|
|
|
// FT2's descent numbers are negative. Be's is positive
|
|
|
|
fHeight.descent = -face->descender;
|
2005-05-07 19:04:52 +04:00
|
|
|
|
|
|
|
// FT2 doesn't provide a linegap, but according to the docs, we can
|
|
|
|
// calculate it because height = ascending + descending + leading
|
2005-05-07 21:32:43 +04:00
|
|
|
fHeight.leading = face->height - (fHeight.ascent + fHeight.descent);
|
|
|
|
fHeight.units_per_em = face->units_per_EM;
|
2003-01-01 01:19:48 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
2003-01-18 23:32:45 +03:00
|
|
|
\brief Destructor
|
2003-01-01 01:19:48 +03:00
|
|
|
|
|
|
|
Frees all data allocated on the heap. All child ServerFonts are marked as having
|
|
|
|
a NULL style so that each ServerFont knows that it is running on borrowed time.
|
|
|
|
This is done because a FontStyle should be deleted only when it no longer has any
|
|
|
|
dependencies.
|
|
|
|
*/
|
2005-06-03 23:30:32 +04:00
|
|
|
FontStyle::~FontStyle()
|
2003-01-01 01:19:48 +03:00
|
|
|
{
|
|
|
|
delete cachedface;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
\brief Returns the name of the style as a string
|
|
|
|
\return The style's name
|
|
|
|
*/
|
2005-06-03 23:30:32 +04:00
|
|
|
const char*
|
|
|
|
FontStyle::Name() const
|
2003-01-01 01:19:48 +03:00
|
|
|
{
|
2005-01-17 05:05:50 +03:00
|
|
|
return fName.String();
|
2003-01-01 01:19:48 +03:00
|
|
|
}
|
|
|
|
|
2005-06-03 23:30:32 +04:00
|
|
|
font_height
|
|
|
|
FontStyle::GetHeight(const float &size) const
|
2005-01-17 23:08:40 +03:00
|
|
|
{
|
2005-06-03 23:30:32 +04:00
|
|
|
font_height fh = { 0, 0, 0 };
|
2005-01-17 23:08:40 +03:00
|
|
|
|
|
|
|
// font units are 26.6 format, so we get REALLY big numbers if
|
|
|
|
// we don't do some shifting.
|
2005-05-08 10:24:35 +04:00
|
|
|
// TODO: As it looks like that the "units_per_em" don't change
|
|
|
|
// for the lifetime of FontStyle, can't we apply these
|
|
|
|
// conversions in the constructor and get rid of "units_per_em" ?
|
2005-05-07 21:32:43 +04:00
|
|
|
fh.ascent = (fHeight.ascent * size) / fHeight.units_per_em;
|
|
|
|
fh.descent = (fHeight.descent * size) / fHeight.units_per_em;
|
|
|
|
fh.leading = (fHeight.leading * size) / fHeight.units_per_em;
|
2005-01-17 23:08:40 +03:00
|
|
|
return fh;
|
|
|
|
}
|
|
|
|
|
2003-01-01 01:19:48 +03:00
|
|
|
/*!
|
|
|
|
\brief Returns the path to the style's font file
|
|
|
|
\return The style's font file path
|
|
|
|
*/
|
2005-06-03 23:30:32 +04:00
|
|
|
const char*
|
|
|
|
FontStyle::GetPath() const
|
2003-01-01 01:19:48 +03:00
|
|
|
{
|
2005-01-17 05:05:50 +03:00
|
|
|
return fPath.String();
|
|
|
|
}
|
|
|
|
|
2005-06-03 23:30:32 +04:00
|
|
|
int32
|
|
|
|
FontStyle::GetFlags() const
|
2005-01-17 05:05:50 +03:00
|
|
|
{
|
|
|
|
int32 flags=0;
|
|
|
|
if(IsFixedWidth())
|
|
|
|
flags|=B_IS_FIXED;
|
|
|
|
|
|
|
|
if(TunedCount()>0)
|
|
|
|
flags|=B_HAS_TUNED_FONT;
|
|
|
|
|
|
|
|
return flags;
|
2003-01-01 01:19:48 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
\brief Converts an ASCII character to Unicode for the style
|
2003-01-20 02:04:58 +03:00
|
|
|
\param c An ASCII character
|
2003-01-01 01:19:48 +03:00
|
|
|
\return A Unicode value for the character
|
|
|
|
*/
|
2005-01-17 05:05:50 +03:00
|
|
|
|
|
|
|
// TODO: Re-enable when I understand how the FT2 Cache system changed from
|
|
|
|
// 2.1.4 to 2.1.8
|
|
|
|
/*
|
2003-01-01 01:19:48 +03:00
|
|
|
int16 FontStyle::ConvertToUnicode(uint16 c)
|
|
|
|
{
|
|
|
|
FT_Face f;
|
2005-01-19 02:18:37 +03:00
|
|
|
if(FTC_Manager_LookupFace(ftmanager,(FTC_FaceID)cachedface,&f)!=0)
|
2003-01-01 01:19:48 +03:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
return FT_Get_Char_Index(f,c);
|
|
|
|
}
|
|
|
|
*/
|
2005-01-17 05:05:50 +03:00
|
|
|
|
2005-06-03 23:30:32 +04:00
|
|
|
uint16
|
|
|
|
FontStyle::TranslateStyleToFace(const char *name) const
|
2003-01-01 01:19:48 +03:00
|
|
|
{
|
2005-01-17 05:05:50 +03:00
|
|
|
if(!name)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
BString str(name);
|
|
|
|
|
|
|
|
|
2005-01-17 05:20:57 +03:00
|
|
|
if(str.IFindFirst("bold")!=B_ERROR)
|
2005-01-17 05:05:50 +03:00
|
|
|
return B_BOLD_FACE;
|
2005-01-17 05:20:57 +03:00
|
|
|
if(str.IFindFirst("italic")!=B_ERROR)
|
|
|
|
return B_ITALIC_FACE;
|
|
|
|
if(str.IFindFirst("oblique")!=B_ERROR)
|
2005-01-17 05:05:50 +03:00
|
|
|
return B_ITALIC_FACE;
|
|
|
|
|
2005-01-17 05:20:57 +03:00
|
|
|
return B_REGULAR_FACE;
|
2003-01-01 01:19:48 +03:00
|
|
|
}
|
|
|
|
|
2005-04-01 11:00:32 +04:00
|
|
|
|
2003-01-01 01:19:48 +03:00
|
|
|
/*!
|
|
|
|
\brief Constructor
|
2003-01-20 02:04:58 +03:00
|
|
|
\param namestr Name of the family
|
2003-01-01 01:19:48 +03:00
|
|
|
*/
|
2005-01-17 05:05:50 +03:00
|
|
|
FontFamily::FontFamily(const char *namestr, const uint16 &index)
|
2003-01-01 01:19:48 +03:00
|
|
|
{
|
2005-06-03 23:30:32 +04:00
|
|
|
fName = namestr;
|
|
|
|
fID = index;
|
2005-01-17 05:05:50 +03:00
|
|
|
|
|
|
|
// will stay uninitialized until needed
|
2005-06-03 23:30:32 +04:00
|
|
|
fFlags = -1;
|
2003-01-01 01:19:48 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
\brief Destructor
|
|
|
|
|
|
|
|
Deletes all child styles. Note that a FontFamily should not be deleted unless
|
|
|
|
its styles have no dependencies or some other really good reason, such as
|
|
|
|
system shutdown.
|
|
|
|
*/
|
2005-06-03 23:30:32 +04:00
|
|
|
FontFamily::~FontFamily()
|
2003-01-01 01:19:48 +03:00
|
|
|
{
|
2005-06-03 23:30:32 +04:00
|
|
|
int32 count = fStyles.CountItems();
|
|
|
|
for (int32 i = 0; i < count; i++)
|
|
|
|
delete (FontStyle*)fStyles.ItemAt(i);
|
2003-01-01 01:19:48 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
\brief Returns the name of the family
|
|
|
|
\return The family's name
|
|
|
|
*/
|
2005-06-03 23:30:32 +04:00
|
|
|
const char*
|
|
|
|
FontFamily::Name()
|
2003-01-01 01:19:48 +03:00
|
|
|
{
|
2005-01-17 05:05:50 +03:00
|
|
|
return fName.String();
|
2003-01-01 01:19:48 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
\brief Adds the style to the family
|
2003-01-20 02:04:58 +03:00
|
|
|
\param path full path to the style's font file
|
|
|
|
\param face FreeType face handle used to obtain info about the font
|
2003-01-01 01:19:48 +03:00
|
|
|
*/
|
2005-06-03 23:30:32 +04:00
|
|
|
bool
|
|
|
|
FontFamily::AddStyle(FontStyle *style)
|
2003-01-01 01:19:48 +03:00
|
|
|
{
|
2005-06-03 23:30:32 +04:00
|
|
|
if (!style)
|
2005-01-17 05:05:50 +03:00
|
|
|
return false;
|
2003-01-01 01:19:48 +03:00
|
|
|
|
|
|
|
FontStyle *item;
|
|
|
|
|
|
|
|
// Don't add if it already is in the family.
|
2005-06-03 23:30:32 +04:00
|
|
|
int32 count = fStyles.CountItems();
|
|
|
|
for(int32 i = 0; i < count; i++) {
|
|
|
|
item = (FontStyle*)fStyles.ItemAt(i);
|
|
|
|
if (item->fName == style->fName)
|
2005-01-17 05:05:50 +03:00
|
|
|
return false;
|
2003-01-01 01:19:48 +03:00
|
|
|
}
|
2005-01-17 05:05:50 +03:00
|
|
|
|
|
|
|
style->family=this;
|
|
|
|
|
2005-06-03 23:30:32 +04:00
|
|
|
if (fStyles.CountItems() > 0) {
|
|
|
|
item = (FontStyle*)fStyles.ItemAt(fStyles.CountItems() - 1);
|
|
|
|
style->fID = item->fID + 1;
|
|
|
|
} else {
|
|
|
|
style->fID = 0;
|
2005-01-17 05:05:50 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
fStyles.AddItem(style);
|
2003-01-01 01:19:48 +03:00
|
|
|
AddDependent();
|
2005-01-17 05:05:50 +03:00
|
|
|
|
|
|
|
// force a refresh if a request for font flags is needed
|
|
|
|
fFlags=-1;
|
|
|
|
|
|
|
|
return true;
|
2003-01-01 01:19:48 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
\brief Removes a style from the family and deletes it
|
2003-01-20 02:04:58 +03:00
|
|
|
\param style Name of the style to be removed from the family
|
2003-01-01 01:19:48 +03:00
|
|
|
*/
|
2005-06-03 23:30:32 +04:00
|
|
|
void
|
|
|
|
FontFamily::RemoveStyle(const char *style)
|
2003-01-01 01:19:48 +03:00
|
|
|
{
|
2005-01-17 05:05:50 +03:00
|
|
|
int32 count=fStyles.CountItems();
|
2003-01-01 01:19:48 +03:00
|
|
|
if(!style || count<1)
|
|
|
|
return;
|
|
|
|
|
|
|
|
FontStyle *fs;
|
|
|
|
for(int32 i=0; i<count; i++)
|
|
|
|
{
|
2005-01-17 05:05:50 +03:00
|
|
|
fs=(FontStyle *)fStyles.ItemAt(i);
|
|
|
|
if(fs && fs->fName.Compare(style)==0)
|
2003-01-01 01:19:48 +03:00
|
|
|
{
|
2005-01-17 05:05:50 +03:00
|
|
|
fs=(FontStyle *)fStyles.RemoveItem(i);
|
2003-01-01 01:19:48 +03:00
|
|
|
if(fs)
|
|
|
|
{
|
|
|
|
delete fs;
|
|
|
|
RemoveDependent();
|
2005-01-17 05:05:50 +03:00
|
|
|
|
|
|
|
// force a refresh if a request for font flags is needed
|
|
|
|
fFlags=-1;
|
2003-01-01 01:19:48 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-01-17 05:05:50 +03:00
|
|
|
/*!
|
|
|
|
\brief Removes a style from the family. The caller is responsible for freeing the object
|
|
|
|
\param style The style to be removed from the family
|
|
|
|
*/
|
2005-06-03 23:30:32 +04:00
|
|
|
void
|
|
|
|
FontFamily::RemoveStyle(FontStyle *style)
|
2005-01-17 05:05:50 +03:00
|
|
|
{
|
2005-06-03 23:30:32 +04:00
|
|
|
if (fStyles.HasItem(style)) {
|
2005-01-17 05:05:50 +03:00
|
|
|
fStyles.RemoveItem(style);
|
|
|
|
RemoveDependent();
|
|
|
|
|
|
|
|
// force a refresh if a request for font flags is needed
|
2005-06-03 23:30:32 +04:00
|
|
|
fFlags = -1;
|
2005-01-17 05:05:50 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-01-01 01:19:48 +03:00
|
|
|
/*!
|
|
|
|
\brief Returns the number of styles in the family
|
|
|
|
\return The number of styles in the family
|
|
|
|
*/
|
2005-06-03 23:30:32 +04:00
|
|
|
int32
|
|
|
|
FontFamily::CountStyles() const
|
2003-01-01 01:19:48 +03:00
|
|
|
{
|
2005-01-17 05:05:50 +03:00
|
|
|
return fStyles.CountItems();
|
2003-01-01 01:19:48 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
\brief Determines whether the style belongs to the family
|
2003-01-20 02:04:58 +03:00
|
|
|
\param style Name of the style being checked
|
2003-01-01 01:19:48 +03:00
|
|
|
\return True if it belongs, false if not
|
|
|
|
*/
|
2005-06-03 23:30:32 +04:00
|
|
|
bool
|
|
|
|
FontFamily::HasStyle(const char *style) const
|
2003-01-01 01:19:48 +03:00
|
|
|
{
|
2005-06-03 23:30:32 +04:00
|
|
|
int32 count = fStyles.CountItems();
|
2005-01-17 05:05:50 +03:00
|
|
|
|
2005-06-03 23:30:32 +04:00
|
|
|
if (!style || count < 1)
|
2003-01-01 01:19:48 +03:00
|
|
|
return false;
|
2005-01-17 05:05:50 +03:00
|
|
|
|
2003-01-01 01:19:48 +03:00
|
|
|
FontStyle *fs;
|
2005-06-03 23:30:32 +04:00
|
|
|
for (int32 i = 0; i < count; i++) {
|
|
|
|
fs = (FontStyle*)fStyles.ItemAt(i);
|
|
|
|
if( fs && fs->fName.Compare(style) == 0)
|
2003-01-01 01:19:48 +03:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
\brief Returns the name of a style in the family
|
2003-01-20 02:04:58 +03:00
|
|
|
\param index list index of the style to be found
|
2003-01-01 01:19:48 +03:00
|
|
|
\return name of the style or NULL if the index is not valid
|
|
|
|
*/
|
2005-06-03 23:30:32 +04:00
|
|
|
FontStyle*
|
|
|
|
FontFamily::GetStyle(int32 index) const
|
2003-01-01 01:19:48 +03:00
|
|
|
{
|
2005-01-17 05:05:50 +03:00
|
|
|
return (FontStyle*)fStyles.ItemAt(index);
|
2003-01-01 01:19:48 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
\brief Get the FontStyle object for the name given
|
2003-01-20 02:04:58 +03:00
|
|
|
\param style Name of the style to be obtained
|
2003-01-01 01:19:48 +03:00
|
|
|
\return The FontStyle object or NULL if none was found.
|
|
|
|
|
|
|
|
The object returned belongs to the family and must not be deleted.
|
|
|
|
*/
|
2005-06-03 23:30:32 +04:00
|
|
|
FontStyle*
|
|
|
|
FontFamily::GetStyle(const char *style) const
|
2003-01-01 01:19:48 +03:00
|
|
|
{
|
2005-01-17 05:05:50 +03:00
|
|
|
int32 count=fStyles.CountItems();
|
2005-06-03 23:30:32 +04:00
|
|
|
if (!style || count < 1)
|
2003-01-01 01:19:48 +03:00
|
|
|
return NULL;
|
2005-06-03 23:30:32 +04:00
|
|
|
|
2003-01-01 01:19:48 +03:00
|
|
|
FontStyle *fs;
|
2005-06-03 23:30:32 +04:00
|
|
|
for (int32 i = 0; i < count; i++) {
|
|
|
|
fs = (FontStyle*)fStyles.ItemAt(i);
|
|
|
|
if (fs && fs->fName.Compare(style) == 0)
|
2003-01-01 01:19:48 +03:00
|
|
|
return fs;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
2005-01-17 05:05:50 +03:00
|
|
|
|
2005-06-03 23:30:32 +04:00
|
|
|
int32
|
|
|
|
FontFamily::GetFlags()
|
2005-01-17 05:05:50 +03:00
|
|
|
{
|
2005-06-03 23:30:32 +04:00
|
|
|
if (fFlags == -1) {
|
|
|
|
fFlags = 0;
|
2005-01-17 05:05:50 +03:00
|
|
|
|
2005-06-03 23:30:32 +04:00
|
|
|
for (int32 i = 0; i < fStyles.CountItems(); i++) {
|
|
|
|
FontStyle* style = (FontStyle*)fStyles.ItemAt(i);
|
|
|
|
if (style) {
|
|
|
|
if (style->IsFixedWidth())
|
|
|
|
fFlags |= B_IS_FIXED;
|
|
|
|
if (style->TunedCount() > 0)
|
|
|
|
fFlags |= B_HAS_TUNED_FONT;
|
2005-01-17 05:05:50 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return fFlags;
|
|
|
|
}
|