AbiWord: fp_TextRun.h Source File

00001 /* AbiWord
00002  * Copyright (C) 1998,1999 AbiSource, Inc.
00003  * Copyright (c) 2001,2002 Tomas Frydrych
00004  *
00005  * This program is free software; you can redistribute it and/or
00006  * modify it under the terms of the GNU General Public License
00007  * as published by the Free Software Foundation; either version 2
00008  * of the License, or (at your option) any later version.
00009  *
00010  * This program is distributed in the hope that it will be useful,
00011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013  * GNU General Public License for more details.
00014  *
00015  * You should have received a copy of the GNU General Public License
00016  * along with this program; if not, write to the Free Software
00017  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
00018  * 02111-1307, USA.
00019  */
00020 
00021 
00022 #ifndef FP_TEXTRUN_H
00023 #define FP_TEXTRUN_H
00024 
00025 #include "fp_Run.h"
00026 
00027 #include "ut_types.h"
00028 #include "ut_misc.h"
00029 #include "pt_Types.h"
00030 #include "gr_RenderInfo.h"
00031 
00032 #ifdef ENABLE_SPELL
00033 #include "fl_Squiggles.h"
00034 #endif
00035 /*
00036     fp_TextRun represents a run of contiguous text sharing the same
00037     properties.
00038 */
00039 #define MAX_SPAN_LEN 250   //initial size for m_pSpanBuff, realocated if needed
00040 #include "ut_timer.h"
00041 
00042 class ABI_EXPORT fp_TextRun : public fp_Run
00043 {
00044 public:
00045     fp_TextRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen, bool bLookupProperties=true);
00046     virtual ~fp_TextRun();
00047 
00048     virtual void            mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos, PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool &isTOC);
00049     virtual void            findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y, UT_sint32& x2, UT_sint32& y2, UT_sint32& height, bool& bDirection);
00050     virtual bool            canBreakAfter(void) const;
00051     virtual bool            canBreakBefore(void) const;
00052     virtual bool            alwaysFits(void) const;
00053     virtual bool            findMaxLeftFitSplitPoint(UT_sint32 iMaxLeftWidth, fp_RunSplitInfo& si, bool bForce=false);
00054     virtual UT_sint32       findTrailingSpaceDistance(void) const;
00055 #ifdef ENABLE_SPELL
00056     void                drawSquiggle(UT_uint32, UT_uint32,FL_SQUIGGLE_TYPE iSquiggle);
00057 #endif
00058     bool                    split(UT_uint32 iSplitOffset);
00059 #if DEBUG
00060     virtual void            printText(void);
00061 #endif
00062     void                    appendTextToBuf(UT_GrowBuf & buf);
00063     virtual bool            hasLayoutProperties(void) const;
00064     //virtual void          fetchCharWidths(fl_CharWidths * pgbCharWidths);
00065     bool                    canMergeWithNext(void);
00066     void                    mergeWithNext(void);
00067     bool                    findFirstNonBlankSplitPoint(fp_RunSplitInfo & splitInfo);
00068     enum
00069     {
00070         Calculate_full_width = -1
00071     };
00072     UT_sint32               simpleRecalcWidth(UT_sint32 iLength = Calculate_full_width);
00073 
00074     void                    resetJustification(bool bPermanent);
00075     void                    justify(UT_sint32 iAmount, UT_uint32 iSpacesInRun);
00076     UT_sint32               countJustificationPoints(bool bLast) const;
00077 
00078     bool                    getCharacter(UT_uint32 run_offset, UT_UCSChar &Character) const;
00079     UT_sint32               findCharacter(UT_uint32 startPosition, UT_UCSChar Character) const;
00080     bool                    isFirstCharacter(UT_UCSChar Character) const;
00081     bool                    isLastCharacter(UT_UCSChar Character) const;
00082     virtual bool            doesContainNonBlankData(void) const;
00083     inline virtual bool isSuperscript(void) const;
00084     inline virtual bool isSubscript(void) const;
00085     const GR_Font*              getFont(void) const
00086         { return _getFont(); }
00087     const gchar *           getLanguage() const;
00088 
00089 
00090     UT_sint32               getStr(UT_UCSChar * str, UT_uint32 &iMax);
00091 
00092     // applies provided values of direction and override to the run
00093     void                    setDirection(UT_BidiCharType dir, UT_BidiCharType override);
00094 
00095     // the usability of the following function is *very* limited, see the note in cpp file
00096     void                    setDirOverride(UT_BidiCharType dir);
00097     virtual UT_BidiCharType getDirection() const { return m_iDirOverride == UT_BIDI_UNSET ? _getDirection() : m_iDirOverride;}
00098     UT_BidiCharType         getDirOverride() const { return m_iDirOverride; }
00099 
00100     void                breakNeighborsAtDirBoundaries();
00101     void                breakMeAtDirBoundaries(UT_BidiCharType iNewOverride);
00102     void                setShapingRequired(GRShapingResult eR)
00103                              {m_pRenderInfo->m_eShapingResult = eR;}
00104     void                orShapingRequired(GRShapingResult eR)
00105                           {
00106                             m_pRenderInfo->m_eShapingResult =
00107                                 (GRShapingResult)((UT_uint32)m_pRenderInfo->m_eShapingResult
00108                                                   | (UT_uint32)eR);
00109                           }
00110 
00111     void                setItem(GR_Item * i) {m_pItem = i;}
00112     const GR_Item *           getItem() const {return m_pItem;}
00113     
00114 
00115     virtual void        updateOnDelete(UT_uint32 offset, UT_uint32 iLen);
00116 
00117     virtual UT_uint32   adjustCaretPosition(UT_uint32 iDocumentPosition, bool bForward);
00118     virtual void        adjustDeletePosition(UT_uint32 &pos1, UT_uint32 &count);
00119     
00120     static UT_uint32    s_iClassInstanceCount;
00121     UT_BidiCharType     m_iDirOverride;
00122     static bool         s_bBidiOS;
00123 
00124     void                measureCharWidths();
00125     
00126 private:
00127     bool                _refreshDrawBuffer();
00128     bool                _addupCharWidths(void);
00129     virtual void        _lookupProperties(const PP_AttrProp * pSpanAP,
00130                                            const PP_AttrProp * pBlockAP,
00131                                            const PP_AttrProp * pSectionAP,
00132                                           GR_Graphics * pG);
00133 
00134 #ifdef FMT_TEST
00135 public:
00136     virtual void            __dump(FILE * fp) const;
00137 #endif
00138 
00139 protected:
00140     virtual bool            _recalcWidth(void);
00141     virtual bool            _canContainPoint(void) const;
00142     virtual void            _draw(dg_DrawArgs*);
00143     virtual void            _clearScreen(bool bFullLineHeightRect = true);
00144 
00145     void                    _drawInvisibleSpaces(UT_sint32, UT_sint32);
00146     void                    _drawInvisibles(UT_sint32, UT_sint32);
00147 #ifdef ENABLE_SPELL
00148     void                    _drawSquiggle(UT_sint32 top, UT_sint32 left, UT_sint32 right,FL_SQUIGGLE_TYPE iSquiggle);
00149 #endif
00150     void                    _getPartRect(UT_Rect* pRect,
00151                                          UT_sint32 xoff,
00152                                          UT_sint32 yoff,
00153                                          UT_uint32 iStart,
00154                                          UT_uint32 iLen);
00155 
00156     void                    _drawLastChar(bool bSelection);
00157     
00158     void                    _drawFirstChar(bool bSelection);
00159 
00160     void                    _fillRect(UT_RGBColor& clr,
00161                                       UT_sint32 xoff,
00162                                       UT_sint32 yoff,
00163                                       UT_uint32 iStart,
00164                                       UT_uint32 iLen,
00165                                       UT_Rect & rect,
00166                                       GR_Graphics * pG);
00167 
00168 private:
00169     enum
00170     {
00171         TEXT_POSITION_NORMAL,
00172         TEXT_POSITION_SUPERSCRIPT,
00173         TEXT_POSITION_SUBSCRIPT
00174     };
00175     UT_Byte             m_fPosition;
00176 
00177     /*
00178       This makes the assumption that all characters in a given run
00179       can be obtained from the same font.  This may not be true.
00180       For example, suppose that a run includes a mixture of latin
00181       and non-latin characters.  The resulting glyphs will probably need to be
00182       retrieved from multiple fonts.
00183       TODO fix this issue
00184     */
00185     bool                    m_bSpellSquiggled;
00186     bool                    m_bGrammarSquiggled;
00187 
00188     // !!! the m_pLanguage member cannot be set to an arbitrary string pointer
00189     // but only a pointer in the static table of the UT_Language class !!!
00190     const gchar *       m_pLanguage;
00191     bool                    m_bIsOverhanging;
00192 
00193     bool                    m_bKeepWidths;
00194 
00195     const GR_Item *               m_pItem;
00196     GR_RenderInfo   *       m_pRenderInfo;
00197 };
00198 
00199 #endif /* FP_TEXTRUN_H */