git.cweiske.de / enigma2.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
replace software update plugin with a more user friendly approach
[enigma2.git] / lib / gdi / font.cpp
diff --git a/lib/gdi/font.cpp b/lib/gdi/font.cpp
index b2df471bbefa3f499e1860fde750a8dd9266e6e5..329c4679c9db68e5e5a797681bda091853b0bf8b 100644 (file)
--- a/lib/gdi/font.cpp
+++ b/lib/gdi/font.cpp
@@ -361,7 +361,7 @@ void eTextPara::calc_bbox()
        boundBox = i->bbox; 
        ++i;
 
-       for (i ; i != glyphs.end(); ++i)
+       for (; i != glyphs.end(); ++i)
        {
                if ( i->flags & GS_ISSPACE )
                        continue;
@@ -406,6 +406,7 @@ void eTextPara::setFont(const gFont *font)
 }
 
 std::string eTextPara::replacement_facename;
+std::set<int> eTextPara::forced_replaces;
 
 void eTextPara::setFont(Font *fnt, Font *replacement)
 {
@@ -442,7 +443,7 @@ void eTextPara::setFont(Font *fnt, Font *replacement)
 void
 shape (std::vector<unsigned long> &string, const std::vector<unsigned long> &text);
 
-int eTextPara::renderString(const std::string &string, int rflags)
+int eTextPara::renderString(const char *string, int rflags)
 {
        singleLock s(ftlock);
        
@@ -466,11 +467,12 @@ int eTextPara::renderString(const std::string &string, int rflags)
        }
        
        std::vector<unsigned long> uc_string, uc_visual;
-       uc_string.reserve(string.length());
+       if (string)
+               uc_string.reserve(strlen(string));
        
-       std::string::const_iterator p(string.begin());
+       const char *p = string ? string : "";
 
-       while(p != string.end())
+       while (*p)
        {
                unsigned int unicode=(unsigned char)*p++;
 
@@ -480,28 +482,28 @@ int eTextPara::renderString(const std::string &string, int rflags)
                        {
                                unicode&=0x1F;
                                unicode<<=6;
-                               if (p != string.end())
+                               if (*p)
                                        unicode|=(*p++)&0x3F;
                        } else if ((unicode & 0xF0)==0xE0) // three bytes
                        {
                                unicode&=0x0F;
                                unicode<<=6;
-                               if (p != string.end())
+                               if (*p)
                                        unicode|=(*p++)&0x3F;
                                unicode<<=6;
-                               if (p != string.end())
+                               if (*p)
                                        unicode|=(*p++)&0x3F;
                        } else if ((unicode & 0xF8)==0xF0) // four bytes
                        {
                                unicode&=0x07;
                                unicode<<=6;
-                               if (p != string.end())
+                               if (*p)
                                        unicode|=(*p++)&0x3F;
                                unicode<<=6;
-                               if (p != string.end())
+                               if (*p)
                                        unicode|=(*p++)&0x3F;
                                unicode<<=6;
-                               if (p != string.end())
+                               if (*p)
                                        unicode|=(*p++)&0x3F;
                        }
                }
@@ -587,9 +589,10 @@ nprint:    isprintable=0;
                }
                if (isprintable)
                {
-                       FT_UInt index;
-
-                       index=(rflags&RS_DIRECT)? *i : FT_Get_Char_Index(current_face, *i);
+                       FT_UInt index = 0;
+                       
+                       if (forced_replaces.find(*i) == forced_replaces.end())
+                               index=(rflags&RS_DIRECT)? *i : FT_Get_Char_Index(current_face, *i);
 
                        if (!index)
                        {
@@ -683,89 +686,92 @@ void eTextPara::blit(gDC &dc, const ePoint &offset, const gRGB &background, cons
 
        int buffer_stride=surface->stride;
        
-       for (glyphString::iterator i(glyphs.begin()); i != glyphs.end(); ++i)
+       for (unsigned int c = 0; c < clip.rects.size(); ++c)
        {
-               if (!(i->flags & GS_INVERT))
-               {
-                       lookup8 = lookup8_normal;
-                       lookup32 = lookup32_normal;
-               } else
+               for (glyphString::iterator i(glyphs.begin()); i != glyphs.end(); ++i)
                {
-                       lookup8 = lookup8_invert;
-                       lookup32 = lookup32_invert;
-               }
+                       if (!(i->flags & GS_INVERT))
+                       {
+                               lookup8 = lookup8_normal;
+                               lookup32 = lookup32_normal;
+                       } else
+                       {
+                               lookup8 = lookup8_invert;
+                               lookup32 = lookup32_invert;
+                       }
                
-               static FTC_SBit glyph_bitmap;
-               if (fontRenderClass::instance->getGlyphBitmap(&i->font->font, i->glyph_index, &glyph_bitmap))
-                       continue;
-               int rx=i->x+glyph_bitmap->left + offset.x();
-               int ry=i->y-glyph_bitmap->top  + offset.y();
+                       static FTC_SBit glyph_bitmap;
+                       if (fontRenderClass::instance->getGlyphBitmap(&i->font->font, i->glyph_index, &glyph_bitmap))
+                               continue;
+                       int rx=i->x+glyph_bitmap->left + offset.x();
+                       int ry=i->y-glyph_bitmap->top  + offset.y();
                
-               __u8 *d=(__u8*)(surface->data)+buffer_stride*ry+rx*surface->bypp;
-               __u8 *s=glyph_bitmap->buffer;
-               register int sx=glyph_bitmap->width;
-               int sy=glyph_bitmap->height;
-               if ((sy+ry) >= clip.extends.bottom())
-                       sy=clip.extends.bottom()-ry;
-               if ((sx+rx) >= clip.extends.right())
-                       sx=clip.extends.right()-rx;
-               if (rx < clip.extends.left())
-               {
-                       int diff=clip.extends.left()-rx;
-                       s+=diff;
-                       sx-=diff;
-                       rx+=diff;
-                       d+=diff*surface->bypp;
-               }
-               if (ry < clip.extends.top())
-               {
-                       int diff=clip.extends.top()-ry;
-                       s+=diff*glyph_bitmap->pitch;
-                       sy-=diff;
-                       ry+=diff;
-                       d+=diff*buffer_stride;
-               }
-               if (sx>0)
-                       for (int ay=0; ay<sy; ay++)
+                       __u8 *d=(__u8*)(surface->data)+buffer_stride*ry+rx*surface->bypp;
+                       __u8 *s=glyph_bitmap->buffer;
+                       register int sx=glyph_bitmap->width;
+                       int sy=glyph_bitmap->height;
+                       if ((sy+ry) >= clip.rects[c].bottom())
+                               sy=clip.rects[c].bottom()-ry;
+                       if ((sx+rx) >= clip.rects[c].right())
+                               sx=clip.rects[c].right()-rx;
+                       if (rx < clip.rects[c].left())
                        {
-                               if (!opcode)            // 4bit lookup to 8bit
-                               {
-                                       register __u8 *td=d;
-                                       register int ax;
-                                       
-                                       for (ax=0; ax<sx; ax++)
-                                       {       
-                                               register int b=(*s++)>>4;
-                                               if(b)
-                                                       *td++=lookup8[b];
-                                               else
-                                                       td++;
-                                       }
-                               } else if (opcode == 1) // 8bit direct
-                               {
-                                       register __u8 *td=d;
-                                       register int ax;
-                                       for (ax=0; ax<sx; ax++)
-                                       {       
-                                               register int b=*s++;
-                                               *td++^=b;
-                                       }
-                               } else
+                               int diff=clip.rects[c].left()-rx;
+                               s+=diff;
+                               sx-=diff;
+                               rx+=diff;
+                               d+=diff*surface->bypp;
+                       }
+                       if (ry < clip.rects[c].top())
+                       {
+                               int diff=clip.rects[c].top()-ry;
+                               s+=diff*glyph_bitmap->pitch;
+                               sy-=diff;
+                               ry+=diff;
+                               d+=diff*buffer_stride;
+                       }
+                       if (sx>0)
+                               for (int ay=0; ay<sy; ay++)
                                {
-                                       register __u32 *td=(__u32*)d;
-                                       register int ax;
-                                       for (ax=0; ax<sx; ax++)
-                                       {       
-                                               register int b=(*s++)>>4;
-                                               if(b)
-                                                       *td++=lookup32[b];
-                                               else
-                                                       td++;
+                                       if (!opcode)            // 4bit lookup to 8bit
+                                       {
+                                               register __u8 *td=d;
+                                               register int ax;
+                                               
+                                               for (ax=0; ax<sx; ax++)
+                                               {       
+                                                       register int b=(*s++)>>4;
+                                                       if(b)
+                                                               *td++=lookup8[b];
+                                                       else
+                                                               td++;
+                                               }
+                                       } else if (opcode == 1) // 8bit direct
+                                       {
+                                               register __u8 *td=d;
+                                               register int ax;
+                                               for (ax=0; ax<sx; ax++)
+                                               {       
+                                                       register int b=*s++;
+                                                       *td++^=b;
+                                               }
+                                       } else
+                                       {
+                                               register __u32 *td=(__u32*)d;
+                                               register int ax;
+                                               for (ax=0; ax<sx; ax++)
+                                               {       
+                                                       register int b=(*s++)>>4;
+                                                       if(b)
+                                                               *td++=lookup32[b];
+                                                       else
+                                                               td++;
+                                               }
                                        }
+                                       s+=glyph_bitmap->pitch-sx;
+                                       d+=buffer_stride;
                                }
-                               s+=glyph_bitmap->pitch-sx;
-                               d+=buffer_stride;
-                       }
+               }
        }
 }
 
Clone of git://git.opendreambox.org/git/enigma2.git before dream multimedia removed all the engima2 sources