text3d.cpp

Go to the documentation of this file.

/* *************************************************************************************
        Writer:         Sebastien Bloc
        Copyright:      2003-2004
        eMail:          sebastien.bloc@free.fr
        URL:            http://mignonsoft.free.fr

        This program is free software; you can redistribute it and/or
        modify it under the terms of the GNU General Public License
        as published by the Free Software Foundation; either version 2
        of the License, or (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
        http://www.gnu.org/copyleft/gpl.html
************************************************************************************* */

#include "3d.h"
#include "MyString.h"
#include "text3d.h"
#include "controlEngine.h"

extern ControlEngine ce;

BasicText3D::BasicText3D()
{
        xCenter=0;
        yCenter=0;
        usePicking=FALSE;
        font=NULL;
        type=ft_unknown;
        material.SetFull();
        depth=0.1f;
        scale=1;
        zCenter=1;
        SetRatioXY(1);
}

void BasicText3D::SetRatioXY(GLdouble value)
{
        ratioXY=value;
        ratioYX=1.0/value;
}

void BasicText3D::Setup(FTFont *f,FontType t,int x,int y)
{
        font=f;
        type=t;
        xCenter=x;
        yCenter=y;
}

void BasicText3D::operator=(BasicText3D &src)
{
        material=src.material;
        font=src.font;
        type=src.type;
        xCenter=src.xCenter;
        yCenter=src.yCenter;
        depth=src.depth;
        scale=src.scale;
        zCenter=src.zCenter;
        usePicking=src.usePicking;
}

BOOL BasicText3D::DrawPicking(char *text)
{
        //glPushName(idLetter);
        return usePicking?Draw(text):FALSE;
}

BOOL BasicText3D::Draw(char letter)
{
        char valueCur[2]={0,0};
        valueCur[0]=letter;
        return Draw(valueCur);
}

BOOL BasicText3D::Draw(char *text)
{
        if (!font) return FALSE;
        ce.monitor.End("draw");
        BOOL result = TRUE;
        material.Use();
        glPushMatrix();
        Point3D<float> decal;
        decal.z=(float)zCenter+(type==ft_extrude)?depth:0; // petit decalade dans les z pour eviter que le text soit caché par la face l'englobant

        ce.monitor.Begin("textRenderCenter");
        switch (xCenter)
        {
        case -1: break;
        case 0: decal.x= -GetWidth(text)/2.0f; break;
        case 1: decal.x= -GetWidth(text); break;
        }

        switch (yCenter)
        {
        case -1: decal.y= -GetAscender(); break;
        case 0: break;
        case 1: decal.y= -GetDescender(); break;
        }

        if (ratioXY!=1) glScaled(1.0/ratioXY,1,1);
        decal.glTranslated();
        ce.monitor.End("textRenderCenter");
        ce.monitor.Begin("textRender");
        switch(type)
        {
        case ft_texture:
                // le contour des lettres doivent etre transparente
                glEnable(GL_TEXTURE_2D); // bug de la ftgl ?! ca devrais etre automatique d'apres moi
                {
                        FTGLTextureFont *curFont = (FTGLTextureFont *)font;
                        curFont->Render(text);
                }
                glDisable(GL_BLEND);
                //font->Render(text);
                break;
        case ft_extrude:
                font->Depth(depth); // profondeur de l'extrude          
                //glEnable(GL_DEPTH_TEST);
                //glDisable(GL_BLEND);
                //glNormal3f(0,0,1);
                font->Render(text);
                break;
        case ft_bitmap: 
        case ft_pixmap:
                glRasterPos2f(0,0);
                font->Render(text);
                break;
        case ft_outline:                
        case ft_polygon:                
                glDisable(GL_BLEND);
                font->Render(text);
                break;
        case ft_unknown: result = FALSE;
        }
        ce.monitor.End("textRender");
        glPopMatrix();
        ce.monitor.Begin("draw");
        return result;
}

Point3D<float> BasicText3D::GetBox(char *text)
{
        Point3D<float> start,end,delta;
        if (!font) return delta; // erreur
        font->BBox(text, start.x,start.y,start.z, end.x,end.y,end.z);
        delta.Set(end.x-start.x,end.y-start.y,end.z-start.z);
        return end;
}

float BasicText3D::GetAscender()
{
        return font->Ascender();
}

float BasicText3D::GetDescender()
{
        return font->Descender();
}

float BasicText3D::GetHeight()
{
        return GetAscender()-GetDescender();
}

float BasicText3D::GetWidth(char letter)
{
        char valueCur[2]={0,0};
        valueCur[0]=letter;
        return GetWidth(valueCur);
}

float BasicText3D::GetWidth(char *text) 
{
        return font->Advance(text);
}

// ***************************************************************************

