workspace/ksplash/ksplashx/qcolor_x11.cpp

   1 /****************************************************************************
   2 **
   3 ** This file is based on sources of the Qt GUI Toolkit, used under the terms
   4 ** of the GNU General Public License version 2 (see the original copyright
   5 ** notice below).
   6 ** All further contributions to this file are (and are required to be)
   7 ** licensed under the terms of the GNU General Public License as published by
   8 ** the Free Software Foundation; either version 2 of the License, or
   9 ** (at your option) any later version.
  10 **
  11 ** The original Qt license header follows:
  12 **
  13 **
  14 ** Implementation of QColor class for X11
  15 **
  16 ** Created : 940112
  17 **
  18 ** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
  19 **
  20 ** This file is part of the kernel module of the Qt GUI Toolkit.
  21 **
  22 ** This file may be distributed under the terms of the Q Public License
  23 ** as defined by Trolltech AS of Norway and appearing in the file
  24 ** LICENSE.QPL included in the packaging of this file.
  25 **
  26 ** This file may be distributed and/or modified under the terms of the
  27 ** GNU General Public License version 2 as published by the Free Software
  28 ** Foundation and appearing in the file LICENSE.GPL included in the
  29 ** packaging of this file.
  30 **
  31 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
  32 ** licenses for Unix/X11 may use this file in accordance with the Qt Commercial
  33 ** License Agreement provided with the Software.
  34 **
  35 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  36 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  37 **
  38 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
  39 **   information about Qt Commercial License Agreements.
  40 ** See http://www.trolltech.com/qpl/ for QPL licensing information.
  41 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
  42 **
  43 ** Contact info@trolltech.com if any conditions of this licensing are
  44 ** not clear to you.
  45 **
  46 **********************************************************************/
  47
  48 #include "qcolor.h"
  49 #include "qcolor_p.h"
  50 //#include "string.h"
  51 //#include "qpaintdevice.h"
  52 //#include "qapplication.h"
  53 //#include "qapplication_p.h"
  54 //#include "qt_x11_p.h"
  55 #include "x11_defs.h"
  56 #include "string.h"
  57
  58 int             qt_ncols_option  = 216;         // used in qcolor_x11.cpp
  59
  60 // NOT REVISED
  61
  62 /*****************************************************************************
  63   The color dictionary speeds up color allocation significantly for X11.
  64   When there are no more colors, QColor::alloc() will set the colors_avail
  65   flag to FALSE and try to find the nearest color.
  66   NOTE: From deep within the event loop, the colors_avail flag is reset to
  67   TRUE (calls the function qt_reset_color_avail()), because some other
  68   application might free its colors, thereby making them available for
  69   this Qt application.
  70  *****************************************************************************/
  71
  72 //#include "qintdict.h"
  73
  74 struct QColorData {
  75     uint pix;                                   // allocated pixel value
  76     int  context;                               // allocation context
  77 };
  78
  79 #if 0
  80 typedef QIntDict<QColorData> QColorDict;
  81 typedef QIntDictIterator<QColorData> QColorDictIt;
  82 #endif
  83 static int      current_alloc_context = 0;      // current color alloc context
  84 static const uint col_std_dict = 419;
  85 static const uint col_large_dict = 18397;
  86
  87 class QColorScreenData {
  88 public:
  89     QColorScreenData()
  90     {
  91 //#     colorDict = 0;
  92         colors_avail = true;
  93         g_vis = 0;
  94         g_carr = 0;
  95         g_carr_fetch = true;
  96         g_cells = 0;
  97         g_our_alloc = 0;
  98         color_reduce = false;
  99     }
 100
 101 //#    QColorDict *colorDict;           // dict of allocated colors
 102     bool colors_avail;                  // X colors available
 103     bool g_truecolor;                   // truecolor visual
 104     Visual *g_vis;                      // visual
 105     XColor *g_carr;                     // color array
 106     bool g_carr_fetch;                  // perform XQueryColors?
 107     int g_cells;                        // number of entries in g_carr
 108     bool *g_our_alloc;                  // our allocated colors
 109     uint red_mask , green_mask , blue_mask;
 110     int red_shift, green_shift, blue_shift;
 111     bool color_reduce;
 112     int col_div_r;
 113     int col_div_g;
 114     int col_div_b;
 115 };
 116
 117 static int screencount = 0;
 118 static QColorScreenData **screendata = 0; // array of screendata pointers
 119
 120
 121 /*
 122   This function is called from the event loop. It resets the colors_avail
 123   flag so that the application can retry to allocate read-only colors
 124   that other applications may have deallocated lately.
 125
 126   The g_our_alloc and g_carr are global arrays that optimize color
 127   approximation when there are no more colors left to allocate.
 128 */
 129
 130 void qt_reset_color_avail()
 131 {
 132     int i;
 133     for ( i = 0; i < screencount; i++ ) {
 134         screendata[i]->colors_avail = true;
 135         screendata[i]->g_carr_fetch = true;     // do XQueryColors if !colors_avail
 136     }
 137 }
 138
 139
 140 /*
 141   Finds the nearest color.
 142 */
 143
 144 static int find_nearest_color( int r, int g, int b, int* mindist_out,
 145                                QColorScreenData *sd )
 146 {
 147     int mincol = -1;
 148     int mindist = 200000;
 149     int rx, gx, bx, dist;
 150     XColor *xc = &sd->g_carr[0];
 151     for ( int i=0; i<sd->g_cells; i++ ) {
 152         rx = r - (xc->red >> 8);
 153         gx = g - (xc->green >> 8);
 154         bx = b - (xc->blue>> 8);
 155         dist = rx*rx + gx*gx + bx*bx;           // calculate distance
 156         if ( dist < mindist ) {                 // minimal?
 157             mindist = dist;
 158             mincol = i;
 159         }
 160         xc++;
 161     }
 162     *mindist_out = mindist;
 163     return mincol;
 164 }
 165
 166
 167 /*****************************************************************************
 168   QColor misc internal functions
 169  *****************************************************************************/
 170
 171 static int highest_bit( uint v )
 172 {
 173     int i;
 174     uint b = (uint)1 << 31;                     // get pos of highest bit in v
 175     for ( i=31; ((b & v) == 0) && i>=0;  i-- )
 176         b >>= 1;
 177     return i;
 178 }
 179
 180
 181 /*****************************************************************************
 182   QColor static member functions
 183  *****************************************************************************/
 184
 185 /*!
 186     Returns the maximum number of colors supported by the underlying
 187     window system if the window system uses a palette.
 188
 189     Otherwise returns -1. Use numBitPlanes() to calculate the available
 190     colors in that case.
 191 */
 192
 193 int QColor::maxColors()
 194 {
 195     Visual *visual = (Visual *) QPaintDevice::x11AppVisual();
 196     if (visual->c_class & 1)
 197         return QPaintDevice::x11AppCells();
 198     return -1;
 199 }
 200
 201 /*!
 202     Returns the number of color bit planes for the underlying window
 203     system.
 204
 205     The returned value is equal to the default pixmap depth.
 206
 207     \sa QPixmap::defaultDepth()
 208 */
 209
 210 int QColor::numBitPlanes()
 211 {
 212     return QPaintDevice::x11AppDepth();
 213 }
 214
 215
 216 /*!
 217     Internal initialization required for QColor.
 218     This function is called from the QApplication constructor.
 219
 220     \sa cleanup()
 221 */
 222
 223 void QColor::initialize()
 224 {
 225     static const int blackIdx = 2;
 226     static const int whiteIdx = 3;
 227
 228     if ( color_init )                           // already initialized
 229         return;
 230     color_init = true;
 231
 232     Display *dpy  = QPaintDevice::x11AppDisplay();
 233     int      spec = QApplication::colorSpec();
 234
 235     screencount = ScreenCount( dpy );
 236     screendata = new QColorScreenData*[ screencount ];
 237
 238     int scr = QPaintDevice::x11AppScreen();
 239
 240     for ( scr = 0; scr < screencount; ++scr ) {
 241         screendata[scr] = new QColorScreenData;
 242         screendata[scr]->g_vis = (Visual *) QPaintDevice::x11AppVisual( scr );
 243         screendata[scr]->g_truecolor = screendata[scr]->g_vis->c_class == TrueColor;
 244
 245         int          ncols= QPaintDevice::x11AppCells( scr );
 246
 247         if ( screendata[scr]->g_truecolor ) {
 248             colormodel = d32;
 249         } else {
 250             colormodel = d8;
 251             // Create the g_our_alloc array, which remembers which color pixels
 252             // we allocated.
 253             screendata[scr]->g_cells = qMin(ncols,256);
 254             screendata[scr]->g_carr  = new XColor[screendata[scr]->g_cells];
 255             Q_CHECK_PTR( screendata[scr]->g_carr );
 256             memset( screendata[scr]->g_carr, 0,
 257                     screendata[scr]->g_cells*sizeof(XColor) );
 258             screendata[scr]->g_carr_fetch = true;       // run XQueryColors on demand
 259             screendata[scr]->g_our_alloc = new bool[screendata[scr]->g_cells];
 260             Q_CHECK_PTR( screendata[scr]->g_our_alloc );
 261             memset( screendata[scr]->g_our_alloc, false,
 262                     screendata[scr]->g_cells*sizeof(bool) );
 263             XColor *xc = &screendata[scr]->g_carr[0];
 264             for ( int i=0; i<screendata[scr]->g_cells; i++ ) {
 265                 xc->pixel = i;          // g_carr[i] = color i
 266                 xc++;
 267             }
 268         }
 269
 270         int dictsize;
 271         if ( screendata[scr]->g_truecolor ) {                   // truecolor
 272             dictsize    = 1;                    // will not need color dict
 273             screendata[scr]->red_mask    = (uint)screendata[scr]->g_vis->red_mask;
 274             screendata[scr]->green_mask  = (uint)screendata[scr]->g_vis->green_mask;
 275             screendata[scr]->blue_mask   = (uint)screendata[scr]->g_vis->blue_mask;
 276             screendata[scr]->red_shift =
 277                 highest_bit( screendata[scr]->red_mask ) - 7;
 278             screendata[scr]->green_shift =
 279                 highest_bit( screendata[scr]->green_mask ) - 7;
 280             screendata[scr]->blue_shift =
 281                 highest_bit( screendata[scr]->blue_mask ) - 7;
 282         } else {
 283             dictsize = col_std_dict;
 284         }
 285 #if 0
 286         screendata[scr]->colorDict = new QColorDict(dictsize);  // create dictionary
 287         Q_CHECK_PTR( screendata[scr]->colorDict );
 288 #endif
 289
 290         if ( spec == (int)QApplication::ManyColor ) {
 291             screendata[scr]->color_reduce = true;
 292
 293             switch ( qt_ncols_option ) {
 294             case 216:
 295                 // 6:6:6
 296                 screendata[scr]->col_div_r = screendata[scr]->col_div_g =
 297                 screendata[scr]->col_div_b = (255/(6-1));
 298                 break;
 299             default: {
 300                 // 2:3:1 proportions, solved numerically
 301                 if ( qt_ncols_option > 255 ) qt_ncols_option = 255;
 302                 if ( qt_ncols_option < 1 ) qt_ncols_option = 1;
 303                 int nr = 2;
 304                 int ng = 2;
 305                 int nb = 2;
 306                 for (;;) {
 307                     if ( nb*2 < nr && (nb+1)*nr*ng < qt_ncols_option )
 308                         nb++;
 309                     else if ( nr*3 < ng*2 && nb*(nr+1)*ng < qt_ncols_option )
 310                         nr++;
 311                     else if ( nb*nr*(ng+1) < qt_ncols_option )
 312                         ng++;
 313                     else break;
 314                 }
 315                 qt_ncols_option = nr*ng*nb;
 316                 screendata[scr]->col_div_r = (255/(nr-1));
 317                 screendata[scr]->col_div_g = (255/(ng-1));
 318                 screendata[scr]->col_div_b = (255/(nb-1));
 319             }
 320             }
 321         }
 322     }
 323
 324     scr = QPaintDevice::x11AppScreen();
 325
 326     // Initialize global color objects
 327     if ( QPaintDevice::x11AppDefaultVisual(scr) &&
 328          QPaintDevice::x11AppDefaultColormap(scr) ) {
 329         globalColors()[blackIdx].setPixel((uint) BlackPixel(dpy, scr));
 330         globalColors()[whiteIdx].setPixel((uint) WhitePixel(dpy, scr));
 331     } else {
 332         globalColors()[blackIdx].alloc(scr);
 333         globalColors()[whiteIdx].alloc(scr);
 334     }
 335
 336 #if 0 /* 0 == allocate colors on demand */
 337     setLazyAlloc( false );                      // allocate global colors
 338     ((QColor*)(&darkGray))->    alloc();
 339     ((QColor*)(&gray))->        alloc();
 340     ((QColor*)(&lightGray))->   alloc();
 341     ((QColor*)(&::red))->       alloc();
 342     ((QColor*)(&::green))->     alloc();
 343     ((QColor*)(&::blue))->      alloc();
 344     ((QColor*)(&cyan))->        alloc();
 345     ((QColor*)(&magenta))->     alloc();
 346     ((QColor*)(&yellow))->      alloc();
 347     ((QColor*)(&darkRed))->     alloc();
 348     ((QColor*)(&darkGreen))->   alloc();
 349     ((QColor*)(&darkBlue))->    alloc();
 350     ((QColor*)(&darkCyan))->    alloc();
 351     ((QColor*)(&darkMagenta))-> alloc();
 352     ((QColor*)(&darkYellow))->  alloc();
 353     setLazyAlloc( true );
 354 #endif
 355 }
 356
 357 /*!
 358     Internal clean up required for QColor.
 359     This function is called from the QApplication destructor.
 360
 361     \sa initialize()
 362 */
 363
 364 void QColor::cleanup()
 365 {
 366     if ( !color_init )
 367         return;
 368     color_init = false;
 369     int scr;
 370     for ( scr = 0; scr < screencount; scr++ ) {
 371         if ( screendata[scr]->g_carr ) {
 372             delete [] screendata[scr]->g_carr;
 373             screendata[scr]->g_carr = 0;
 374         }
 375         if ( screendata[scr]->g_our_alloc ) {
 376             delete [] screendata[scr]->g_our_alloc;
 377             screendata[scr]->g_our_alloc = 0;
 378         }
 379 #if 0
 380         if ( screendata[scr]->colorDict ) {
 381             screendata[scr]->colorDict->setAutoDelete( true );
 382             screendata[scr]->colorDict->clear();
 383             delete screendata[scr]->colorDict;
 384             screendata[scr]->colorDict = 0;
 385         }
 386 #endif
 387         delete screendata[scr];
 388         screendata[scr] = 0;
 389     }
 390     delete [] screendata;
 391     screendata = 0;
 392     screencount = 0;
 393 }
 394
 395
 396 /*****************************************************************************
 397   QColor member functions
 398  *****************************************************************************/
 399
 400 /*!
 401   \internal
 402   Allocates the color on screen \a screen.  Only used in X11.
 403
 404   \sa alloc(), pixel()
 405 */
 406 uint QColor::alloc( int screen )
 407 {
 408     Display *dpy = QPaintDevice::x11AppDisplay();
 409     if ( screen < 0 )
 410         screen = QPaintDevice::x11AppScreen();
 411     if ( !color_init )
 412         return dpy ? (uint)BlackPixel(dpy, screen) : 0;
 413     int r = qRed(d.argb);
 414     int g = qGreen(d.argb);
 415     int b = qBlue(d.argb);
 416     uint pix = 0;
 417     QColorScreenData *sd = screendata[screen];
 418     if ( sd->g_truecolor ) {                    // truecolor: map to pixel
 419         r = sd->red_shift   > 0 ? r << sd->red_shift   : r >> -sd->red_shift;
 420         g = sd->green_shift > 0 ? g << sd->green_shift : g >> -sd->green_shift;
 421         b = sd->blue_shift  > 0 ? b << sd->blue_shift  : b >> -sd->blue_shift;
 422         pix = (b & sd->blue_mask) | (g & sd->green_mask) | (r & sd->red_mask)
 423               | ~(sd->blue_mask | sd->green_mask | sd->red_mask);
 424         if ( screen == QPaintDevice::x11AppScreen() )
 425             d.d32.pix = pix;
 426         return pix;
 427     }
 428 #if 0
 429     QColorData *c = sd->colorDict->find( (long)(d.argb) );
 430     if ( c ) {                                  // found color in dictionary
 431         pix = c->pix;
 432         if ( screen == QPaintDevice::x11AppScreen() ) {
 433             d.d8.invalid = false;               // color ok
 434             d.d8.dirty = false;
 435             d.d8.pix = pix;                     // use same pixel value
 436             if ( c->context != current_alloc_context ) {
 437                 c->context = 0;                 // convert to default context
 438                 sd->g_our_alloc[pix] = true;    // reuse without XAllocColor
 439             }
 440         }
 441         return pix;
 442     }
 443 #endif
 444
 445     XColor col;
 446     col.red   = r << 8;
 447     col.green = g << 8;
 448     col.blue  = b << 8;
 449
 450     bool try_again = false;
 451     bool try_alloc = !sd->color_reduce;
 452     int  try_count = 0;
 453
 454     do {
 455         // This loop is run until we manage to either allocate or
 456         // find an approximate color, it stops after a few iterations.
 457
 458         try_again = false;
 459
 460         if ( try_alloc && sd->colors_avail &&
 461              XAllocColor(dpy, QPaintDevice::x11AppColormap( screen ),&col) ) {
 462             // We could allocate the color
 463             pix = (uint) col.pixel;
 464             if ( screen == QPaintDevice::x11AppScreen() ) {
 465                 d.d8.pix = pix;
 466                 d.d8.invalid = false;
 467                 d.d8.dirty = false;
 468                 sd->g_carr[d.d8.pix] = col;             // update color array
 469                 if ( current_alloc_context == 0 )
 470                     sd->g_our_alloc[d.d8.pix] = true;   // reuse without XAllocColor
 471             }
 472         } else {
 473             // No available colors, or we did not want to allocate one
 474             int i;
 475             sd->colors_avail = false;           // no more available colors
 476             if ( sd->g_carr_fetch ) {           // refetch color array
 477                 sd->g_carr_fetch = false;
 478                 XQueryColors( dpy, QPaintDevice::x11AppColormap( screen ), sd->g_carr,
 479                               sd->g_cells );
 480             }
 481             int mindist;
 482             i = find_nearest_color( r, g, b, &mindist, sd );
 483
 484             if ( mindist != 0 && !try_alloc ) {
 485                 // Not an exact match with an existing color
 486                 int rr = ((r+sd->col_div_r/2)/sd->col_div_r)*sd->col_div_r;
 487                 int rg = ((g+sd->col_div_g/2)/sd->col_div_g)*sd->col_div_g;
 488                 int rb = ((b+sd->col_div_b/2)/sd->col_div_b)*sd->col_div_b;
 489                 int rx = rr - r;
 490                 int gx = rg - g;
 491                 int bx = rb - b;
 492                 int dist = rx*rx + gx*gx + bx*bx; // calculate distance
 493                 if ( dist < mindist ) {
 494                     // reduced color is closer - try to alloc it
 495                     r = rr;
 496                     g = rg;
 497                     b = rb;
 498                     col.red   = r << 8;
 499                     col.green = g << 8;
 500                     col.blue  = b << 8;
 501                     try_alloc = true;
 502                     try_again = true;
 503                     sd->colors_avail = true;
 504                     continue; // Try alloc reduced color
 505                 }
 506             }
 507
 508             if ( i == -1 ) {                    // no nearest color?!
 509                 int unused, value;
 510                 hsv(&unused, &unused, &value);
 511                 if (value < 128) { // dark, use black
 512                     d.argb = qRgb(0,0,0);
 513                     pix = (uint)BlackPixel( dpy, screen );
 514                     if ( screen == QPaintDevice::x11AppScreen() ) {
 515                         d.d8.invalid = false;
 516                         d.d8.dirty = false;
 517                         d.d8.pix = pix;
 518                     }
 519                 } else { // light, use white
 520                     d.argb = qRgb(0xff,0xff,0xff);
 521                     pix = (uint)WhitePixel( dpy, screen );
 522                     if ( screen == QPaintDevice::x11AppScreen() ) {
 523                         d.d8.invalid = false;
 524                         d.d8.dirty = false;
 525                         d.d8.pix = pix;
 526                     }
 527                 }
 528                 return pix;
 529             }
 530             if ( sd->g_our_alloc[i] ) {         // we've already allocated it
 531                 ; // i == g_carr[i].pixel
 532             } else {
 533                 // Try to allocate existing color
 534                 col = sd->g_carr[i];
 535                 if ( XAllocColor(dpy, QPaintDevice::x11AppColormap( screen ), &col) ) {
 536                     i = (uint)col.pixel;
 537                     sd->g_carr[i] = col;                // update color array
 538                     if ( screen == QPaintDevice::x11AppScreen() ) {
 539                         if ( current_alloc_context == 0 )
 540                             sd->g_our_alloc[i] = true;  // only in the default context
 541                     }
 542                 } else {
 543                     // Oops, it's gone again
 544                     try_count++;
 545                     try_again    = true;
 546                     sd->colors_avail = true;
 547                     sd->g_carr_fetch = true;
 548                 }
 549             }
 550             if ( !try_again ) {                         // got it
 551                 pix = (uint)sd->g_carr[i].pixel;
 552                 if ( screen == QPaintDevice::x11AppScreen() ) {
 553                     d.d8.invalid = false;
 554                     d.d8.dirty = false;
 555                     d.d8.pix = pix;                     // allocated X11 color
 556                 }
 557             }
 558         }
 559
 560     } while ( try_again && try_count < 2 );
 561
 562     if ( try_again ) {                          // no hope of allocating color
 563         int unused, value;
 564         hsv(&unused, &unused, &value);
 565         if (value < 128) { // dark, use black
 566             d.argb = qRgb(0,0,0);
 567             pix = (uint)BlackPixel( dpy, screen );
 568             if ( screen == QPaintDevice::x11AppScreen() ) {
 569                 d.d8.invalid = false;
 570                 d.d8.dirty = false;
 571                 d.d8.pix = pix;
 572             }
 573         } else { // light, use white
 574             d.argb = qRgb(0xff,0xff,0xff);
 575             pix = (uint)WhitePixel( dpy, screen );
 576             if ( screen == QPaintDevice::x11AppScreen() ) {
 577                 d.d8.invalid = false;
 578                 d.d8.dirty = false;
 579                 d.d8.pix = pix;
 580             }
 581         }
 582         return pix;
 583     }
 584 #if 0
 585     // All colors outside context 0 must go into the dictionary
 586     bool many = sd->colorDict->count() >= sd->colorDict->size() * 8;
 587     if ( many && sd->colorDict->size() == col_std_dict ) {
 588         sd->colorDict->resize( col_large_dict );
 589     }
 590     if ( !many || current_alloc_context != 0 ) {
 591         c = new QColorData;                     // insert into color dict
 592         Q_CHECK_PTR( c );
 593         c->pix     = pix;
 594         c->context = current_alloc_context;
 595         sd->colorDict->insert( (long)d.argb, c );       // store color in dict
 596     }
 597 #endif
 598     return pix;
 599 }
 600
 601 /*!
 602   Allocates the RGB color and returns the pixel value.
 603
 604   Allocating a color means to obtain a pixel value from the RGB
 605   specification.  The pixel value is an index into the global color
 606   table, but should be considered an arbitrary platform-dependent value.
 607
 608   The pixel() function calls alloc() if necessary, so in general you
 609   don't need to call this function.
 610
 611   \sa enterAllocContext()
 612 */
 613 // ### 4.0 - remove me?
 614 uint QColor::alloc()
 615 {
 616     return alloc( -1 );
 617 }
 618
 619 /*!
 620     \overload
 621
 622   Returns the pixel value for screen \a screen.
 623
 624   This value is used by the underlying window system to refer to a color.
 625   It can be thought of as an index into the display hardware's color table,
 626   but the value is an arbitrary 32-bit value.
 627
 628   \sa alloc()
 629 */
 630 uint QColor::pixel( int screen ) const
 631 {
 632     if (screen != QPaintDevice::x11AppScreen() &&
 633         // don't allocate color0 or color1, they have fixed pixel
 634         // values for all screens
 635         d.argb != qRgba(255, 255, 255, 1) && d.argb != qRgba(0, 0, 0, 1))
 636         return ((QColor*)this)->alloc( screen );
 637     return pixel();
 638 }
 639
 640 #if 0
 641 void QColor::setSystemNamedColor( const QString& name )
 642 #else
 643 void QColor::setSystemNamedColor( const char* name )
 644 #endif
 645 {
 646     // setSystemNamedColor should look up rgb values from the built in
 647     // color tables first (see qcolor_p.cpp), and failing that, use
 648     // the window system's interface for translating names to rgb values...
 649     // we do this so that things like uic can load an XPM file with named colors
 650     // and convert it to a png without having to use window system functions...
 651 #if 0
 652     d.argb = qt_get_rgb_val( name.latin1() );
 653 #else
 654     d.argb = qt_get_rgb_val( name );
 655 #endif
 656     QRgb rgb;
 657 #if 0
 658     if ( qt_get_named_rgb( name.latin1(), &rgb ) ) {
 659 #else
 660     if ( qt_get_named_rgb( name, &rgb ) ) {
 661 #endif
 662         setRgb( qRed(rgb), qGreen(rgb), qBlue(rgb) );
 663         if ( colormodel == d8 ) {
 664             d.d8.invalid = false;
 665             d.d8.dirty = true;
 666             d.d8.pix = 0;
 667         } else {
 668             alloc();
 669         }
 670     } else if ( !color_init ) {
 671 #if defined(QT_CHECK_STATE)
 672         qWarning( "QColor::setSystemNamedColor: Cannot perform this operation "
 673                   "because QApplication does not exist" );
 674 #endif
 675         // set color to invalid
 676         *this = QColor();
 677     } else {
 678         XColor col, hw_col;
 679         if ( XLookupColor(QPaintDevice::x11AppDisplay(),
 680 #if 0
 681                           QPaintDevice::x11AppColormap(), name.latin1(),
 682 #else
 683                           QPaintDevice::x11AppColormap(), name,
 684 #endif
 685                           &col, &hw_col) ) {
 686             setRgb( col.red>>8, col.green>>8, col.blue>>8 );
 687         } else {
 688             // set color to invalid
 689             *this = QColor();
 690         }
 691     }
 692 }
 693
 694 #define MAX_CONTEXTS 16
 695 static int  context_stack[MAX_CONTEXTS];
 696 static int  context_ptr = 0;
 697
 698 static void init_context_stack()
 699 {
 700     static bool did_init = false;
 701     if ( !did_init ) {
 702         did_init = true;
 703         context_stack[0] = current_alloc_context = 0;
 704     }
 705 }
 706
 707
 708 /*!
 709     Enters a color allocation context and returns a non-zero unique
 710     identifier.
 711
 712     Color allocation contexts are useful for programs that need to
 713     allocate many colors and throw them away later, like image
 714     viewers. The allocation context functions work for true color
 715     displays as well as for colormap displays, except that
 716     QColor::destroyAllocContext() does nothing for true color.
 717
 718     Example:
 719     \code
 720     QPixmap loadPixmap( QString fileName )
 721     {
 722         static int alloc_context = 0;
 723         if ( alloc_context )
 724             QColor::destroyAllocContext( alloc_context );
 725         alloc_context = QColor::enterAllocContext();
 726         QPixmap pm( fileName );
 727         QColor::leaveAllocContext();
 728         return pm;
 729     }
 730     \endcode
 731
 732     The example code loads a pixmap from file. It frees up all colors
 733     that were allocated the last time loadPixmap() was called.
 734
 735     The initial/default context is 0. Qt keeps a list of colors
 736     associated with their allocation contexts. You can call
 737     destroyAllocContext() to get rid of all colors that were allocated
 738     in a specific context.
 739
 740     Calling enterAllocContext() enters an allocation context. The
 741     allocation context lasts until you call leaveAllocContext().
 742     QColor has an internal stack of allocation contexts. Each call to
 743     enterAllocContex() must have a corresponding leaveAllocContext().
 744
 745     \code
 746         // context 0 active
 747     int c1 = QColor::enterAllocContext();    // enter context c1
 748         // context c1 active
 749     int c2 = QColor::enterAllocContext();    // enter context c2
 750         // context c2 active
 751     QColor::leaveAllocContext();             // leave context c2
 752         // context c1 active
 753     QColor::leaveAllocContext();             // leave context c1
 754         // context 0 active
 755         // Now, free all colors that were allocated in context c2
 756     QColor::destroyAllocContext( c2 );
 757     \endcode
 758
 759     You may also want to set the application's color specification.
 760     See QApplication::setColorSpec() for more information.
 761
 762     \sa leaveAllocContext(), currentAllocContext(), destroyAllocContext(),
 763     QApplication::setColorSpec()
 764 */
 765
 766 int QColor::enterAllocContext()
 767 {
 768     static int context_seq_no = 0;
 769     init_context_stack();
 770     if ( context_ptr+1 == MAX_CONTEXTS ) {
 771 #if defined(QT_CHECK_STATE)
 772         qWarning( "QColor::enterAllocContext: Context stack overflow" );
 773 #endif
 774         return 0;
 775     }
 776     current_alloc_context = context_stack[++context_ptr] = ++context_seq_no;
 777     return current_alloc_context;
 778 }
 779
 780
 781 /*!
 782     Leaves a color allocation context.
 783
 784     See enterAllocContext() for a detailed explanation.
 785
 786     \sa enterAllocContext(), currentAllocContext()
 787 */
 788
 789 void QColor::leaveAllocContext()
 790 {
 791     init_context_stack();
 792     if ( context_ptr == 0 ) {
 793 #if defined(QT_CHECK_STATE)
 794         qWarning( "QColor::leaveAllocContext: Context stack underflow" );
 795 #endif
 796         return;
 797     }
 798     current_alloc_context = context_stack[--context_ptr];
 799 }
 800
 801
 802 /*!
 803     Returns the current color allocation context.
 804
 805     The default context is 0.
 806
 807     \sa enterAllocContext(), leaveAllocContext()
 808 */
 809
 810 int QColor::currentAllocContext()
 811 {
 812     return current_alloc_context;
 813 }
 814
 815
 816 /*!
 817     Destroys a color allocation context, \e context.
 818
 819     This function deallocates all colors that were allocated in the
 820     specified \a context. If \a context == -1, it frees up all colors
 821     that the application has allocated. If \a context == -2, it frees
 822     up all colors that the application has allocated, except those in
 823     the default context.
 824
 825     The function does nothing for true color displays.
 826
 827     \sa enterAllocContext(), alloc()
 828 */
 829
 830 void QColor::destroyAllocContext( int context )
 831 {
 832     init_context_stack();
 833     if ( !color_init )
 834         return;
 835
 836     int screen;
 837     for ( screen = 0; screen < screencount; ++screen ) {
 838         if ( screendata[screen]->g_truecolor )
 839             continue;
 840
 841 #if 1
 842         Q_UNUSED(context);
 843 #else
 844         ulong pixels[256];
 845         bool freeing[256];
 846         memset( freeing, false, screendata[screen]->g_cells*sizeof(bool) );
 847         QColorData   *d;
 848         QColorDictIt it( *screendata[screen]->colorDict );
 849         int i = 0;
 850         uint rgbv;
 851         while ( (d=it.current()) ) {
 852             rgbv = (uint)it.currentKey();
 853             if ( (d->context || context==-1) &&
 854                  (d->context == context || context < 0) ) {
 855                 if ( !screendata[screen]->g_our_alloc[d->pix] && !freeing[d->pix] ) {
 856                     // will free this color
 857                     pixels[i++] = d->pix;
 858                     freeing[d->pix] = true;
 859                 }
 860                 // remove from dict
 861                 screendata[screen]->colorDict->remove( (long)rgbv );
 862             }
 863             ++it;
 864         }
 865         if ( i )
 866             XFreeColors( QPaintDevice::x11AppDisplay(),
 867                          QPaintDevice::x11AppColormap( screen ),
 868                          pixels, i, 0 );
 869 #endif
 870     }
 871 }