/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 * 
 *************************************************************/


// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_starmath.hxx"


#include <tools/stream.hxx>
#include <vcl/svapp.hxx>
#include <editeng/scripttypeitem.hxx>
#include "format.hxx"

/////////////////////////////////////////////////////////////////

// Latin default-fonts
static const sal_uInt16 aLatinDefFnts[FNT_END] =
{
    DEFAULTFONT_SERIF,  // FNT_VARIABLE
    DEFAULTFONT_SERIF,  // FNT_FUNCTION
    DEFAULTFONT_SERIF,  // FNT_NUMBER
    DEFAULTFONT_SERIF,  // FNT_TEXT
    DEFAULTFONT_SERIF,  // FNT_SERIF
    DEFAULTFONT_SANS,   // FNT_SANS
    DEFAULTFONT_FIXED   // FNT_FIXED
    //OpenSymbol,    // FNT_MATH
};

// CJK default-fonts
//! we use non-asian fonts for variables, functions and numbers since they
//! look better and even in asia only latin letters will be used for those.
//! At least that's what I was told...
static const sal_uInt16 aCJKDefFnts[FNT_END] =
{
    DEFAULTFONT_SERIF,          // FNT_VARIABLE
    DEFAULTFONT_SERIF,          // FNT_FUNCTION
    DEFAULTFONT_SERIF,          // FNT_NUMBER
    DEFAULTFONT_CJK_TEXT,       // FNT_TEXT
    DEFAULTFONT_CJK_TEXT,       // FNT_SERIF
    DEFAULTFONT_CJK_DISPLAY,    // FNT_SANS
    DEFAULTFONT_CJK_TEXT        // FNT_FIXED
    //OpenSymbol,    // FNT_MATH
};

// CTL default-fonts
static const sal_uInt16 aCTLDefFnts[FNT_END] =
{
    DEFAULTFONT_CTL_TEXT,    // FNT_VARIABLE
    DEFAULTFONT_CTL_TEXT,    // FNT_FUNCTION
    DEFAULTFONT_CTL_TEXT,    // FNT_NUMBER
    DEFAULTFONT_CTL_TEXT,    // FNT_TEXT
    DEFAULTFONT_CTL_TEXT,    // FNT_SERIF
    DEFAULTFONT_CTL_TEXT,    // FNT_SANS
    DEFAULTFONT_CTL_TEXT     // FNT_FIXED
    //OpenSymbol,    // FNT_MATH
};


String GetDefaultFontName( LanguageType nLang, sal_uInt16 nIdent )
{
    DBG_ASSERT( /*FNT_BEGIN <= nIdent  &&*/  nIdent <= FNT_END,
            "index out opd range" );

    if (FNT_MATH == nIdent)
        return String::CreateFromAscii( FNTNAME_MATH );
    else
    {
        const sal_uInt16 *pTable;
        switch ( SvtLanguageOptions::GetScriptTypeOfLanguage( nLang ) )
        {
            case SCRIPTTYPE_LATIN :     pTable = aLatinDefFnts; break;
            case SCRIPTTYPE_ASIAN :     pTable = aCJKDefFnts; break;
            case SCRIPTTYPE_COMPLEX :   pTable = aCTLDefFnts; break;
            default :
                pTable = aLatinDefFnts;
                DBG_ERROR( "unknown script-type" );
        }

        return Application::GetDefaultDevice()->GetDefaultFont(
                        pTable[ nIdent ], nLang,
                        DEFAULTFONT_FLAGS_ONLYONE ).GetName();
    }
}

/////////////////////////////////////////////////////////////////

