lib/gui/eskin.cpp

   1 #include <stdio.h>
   2 #include <errno.h>
   3 #include <stdlib.h>
   4
   5 #include <lib/gui/eskin.h>
   6 #include <lib/gui/ewidget.h>
   7 #include <lib/gdi/gfbdc.h>
   8 #include <lib/gdi/glcddc.h>
   9 #include <lib/gdi/epng.h>
  10 #include <lib/base/eerror.h>
  11 #include <lib/gdi/font.h>
  12 #include <lib/base/eptrlist.h>
  13
  14 /*
  15  * Notes on images/colors:
  16  *
  17  * When loading images, the colors they use are parsed, and added to our palette.
  18  * Because we only have room for 256 colors in our 8bit palette, we cannot simply
  19  * allocate all required colors for every image.
  20  * Therefore, only colors that are farther apart than a certain 'maxcolordistance',
  21  * are added to the palette.
  22  *
  23  * Colors defined in the skin are always added to the palette first, and the remaining
  24  * free slots in the palette are used for image colors.
  25  * Images are parsed in the order in which they appear in the skin file, until
  26  * the palette is completely filled.
  27  *
  28  * Skinmakers can influence color allocation in the following ways:
  29  *
  30  * -change the order in which the images are placed in the skin file
  31  * -define a 'maxcolordistance' per image. When omitted, the maximum color distance
  32  * defaults to 15500
  33  *
  34  * or the hard way:
  35  *
  36  * -explicitly list all colors that need to be allocated
  37  */
  38
  39 std::map< eString,tWidgetCreator > eSkin::widget_creator;
  40
  41 eSkin *eSkin::active;
  42
  43 eNamedColor *eSkin::searchColor(const eString &name)
  44 {
  45         for (std::list<eNamedColor>::iterator i(colors.begin()); i != colors.end(); ++i)
  46         {
  47                 if (!i->name.compare(name))
  48                         return &*i;
  49         }
  50         return 0;
  51 }
  52
  53 int eSkin::findColorDistance(const gRGB &rgb)
  54 {
  55         int difference = 1 << 30;
  56         for (int t = 0; t < maxcolors; t++)
  57         {
  58                 if (!colorused[t]) break;
  59                 int ttd;
  60                 int td = (signed)(rgb.r - palette[t].r); td *= td; td *= (255 - palette[t].a);
  61                 ttd = td;
  62                 if (ttd >= difference) continue;
  63                 td = (signed)(rgb.g - palette[t].g); td *= td; td *= (255 - palette[t].a);
  64                 ttd += td;
  65                 if (ttd >= difference) continue;
  66                 td = (signed)(rgb.b - palette[t].b); td *= td; td *= (255 - palette[t].a);
  67                 ttd += td;
  68                 if (ttd >= difference) continue;
  69                 td = (signed)(rgb.a - palette[t].a); td *= td; td *= 255;
  70                 ttd += td;
  71                 if (ttd >= difference) continue;
  72                 difference = ttd;
  73         }
  74         return difference;
  75 }
  76
  77 void eSkin::clear()
  78 {
  79 }
  80
  81 void eSkin::addWidgetCreator(const eString &name, tWidgetCreator creator)
  82 {
  83         widget_creator[name] = creator; // add this tWidgetCreator to map... if exist.. overwrite
  84 }
  85
  86 void eSkin::removeWidgetCreator(const eString &name, tWidgetCreator creator)
  87 {
  88         widget_creator.erase(name);
  89 }
  90
  91 int eSkin::parseColor(const eString &name, const char* color, gRGB &col)
  92 {
  93         if (color[0]=='#')
  94         {
  95                 unsigned long vcol=0;
  96                 if (sscanf(color+1, "%lx", &vcol)!=1)
  97                 {
  98                         eDebug("invalid color named \"%s\" (value: %s)", name.c_str(), color+1);
  99                         return -1;
 100                 }
 101                 col.r=(vcol>>16)&0xFF;
 102                 col.g=(vcol>>8)&0xFF;
 103                 col.b=vcol&0xFF;
 104                 col.a=(vcol>>24)&0xFF;
 105         } else
 106         {
 107                 eNamedColor *n=searchColor(color);
 108                 if (!n)
 109                 {
 110                         eDebug("invalid color named \"%s\" (alias to: \"%s\")", name.c_str(), color);
 111                         return -1;
 112                 }
 113                 col=n->value;
 114         }
 115         return 0;
 116 }
 117
 118 int eSkin::parseColors(XMLTreeNode *xcolors)
 119 {
 120         XMLTreeNode *node;
 121
 122         std::list<eNamedColor>::iterator newcolors=colors.end();
 123
 124         for (node=xcolors->GetChild(); node; node=node->GetNext())
 125         {
 126                 if (strcmp(node->GetType(), "color"))
 127                 {
 128                         eDebug("junk found in colorsection (%s)", node->GetType());
 129                         continue;
 130                 }
 131
 132                 const char *name=node->GetAttributeValue("name"), *color=node->GetAttributeValue("color"), *end=node->GetAttributeValue("end");
 133
 134                 if (!color || !name)
 135                 {
 136                         eDebug("no color/name specified");
 137                         continue;
 138                 }
 139
 140                 eNamedColor col;
 141                 col.name=name;
 142
 143                 const char *size=node->GetAttributeValue("size");
 144
 145                 if (size)
 146                         col.size=atoi(size);
 147                 else
 148                         col.size=0;
 149
 150                 if (!col.size)
 151                         col.size=1;
 152
 153                 if ((col.size>1) && (!end))
 154                 {
 155                         eDebug("no end specified in \"%s\" but is gradient", name);
 156                         continue;
 157                 }
 158
 159                 if (parseColor(name, color, col.value))
 160                         continue;
 161
 162                 if (end && parseColor(name, end, col.end))
 163                         continue;
 164
 165                 colors.push_back(col);
 166                 if (newcolors == colors.end())
 167                         --newcolors;
 168         }
 169
 170         for (std::list<eNamedColor>::iterator i(newcolors); i != colors.end(); ++i)
 171         {
 172                 eNamedColor &col=*i;
 173                 int d;
 174                 for (d=0; d<maxcolors; d+=col.size)
 175                 {
 176                         int s;
 177                         for (s=0; s<col.size; s++)
 178                                 if ((d+s>maxcolors) || colorused[d+s])
 179                                         break;
 180                         if (s==col.size)
 181                                 break;
 182                 }
 183                 if (d==maxcolors)
 184                         continue;
 185                 col.index=gColor(d);
 186                 for (int s=0; s<col.size; s++, d++)
 187                 {
 188                         colorused[d]=1;
 189                         if (s)
 190                         {
 191                                 int rdiff=-col.value.r+col.end.r;
 192                                 int gdiff=-col.value.g+col.end.g;
 193                                 int bdiff=-col.value.b+col.end.b;
 194                                 int adiff=-col.value.a+col.end.a;
 195                                 rdiff*=s; rdiff/=(col.size-1);
 196                                 gdiff*=s; gdiff/=(col.size-1);
 197                                 bdiff*=s; bdiff/=(col.size-1);
 198                                 adiff*=s; adiff/=(col.size-1);
 199                                 palette[d].r=col.value.r+rdiff;
 200                                 palette[d].g=col.value.g+gdiff;
 201                                 palette[d].b=col.value.b+bdiff;
 202                                 palette[d].a=col.value.a+adiff;
 203                         } else
 204                                 palette[d]=col.value;
 205                 }
 206         }
 207         return 0;
 208 }
 209
 210 int eSkin::parseScheme(XMLTreeNode *xscheme)
 211 {
 212         XMLTreeNode *node;
 213         for (node=xscheme->GetChild(); node; node=node->GetNext())
 214         {
 215                 if (strcmp(node->GetType(), "map"))
 216                 {
 217                         eDebug("illegal scheme entry found: %s", node->GetType());
 218                         continue;
 219                 }
 220                 char *name=node->GetAttributeValue("name"), *color=node->GetAttributeValue("color");
 221                 if (!name || !color)
 222                 {
 223                         eDebug("no name or color specified in colorscheme");
 224                         continue;
 225                 }
 226                 eString base=color;
 227                 int offset=0, p;
 228                 if ((p=base.find('+'))!=-1)
 229                 {
 230                         offset=atoi(base.mid(p).c_str());
 231                         base=base.left(p);
 232                 }
 233                 eNamedColor *n=searchColor(base);
 234                 if (!n)
 235                 {
 236                         eDebug("illegal color \"%s\" specified", base.c_str());
 237                         continue;
 238                 }
 239                 scheme[name] = gColor(n->index+offset);
 240         }
 241         return 0;
 242 }
 243
 244 int eSkin::parseFontAlias(XMLTreeNode *xscheme)
 245 {
 246         XMLTreeNode *node;
 247         for (node=xscheme->GetChild(); node; node=node->GetNext())
 248         {
 249                 if (strcmp(node->GetType(), "map"))
 250                 {
 251                         eDebug("illegal fontalias entry found: %s", node->GetType());
 252                         continue;
 253                 }
 254                 char *font=node->GetAttributeValue("font"),
 255                                  *name=node->GetAttributeValue("name"),
 256                                  *size=node->GetAttributeValue("size");
 257
 258                 if (!name || !font || !size)
 259                 {
 260                         eDebug("no name, alias or size spezified in fontaliase");
 261                         continue;
 262                 }
 263
 264                 std::map<eString, gFont>::iterator it = fontAlias.find(name);
 265                 if (it != fontAlias.end())
 266                 {
 267                         eDebug("fontalias %s does exist, skip make alias for font %s", name, font);
 268                         continue;
 269                 }
 270
 271                 std::map<eString, eString>::iterator i = fonts.find(font);
 272                 if (i == fonts.end())
 273                 {
 274                         eDebug("font %s not found, skip make alias %s", font, name);
 275                         continue;
 276                 }
 277                 fontAlias[name]=gFont(i->second, atoi(size));
 278         }
 279         return 0;
 280 }
 281
 282 int eSkin::parseImages(XMLTreeNode *inode)
 283 {
 284         char *abasepath=inode->GetAttributeValue("basepath");
 285         if (!abasepath)
 286                 abasepath="";
 287         eString basepath=eString("/enigma/pictures/");
 288         if (abasepath[0] == '/') // allow absolute paths
 289                 basepath="";
 290         basepath+=abasepath;
 291         if (basepath[basepath.length()-1]!='/')
 292                 basepath+="/";
 293
 294         int d;
 295         for (d = 0; d < maxcolors; d++)
 296         {
 297                 if (!colorused[d]) break;
 298         }
 299
 300         for (XMLTreeNode *node=inode->GetChild(); node; node=node->GetNext())
 301         {
 302                 if (strcmp(node->GetType(), "img"))
 303                 {
 304                         eDebug("illegal image entry found: %s", node->GetType());
 305                         continue;
 306                 }
 307                 const char *name=node->GetAttributeValue("name");
 308                 if (!name)
 309                 {
 310                         eDebug("illegal <img> entry: no name");
 311                         continue;
 312                 }
 313                 const char *src=node->GetAttributeValue("src");
 314                 if (!src)
 315                 {
 316                         eDebug("image/img=\"%s\" no src given", name);
 317                         continue;
 318                 }
 319                 std::map<eString, gPixmap*>::iterator it = images.find(name);
 320                 if (it != images.end())
 321                 {
 322                         eDebug("Image with name %s already loaded, skip %s", name, src);
 323                         continue;
 324                 }
 325                 gPixmap *image=0;
 326                 eString filename=basepath + eString(src);
 327                 if (abasepath[0] != '/')
 328                 {
 329                         // search first in CONFIGDIR
 330                         image=loadPNG((eString(CONFIGDIR)+filename).c_str());
 331                         if (!image)
 332                                 image=loadPNG((eString(TUXBOXDATADIR)+filename).c_str());
 333                 }
 334                 else // abs path
 335                         image=loadPNG(filename.c_str());
 336
 337                 if (!image)
 338                 {
 339                         eDebug("image/img=\"%s\" - %s: file not found", name, filename.c_str());
 340                         continue;
 341                 }
 342
 343                 if (d < maxcolors)
 344                 {
 345                         int maxcolordistance = 15500;
 346                         char *distance = node->GetAttributeValue("maxcolordistance");
 347                         if (distance) maxcolordistance = atoi(distance);
 348
 349                         /* add the image's colors to our palette, but only if they are not too close to colors we already have */
 350                         for (int i = 0; i < image->clut.colors; i++)
 351                         {
 352                                 if (findColorDistance(image->clut.data[i]) > maxcolordistance)
 353                                 {
 354                                         colorused[d] = 1;
 355                                         palette[d++] = image->clut.data[i];
 356                                         if (d >= maxcolors) break;
 357                                 }
 358                         }
 359                 }
 360                 if (paldummy && !node->GetAttributeValue("nomerge"))
 361                 {
 362                         gPixmapDC mydc(image);
 363                         gPainter p(mydc);
 364                         p.mergePalette(*paldummy);
 365                 }
 366                 images[name] = image;
 367                 image->cancompress = true;
 368                 image->compressdata();
 369         }
 370         return 0;
 371 }
 372
 373 int eSkin::parseImageAlias(XMLTreeNode *xvalues)
 374 {
 375         for (XMLTreeNode *node=xvalues->GetChild(); node; node=node->GetNext())
 376         {
 377                 if (strcmp(node->GetType(), "map"))
 378                 {
 379                         eDebug("illegal values entry %s", node->GetType());
 380                         continue;
 381                 }
 382                 const char *name=node->GetAttributeValue("name"),
 383                                                          *img=node->GetAttributeValue("img");
 384                 if (!name || !img)
 385                 {
 386                         eDebug("map entry has no name or img");
 387                         continue;
 388                 }
 389                 std::map<eString, eString>::iterator it = imageAlias.find(name);
 390                 if (it != imageAlias.end())
 391                 {
 392                         eDebug("imagealias %s does exist, skip make alias for image %s", name, img);
 393                         continue;
 394                 }
 395                 std::map<eString, gPixmap*>::iterator i = images.find(img);
 396                 if (i == images.end())
 397                 {
 398                         eDebug("image %s not found, skip make alias %s", img , name);
 399                         continue;
 400                 }
 401                 imageAlias[name]=img;
 402         }
 403         return 0;
 404 }
 405
 406 int eSkin::parseFonts(XMLTreeNode *xfonts)
 407 {
 408         const char *abasepath=xfonts->GetAttributeValue("basepath");
 409         eString basepath=abasepath?abasepath:FONTDIR;
 410
 411         if (basepath.length())
 412                 if (basepath[basepath.length()-1]!='/')
 413                         basepath+="/";
 414
 415         for (XMLTreeNode *node=xfonts->GetChild(); node; node=node->GetNext())
 416         {
 417                 if (strcmp(node->GetType(), "font"))
 418                 {
 419                         eDebug("illegal fonts entry %s", node->GetType());
 420                         continue;
 421                 }
 422                 const char *file=node->GetAttributeValue("file");
 423                 if (!file)
 424                 {
 425                         eDebug("fonts entry has no file");
 426                         continue;
 427                 }
 428                 const char *name=node->GetAttributeValue("name");
 429                 if (!name)
 430                 {
 431                         eDebug("fonts entry has no name use filename %s as name", file);
 432                         name = file;
 433                 }
 434                 std::map<eString, eString>::iterator it = fonts.find(name);
 435                 const char *ascale=node->GetAttributeValue("scale");
 436                 int scale=0;
 437                 if (ascale)
 438                         scale=atoi(ascale);
 439                 if (!scale)
 440                         scale=100;
 441                 if (it != fonts.end())
 442                 {
 443                         eDebug("Font with name %s already loaded, skip %s", name, file);
 444                         continue;
 445                 }
 446                 fonts[name]=fontRenderClass::getInstance()->AddFont(basepath+eString(file), name, scale);
 447                 if (node->GetAttributeValue("replacement"))
 448                         eTextPara::setReplacementFont(name);
 449         }
 450         return 0;
 451 }
 452
 453 int eSkin::parseValues(XMLTreeNode *xvalues)
 454 {
 455         for (XMLTreeNode *node=xvalues->GetChild(); node; node=node->GetNext())
 456         {
 457                 if (strcmp(node->GetType(), "value"))
 458                 {
 459                         eDebug("illegal values entry %s", node->GetType());
 460                         continue;
 461                 }
 462                 const char *name=node->GetAttributeValue("name");
 463                 if (!name)
 464                 {
 465                         eDebug("values entry has no name");
 466                         continue;
 467                 }
 468                 const char *value=node->GetAttributeValue("value");
 469                 if (!value)
 470                 {
 471                         eDebug("values entry has no value");
 472                         continue;
 473                 }
 474                 std::map<eString, int>::iterator it = values.find(name);
 475                 if (it != values.end())
 476                 {
 477                         eDebug("value %s does exist, skip make value %s=%i", name, value);
 478                         continue;
 479                 }
 480                 values[name]=atoi(value);
 481         }
 482         return 0;
 483 }
 484
 485 gDC *eSkin::getDCbyName(const char *name)
 486 {
 487         gPixmapDC *dc=0;
 488         if (!strcmp(name, "fb"))
 489                 dc=gFBDC::getInstance();
 490 #ifndef DISABLE_LCD
 491         else if (!strcmp(name, "lcd"))
 492                 dc=gLCDDC::getInstance();
 493 #endif
 494         return dc;
 495 }
 496
 497 int eSkin::build(eWidget *widget, XMLTreeNode *node)
 498 {
 499 //       eDebug("building a %s", node->GetType());
 500 /*       if (widget->getType() != node->GetType())
 501                         return -1;*/
 502
 503         for (XMLAttribute *attrib=node->GetAttributes(); attrib; attrib=attrib->GetNext())
 504         {
 505 //              eDebug("setting %s := %s", attrib->GetName(), attrib->GetValue());
 506                 if (widget->setProperty(attrib->GetName(), attrib->GetValue()))
 507                 {
 508                         eDebug("failed");
 509                         return -1;
 510                 }
 511         }
 512         for (XMLTreeNode *c=node->GetChild(); c; c=c->GetNext())
 513         {
 514                 eWidget *w=0;
 515
 516                 const char *name=c->GetAttributeValue("name");
 517
 518                 if (name)
 519                         w=widget->search(name);
 520
 521                 if (!w)
 522                 {
 523                         std::map< eString, tWidgetCreator >::iterator it = widget_creator.find(c->GetType());
 524
 525                         if ( it == widget_creator.end() )
 526                         {
 527                                 eWarning("widget class %s does not exist", c->GetType());
 528                                 return -ENOENT;
 529                         }
 530                         w = (it->second)(widget);
 531                 }
 532                 if (!w)
 533                 {
 534                         // eDebug("failed.");
 535                         return -EINVAL;
 536                 }
 537                 w->zOrderRaise();
 538                 int err;
 539                 if ((err=build(w, c)))
 540                 {
 541                         return err;
 542                 }
 543         }
 544         return 0;
 545 }
 546
 547 eSkin::eSkin()
 548 {
 549         maxcolors=256;
 550
 551         palette=new gRGB[maxcolors];
 552
 553         memset(palette, 0, sizeof(gRGB)*maxcolors);
 554         paldummy=new gImage(eSize(1, 1), 8);
 555         paldummy->clut.data=palette;
 556         paldummy->clut.colors=maxcolors;
 557
 558         colorused=new int[maxcolors];
 559         memset(colorused, 0, maxcolors*sizeof(int));
 560 }
 561
 562 eSkin::~eSkin()
 563 {
 564         if (active==this)
 565                 active=0;
 566
 567         clear();
 568
 569         delete [] colorused;
 570
 571         for (std::map<eString, gPixmap*>::iterator it(images.begin()); it != images.end(); ++it)
 572                 delete it->second;
 573
 574         if (paldummy)
 575                 delete paldummy;
 576 }
 577
 578 int eSkin::load(const char *filename)
 579 {
 580         eDebug("loading skin: %s", filename);
 581         FILE *in=fopen(filename, "rt");
 582         if (!in)
 583                 return -1;
 584
 585         parsers.push_front(new XMLTreeParser("ISO-8859-1"));
 586         parsers.setAutoDelete(true);
 587         XMLTreeParser &parser=*parsers.first();
 588         char buf[2048];
 589
 590         int done;
 591         do
 592         {
 593                 unsigned int len=fread(buf, 1, sizeof(buf), in);
 594                 done=len<sizeof(buf);
 595                 if (!parser.Parse(buf, len, done))
 596                 {
 597                         eDebug("parse error: %s at line %d",
 598                                 parser.ErrorString(parser.GetErrorCode()),
 599                                 parser.GetCurrentLineNumber());
 600                         parsers.pop_front();
 601                         fclose(in);
 602                         return -1;
 603                 }
 604         } while (!done);
 605         fclose(in);
 606
 607         XMLTreeNode *root=parser.RootNode();
 608         if (!root)
 609                 return -1;
 610         if (strcmp(root->GetType(), "eskin"))
 611         {
 612                 eDebug("not an eskin");
 613                 return -1;
 614         }
 615
 616         return 0;
 617 }
 618
 619 void eSkin::parseSkins()
 620 {
 621         for (ePtrList<XMLTreeParser>::reverse_iterator it(parsers); it != parsers.rend(); it++)
 622         {
 623                 XMLTreeNode *node=it->RootNode();
 624
 625                 for (node=node->GetChild(); node; node=node->GetNext())
 626                         if (!strcmp(node->GetType(), "colors"))
 627                                 parseColors(node);
 628          }
 629
 630         for (ePtrList<XMLTreeParser>::reverse_iterator it(parsers); it != parsers.rend(); it++)
 631         {
 632                 XMLTreeNode *node=it->RootNode();
 633
 634                 for (node=node->GetChild(); node; node=node->GetNext())
 635                         if (!strcmp(node->GetType(), "colorscheme"))
 636                                 parseScheme(node);
 637          }
 638
 639         for (ePtrList<XMLTreeParser>::iterator it(parsers); it != parsers.end(); it++)
 640         {
 641                 XMLTreeNode *node=it->RootNode();
 642
 643                 for (node=node->GetChild(); node; node=node->GetNext())
 644                         if (!strcmp(node->GetType(), "fonts"))
 645                                 parseFonts(node);
 646          }
 647
 648         for (ePtrList<XMLTreeParser>::iterator it(parsers); it != parsers.end(); it++)
 649         {
 650                 XMLTreeNode *node=it->RootNode();
 651
 652                 for (node=node->GetChild(); node; node=node->GetNext())
 653                         if (!strcmp(node->GetType(), "fontalias"))
 654                                 parseFontAlias(node);
 655          }
 656
 657         for (ePtrList<XMLTreeParser>::iterator it(parsers); it != parsers.end(); it++)
 658         {
 659                 XMLTreeNode *node=it->RootNode();
 660
 661                 for (node=node->GetChild(); node; node=node->GetNext())
 662                         if (!strcmp(node->GetType(), "images"))
 663                                 parseImages(node);
 664
 665          }
 666
 667         for (ePtrList<XMLTreeParser>::iterator it(parsers); it != parsers.end(); it++)
 668         {
 669                 XMLTreeNode *node=it->RootNode();
 670
 671                 for (node=node->GetChild(); node; node=node->GetNext())
 672                         if (!strcmp(node->GetType(), "imagealias"))
 673                                 parseImageAlias(node);
 674
 675          }
 676
 677         for (ePtrList<XMLTreeParser>::iterator it(parsers); it != parsers.end(); it++)
 678         {
 679                 XMLTreeNode *node=it->RootNode();
 680
 681                 for (node=node->GetChild(); node; node=node->GetNext())
 682                         if (!strcmp(node->GetType(), "values"))
 683                                 parseValues(node);
 684         }
 685 }
 686
 687
 688 int eSkin::build(eWidget *widget, const char *name)
 689 {
 690         for (parserList::iterator i(parsers.begin()); i!=parsers.end(); ++i)
 691         {
 692                 XMLTreeNode *node=i->RootNode();
 693                         node=node->GetChild();
 694                 while (node)
 695                 {
 696                         if (!strcmp(node->GetType(), "object"))
 697                         {
 698                                 const char *oname=node->GetAttributeValue("name");
 699                                 if (!std::strcmp(name, oname))
 700                                 {
 701                                         node=node->GetChild();
 702                                         return build(widget, node);
 703                                 }
 704                         }
 705                         node=node->GetNext();
 706                 }
 707         }
 708         eDebug("didn't found it");
 709         return -ENOENT;
 710 }
 711
 712 void eSkin::setPalette(gPixmapDC *pal)
 713 {
 714         if (palette)
 715         {
 716                 gPainter p(*pal);
 717                 p.setPalette(palette, 0, 256);
 718         }
 719 }
 720
 721 eSkin *eSkin::getActive()
 722 {
 723         if (!active)
 724                 eFatal("no active skin");
 725         return active;
 726 }
 727
 728 void eSkin::makeActive()
 729 {
 730         active=this;
 731 }
 732
 733 gColor eSkin::queryScheme(const eString& name) const
 734 {
 735         eString base=name;
 736         int offset=0, p;
 737         if ((p=base.find('+'))!=-1)
 738         {
 739                 offset=atoi(base.mid(p).c_str());
 740                 base=base.left(p);
 741         }
 742
 743         std::map<eString, gColor>::const_iterator it = scheme.find(base);
 744
 745         if (it != scheme.end())
 746                 return it->second + offset;
 747
 748 //      eWarning("%s does not exist", name.c_str());
 749
 750         return gColor(0);
 751 }
 752
 753 gPixmap *eSkin::queryImage(const eString& name) const
 754 {
 755         eString img;
 756
 757         std::map<eString, eString>::const_iterator i = imageAlias.find(name);
 758
 759         if (i != imageAlias.end())
 760                 img = i->second;
 761         else
 762                 img = name;
 763
 764         std::map<eString, gPixmap*>::const_iterator it = images.find(img);
 765
 766         if (it != images.end())
 767                 return it->second;
 768
 769         return 0;
 770 }
 771
 772 int eSkin::queryValue(const eString& name, int d) const
 773 {
 774         std::map<eString, int>::const_iterator it = values.find(name);
 775
 776         if (it != values.end())
 777                 return it->second;
 778
 779         return d;
 780 }
 781
 782 gColor eSkin::queryColor(const eString& name)
 783 {
 784         char *end;
 785
 786         int numcol=strtol(name.c_str(), &end, 10);
 787
 788         if (!*end)
 789                 return gColor(numcol);
 790
 791         eString base=name;
 792         int offset=0, p;
 793         if ((p=base.find('+'))!=-1)
 794         {
 795                 offset=atoi(base.mid(p).c_str());
 796                 base=base.left(p);
 797         }
 798
 799         eNamedColor *col=searchColor(base);
 800
 801         if (!col)
 802         {
 803                 return queryScheme(name);
 804         } else
 805                 return col->index + offset;
 806 }
 807
 808 gFont eSkin::queryFont(const eString& name)
 809 {
 810         std::map<eString, gFont>::iterator it = fontAlias.find(name);  // check if name is a font alias
 811
 812         if ( it != fontAlias.end() )            // font alias found
 813                 return it->second;
 814
 815         eString family;
 816         int size=0;
 817
 818         unsigned int sem = name.rfind(';');             // check if exist ';' in name
 819         if (sem != eString::npos)                                               // then exist
 820         {
 821                 family=name.left(sem);
 822                 size = atoi( name.mid(sem+1).c_str() );
 823                 if (size<=0)
 824                         size=16;
 825         }
 826
 827         std::map<eString, eString>::iterator i = fonts.find(family);   // check if family is a font name
 828         if ( i != fonts.end() ) // font exist
 829                 return gFont(i->second, size);
 830
 831         for (i = fonts.begin() ; i != fonts.end(); i++)                         // as last check if family name is a complete font Face
 832                 if ( i->second == family)
 833                         return gFont(i->second, size);
 834
 835         eFatal("Font %s does not exist", name.c_str() );                        //  halt Programm now... Font does not exist
 836
 837         return gFont();
 838 }