nevrax.org : docs

00001 
+00007 /* Copyright, 2001 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 #ifndef NL_TEXT_CONTEXT_USER_H
+00027 #define NL_TEXT_CONTEXT_USER_H
+00028 
+00029 #include "nel/misc/types_nl.h"
+00030 #include "nel/3d/u_text_context.h"
+00031 #include "3d/text_context.h"
+00032 #include "3d/driver_user.h"
+00033 
+00034 
+00035 namespace NL3D
+00036 {
+00037 
+00038 
+00045 class CTextContextUser : public UTextContext
+00046 {
+00047 private:
+00048         CTextContext    _TextContext;
+00049         CDriverUser             *_DriverUser;
+00050         IDriver                 *_Driver;
+00051 
+00052 public:
+00053 
+00055         CTextContextUser(const std::string fontFileName, const std::string fontExFileName, CDriverUser *drv, CFontManager *fmg)
+00056         {
+00057                 nlassert(drv);
+00058                 _DriverUser= drv;
+00059 
+00060                 // The enum of CComputedString and UTextContext MUST be the same!!!
+00061                 nlassert((uint)UTextContext::HotSpotCount== (uint)CComputedString::HotSpotCount);
+00062 
+00063                 _Driver= drv->getDriver();
+00064                 _TextContext.init(_Driver, fmg);
+00065                 _TextContext.setFontGenerator(fontFileName, fontExFileName);
+00066         }
+00067         virtual ~CTextContextUser() {}
+00068 
+00069 
+00071         // @{
+00072         void setColor(NLMISC::CRGBA color)
+00073         {
+00074                 _TextContext.setColor(color);
+00075         }
+00076         void setFontSize(uint32 fontSize) 
+00077         {
+00078                 _TextContext.setFontSize(fontSize);
+00079         }
+00080         uint32 getFontSize() const  
+00081         {
+00082                 return _TextContext.getFontSize();
+00083         }
+00084         void setHotSpot(THotSpot hotSpot)  
+00085         {
+00086                 _TextContext.setHotSpot((CComputedString::THotSpot)(uint32)hotSpot) ;
+00087         }
+00088         THotSpot getHotSpot() const 
+00089         {
+00090                 return (THotSpot)(uint32)_TextContext.getHotSpot();
+00091         }
+00092         void setScaleX(float scaleX)  
+00093         {
+00094                 _TextContext.setScaleX(scaleX);
+00095         }
+00096         void setScaleY(float scaleY)  
+00097         {
+00098                 _TextContext.setScaleZ(scaleY);
+00099         }
+00100         float getScaleX() const 
+00101         {
+00102                 return _TextContext.getScaleX();
+00103         }
+00104         float getScaleY() const 
+00105         {
+00106                 return _TextContext.getScaleZ();
+00107         }
+00108         void setShaded(bool b) 
+00109         {
+00110                 _TextContext.setShaded(b);
+00111         }
+00112         bool getShaded() const  
+00113         {
+00114                 return _TextContext.getShaded();
+00115         }
+00116         void setShadeExtent(float shext) 
+00117         {
+00118                 _TextContext.setShadeExtent(shext);
+00119         }
+00120         virtual void                    setKeep800x600Ratio(bool keep)
+00121         {
+00122                 _TextContext.setKeep800x600Ratio(keep);
+00123         }
+00124         virtual bool                    getKeep800x600Ratio() const
+00125         {
+00126                 return _TextContext.getKeep800x600Ratio();
+00127         }
+00128         // @}
+00129 
+00130 
+00132 
+00135         // @{
+00136         uint32 textPush(const char *format, ...)  
+00137         {
+00138                 char *str;
+00139                 NLMISC_CONVERT_VARGS (str, format, NLMISC::MaxCStringSize);
+00140 
+00141                 return _TextContext.textPush(ucstring(str)) ;
+00142         }
+00143         uint32 textPush(const ucstring &str)  
+00144         {
+00145                 return _TextContext.textPush(str) ;
+00146         }
+00147         void erase(uint32 i)  
+00148         {
+00149                 _TextContext.erase(i);
+00150         }
+00151         virtual CStringInfo             getStringInfo(uint32 i)
+00152         {
+00153                 CComputedString         *cstr= _TextContext.getComputedString(i);
+00154                 if(!cstr)
+00155                         return CStringInfo(0,0);
+00156                 else
+00157                         return  CStringInfo(cstr->StringWidth, cstr->StringHeight);
+00158         }
+00159         void clear()  
+00160         {
+00161                 _TextContext.clear();
+00162         }
+00163         void printAt(float x, float y, uint32 i) 
+00164         {
+00165                 _TextContext.printAt(x, y, i);
+00166                 _DriverUser->restoreMatrixContext();
+00167         }
+00168         void printAt(float x, float y, ucstring ucstr) 
+00169         {
+00170                 _TextContext.printAt(x, y, ucstr);
+00171                 _DriverUser->restoreMatrixContext();
+00172         }
+00173         void printfAt(float x, float y, const char * format, ...) 
+00174         {
+00175                 char *str;
+00176                 NLMISC_CONVERT_VARGS (str, format, NLMISC::MaxCStringSize);
+00177 
+00178                 _TextContext.printAt(x, y, ucstring(str)) ;
+00179                 _DriverUser->restoreMatrixContext();
+00180         }
+00181 
+00182         void render3D(const CMatrix &mat, ucstring ucstr) 
+00183         {
+00184                 CComputedString computedStr;
+00185                 _TextContext.computeString(ucstr,computedStr);
+00186                 
+00187                 computedStr.render3D(*_Driver,mat);
+00188 
+00189                 _DriverUser->restoreMatrixContext();
+00190         }
+00191         void render3D(const CMatrix &mat, const char *format, ...) 
+00192         {
+00193                 char *str;
+00194                 NLMISC_CONVERT_VARGS (str, format, NLMISC::MaxCStringSize);
+00195 
+00196                 render3D(mat, ucstring(str));
+00197 
+00198                 _DriverUser->restoreMatrixContext();
+00199         }
+00200 
+00201 
+00202         float getLastXBound() const 
+00203         {
+00204                 return _TextContext.getLastXBound();
+00205         }
+00206         // @}
+00207 
+00208         void                    dumpCacheTexture (const char *filename)
+00209         {
+00210                 _TextContext.dumpCache (filename);
+00211         }
+00212 
+00213 };
+00214 
+00215 
+00216 } // NL3D
+00217 
+00218 
+00219 #endif // NL_TEXT_CONTEXT_USER_H
+00220 
+00221 /* End of text_context_user.h */
+