ParsingLine::ParsingLine() : ParsingElem()
{
        nbChar=0;
        deltaY=0;
        align=align_begin;
}

void ParsingLine::operator=(ParsingLine &src)
{
        ParsingElem::operator=(src);
        nbChar=src.nbChar;
        deltaY=src.deltaY;
        align=src.align;
        words=src.words; // copie de la list des mots (a verrifié)
}

// ***************************************************************************

ParsingElem::ParsingElem()
{
        deltaX=0;
        isWord=FALSE;
}

void ParsingElem::operator=(ParsingElem &src)
{
        deltaX=src.deltaX;
        isWord=src.isWord;
}

// ***************************************************************************

ParsingWord::ParsingWord() : ParsingElem()
{
        deltaX=0;
}

void ParsingWord::operator=(ParsingWord &src)
{
        ParsingElem::operator=(src);
        text=src.text;
}

// ***************************************************************************

Text3D::Text3D()
{
        idCallList=0;
        xAlign=align_begin;
        yAlign=align_begin;
        SetJustifyLimit(10,10);
        enableClipping=FALSE;
        isChanged=FALSE;
        SetWrapping(FALSE,TRUE,TRUE);
}

Text3D::~Text3D()
{
        if (idCallList) glDeleteLists(idCallList,1);
}
void Text3D::operator=(Text3D &src)
{
        BasicText3D::operator=(src);
        clipping=src.clipping;
        xAlign=src.xAlign;
        yAlign=src.yAlign;
        enableClipping=src.enableClipping;
        idCallList=0; // si recopie le callList dois etre differentié
        isChanged=TRUE; 
        wordWrap=src.wordWrap;
        lineWrap=src.lineWrap;
        letterWrap=src.letterWrap;
        xJustifyLimit=src.xJustifyLimit;
}

void Text3D::SetWrapping(BOOL line,BOOL word,BOOL letter)
{
        wordWrap=word;
        lineWrap=line;
        letterWrap=letter;
}

void Text3D::SetClipping(double xClipping,double yClipping)
{
        isChanged=isChanged||clipping.x!=xClipping||clipping.y!=yClipping;
        enableClipping=TRUE;
        clipping.Set(xClipping,yClipping);
}

void Text3D::SetClipping(Point2D<double> newClipping)
{
        isChanged=isChanged||clipping.x!=newClipping.x||clipping.y!=newClipping.y;
        enableClipping=TRUE;
        clipping=newClipping;
}

void Text3D::SetAlign(TextAlign x,TextAlign y)
{
        isChanged=isChanged||xAlign!=x||yAlign!=y;
        xAlign=x;
        yAlign=y;
}

void Text3D::Setup(FTFont *f,FontType t)
{
        isChanged=isChanged||font!=f||type!=t;
        BasicText3D::Setup(f,t,-1,-1);
}

void Text3D::ComputeSize(MyList<ParsingLine> *linesCur,BOOL isWordSizeCompute)
{
        ParsingLine *line;
        for (linesCur->i=0;linesCur->i.More();linesCur->i++)
        {
                line = linesCur->i.GetElemPtr();
                ComputeLineSize(line,isWordSizeCompute);
        }
}

void Text3D::ComputeLineSize(ParsingLine *line,BOOL isWordSizeCompute)
{
        ParsingWord *word;
        line->nbChar=0;
        line->deltaX=0;
        line->deltaY=GetHeight();
        line->align=xAlign;
        for (line->words.i=0;line->words.i.More();line->words.i++)
        {
                word = line->words.i.GetElem();
                if (isWordSizeCompute) word->deltaX=GetWidth(word->text);
                line->deltaX+=word->deltaX;
                line->nbChar+=word->text.GetSize();
        }
}

float Text3D::AddLine(ParsingLine *line)
{
        ParsingLine **lineOutPtr = linesUses.i.AddNewLast();
        *lineOutPtr=line;

        int nbObject;
        line->xPos=0; 
        line->xJustify=0;
        switch(line->align)
        {
        case align_begin: break;
        case align_center: 
                line->xPos=(realClipping.x-line->deltaX)/2.0; 
                break;
        case align_end: 
                line->xPos=realClipping.x-line->deltaX; 
                break; 
        case align_justify: 
                if (wordWrap) nbObject = (line->words.GetNbElem()+1)/2; //  0=>0 , 1=>1 , 2=>1 , 3=>2, etc ...
                else nbObject = line->nbChar;
                if (nbObject>1) line->xJustify=(realClipping.x-line->deltaX)/(GLdouble)(nbObject-1); 
                if (line->xJustify>xJustifyLimit) line->xJustify=0; // si la justification espace trop les mots alirs anule la justification
                break; 
        }
        return line->deltaY;
}

