6 files changed, 7 insertions, 5 deletions

diff --git a/core/multimedia/opieplayer/libflash/config.in b/core/multimedia/opieplayer/libflash/config.in
index 91a57da..258e8ee 100644
--- a/core/multimedia/opieplayer/libflash/config.in
+++ b/core/multimedia/opieplayer/libflash/config.in
@@ -1,4 +1,4 @@
 #  config #LIBFLASH
 #    boolean "libflash"
 #    default "y"
-#    depends ( LIBQPE || LIBQPE-X11 ) && LIBOPIE
+#    depends ( LIBQPE || LIBQPE-X11 ) 
diff --git a/core/multimedia/opieplayer/libflash/shape.cc b/core/multimedia/opieplayer/libflash/shape.cc
index 0d8df93..4d4ecb8 100644
--- a/core/multimedia/opieplayer/libflash/shape.cc
+++ b/core/multimedia/opieplayer/libflash/shape.cc
@@ -1,1205 +1,1207 @@
 /////////////////////////////////////////////////////////////
 // Flash Plugin and Player
 // Copyright (C) 1998,1999 Olivier Debon
 // 
 // 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.
 // 
 // You should have received a copy of the GNU General Public License
 // along with this program; if not, write to the Free Software
 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 // 
 ///////////////////////////////////////////////////////////////
 //  Author : Olivier Debon  <odebon@club-internet.fr>
 //
 
 #include "swf.h"
 