SmFormat::SmFormat()
:	aBaseSize(0, SmPtsTo100th_mm(12))
{
	nVersion 	= SM_FMT_VERSION_NOW;

	eHorAlign       = AlignCenter;
    nGreekCharStyle = 0;
	bIsTextmode     = bScaleNormalBrackets = sal_False;

	vSize[SIZ_TEXT] 	= 100;
	vSize[SIZ_INDEX]	= 60;
	vSize[SIZ_FUNCTION] =
	vSize[SIZ_OPERATOR] = 100;
	vSize[SIZ_LIMITS]	= 60;

	vDist[DIS_HORIZONTAL]	 		= 10;
	vDist[DIS_VERTICAL] 	 		= 5;
	vDist[DIS_ROOT] 		 		= 0;
	vDist[DIS_SUPERSCRIPT]	 		=
	vDist[DIS_SUBSCRIPT]	 		= 20;
	vDist[DIS_NUMERATOR]	 		=
	vDist[DIS_DENOMINATOR]	 		= 0;
	vDist[DIS_FRACTION] 	 		= 10;
	vDist[DIS_STROKEWIDTH]	 		= 5;
	vDist[DIS_UPPERLIMIT]	 		=
	vDist[DIS_LOWERLIMIT]    		= 0;
	vDist[DIS_BRACKETSIZE]	 		=
	vDist[DIS_BRACKETSPACE]  		= 5;
	vDist[DIS_MATRIXROW]	 		= 3;
	vDist[DIS_MATRIXCOL]	 		= 30;
	vDist[DIS_ORNAMENTSIZE]  		=
	vDist[DIS_ORNAMENTSPACE] 		= 0;
	vDist[DIS_OPERATORSIZE]  		= 50;
	vDist[DIS_OPERATORSPACE] 		= 20;
	vDist[DIS_LEFTSPACE]	 		=
	vDist[DIS_RIGHTSPACE]	 		= 100;
	vDist[DIS_TOPSPACE]		 		=
	vDist[DIS_BOTTOMSPACE]	 		=
	vDist[DIS_NORMALBRACKETSIZE]	= 0;

	vFont[FNT_VARIABLE]	=
	vFont[FNT_FUNCTION]	=
	vFont[FNT_NUMBER]	=
	vFont[FNT_TEXT]		=
	vFont[FNT_SERIF]	= SmFace(C2S(FNTNAME_TIMES), aBaseSize);
	vFont[FNT_SANS]		= SmFace(C2S(FNTNAME_HELV),  aBaseSize);
	vFont[FNT_FIXED]	= SmFace(C2S(FNTNAME_COUR),  aBaseSize);
	vFont[FNT_MATH]		= SmFace(C2S(FNTNAME_MATH),  aBaseSize);

    vFont[FNT_MATH].SetCharSet( RTL_TEXTENCODING_UNICODE );

	vFont[FNT_VARIABLE].SetItalic(ITALIC_NORMAL);
	vFont[FNT_FUNCTION].SetItalic(ITALIC_NONE);
    vFont[FNT_NUMBER]  .SetItalic(ITALIC_NONE);
    vFont[FNT_TEXT]    .SetItalic(ITALIC_NONE);
    vFont[FNT_SERIF]   .SetItalic(ITALIC_NONE);
    vFont[FNT_SANS]    .SetItalic(ITALIC_NONE);
    vFont[FNT_FIXED]   .SetItalic(ITALIC_NONE);

	for ( sal_uInt16 i = FNT_BEGIN;  i <= FNT_END;  i++ )
	{
        SmFace &rFace = vFont[i];
        rFace.SetTransparent( sal_True );
        rFace.SetAlign( ALIGN_BASELINE );
        rFace.SetColor( COL_AUTO );
        bDefaultFont[i] = sal_False;
	}
}


void SmFormat::SetFont(sal_uInt16 nIdent, const SmFace &rFont, sal_Bool bDefault )
{
    vFont[nIdent] = rFont;
    vFont[nIdent].SetTransparent( sal_True );
    vFont[nIdent].SetAlign( ALIGN_BASELINE );

    bDefaultFont[nIdent] = bDefault;
}

SmFormat & SmFormat::operator = (const SmFormat &rFormat)
{
	SetBaseSize(rFormat.GetBaseSize());
	SetVersion (rFormat.GetVersion());
	SetHorAlign(rFormat.GetHorAlign());
	SetTextmode(rFormat.IsTextmode());
	SetGreekCharStyle(rFormat.GetGreekCharStyle());
	SetScaleNormalBrackets(rFormat.IsScaleNormalBrackets());

	sal_uInt16  i;
	for (i = FNT_BEGIN;  i <= FNT_END;  i++)
    {
		SetFont(i, rFormat.GetFont(i));
        SetDefaultFont(i, rFormat.IsDefaultFont(i));
    }
	for (i = SIZ_BEGIN;  i <= SIZ_END;  i++)
		SetRelSize(i, rFormat.GetRelSize(i));
	for (i = DIS_BEGIN;  i <= DIS_END;  i++)
		SetDistance(i, rFormat.GetDistance(i));

	return *this;
}


sal_Bool SmFormat::operator == (const SmFormat &rFormat) const
{
    sal_Bool bRes = aBaseSize == rFormat.aBaseSize  &&
                eHorAlign == rFormat.eHorAlign  &&
                nGreekCharStyle == rFormat.nGreekCharStyle &&
                bIsTextmode == rFormat.bIsTextmode  &&
                bScaleNormalBrackets  == rFormat.bScaleNormalBrackets;

    sal_uInt16 i;
    for (i = 0;  i <= SIZ_END && bRes;  ++i)
    {
        if (vSize[i] != rFormat.vSize[i])
            bRes = sal_False;
    }
    for (i = 0;  i <= DIS_END && bRes;  ++i)
    {
        if (vDist[i] != rFormat.vDist[i])
            bRes = sal_False;
    }
    for (i = 0;  i <= FNT_END && bRes;  ++i)
    {
        if (vFont[i] != rFormat.vFont[i]  ||
            bDefaultFont[i] != rFormat.bDefaultFont[i])
            bRes = sal_False;
    }

    return bRes;
}