void Text3D::ApplyRealClipping()
{
        if (scale!=1)
        {
                glScaled(scale,scale,1); // taille relative     
                realClipping=clipping/scale; // agrandi le clipping pour coller au scalling
        }
        else realClipping=clipping;
}

BOOL Text3D::Draw()
{
        //return TRUE;
        if (value.IsEmpty()) return TRUE;
        ce.monitor.Begin("text");

        glPushMatrix();
        ApplyRealClipping();    // calcul le clipping reel suivant le scale
        ComputeSize(&lines,TRUE); // calcul la taille des mots et des lignes
        double ySize=ComputeLayout();// calcul de la mise en page

        // alignement dans les Y
        yJustify = 0;
        switch(yAlign)
        {
        case align_begin: break;
        case align_center: glTranslated(0,-(realClipping.y-ySize)/2.0,0); break;
        case align_end: glTranslated(0,-(realClipping.y-ySize),0); break;
        case align_justify: 
                if (linesUses.GetNbElem()>1) 
                {
                        yJustify=(realClipping.y-ySize)/(double)(linesUses.GetNbElem()-1); 
                        if (yJustify>yJustifyLimit) yJustify=0;
                }
        }

        // affichage proprement dit
        for (linesUses.i=0;linesUses.i.More();linesUses.i++) 
                DrawLine(linesUses.i.GetElem());
        glPopMatrix();
        ce.monitor.End("text");
        return TRUE;
}


void Text3D::SetText(char *text)
{
        value=text;
        AnalyseGram();
}

BOOL Text3D::AnalyseLex(int indBegin,int *indEnd,BOOL *isEnd,BOOL *isReturn)
{
        char letter;
        BOOL isSeparator = FALSE;
        BOOL isWord = FALSE;
        *isReturn=FALSE;
        *isEnd=FALSE;
        int i;
        for (i=indBegin;i<value.GetSize();i++)
        {
                letter=value[i];
                switch (letter)
                {
                case '\n':
                        *indEnd=i;
                        *isReturn=TRUE;
                        return isWord;
                case ' ':
                case '\t':
                        if (isWord)
                        {
                                *indEnd=i;
                                return isWord;
                        }
                        isSeparator=TRUE;
                        break;
                default:
                        if (isSeparator)
                        {
                                *indEnd=i;
                                return isWord;
                        }
                        isWord=TRUE;
                }
        }
        *indEnd=i;
        *isEnd=TRUE;
        return isWord;
}

void Text3D::AnalyseGram()
{
        lines.i.SuprAll();
        words.i.SuprAll();

        ParsingLine *line = NULL;
        ParsingWord *word = NULL;

        BOOL isEnd;
        BOOL isReturn;
        BOOL isWord;
        int indBegin = 0;
        int indEnd;
        do
        {
                isWord = AnalyseLex(indBegin,&indEnd,&isEnd,&isReturn);
                if (isEnd&&(indBegin==indEnd)) break; // si c'est la fin sans mots ==> finir
                if (!line) line = lines.i.AddNewLast();
                if (isReturn&&(indBegin==indEnd)) 
                {       // ligne suivante sans mots
                        line=NULL; 
                        indBegin++; 
                        continue; 
                } 
                word = words.i.AddNewLast();
                word->text=value.Mids(indBegin,indEnd-indBegin);
                indBegin=indEnd;
                word->isWord=isWord;
                line->words.i+=word;
                if (isReturn) { indBegin++; line = NULL; }
        } while (!isEnd);
}