+#include "math.h"
+
 #ifdef RCSID
 static char *rcsid = "$Id$";
 #endif
 
 #define PRINT 0
 
 #define ABS(v) ((v) < 0 ? -(v) : (v))
 
 static void prepareStyles(GraphicDevice *gd, Matrix *matrix, Cxform *cxform, FillStyleDef *f, long n);
 
 static void clearStyles(GraphicDevice *gd, FillStyleDef *f, long n);
 
 static void drawShape(GraphicDevice *gd, Matrix *matrix1, Cxform *cxform, Shape *shape,
                       ShapeAction shapeAction, void *id,ScanLineFunc scan_line_func);
 
 // Constructor
 
 Shape::Shape(long id, int level) : Character(ShapeType, id)
 {
     defLevel = level;
 
     defaultFillStyle.type = f_Solid;
     defaultFillStyle.color.red = 0;
     defaultFillStyle.color.green = 0;
     defaultFillStyle.color.blue = 0;
     defaultFillStyle.color.alpha = ALPHA_OPAQUE;
 
     defaultLineStyle.width = 0;
 
     // This is to force a first update
     lastMat.a = 0;
     lastMat.d = 0;
     shape_size += sizeof(Shape);
     shape_nb ++;
 
     file_ptr = NULL;
     getStyles = 0;
     getAlpha = 0;
 }
 
 Shape::~Shape()
 {
         if (file_ptr) {
                 free(file_ptr);
         }
 }
 
 void
 Shape::setBoundingBox(Rect rect)
 {
     boundary = rect;
 }
 
 void
 Shape::getBoundingBox(Rect *bb, DisplayListEntry *e)
 {
     *bb =  boundary;
 }
 
 int
 Shape::execute(GraphicDevice *gd, Matrix *matrix, Cxform *cxform)
 {
     //printf("TagId = %d\n", getTagId());
     //if (getTagId() != 220) return 0;
 
     if (cxform) {
         defaultFillStyle.color = cxform->getColor(gd->getForegroundColor());
     } else {
         defaultFillStyle.color = gd->getForegroundColor();
     }
     defaultFillStyle.color.pixel = gd->allocColor(defaultFillStyle.color);
 
     drawShape(gd, matrix, cxform, this, ShapeDraw, NULL, 0);
     return 0;
 }
 
 void
 Shape::getRegion(GraphicDevice *gd, Matrix *matrix, void *id, ScanLineFunc scan_line_func)
 {
     gd->setClipping(0);
     drawShape(gd,matrix,0,this,ShapeGetRegion,id,scan_line_func);
     gd->setClipping(1);
 }
 
 /************************************************************************/
 
 /* create a new path */
 
 static void newPath(ShapeParser *shape,
                     long x, long y)
 {
     Path *p;
     long x1,y1;
 
     p=&shape->curPath;
     
     x1 = shape->matrix->getX(x, y);
     y1 = shape->matrix->getY(x, y);
 
     p->lastX = x1;
     p->lastY = y1;
 
     p->nb_edges = 0;
     p->nb_segments = 0;
 }
 
 
 static void addSegment1(ShapeParser *shape,
                         long x, long y,
                         FillStyleDef *f0,
                         FillStyleDef *f1,
                         LineStyleDef *l)
 {
     Path *p;
     p=&shape->curPath;
 
     if (l) {
         /* a line is defined ... it will be drawn later */
         LineSegment *ls;
 
         ls = new LineSegment;
         if (ls != NULL) {
                 ls->l = l;
                 ls->x1 = p->lastX;
                 ls->y1 = p->lastY;
                 ls->x2 = x;
                 ls->y2 = y;
                 ls->first = (p->nb_segments == 0);
                 ls->next = NULL;
                 if (shape->last_line == NULL) {
                     shape->first_line = ls;
                 } else {
                     shape->last_line->next = ls;
                 }
                 shape->last_line = ls;
         }
     }
 
     /* anti antialiasing not needed if line */
     if (!shape->reverse) {
         shape->gd->addSegment(p->lastX,p->lastY,x,y,f0,f1,l ? 0 : 1);
     } else {
         shape->gd->addSegment(p->lastX,p->lastY,x,y,f1,f0,l ? 0 : 1);
     }
 
     p->lastX = x;
     p->lastY = y;
 
     p->nb_segments++;
 }
 
 
 static void addLine(ShapeParser *shape, long x, long y,
                     FillStyleDef *f0,
                     FillStyleDef *f1,
                     LineStyleDef *l)
 {
     long x1,y1;
     Path *p;
 
     p=&shape->curPath;
 
     x1 = shape->matrix->getX(x, y);
     y1 = shape->matrix->getY(x, y);
     
     addSegment1(shape,x1,y1,f0,f1,l);
 
     p->nb_edges++;
 }
 
 
 // This is based on Divide and Conquer algorithm.
 
 #define BFRAC_BITS  0
 #define BFRAC       (1 << BFRAC_BITS)
 
 static void
 bezierBuildPoints (ShapeParser *s,
                    int subdivisions,
                    long a1X, long a1Y,
                    long cX, long cY,
                    long a2X, long a2Y)
 {
     long c1X,c1Y;
     long c2X,c2Y;
     long X,Y;
     long xmin,ymin,xmax,ymax;
 
     if (subdivisions != 0) {
 
         /* find the bounding box */
 
         if (a1X < cX) {
             xmin = a1X;
             xmax = cX;
         } else {
             xmin = cX;
             xmax = a1X;
         }
         if (a2X < xmin) xmin = a2X;
         if (a2X > xmax) xmax = a2X;
         
         if (a1Y < cY) {
             ymin = a1Y;
             ymax = cY;
         } else {
             ymin = cY;
             ymax = a1Y;
         }
         if (a2Y < ymin) ymin = a2Y;
         if (a2Y > ymax) ymax = a2Y;
     
         if (((xmax - xmin) + (ymax - ymin)) >= (BFRAC*FRAC*2)) {
             // Control point 1
             c1X = (a1X+cX) >> 1;
             c1Y = (a1Y+cY) >> 1;
             
             // Control point 2
             c2X = (a2X+cX) >> 1;
             c2Y = (a2Y+cY) >> 1;
             
             // New point
             X = (c1X+c2X) >> 1;
             Y = (c1Y+c2Y) >> 1;
             
             subdivisions--;
 
             bezierBuildPoints(s, subdivisions, 
                               a1X, a1Y, c1X, c1Y, X, Y);
             bezierBuildPoints(s, subdivisions, 
                               X, Y, c2X, c2Y, a2X, a2Y);
             
             return;
         }
     }
             
     addSegment1(s, (a2X+(BFRAC/2)) >> BFRAC_BITS, 
                 (a2Y+(BFRAC/2)) >> BFRAC_BITS, s->f0, s->f1, s->l);
 }
 
 /* this code is broken, but useful to get something */
 static void flushPaths(ShapeParser *s)
 {
     LineSegment *ls;
     LineStyleDef *l;
     long nx,ny,nn,w;
     GraphicDevice *gd = s->gd;
 
     /* draw the filled polygon */
     gd->drawPolygon();
     
     /* draw the lines */
     ls = s->first_line;
     if (ls != NULL) {
         do {
             l = ls->l;
 
 #if 0
             printf("line %d %d %d %d width=%d\n",
                    ls->x1, ls->y1, ls->x2, ls->y2, l->width);
 #endif
 
             /* XXX: this width is false, but it is difficult (and expensive)
                to have the correct one */
             w = ABS((long)(s->matrix->a * l->width));
 
             if (w <= ((3*FRAC)/2)) {
                     w = FRAC;
             }
 #ifdef THIN_LINES
             if (w <= ((3*FRAC)/2)) {
                 // draw the thin lines only in shapeAction == shapeDraw
                 if (gd->scan_line_func == NULL) {
                     gd->setForegroundColor(l->fillstyle.color);
                     gd->drawLine(ls->x1, ls->y1, ls->x2, ls->y2, w);
                 }
             } else {
 #else
             {
 #endif
                 /* compute the normal vector */
                 
                 nx = -(ls->y2 - ls->y1);
                 ny = (ls->x2 - ls->x1);
                 
                 /* normalize & width */
                 nn = 2 * (long) sqrt(nx * nx + ny * ny);
                 
 #define UL ls->x1 + nx -ny, ls->y1 + ny +nx
 #define UR ls->x2 + nx +ny, ls->y2 + ny -nx
 #define LL ls->x1 - nx -ny, ls->y1 - ny +nx
 #define LR ls->x2 - nx +ny, ls->y2 - ny -nx
 
                 if (nn > 0) {
                     nx = (nx * w) / nn;
                     ny = (ny * w) / nn;
                     
                     /* top segment */
                     gd->addSegment(UL, UR, NULL, &l->fillstyle, 1);
                     
                     /* bottom segment */
                     gd->addSegment(LL, LR, &l->fillstyle, NULL, 1);
                 
                     /* right segment */
                     gd->addSegment(UR, LR, &l->fillstyle, NULL, 1);
                 
                     /* left segment */
                     gd->addSegment(UL, LL, NULL, &l->fillstyle, 1);
                 
                     /* draw the line polygon */
                     gd->drawPolygon();
                 }
             }
                 
             ls = ls->next;
         } while (ls != NULL);
         
         /* delete the line structures */
 
         ls = s->first_line;
         while (ls != NULL) {
             LineSegment *ls1;
             ls1 = ls->next;
             delete ls;
             ls = ls1;
         }
 
         /* reset the line pointers */
         s->first_line = NULL;
         s->last_line = NULL;
     }
 }
 
 
 static void addBezier(ShapeParser *shape, 
                       long ctrlX1, long ctrlY1,
                       long newX1, long newY1,
                       FillStyleDef *f0,
                       FillStyleDef *f1,
                       LineStyleDef *l)
 {
     long newX,newY,ctrlX,ctrlY;
     Path *p;
 
     p=&shape->curPath;
 
     /* note: we do the matrix multiplication before calculating the
        bezier points (faster !) */
 
     ctrlX = shape->matrix->getX(ctrlX1, ctrlY1);
     ctrlY = shape->matrix->getY(ctrlX1, ctrlY1);
     newX = shape->matrix->getX(newX1, newY1);
     newY = shape->matrix->getY(newX1, newY1);
 
     shape->f0 = f0;
     shape->f1 = f1;
     shape->l = l;
 
     bezierBuildPoints(shape, 3,
                       p->lastX<<BFRAC_BITS,p->lastY<<BFRAC_BITS,
                       ctrlX<<BFRAC_BITS,ctrlY<<BFRAC_BITS,
                       newX<<BFRAC_BITS,newY<<BFRAC_BITS);
 
     p->nb_edges++;
 }
 
 /***********************************************************************/
 
 
 /* bit parser */
 
 static void InitBitParser(struct BitParser *b,U8 *buf) 
 {
     b->ptr = buf;
 }
 
 static void InitBits(struct BitParser *b)
 {
     // Reset the bit position and buffer.
     b->m_bitPos = 0;
     b->m_bitBuf = 0;
 }
 
 
 
 static inline U8 GetByte(struct BitParser *b)
 {
     U8 v;
     v = *b->ptr++;
     return v;
 }
 
 static inline U16 GetWord(struct BitParser *b)
 {
     U8 *s;
     U16 v;
     s = b->ptr;
     v = s[0] | ((U16) s[1] << 8);
     b->ptr = s + 2;
     return v;
 }
 
 static inline U32 GetDWord(struct BitParser *b)
 {
     U32 v;
     U8 * s = b->ptr;
     v = (U32) s[0] | ((U32) s[1] << 8) | 
         ((U32) s[2] << 16) | ((U32) s [3] << 24);
     b->ptr = s + 4;
     return v;
 }
 
 static inline U32 GetBit (struct BitParser *b)
 {
     U32 v;
     S32 m_bitPos = b->m_bitPos;
     U32 m_bitBuf = b->m_bitBuf;
     
     if (m_bitPos == 0) {
         m_bitBuf = (U32)(*b->ptr++) << 24;
         m_bitPos = 8;
     }
 
     v = (m_bitBuf >> 31);
 
     m_bitPos--;
     m_bitBuf <<= 1;
 
     b->m_bitPos = m_bitPos;
     b->m_bitBuf = m_bitBuf;
 
     return v;
 }
 
 static inline U32 GetBits (struct BitParser *b, int n)
 {
     U32 v;
     S32 m_bitPos = b->m_bitPos;
     U32 m_bitBuf = b->m_bitBuf;
 
     if (n == 0) 
         return 0;
 
     while (m_bitPos < n) {
         m_bitBuf |= (U32)(*b->ptr++) << (24 - m_bitPos);
         m_bitPos += 8;
     }
 
     v = m_bitBuf >> (32 - n);
     m_bitBuf <<= n;
     m_bitPos -= n;
 
     b->m_bitPos = m_bitPos;
     b->m_bitBuf = m_bitBuf;
     return v;
 }
 
 // Get n bits from the string with sign extension.
 static inline S32 GetSBits (struct BitParser *b,S32 n)
 {
     // Get the number as an unsigned value.
     S32 v = (S32) GetBits(b,n);
 
     // Is the number negative?
     if (v & (1L << (n - 1)))
     {
         // Yes. Extend the sign.
         v |= -1L << n;
     }
 
     return v;
 }
 
 
 
 /************************************************************************/
 
 static void GetMatrix(BitParser *b, Matrix* mat)
 {
     InitBits(b);
 
     // Scale terms
     if (GetBit(b))
     {
         int nBits = (int) GetBits(b,5);
         mat->a = (float)(GetSBits(b,nBits))/(float)0x10000;
         mat->d = (float)(GetSBits(b,nBits))/(float)0x10000;
     }
     else
     {
              mat->a = mat->d = 1.0;
     }
 
     // Rotate/skew terms
     if (GetBit(b))
     {
         int nBits = (int)GetBits(b,5);
         mat->c = (float)(GetSBits(b,nBits))/(float)0x10000;
         mat->b = (float)(GetSBits(b,nBits))/(float)0x10000;
     }
     else
     {
              mat->b = mat->c = 0.0;
     }
 
     // Translate terms
     int nBits = (int) GetBits(b,5);
     mat->tx = GetSBits(b,nBits);
     mat->ty = GetSBits(b,nBits);
 }
 
 static FillStyleDef * ParseFillStyle(ShapeParser *shape, long *n, long getAlpha)
 {
     BitParser *b = &shape->bit_parser;
         FillStyleDef *defs;
         U16 i = 0;
 
         // Get the number of fills.
         U16 nFills = GetByte(b);
 
         // Do we have a larger number?
         if (nFills == 255)
         {
                 // Get the larger number.
                 nFills = GetWord(b);
         }
 
         *n = nFills;
         defs = new FillStyleDef[ nFills ];
         if (defs == NULL) return NULL;
 
         // Get each of the fill style.
         for (i = 0; i < nFills; i++)
         {
                 U16 fillStyle = GetByte(b);
 
                 defs[i].type = (FillType) fillStyle;
 
                 if (fillStyle & 0x10)
                 {
                         defs[i].type = (FillType) (fillStyle & 0x12);
 
                         // Get the gradient matrix.
                         GetMatrix(b,&(defs[i].matrix));
 
                         // Get the number of colors.
                         defs[i].gradient.nbGradients = GetByte(b);
 
                         // Get each of the colors.
                         for (U16 j = 0; j < defs[i].gradient.nbGradients; j++)
                         {
                                 defs[i].gradient.ratio[j] = GetByte(b);
                                 defs[i].gradient.color[j].red = GetByte(b);
                                 defs[i].gradient.color[j].green = GetByte(b);
                                 defs[i].gradient.color[j].blue = GetByte(b);
                                 if (getAlpha) {
                                     defs[i].gradient.color[j].alpha = GetByte(b);
                                 } else {
                                         defs[i].gradient.color[j].alpha = ALPHA_OPAQUE;
                                 }
                         }
                 }
                 else if (fillStyle & 0x40)
                 {
                         defs[i].type = (FillType) (fillStyle & 0x41);
 
                         // Get the bitmapId
                         defs[i].bitmap = (Bitmap *)shape->dict->getCharacter(GetWord(b));
                         // Get the bitmap matrix.
                         GetMatrix(b,&(defs[i].matrix));
                 }
                 else
                 {
                         defs[i].type = (FillType) 0;
 
                         // A solid color
                         defs[i].color.red = GetByte(b);
                         defs[i].color.green = GetByte(b);
                         defs[i].color.blue = GetByte(b);
                         if (getAlpha) {
                                 defs[i].color.alpha = GetByte(b);
                         } else {
                                 defs[i].color.alpha = ALPHA_OPAQUE;
                         }
                 }
         }
         
         return defs;
 }
 
 static LineStyleDef * ParseLineStyle(ShapeParser *shape, long *n, long getAlpha)
 {
     BitParser *b = &shape->bit_parser;
     LineStyleDef *defs,*def;
     FillStyleDef *f;
     long i;
 
         // Get the number of lines.
         U16 nLines = GetByte(b);
 
         // Do we have a larger number?
         if (nLines == 255)
         {
                 // Get the larger number.
                 nLines = GetWord(b);
         }
 
         *n = nLines;
         defs = new LineStyleDef[ nLines ];
         if (defs == NULL) return NULL;
 
         // Get each of the line styles.
         for (i = 0; i < nLines; i++)
         {
             def=&defs[i];
             def->width = GetWord(b);
             def->color.red = GetByte(b);
             def->color.green = GetByte(b);
             def->color.blue = GetByte(b);
             if (getAlpha) {
                 def->color.alpha = GetByte(b);
             } else {
                 def->color.alpha = ALPHA_OPAQUE;
             }
             
             f=&def->fillstyle;
             f->type = f_Solid;
             f->color = def->color;
             if (shape->cxform) {
                 f->color = shape->cxform->getColor(f->color);
             }
             f->color.pixel = shape->gd->allocColor(f->color);
         }
 
         return defs;
 }
 
 /* 0 = end of shape */
 static int ParseShapeRecord(ShapeParser *shape, ShapeRecord *sr, long getAlpha)
 {
     BitParser *b = &shape->bit_parser;
 
         // Determine if this is an edge.
         BOOL isEdge = (BOOL) GetBit(b);
 
         if (!isEdge)
         {
                 // Handle a state change
                 U16 flags = (U16) GetBits(b,5);
 
                 // Are we at the end?
                 if (flags == 0)
                 {
                         // End of shape
                         return 0;
                 }
 
                 sr->type = shapeNonEdge;
                 sr->flags = (ShapeFlags)flags;
 
                 // Process a move to.
                 if (flags & flagsMoveTo)
                 {
                         U16 nBits = (U16) GetBits(b,5);
                         sr->x = GetSBits(b,nBits);
                         sr->y = GetSBits(b,nBits);
                 }
 
                 // Get new fill info.
                 if (flags & flagsFill0)
                 {
                         sr->fillStyle0 = GetBits(b,shape->m_nFillBits);
                 }
                 if (flags & flagsFill1)
                 {
                         sr->fillStyle1 = GetBits(b,shape->m_nFillBits);
                 }
 
                 // Get new line info
                 if (flags & flagsLine)
                 {
                         sr->lineStyle = GetBits(b,shape->m_nLineBits);
                 }
 
                 // Check to get a new set of styles for a new shape layer.
                 if (flags & flagsNewStyles)
                 {
                         FillStyleDef *fillDefs;
                         LineStyleDef *lineDefs;
                         long n;
 
                         // Parse the style.
                         fillDefs = ParseFillStyle(shape, &n, getAlpha);
                         if (fillDefs == NULL)  return 0;
 
                         sr->newFillStyles = fillDefs;
                         sr->nbNewFillStyles = n;
 
                         lineDefs = ParseLineStyle(shape, &n, getAlpha);
                         if (lineDefs == NULL) return 0;
 
                         sr->newLineStyles = lineDefs;
                         sr->nbNewLineStyles = n;
 
                                 InitBits(b);// Bug !
 
                         // Reset.
                         shape->m_nFillBits = (U16) GetBits(b,4);
                         shape->m_nLineBits = (U16) GetBits(b,4);
                 }
 
                 //if (flags & flagsEndShape)
                         //printf("\tEnd of shape.\n\n");
   
                 return flags & flagsEndShape ? 0 : 1;
         }
         else
         {
                 if (GetBit(b))
                 {
                         sr->type = shapeLine;
 
                         // Handle a line
                                 U16 nBits = (U16) GetBits(b,4) + 2;// nBits is biased by 2
 
                         // Save the deltas
                         if (GetBit(b))
                         {
                                 // Handle a general line.
                                 sr->dX = GetSBits(b,nBits);
                                 sr->dY = GetSBits(b,nBits);
                         }
                         else
                         {
                                 // Handle a vert or horiz line.
                                 if (GetBit(b))
                                 {
                                         // Vertical line
                                         sr->dY = GetSBits(b,nBits);
                                         sr->dX = 0;
                                 }
                                 else
                                 {
                                         // Horizontal line
                                         sr->dX = GetSBits(b,nBits);
                                         sr->dY = 0;
                                 }
                         }
                 }
                 else
                 {
                         sr->type = shapeCurve;
 
                          // Handle a curve
                                 U16 nBits = (U16) GetBits(b,4) + 2;// nBits is biased by 2
 
                         // Get the control
                         sr->ctrlX = GetSBits(b,nBits);
                         sr->ctrlY = GetSBits(b,nBits);
 
                         // Get the anchor
                         sr->anchorX = GetSBits(b,nBits);
                         sr->anchorY = GetSBits(b,nBits);
                 }
 
                 return 1;
         }
 }
 
 static void drawShape(GraphicDevice *gd, Matrix *matrix1, Cxform *cxform, Shape *shape,
                       ShapeAction shapeAction, void *id,ScanLineFunc scan_line_func)
 {
     LineStyleDef *l;
     FillStyleDef *f0;
     FillStyleDef *f1;
     ShapeRecord sr1,*sr = &sr1;
     int firstPoint;
     long lastX,lastY;
     LineStyleDef *curLineStyle;
     long curNbLineStyles;
     FillStyleDef *curFillStyle;
     long curNbFillStyles;
     StyleList *sl;
     ShapeParser sp1,*sp=&sp1;
     BitParser *b;
     Matrix     mat,*matrix;
 
     mat = (*gd->adjust) * (*matrix1);
     matrix = &mat;
     
     sp->reverse = (mat.a * mat.d) < 0;
 
     curLineStyle = NULL;
     curNbLineStyles = 0;
     curFillStyle = NULL;
     curNbFillStyles = 0;
     sp->style_list = NULL;
 
     sp->shape = shape;
     sp->gd = gd;
     sp->matrix = matrix;
     sp->cxform = cxform;
     sp->dict = shape->dict;
 
     if (shapeAction == ShapeGetRegion) {
         gd->scan_line_func = scan_line_func;
         gd->scan_line_func_id = id;
     } else {
         gd->scan_line_func = NULL;
     }
 
     b = &sp->bit_parser;
     InitBitParser(b,shape->file_ptr);
 
     if (shape->getStyles) {
         // ShapeWithStyle
         curFillStyle = ParseFillStyle(sp, &curNbFillStyles, shape->getAlpha);
         if (curFillStyle == NULL) return;
 
         curLineStyle = ParseLineStyle(sp, &curNbLineStyles, shape->getAlpha);
         if (curLineStyle == NULL) return;
 
         sl = new StyleList;
         if (sl == NULL) return;
 
         sl->next = NULL;
         sl->newFillStyles = curFillStyle;
         sl->nbNewFillStyles = curNbFillStyles;
         sl->newLineStyles = curLineStyle;
         sl->nbNewLineStyles = curNbLineStyles;
 
         sp->style_list = sl;
 
         if (shapeAction == ShapeDraw) {
             prepareStyles(gd, matrix, cxform, curFillStyle, curNbFillStyles);
         }
     }
         
     InitBits(b);
     sp->m_nFillBits = (U16) GetBits(b,4);
     sp->m_nLineBits = (U16) GetBits(b,4);
 
     l = 0;
     f0 = 0;
     f1 = 0;
     firstPoint = 1;
     lastX = 0;
     lastY = 0;
     sp->curPath.nb_edges = 0;
     sp->first_line = NULL;
     sp->last_line = NULL;
 
     for(;;) {
         if (ParseShapeRecord(sp, sr, shape->getAlpha) == 0) break;
 
         switch (sr->type)
         {
             case shapeNonEdge:
                 if (sr->flags & flagsNewStyles) {
 
                     curFillStyle = sr->newFillStyles;
                     curNbFillStyles = sr->nbNewFillStyles;
                     curLineStyle = sr->newLineStyles;
                     curNbLineStyles = sr->nbNewLineStyles;
                     
                     sl = new StyleList;
                     sl->next = sp->style_list;
                     sl->newFillStyles = sr->newFillStyles;
                     sl->nbNewFillStyles = sr->nbNewFillStyles;
                     sl->newLineStyles = sr->newLineStyles;
                     sl->nbNewLineStyles = sr->nbNewLineStyles;
 
                     sp->style_list = sl;
 
                     if (shapeAction == ShapeDraw) {
                         prepareStyles(gd, matrix, cxform, curFillStyle, curNbFillStyles);
                     }
                 }
                 if (sr->flags & flagsFill0) {
                     if (sr->fillStyle0) {
                         if (curFillStyle) {
                             f0 = &curFillStyle[sr->fillStyle0-1];
                         } else {
                             f0 = &shape->defaultFillStyle;
                         }
                     } else {
                         f0 = 0;
                     }
                 }
                 if (sr->flags & flagsFill1) {
                     if (sr->fillStyle1) {
                         if (curFillStyle) {
                             f1 = &curFillStyle[sr->fillStyle1-1];
                         } else {
                             f1 = &shape->defaultFillStyle;
                         }
                     } else {
                         f1 = 0;
                     }
                 }
                 if (sr->flags & flagsLine) {
                     if (sr->lineStyle) {
                         l = &curLineStyle[sr->lineStyle-1];
                     } else {
                         l = 0;
                     }
                 }
                 if (sr->flags & flagsMoveTo) {
                     if (sp->curPath.nb_edges == 0) {
                         /* if no edges, draw the polygon, then the lines */
                         flushPaths(sp);
                     }
 
                     newPath(sp, sr->x, sr->y);
                     firstPoint = 0;
 
                     lastX = sr->x;
                     lastY = sr->y;
 
 #if PRINT
                     printf("---------\nX,Y    = %4d,%4d\n", sr->x/20, sr->y/20);
 #endif
                 }
                 break;
             case shapeCurve:
                 // Handle Bezier Curves !!!
                 if (firstPoint) {
                     newPath(sp, 0, 0);
                     firstPoint = 0;
                 }
                 {
                     long newX,newY,ctrlX,ctrlY;
                     
                     ctrlX = lastX+sr->ctrlX;
                     ctrlY = lastY+sr->ctrlY;
                     newX = ctrlX+sr->anchorX;
                     newY = ctrlY+sr->anchorY;
 
 #if 1
                     addBezier(sp, ctrlX, ctrlY, newX, newY, f0 , f1, l);
 #else
                     addLine(sp, newX, newY, f0, f1, l);
 #endif
                     
                     lastX = newX;
                     lastY = newY;
                 }
                 break;
             case shapeLine:
                 if (firstPoint) {
                     newPath(sp, 0, 0);
                     firstPoint = 0;
                 }
 
                 lastX += sr->dX;
                 lastY += sr->dY;
 
                 addLine(sp, lastX, lastY, f0, f1, l);
 #if PRINT
                 printf(" X, Y  = %4d,%4d\n", lastX/20, lastY/20);
 #endif
                 break;
         }
     }
 
     /* XXX: should test if there is something to draw */
     flushPaths(sp);
 
     /* free the styles */
     while (sp->style_list) {
         StyleList *sl;
         
         sl=sp->style_list;
         sp->style_list = sl->next;
         
         if (shapeAction == ShapeDraw) {
             clearStyles(gd, sl->newFillStyles, sl->nbNewFillStyles);
         }
 
         delete[] sl->newFillStyles;
         delete[] sl->newLineStyles;
         
         delete sl;
     }
 }
 
 static void
 prepareStyles(GraphicDevice *gd, Matrix *matrix, Cxform *cxform, 
               FillStyleDef *ftab, long n)
 {
     long fs;
     FillStyleDef *f;
 
     for(fs = 0; fs < n; fs++)
     {
         f = ftab + fs;
         switch (f->type)
         {
             case f_None:
                     break;
             case f_Solid:
                 if (cxform) {
                     f->color = cxform->getColor(f->color);
                 }
                 f->color.pixel = gd->allocColor(f->color);
                 break;
             case f_LinearGradient:
             case f_RadialGradient:
                 {
                     Matrix mat;
                     int  n,r,l;
                     long red, green, blue, alpha;
                     long dRed, dGreen, dBlue, dAlpha;
                     long min,max;
                     Matrix *m;
 
                     mat = *(matrix) * f->matrix;
                     // Compute inverted matrix
                     f->gradient.imat = mat.invert();
 
                     /* renormalize the matrix */
                     m=&f->gradient.imat;
                     if (f->type == f_LinearGradient) {
                         m->a = m->a * FRAC * (1/128.0) * 65536.0;
                         m->b = m->b * FRAC * (1/128.0) * 65536.0;
                         m->tx = (long) ((m->tx + 16384) * (1/128.0) * 65536.0);
                     } else {
                         m->a = m->a * FRAC * (1/64.0) * 65536.0;
                         m->b = m->b * FRAC * (1/64.0) * 65536.0;
                         m->c = m->c * FRAC * (1/64.0) * 65536.0;
                         m->d = m->d * FRAC * (1/64.0) * 65536.0;
                         m->tx = (long) (m->tx * (1/64.0) * 65536.0);
                         m->ty = (long) (m->ty * (1/64.0) * 65536.0);
                     }
 
                     // Reset translation in inverted matrix
                     f->gradient.has_alpha = 0;
 
                     // Build a 256 color ramp
                     f->gradient.ramp = new Color[256];
                     if (f->gradient.ramp == NULL) {
                             // Invalidate fill style
                         f->type = f_None;
                         continue;
                     }
 
                     // Store min and max
                     min = f->gradient.ratio[0];
                     max = f->gradient.ratio[f->gradient.nbGradients-1];
                     for(r=0; r < f->gradient.nbGradients-1; r++)
                     {
                         Color start,end;
 
                         l = f->gradient.ratio[r+1]-f->gradient.ratio[r];
                         if (l == 0) continue;
 
                         if (cxform) {
                             start = cxform->getColor(f->gradient.color[r]);
                             end   = cxform->getColor(f->gradient.color[r+1]);
                         } else {
                             start = f->gradient.color[r];
                             end   = f->gradient.color[r+1];
                         }
                         
                         if (start.alpha != ALPHA_OPAQUE || 
                             end.alpha != ALPHA_OPAQUE) {
                             f->gradient.has_alpha = 1;
                         }
 
                         dRed   = end.red - start.red;
                         dGreen = end.green - start.green;
                         dBlue  = end.blue - start.blue;
                         dAlpha = end.alpha - start.alpha;
                         
                         dRed   = (dRed<<16)/l;
                         dGreen = (dGreen<<16)/l;
                         dBlue  = (dBlue<<16)/l;
                         dAlpha  = (dAlpha<<16)/l;
 
                         red   = start.red <<16;
                         green = start.green <<16;
                         blue  = start.blue <<16;
                         alpha  = start.alpha <<16;
 
                         for (n=f->gradient.ratio[r]; n<=f->gradient.ratio[r+1]; n++) {
                             f->gradient.ramp[n].red = red>>16;
                             f->gradient.ramp[n].green = green>>16;
                             f->gradient.ramp[n].blue = blue>>16;
                             f->gradient.ramp[n].alpha = alpha>>16;
 
                             f->gradient.ramp[n].pixel = gd->allocColor(f->gradient.ramp[n]);
                             red += dRed;
                             green += dGreen;
                             blue += dBlue;
                             alpha += dAlpha;
                         }
                     }
                     for(n=0; n<min; n++) {
                         f->gradient.ramp[n] = f->gradient.ramp[min];
                     }
                     for(n=max; n<256; n++) {
                         f->gradient.ramp[n] = f->gradient.ramp[max];
                     }
                 }
                 break;
             case f_TiledBitmap:
             case f_clippedBitmap:
                 if (f->bitmap) {
                     Matrix *m;
 
                     f->cmap = gd->getColormap(f->bitmap->colormap, 
                                               f->bitmap->nbColors, cxform);
                     if (f->cmap == NULL) {
                         /* Get the normal cmap anyway */
                             f->cmap = f->bitmap->colormap;
                     }
 
                     f->bitmap_matrix = *(matrix) * f->matrix;
 
                     f->bitmap_matrix = f->bitmap_matrix.invert();
 
                     m=&f->bitmap_matrix;
                     m->a = m->a * FRAC * 65536.0;
                     m->b = m->b * FRAC * 65536.0;
                     m->c = m->c * FRAC * 65536.0;
                     m->d = m->d * FRAC * 65536.0;
                     m->tx = (long) (m->tx * 65536.0);
                     m->ty = (long) (m->ty * 65536.0);
 
                     f->alpha_table = NULL;
 
                     if (f->bitmap->alpha_buf && cxform) {
                         unsigned char *alpha_table;
                         int i;
 
                         alpha_table = (unsigned char *)malloc (256);
                         if (alpha_table != NULL) {
                             for(i=0;i<256;i++) {
                                 alpha_table[i] = cxform->getAlpha(i);
                             }
                         }
                         f->alpha_table = alpha_table;
                     }
                 }
                 break;
         }
     }
 }
 
 static void
 clearStyles(GraphicDevice *gd, FillStyleDef *ftab, long n)
 {
     long fs;
     FillStyleDef *f;
 
     for(fs = 0; fs < n; fs++)
     {
         f = ftab + fs;
         switch (f->type)
         {
             case f_Solid:
                 break;
             case f_LinearGradient:
             case f_RadialGradient:
                 if (f->gradient.ramp) {
                     delete f->gradient.ramp;
                 }
                 break;
             case f_TiledBitmap:
             case f_clippedBitmap:
                 if (f->bitmap) {
                     if (f->cmap && f->cmap != f->bitmap->colormap) delete f->cmap;
                     if (f->alpha_table) free(f->alpha_table);
                 }
                 break;
             case f_None:
                     break;
         }
     }
 }
 
diff --git a/core/multimedia/opieplayer/libmad/config.in b/core/multimedia/opieplayer/libmad/config.in
index 72249dc..f38e52d 100644
--- a/core/multimedia/opieplayer/libmad/config.in
+++ b/core/multimedia/opieplayer/libmad/config.in
@@ -1,4 +1,4 @@
   config LIBMAD
     boolean "opieplayer1-libmadplugin (plugin with shoutcast/icecast support to play MP3 files)"
     default "y"
-    depends ( LIBQPE || LIBQPE-X11 ) && LIBOPIE && OPIEPLAYER
+    depends ( LIBQPE || LIBQPE-X11 ) && OPIEPLAYER
diff --git a/core/multimedia/opieplayer/libmpeg3/config.in b/core/multimedia/opieplayer/libmpeg3/config.in
index b965a40..d964fb9 100644
--- a/core/multimedia/opieplayer/libmpeg3/config.in
+++ b/core/multimedia/opieplayer/libmpeg3/config.in
@@ -1,4 +1,4 @@
   config LIBMPEG3
     boolean "opieplayer1-libmpeg3plugin (play MPEG3 video files)"
     default "y"
-    depends ( LIBQPE || LIBQPE-X11 ) && LIBOPIE && OPIEPLAYER
+    depends ( LIBQPE || LIBQPE-X11 ) && OPIEPLAYER
diff --git a/core/multimedia/opieplayer/modplug/config.in b/core/multimedia/opieplayer/modplug/config.in
index 86e4725..d7496b0 100644
--- a/core/multimedia/opieplayer/modplug/config.in
+++ b/core/multimedia/opieplayer/modplug/config.in
@@ -1,4 +1,4 @@
   config MODPLUG
     boolean "opieplayer1-modplugin (play MOD/XM/S3M/IT amiga tracker modules)"
     default "y"
-    depends ( LIBQPE || LIBQPE-X11 ) && LIBOPIE && OPIEPLAYER
+    depends ( LIBQPE || LIBQPE-X11 ) && OPIEPLAYER
diff --git a/core/multimedia/opieplayer/wavplugin/config.in b/core/multimedia/opieplayer/wavplugin/config.in
index 56bdfab..b7dddc5 100644
--- a/core/multimedia/opieplayer/wavplugin/config.in
+++ b/core/multimedia/opieplayer/wavplugin/config.in
@@ -1,4 +1,4 @@
   config WAVPLUGIN
     boolean "opieplayer1-wavplugin (play WAV files)"
     default "y"
-    depends ( LIBQPE || LIBQPE-X11 ) && LIBOPIE && OPIEPLAYER
+    depends ( LIBQPE || LIBQPE-X11 ) && OPIEPLAYER