float Text3D::ComputeLayout()
{
        // mise a zero
        layoutLines.i.SuprAll();
        layoutWords.i.SuprAll();
        linesUses.i.SuprAll();

        ParsingLine *line;
        ParsingWord *word;
        BOOL testDeltaX=FALSE;

        GLfloat yPos=0;
        for (lines.i=0;lines.i.More();lines.i++)
        {       // iteration sur les lignes
                line = lines.i.GetElemPtr();
                if (enableClipping)
                {       // test du clipping, peut on affiché la ligne ?
                        if ((line->deltaY+yPos)>realClipping.y) return yPos;
                        if (line->deltaX<=realClipping.x) 
                        {
                                yPos+=AddLine(line);
                                continue;
                        }
                }
                else
                {
                        yPos+=AddLine(line);
                        continue;
                }

                // on est sortie du clipping => gestion des wrapping
                ParsingLine *layoutLine = NULL;
                ParsingWord *newWord,*wordCutting;
                double xPos;
                int offsetLetter=0;
                BOOL goNext = TRUE;

                // remplie layoutLine du text affichable
                // on arrive ici uniquement si la ligne deplace le clipping autorisé
                for (line->words.i=0;line->words.i.More();line->words.i.GoIndex(list_current,goNext))
                {       // iteration de tout les mots de la ligne
                        goNext=TRUE;
                        if (!layoutLine)
                        {
                                if ((yPos+line->deltaY)>realClipping.y) return yPos;
                                layoutLine = layoutLines.i.AddNewLast();
                                layoutLine->deltaY=line->deltaY;
                                xPos=0;
                        }
                        if (offsetLetter)
                        {
                                wordCutting = layoutWords.i.AddNewLast();
                                *wordCutting=*word;
                                wordCutting->text=word->text.Mids(offsetLetter,word->text.GetSize()-offsetLetter);
                                wordCutting->deltaX=GetWidth(wordCutting->text);
                                word=wordCutting;
                                offsetLetter=0;
                        }
                        else word = line->words.i.GetElem();

                        xPos+=word->deltaX;
                        if (xPos>realClipping.x)
                        {       // sort t'on du clipping en X
                                if (wordWrap) 
                                {       // affiche la ligne delimité et poursuis
                                        ComputeLineSize(layoutLine,FALSE);
                                        yPos+=AddLine(layoutLine);
                                        layoutLine=NULL;
                                        if (!lineWrap)
                                        {       // si retour a la ligne automatique active poursuivre
                                                goNext=FALSE; // toujours sur le meme mots
                                                continue;
                                        }
                                        else break;
                                }
                                else
                                {       // si pas wordWrap cherché le caractere dans la ligne qui le delimite
                                        newWord = layoutWords.i.AddNewLast();
                                        *newWord = *word;
                                        double deltaLetter;
                                        double deltaNeed = xPos-realClipping.x; 
                                        double sumDeltaLetter = 0;
                                        for (offsetLetter=word->text.GetSize()-1;offsetLetter>=0;offsetLetter--)
                                        {       // recherche du caracter qui fait sortir du clipping
                                                deltaLetter = GetWidth(word->text[offsetLetter]);
                                                sumDeltaLetter+=deltaLetter;
                                                deltaNeed-=deltaLetter;
                                                if (deltaNeed<=0) break;
                                        }
                                        // decoupage en 2 word pour le passage a la ligne
                                        newWord->deltaX=word->deltaX-(GLfloat)sumDeltaLetter;
                                        newWord->text= word->text.Mids(0,offsetLetter);
                                        layoutLine->words.i+=newWord;
                                        xPos=0;
                                        ComputeLineSize(layoutLine,FALSE);
                                        yPos+=AddLine(layoutLine);
                                        layoutLine=NULL;
                                        if (!lineWrap)
                                        {       // si retour a la ligne automatique active poursuivre
                                                goNext=FALSE; // toujours sur le meme mots
                                                continue;
                                        }
                                        else 
                                        { 
                                                offsetLetter=0; 
                                                break; 
                                        }
                                }
                        }
                        else layoutLine->words.i+=word; // si pas de probleme de clipping ajout le mots
                }
                if (layoutLine)
                {
                        ComputeLineSize(layoutLine,FALSE);
                        yPos+=AddLine(layoutLine);
                        layoutLine=NULL;
                }
        }
        return yPos;
}

char * Text3D::GetText()
{
        return value.GetValue();
}

void Text3D::DrawLine(ParsingLine *line)
{
        GLdouble xMove = line->xPos;
        GLdouble xPos=0;
        ParsingWord *word;
        for (line->words.i=0;line->words.i.More();line->words.i++)
        {
                word = line->words.i.GetElem();
                if (word->isWord)
                {
                        if (!wordWrap)
                        {
                                if (!line->xJustify) 
                                {
                                        xPos+=xMove;
                                        glTranslated(xMove,0,0);
                                        BasicText3D::Draw(word->text); // si le mots n'a pas de séparation
                                        xMove = word->deltaX;
                                }
                                else
                                {       // si le mots a des separations
                                        char letter;
                                        for (int i=0;i<word->text.GetSize();i++)
                                        {
                                                letter=word->text[i];
                                                xPos+=xMove;
                                                glTranslated(xMove,0,0);
                                                BasicText3D::Draw(letter);
                                                xMove=GetWidth(letter)+line->xJustify;
                                        }
                                }
                        }
                        else
                        {
                                xPos+=xMove;
                                glTranslated(xMove,0,0);
                                BasicText3D::Draw(word->text);
                                xMove = word->deltaX+line->xJustify;
                        }
                }
                else xMove+=word->deltaX;
        }
        glTranslated(-xPos,-line->deltaY-yJustify,0);   // passe a la ligne suivante
}

BOOL Text3D::DrawPicking()
{
        if (!usePicking) return FALSE;
        //glPushName(idLetter);
        //return Draw();
        return TRUE;
}


void Text3D::SetJustifyLimit(GLdouble x,GLdouble y)
{
        xJustifyLimit = x;
        yJustifyLimit = y;
}

---