Actually move the kde files that were renamed in the last commit

1 files changed, 1616 insertions, 0 deletions

diff --git a/tdeui/kcolordialog.cpp b/tdeui/kcolordialog.cpp
new file mode 100644
index 000000000..a9b1c36ac
--- /dev/null
+++ b/tdeui/kcolordialog.cpp
@@ -0,0 +1,1616 @@
+/* This file is part of the KDE libraries
+    Copyright (C) 1997 Martin Jones (mjones@kde.org)
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+//-----------------------------------------------------------------------------
+// KDE color selection dialog.
+//
+// 1999-09-27 Espen Sand <espensa@online.no>
+// KColorDialog is now subclassed from KDialogBase. I have also extended
+// KColorDialog::getColor() so that it contains a parent argument. This
+// improves centering capability.
+//
+// layout management added Oct 1997 by Mario Weilguni
+// <mweilguni@sime.com>
+//
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <tqcheckbox.h>
+#include <tqcombobox.h>
+#include <tqdrawutil.h>
+#include <tqevent.h>
+#include <tqfile.h>
+#include <tqimage.h>
+#include <tqlabel.h>
+#include <tqlayout.h>
+#include <tqvalidator.h>
+#include <tqpainter.h>
+#include <tqpushbutton.h>
+#include <tqspinbox.h>
+#include <tqtimer.h>
+
+#include <kapplication.h>
+#include <kconfig.h>
+#include <kglobal.h>
+#include <kglobalsettings.h>
+#include <kiconloader.h>
+#include <klineedit.h>
+#include <klistbox.h>
+#include <klocale.h>
+#include <kmessagebox.h>
+#include <kseparator.h>
+#include <kpalette.h>
+#include <kimageeffect.h>
+
+#include "kcolordialog.h"
+#include "kcolordrag.h"
+#include "kstaticdeleter.h"
+#include <config.h>
+#include <kdebug.h>
+
+#include "config.h"
+#ifdef Q_WS_X11
+#include <X11/Xlib.h> 
+
+// defined in qapplication_x11.cpp
+typedef int (*QX11EventFilter) (XEvent*);
+extern QX11EventFilter qt_set_x11_event_filter (QX11EventFilter filter);
+#endif
+
+struct ColorPaletteNameType
+{
+    const char* m_fileName;
+    const char* m_displayName;
+};
+
+const ColorPaletteNameType colorPaletteName[]=
+{
+    { "Recent_Colors", I18N_NOOP2( "palette name", "* Recent Colors *" ) },
+    { "Custom_Colors", I18N_NOOP2( "palette name", "* Custom Colors *" ) },
+    { "40.colors",     I18N_NOOP2( "palette name", "Forty Colors" ) },
+    { "Rainbow.colors",I18N_NOOP2( "palette name", "Rainbow Colors" ) },
+    { "Royal.colors",  I18N_NOOP2( "palette name", "Royal Colors" ) },
+    { "Web.colors",    I18N_NOOP2( "palette name", "Web Colors" ) },
+    { 0, 0 } // end of data
+};
+
+const int recentColorIndex = 0;
+const int customColorIndex = 1;
+
+class KColorSpinBox : public TQSpinBox
+{
+public:
+  KColorSpinBox(int minValue, int maxValue, int step, TQWidget* parent)
+   : TQSpinBox(minValue, maxValue, step, parent, "kcolorspinbox")
+  { }
+
+  // Override Qt's braindead auto-selection.
+  virtual void valueChange()
+  {
+      updateDisplay();
+      emit valueChanged( value() );
+      emit valueChanged( currentValueText() );
+  }
+
+};
+
+
+#define STANDARD_PAL_SIZE 17
+
+KColor::KColor()
+: TQColor()
+{
+  r = 0; g = 0; b = 0; h = 0; s = 0; v = 0;
+}
+
+KColor::KColor( const KColor &col)
+: TQColor( col )
+{
+  h = col.h; s = col.s; v = col.v;
+  r = col.r; g = col.g; b = col.b;
+}
+
+KColor::KColor( const TQColor &col)
+: TQColor( col )
+{
+  TQColor::getRgb(&r, &g, &b);
+  TQColor::getHsv(&h, &s, &v);
+}
+
+bool KColor::operator==(const KColor& col) const
+{
+  return (h == col.h) && (s == col.s) && (v == col.v) &&
+         (r == col.r) && (g == col.g) && (b == col.b);
+}
+
+KColor& KColor::operator=(const KColor& col)
+{
+  *(TQColor *)this = col;
+  h = col.h; s = col.s; v = col.v;
+  r = col.r; g = col.g; b = col.b;
+  return *this;
+}
+
+void
+KColor::setHsv(int _h, int _s, int _v)
+{
+  h = _h; s = _s; v = _v;
+  TQColor::setHsv(h, s, v);
+  TQColor::rgb(&r, &g, &b);
+}
+
+void
+KColor::setRgb(int _r, int _g, int _b)
+{
+  r = _r; g = _g; b = _b;
+  TQColor::setRgb(r, g, b);
+  TQColor::hsv(&h, &s, &v);
+}
+
+void
+KColor::rgb(int *_r, int *_g, int *_b) const
+{
+  *_r = r; *_g = g; *_b = b;
+}
+
+void
+KColor::hsv(int *_h, int *_s, int *_v) const
+{
+  *_h = h; *_s = s; *_v = v;
+}
+
+
+static TQColor *standardPalette = 0;
+static KStaticDeleter<TQColor> spd;
+
+static void createStandardPalette()
+{
+    if ( standardPalette )
+	return;
+
+    spd.setObject(standardPalette, new TQColor [STANDARD_PAL_SIZE], true/*array*/);
+
+    int i = 0;
+
+    standardPalette[i++] = Qt::red;
+    standardPalette[i++] = Qt::green;
+    standardPalette[i++] = Qt::blue;
+    standardPalette[i++] = Qt::cyan;
+    standardPalette[i++] = Qt::magenta;
+    standardPalette[i++] = Qt::yellow;
+    standardPalette[i++] = Qt::darkRed;
+    standardPalette[i++] = Qt::darkGreen;
+    standardPalette[i++] = Qt::darkBlue;
+    standardPalette[i++] = Qt::darkCyan;
+    standardPalette[i++] = Qt::darkMagenta;
+    standardPalette[i++] = Qt::darkYellow;
+    standardPalette[i++] = Qt::white;
+    standardPalette[i++] = Qt::lightGray;
+    standardPalette[i++] = Qt::gray;
+    standardPalette[i++] = Qt::darkGray;
+    standardPalette[i++] = Qt::black;
+}
+
+
+KHSSelector::KHSSelector( TQWidget *parent, const char *name )
+	: KXYSelector( parent, name )
+{
+	setRange( 0, 0, 359, 255 );
+}
+
+void KHSSelector::updateContents()
+{
+	drawPalette(&pixmap);
+}
+
+void KHSSelector::resizeEvent( TQResizeEvent * )
+{
+	updateContents();
+}
+
+void KHSSelector::drawContents( TQPainter *painter )
+{
+	painter->drawPixmap( contentsRect().x(), contentsRect().y(), pixmap );
+}
+
+void KHSSelector::drawPalette( TQPixmap *pixmap )
+{
+	int xSize = contentsRect().width(), ySize = contentsRect().height();
+	TQImage image( xSize, ySize, 32 );
+	TQColor col;
+	int h, s;
+	uint *p;
+
+	for ( s = ySize-1; s >= 0; s-- )
+	{
+		p = (uint *) image.scanLine( ySize - s - 1 );
+		for( h = 0; h < xSize; h++ )
+		{
+			col.setHsv( 359*h/(xSize-1), 255*s/((ySize == 1) ? 1 : ySize-1), 192 );
+			*p = col.rgb();
+			p++;
+		}
+	}
+
+	if ( TQColor::numBitPlanes() <= 8 )
+	{
+		createStandardPalette();
+		KImageEffect::dither( image, standardPalette, STANDARD_PAL_SIZE );
+	}
+	pixmap->convertFromImage( image );
+}
+
+
+//-----------------------------------------------------------------------------
+
+KValueSelector::KValueSelector( TQWidget *parent, const char *name )
+	: KSelector( Qt::Vertical, parent, name ), _hue(0), _sat(0)
+{
+	setRange( 0, 255 );
+	pixmap.setOptimization( TQPixmap::BestOptim );
+}
+
+KValueSelector::KValueSelector(Orientation o, TQWidget *parent, const char *name
+ )
+	: KSelector( o, parent, name), _hue(0), _sat(0)
+{
+	setRange( 0, 255 );
+	pixmap.setOptimization( TQPixmap::BestOptim );
+}
+
+void KValueSelector::updateContents()
+{
+	drawPalette(&pixmap);
+}
+
+void KValueSelector::resizeEvent( TQResizeEvent * )
+{
+	updateContents();
+}
+
+void KValueSelector::drawContents( TQPainter *painter )
+{
+	painter->drawPixmap( contentsRect().x(), contentsRect().y(), pixmap );
+}
+
+void KValueSelector::drawPalette( TQPixmap *pixmap )
+{
+	int xSize = contentsRect().width(), ySize = contentsRect().height();
+	TQImage image( xSize, ySize, 32 );
+	TQColor col;
+	uint *p;
+	QRgb rgb;
+
+	if ( orientation() == Qt::Horizontal )
+	{
+		for ( int v = 0; v < ySize; v++ )
+		{
+			p = (uint *) image.scanLine( ySize - v - 1 );
+
+			for( int x = 0; x < xSize; x++ )
+			{
+				col.setHsv( _hue, _sat, 255*x/((xSize == 1) ? 1 : xSize-1) );
+				rgb = col.rgb();
+				*p++ = rgb;
+			}
+		}
+	}
+
+	if( orientation() == Qt::Vertical )
+	{
+		for ( int v = 0; v < ySize; v++ )
+		{
+			p = (uint *) image.scanLine( ySize - v - 1 );
+			col.setHsv( _hue, _sat, 255*v/((ySize == 1) ? 1 : ySize-1) );
+			rgb = col.rgb();
+			for ( int i = 0; i < xSize; i++ )
+				*p++ = rgb;
+		}
+	}
+
+	if ( TQColor::numBitPlanes() <= 8 )
+	{
+		createStandardPalette();
+		KImageEffect::dither( image, standardPalette, STANDARD_PAL_SIZE );
+	}
+	pixmap->convertFromImage( image );
+}
+
+//-----------------------------------------------------------------------------
+
+KColorCells::KColorCells( TQWidget *parent, int rows, int cols )
+	: TQGridView( parent )
+{
+	shade = true;
+	setNumRows( rows );
+	setNumCols( cols );
+	colors = new TQColor [ rows * cols ];
+
+	for ( int i = 0; i < rows * cols; i++ )
+		colors[i] = TQColor();
+
+	selected = 0;
+        inMouse = false;
+
+	// Drag'n'Drop
+	setAcceptDrops( true);
+
+	setHScrollBarMode( AlwaysOff );
+	setVScrollBarMode( AlwaysOff );
+	viewport()->setBackgroundMode( PaletteBackground );
+	setBackgroundMode( PaletteBackground );
+}
+
+KColorCells::~KColorCells()
+{
+	delete [] colors;
+}
+
+void KColorCells::setColor( int colNum, const TQColor &col )
+{
+	colors[colNum] = col;
+	updateCell( colNum/numCols(), colNum%numCols() );
+}
+
+void KColorCells::paintCell( TQPainter *painter, int row, int col )
+{
+	TQBrush brush;
+        int w = 1;
+
+	if (shade)
+        {
+		qDrawShadePanel( painter, 1, 1, cellWidth()-2,
+		    cellHeight()-2, tqcolorGroup(), true, 1, &brush );
+		w = 2;
+        }
+        TQColor color = colors[ row * numCols() + col ];
+        if (!color.isValid())
+	{
+		if (!shade) return;
+		color = backgroundColor();
+	}
+
+	painter->setPen( color );
+	painter->setBrush( TQBrush( color ) );
+	painter->drawRect( w, w, cellWidth()-w*2, cellHeight()-w*2 );
+
+	if ( row * numCols() + col == selected )
+		painter->drawWinFocusRect( w, w, cellWidth()-w*2, cellHeight()-w*2 );
+}
+
+void KColorCells::resizeEvent( TQResizeEvent * )
+{
+	setCellWidth( width() / numCols() );
+	setCellHeight( height() / numRows() );
+}
+
+void KColorCells::mousePressEvent( TQMouseEvent *e )
+{
+    inMouse = true;
+    mPos = e->pos();
+}
+
+int KColorCells::posToCell(const TQPoint &pos, bool ignoreBorders)
+{
+   int row = pos.y() / cellHeight();
+   int col = pos.x() / cellWidth();
+   int cell = row * numCols() + col;
+
+   if (!ignoreBorders)
+   {
+      int border = 2;
+      int x = pos.x() - col * cellWidth();
+      int y = pos.y() - row * cellHeight();
+      if ( (x < border) || (x > cellWidth()-border) ||
+           (y < border) || (y > cellHeight()-border))
+         return -1;
+   }
+   return cell;
+}
+
+void KColorCells::mouseMoveEvent( TQMouseEvent *e )
+{
+    if( !(e->state() & Qt::LeftButton)) return;
+
+    if(inMouse) {
+        int delay = KGlobalSettings::dndEventDelay();
+        if(e->x() > mPos.x()+delay || e->x() < mPos.x()-delay ||
+           e->y() > mPos.y()+delay || e->y() < mPos.y()-delay){
+            // Drag color object
+            int cell = posToCell(mPos);
+            if ((cell != -1) && colors[cell].isValid())
+            {
+               KColorDrag *d = new KColorDrag( colors[cell], this);
+               d->dragCopy();
+            }
+        }
+    }
+}
+
+void KColorCells::dragEnterEvent( TQDragEnterEvent *event)
+{
+     event->accept( acceptDrags && KColorDrag::canDecode( event));
+}
+
+void KColorCells::dropEvent( TQDropEvent *event)
+{
+     TQColor c;
+     if( KColorDrag::decode( event, c)) {
+          int cell = posToCell(event->pos(), true);
+	  setColor(cell,c);
+     }
+}
+
+void KColorCells::mouseReleaseEvent( TQMouseEvent *e )
+{
+	int cell = posToCell(mPos);
+        int currentCell = posToCell(e->pos());
+
+        // If we release the mouse in another cell and we don't have
+        // a drag we should ignore this event.
+        if (currentCell != cell)
+           cell = -1;
+
+	if ( (cell != -1) && (selected != cell) )
+	{
+		int prevSel = selected;
+		selected = cell;
+		updateCell( prevSel/numCols(), prevSel%numCols() );
+		updateCell( cell/numCols(), cell%numCols() );
+        }
+
+        inMouse = false;
+        if (cell != -1)
+	    emit colorSelected( cell );
+}
+
+void KColorCells::mouseDoubleClickEvent( TQMouseEvent * /*e*/ )
+{
+  int cell = posToCell(mPos);
+
+  if (cell != -1)
+    emit colorDoubleClicked( cell );
+}
+
+
+//-----------------------------------------------------------------------------
+
+KColorPatch::KColorPatch( TQWidget *parent ) : TQFrame( parent )
+{
+	setFrameStyle( TQFrame::Panel | TQFrame::Sunken );
+	colContext = 0;
+	setAcceptDrops( true);
+}
+
+KColorPatch::~KColorPatch()
+{
+  if ( colContext )
+    TQColor::destroyAllocContext( colContext );
+}
+
+void KColorPatch::setColor( const TQColor &col )
+{
+	if ( colContext )
+		TQColor::destroyAllocContext( colContext );
+	colContext = TQColor::enterAllocContext();
+	color.setRgb( col.rgb() );
+	color.alloc();
+	TQColor::leaveAllocContext();
+
+	TQPainter painter;
+
+	painter.begin( this );
+	drawContents( &painter );
+	painter.end();
+}
+
+void KColorPatch::drawContents( TQPainter *painter )
+{
+	painter->setPen( color );
+	painter->setBrush( TQBrush( color ) );
+	painter->drawRect( contentsRect() );
+}
+
+void KColorPatch::mouseMoveEvent( TQMouseEvent *e )
+{
+        // Drag color object
+        if( !(e->state() & Qt::LeftButton)) return;
+	KColorDrag *d = new KColorDrag( color, this);
+	d->dragCopy();
+}
+
+void KColorPatch::dragEnterEvent( TQDragEnterEvent *event)
+{
+     event->accept( KColorDrag::canDecode( event));
+}
+
+void KColorPatch::dropEvent( TQDropEvent *event)
+{
+     TQColor c;
+     if( KColorDrag::decode( event, c)) {
+	  setColor( c);
+	  emit colorChanged( c);
+     }
+}
+
+class KPaletteTable::KPaletteTablePrivate
+{
+public:
+    TQMap<TQString,TQColor> m_namedColorMap;
+};
+
+KPaletteTable::KPaletteTable( TQWidget *parent, int minWidth, int cols)
+    : TQWidget( parent ), cells(0), mPalette(0), mMinWidth(minWidth), mCols(cols)
+{
+  d = new KPaletteTablePrivate;
+  
+  i18n_namedColors  = i18n("Named Colors");
+
+  TQStringList diskPaletteList = KPalette::getPaletteList();
+  TQStringList paletteList;
+
+  // We must replace the untranslated file names by translate names (of course only for KDE's standard palettes)
+  for ( int i = 0; colorPaletteName[i].m_fileName; ++i )
+  {
+      diskPaletteList.remove( colorPaletteName[i].m_fileName );
+      paletteList.append( i18n( "palette name", colorPaletteName[i].m_displayName ) );
+  }
+  paletteList += diskPaletteList;
+  paletteList.append( i18n_namedColors );
+
+  TQVBoxLayout *layout = new TQVBoxLayout( this );
+
+  combo = new TQComboBox( false, this );
+  combo->insertStringList( paletteList );
+  layout->addWidget(combo);
+
+  sv = new TQScrollView( this );
+  TQSize cellSize = TQSize( mMinWidth, 120);
+  sv->setHScrollBarMode( TQScrollView::AlwaysOff);
+  sv->setVScrollBarMode( TQScrollView::AlwaysOn);
+  TQSize minSize = TQSize(sv->verticalScrollBar()->width(), 0);
+  minSize += TQSize(sv->frameWidth(), 0);
+  minSize += TQSize(cellSize);
+  sv->setFixedSize(minSize);
+  layout->addWidget(sv);
+
+  mNamedColorList = new KListBox( this, "namedColorList", 0 );
+  mNamedColorList->setFixedSize(minSize);
+  mNamedColorList->hide();
+  layout->addWidget(mNamedColorList);
+  connect( mNamedColorList, TQT_SIGNAL(highlighted( const TQString & )),
+	   this, TQT_SLOT( slotColorTextSelected( const TQString & )) );
+
+  setFixedSize( tqsizeHint());
+  connect( combo, TQT_SIGNAL(activated(const TQString &)),
+	this, TQT_SLOT(slotSetPalette( const TQString &)));
+}
+
+KPaletteTable::~KPaletteTable()
+{
+   delete mPalette;
+   delete d;
+}
+
+TQString
+KPaletteTable::palette() const
+{
+  return combo->currentText();
+}
+
+
+static const char * const *namedColorFilePath( void )
+{
+  //
+  // 2000-02-05 Espen Sand.
+  // Add missing filepaths here. Make sure the last entry is 0!
+  //
+  static const char * const path[] =
+  {
+#ifdef X11_RGBFILE
+    X11_RGBFILE,
+#endif
+	"/usr/share/X11/rgb.txt",
+    "/usr/X11R6/lib/X11/rgb.txt",
+    "/usr/openwin/lib/X11/rgb.txt", // for Solaris.
+    0
+  };
+  return path;
+}
+
+
+
+
+void
+KPaletteTable::readNamedColor( void )
+{
+  if( mNamedColorList->count() != 0 )
+  {
+    return; // Strings already present
+  }
+
+  KGlobal::locale()->insertCatalogue("kdelibs_colors");
+
+  //
+  // Code somewhat inspired by KPalette.
+  //
+
+  const char * const *path = namedColorFilePath();
+  for( int i=0; path[i]; ++i )
+  {
+    TQFile paletteFile( path[i] );
+    if( !paletteFile.open( IO_ReadOnly ) )
+    {
+      continue;
+    }
+
+    TQString line;
+    TQStringList list;
+    while( paletteFile.readLine( line, 100 ) != -1 )
+    {
+      int red, green, blue;
+      int pos = 0;
+
+      if( sscanf(line.ascii(), "%d %d %d%n", &red, &green, &blue, &pos ) == 3 )
+      {
+	//
+	// Remove duplicates. Every name with a space and every name
+	// that start with "gray".
+	//
+	TQString name = line.mid(pos).stripWhiteSpace();
+	if( name.isNull() || name.find(' ') != -1 ||
+	    name.find( "gray" ) != -1 ||  name.find( "grey" ) != -1 )
+	{
+	  continue;
+	}
+
+        const TQColor color ( red, green, blue );
+        if ( color.isValid() )
+        {
+            const TQString colorName( i18n("color", name.latin1() ) );
+            list.append( colorName );
+            d->m_namedColorMap[ colorName ] = color;
+        }
+      }
+    }
+
+    list.sort();
+    mNamedColorList->insertStringList( list );
+    break;
+  }
+
+  if( mNamedColorList->count() == 0 )
+  {
+    //
+    // Give the error dialog box a chance to center above the
+    // widget (or dialog). If we had displayed it now we could get a
+    // situation where the (modal) error dialog box pops up first
+    // preventing the real dialog to become visible until the
+    // error dialog box is removed (== bad UI).
+    //
+    TQTimer::singleShot( 10, this, TQT_SLOT(slotShowNamedColorReadError()) );
+  }
+}
+
+
+void
+KPaletteTable::slotShowNamedColorReadError( void )
+{
+  if( mNamedColorList->count() == 0 )
+  {
+    TQString msg = i18n(""
+      "Unable to read X11 RGB color strings. The following "
+      "file location(s) were examined:\n");
+
+    const char * const *path = namedColorFilePath();
+    for( int i=0; path[i]; ++i )
+    {
+      msg += path[i];
+      msg += "\n";
+    }
+    KMessageBox::sorry( this, msg );
+  }
+}
+
+
+//
+// 2000-02-12 Espen Sand
+// Set the color in two steps. The setPalette() slot will not emit a signal
+// with the current color setting. The reason is that setPalette() is used
+// by the color selector dialog on startup. In the color selector dialog
+// we normally want to display a startup color which we specify
+// when the dialog is started. The slotSetPalette() slot below will
+// set the palette and then use the information to emit a signal with the
+// new color setting. It is only used by the combobox widget.
+//
+void
+KPaletteTable::slotSetPalette( const TQString &_paletteName )
+{
+  setPalette( _paletteName );
+  if( mNamedColorList->isVisible() )
+  {
+    int item = mNamedColorList->currentItem();
+    mNamedColorList->setCurrentItem( item < 0 ? 0 : item );
+    slotColorTextSelected( mNamedColorList->currentText() );
+  }
+  else
+  {
+    slotColorCellSelected(0); // FIXME: We need to save the current value!!
+  }
+}
+
+
+void
+KPaletteTable::setPalette( const TQString &_paletteName )
+{
+  TQString paletteName( _paletteName);
+  if (paletteName.isEmpty())
+     paletteName = i18n_recentColors;
+
+  if (combo->currentText() != paletteName)
+  {
+     bool found = false;
+     for(int i = 0; i < combo->count(); i++)
+     {
+        if (combo->text(i) == paletteName)
+        {
+           combo->setCurrentItem(i);
+           found = true;
+           break;
+        }
+     }
+     if (!found)
+     {
+        combo->insertItem(paletteName);
+        combo->setCurrentItem(combo->count()-1);
+     }
+  }
+
+  // We must again find the file name of the palette from the eventual translation
+  for ( int i = 0; colorPaletteName[i].m_fileName; ++i )
+  {
+      if ( paletteName == i18n( "palette name", colorPaletteName[i].m_displayName ) )
+      {
+          paletteName = colorPaletteName[i].m_fileName;
+          break;
+      }
+  }
+
+
+  //
+  // 2000-02-12 Espen Sand
+  // The palette mode "i18n_namedColors" does not use the KPalette class.
+  // In fact, 'mPalette' and 'cells' are 0 when in this mode. The reason
+  // for this is maninly that KPalette reads from and writes to files using
+  // "locate()". The colors used in "i18n_namedColors" mode comes from the
+  // X11 diretory and is not writable. I don't think this fit in KPalette.
+  //
+  if( !mPalette || mPalette->name() != paletteName )
+  {
+    if( paletteName == i18n_namedColors )
+    {
+      sv->hide();
+      mNamedColorList->show();
+      readNamedColor();
+
+      delete cells; cells = 0;
+      delete mPalette; mPalette = 0;
+    }
+    else
+    {
+      mNamedColorList->hide();
+      sv->show();
+
+      delete cells;
+      delete mPalette;
+      mPalette = new KPalette(paletteName);
+      int rows = (mPalette->nrColors()+mCols-1) / mCols;
+      if (rows < 1) rows = 1;
+      cells = new KColorCells( sv->viewport(), rows, mCols);
+      cells->setShading(false);
+      cells->setAcceptDrags(false);
+      TQSize cellSize = TQSize( mMinWidth, mMinWidth * rows / mCols);
+      cells->setFixedSize( cellSize );
+      for( int i = 0; i < mPalette->nrColors(); i++)
+      {
+        cells->setColor( i, mPalette->color(i) );
+      }
+      connect( cells, TQT_SIGNAL( colorSelected( int ) ),
+	       TQT_SLOT( slotColorCellSelected( int ) ) );
+      connect( cells, TQT_SIGNAL( colorDoubleClicked( int ) ),
+	       TQT_SLOT( slotColorCellDoubleClicked( int ) ) );
+      sv->addChild( cells );
+      cells->show();
+      sv->updateScrollBars();
+    }
+  }
+}
+
+
+
+void
+KPaletteTable::slotColorCellSelected( int col )
+{
+  if (!mPalette || (col >= mPalette->nrColors()))
+     return;
+  emit colorSelected( mPalette->color(col), mPalette->colorName(col) );
+}
+
+void
+KPaletteTable::slotColorCellDoubleClicked( int col )
+{
+  if (!mPalette || (col >= mPalette->nrColors()))
+     return;
+  emit colorDoubleClicked( mPalette->color(col), mPalette->colorName(col) );
+}
+
+
+void
+KPaletteTable::slotColorTextSelected( const TQString &colorText )
+{
+  emit colorSelected( d->m_namedColorMap[ colorText ], colorText );
+}
+
+
+void
+KPaletteTable::addToCustomColors( const TQColor &color)
+{
+  setPalette(i18n( "palette name", colorPaletteName[ customColorIndex ].m_displayName ));
+  mPalette->addColor( color );
+  mPalette->save();
+  delete mPalette;
+  mPalette = 0;
+  setPalette(i18n( "palette name", colorPaletteName[ customColorIndex ].m_displayName ));
+}
+
+void
+KPaletteTable::addToRecentColors( const TQColor &color)
+{
+  //
+  // 2000-02-12 Espen Sand.
+  // The 'mPalette' is always 0 when current mode is i18n_namedColors
+  //
+  bool recentIsSelected = false;
+  if ( mPalette && mPalette->name() == colorPaletteName[ recentColorIndex ].m_fileName )
+  {
+     delete mPalette;
+     mPalette = 0;
+     recentIsSelected = true;
+  }
+  KPalette *recentPal = new KPalette( colorPaletteName[ recentColorIndex ].m_fileName );
+  if (recentPal->findColor(color) == -1)
+  {
+     recentPal->addColor( color );
+     recentPal->save();
+  }
+  delete recentPal;
+  if (recentIsSelected)
+      setPalette( i18n( "palette name", colorPaletteName[ recentColorIndex ].m_displayName ) );
+}
+
+class KColorDialog::KColorDialogPrivate {
+public:
+    KPaletteTable *table;
+    TQString originalPalette;
+    bool bRecursion;
+    bool bEditRgb;
+    bool bEditHsv;
+    bool bEditHtml;
+    bool bColorPicking;
+    TQLabel *colorName;
+    KLineEdit *htmlName;
+    KColorSpinBox *hedit;
+    KColorSpinBox *sedit;
+    KColorSpinBox *vedit;
+    KColorSpinBox *redit;
+    KColorSpinBox *gedit;
+    KColorSpinBox *bedit;
+    KColorPatch *patch;
+    KHSSelector *hsSelector;
+    KPalette *palette;
+    KValueSelector *valuePal;
+    TQVBoxLayout* l_right;
+    TQGridLayout* tl_layout;
+    TQCheckBox *cbDefaultColor;
+    KColor defaultColor;
+    KColor selColor;
+#ifdef Q_WS_X11
+    QX11EventFilter oldfilter;
+#endif
+};
+
+
+KColorDialog::KColorDialog( TQWidget *parent, const char *name, bool modal )
+  :KDialogBase( parent, name, modal, i18n("Select Color"),
+		modal ? Ok|Cancel : Close,
+		Ok, true )
+{
+  d = new KColorDialogPrivate;
+  d->bRecursion = true;
+  d->bColorPicking = false;
+#ifdef Q_WS_X11
+  d->oldfilter = 0;
+#endif
+  d->cbDefaultColor = 0L;
+  connect( this, TQT_SIGNAL(okClicked(void)),this,TQT_SLOT(slotWriteSettings(void)));
+  connect( this, TQT_SIGNAL(closeClicked(void)),this,TQT_SLOT(slotWriteSettings(void)));
+
+  TQLabel *label;
+
+  //
+  // Create the top level page and its layout
+  //
+  TQWidget *page = new TQWidget( this );
+  setMainWidget( page );
+
+  TQGridLayout *tl_layout = new TQGridLayout( page, 3, 3, 0, spacingHint() );
+  d->tl_layout = tl_layout;
+  tl_layout->addColSpacing( 1, spacingHint() * 2 );
+
+  //
+  // the more complicated part: the left side
+  // add a V-box
+  //
+  TQVBoxLayout *l_left = new TQVBoxLayout();
+  tl_layout->addLayout(l_left, 0, 0);
+
+  //
+  // add a H-Box for the XY-Selector and a grid for the
+  // entry fields
+  //
+  TQHBoxLayout *l_ltop = new TQHBoxLayout();
+  l_left->addLayout(l_ltop);
+
+  // a little space between
+  l_left->addSpacing(10);
+
+  TQGridLayout *l_lbot = new TQGridLayout(3, 6);
+  l_left->addLayout(TQT_TQLAYOUT(l_lbot));
+
+  //
+  // the palette and value selector go into the H-box
+  //
+  d->hsSelector = new KHSSelector( page );
+  d->hsSelector->setMinimumSize(140, 70);
+  l_ltop->addWidget(d->hsSelector, 8);
+  connect( d->hsSelector, TQT_SIGNAL( valueChanged( int, int ) ),
+	   TQT_SLOT( slotHSChanged( int, int ) ) );
+
+  d->valuePal = new KValueSelector( page );
+  d->valuePal->setMinimumSize(26, 70);
+  l_ltop->addWidget(d->valuePal, 1);
+  connect( d->valuePal, TQT_SIGNAL( valueChanged( int ) ),
+	   TQT_SLOT( slotVChanged( int ) ) );
+
+
+  //
+  // add the HSV fields
+  //
+  label = new TQLabel( i18n("H:"), page );
+  label->tqsetAlignment(AlignRight | AlignVCenter);
+  l_lbot->addWidget(label, 0, 2);
+  d->hedit = new KColorSpinBox( 0, 359, 1, page );
+  d->hedit->setValidator( new TQIntValidator( TQT_TQOBJECT(d->hedit) ) );
+  l_lbot->addWidget(d->hedit, 0, 3);
+  connect( d->hedit, TQT_SIGNAL( valueChanged(int) ),
+  	TQT_SLOT( slotHSVChanged() ) );
+
+  label = new TQLabel( i18n("S:"), page );
+  label->tqsetAlignment(AlignRight | AlignVCenter);
+  l_lbot->addWidget(label, 1, 2);
+  d->sedit = new KColorSpinBox( 0, 255, 1, page );
+  d->sedit->setValidator( new TQIntValidator( TQT_TQOBJECT(d->sedit) ) );
+  l_lbot->addWidget(d->sedit, 1, 3);
+  connect( d->sedit, TQT_SIGNAL( valueChanged(int) ),
+  	TQT_SLOT( slotHSVChanged() ) );
+
+  label = new TQLabel( i18n("V:"), page );
+  label->tqsetAlignment(AlignRight | AlignVCenter);
+  l_lbot->addWidget(label, 2, 2);
+  d->vedit = new KColorSpinBox( 0, 255, 1, page );
+  d->vedit->setValidator( new TQIntValidator( TQT_TQOBJECT(d->vedit) ) );
+  l_lbot->addWidget(d->vedit, 2, 3);
+  connect( d->vedit, TQT_SIGNAL( valueChanged(int) ),
+  	TQT_SLOT( slotHSVChanged() ) );
+
+  //
+  // add the RGB fields
+  //
+  label = new TQLabel( i18n("R:"), page );
+  label->tqsetAlignment(AlignRight | AlignVCenter);
+  l_lbot->addWidget(label, 0, 4);
+  d->redit = new KColorSpinBox( 0, 255, 1, page );
+  d->redit->setValidator( new TQIntValidator( TQT_TQOBJECT(d->redit) ) );
+  l_lbot->addWidget(d->redit, 0, 5);
+  connect( d->redit, TQT_SIGNAL( valueChanged(int) ),
+  	TQT_SLOT( slotRGBChanged() ) );
+
+  label = new TQLabel( i18n("G:"), page );
+  label->tqsetAlignment(AlignRight | AlignVCenter);
+  l_lbot->addWidget( label, 1, 4);
+  d->gedit = new KColorSpinBox( 0, 255,1, page );
+  d->gedit->setValidator( new TQIntValidator( TQT_TQOBJECT(d->gedit) ) );
+  l_lbot->addWidget(d->gedit, 1, 5);
+  connect( d->gedit, TQT_SIGNAL( valueChanged(int) ),
+  	TQT_SLOT( slotRGBChanged() ) );
+
+  label = new TQLabel( i18n("B:"), page );
+  label->tqsetAlignment(AlignRight | AlignVCenter);
+  l_lbot->addWidget(label, 2, 4);
+  d->bedit = new KColorSpinBox( 0, 255, 1, page );
+  d->bedit->setValidator( new TQIntValidator( TQT_TQOBJECT(d->bedit) ) );
+  l_lbot->addWidget(d->bedit, 2, 5);
+  connect( d->bedit, TQT_SIGNAL( valueChanged(int) ),
+  	TQT_SLOT( slotRGBChanged() ) );
+
+  //
+  // the entry fields should be wide enough to hold 8888888
+  //
+  int w = d->hedit->fontMetrics().width("8888888");
+  d->hedit->setFixedWidth(w);
+  d->sedit->setFixedWidth(w);
+  d->vedit->setFixedWidth(w);
+
+  d->redit->setFixedWidth(w);
+  d->gedit->setFixedWidth(w);
+  d->bedit->setFixedWidth(w);
+
+  //
+  // add a layout for the right side
+  //
+  d->l_right = new TQVBoxLayout;
+  tl_layout->addLayout(d->l_right, 0, 2);
+
+  //
+  // Add the palette table
+  //
+  d->table = new KPaletteTable( page );
+  d->l_right->addWidget(d->table, 10);
+
+  connect( d->table, TQT_SIGNAL( colorSelected( const TQColor &, const TQString & ) ),
+	   TQT_SLOT( slotColorSelected( const TQColor &, const TQString & ) ) );
+
+  connect(
+    d->table,
+    TQT_SIGNAL( colorDoubleClicked( const TQColor &, const TQString & ) ),
+    TQT_SLOT( slotColorDoubleClicked( const TQColor &, const TQString & ) )
+  );
+  // Store the default value for saving time.
+  d->originalPalette = d->table->palette();
+
+  //
+  // a little space between
+  //
+  d->l_right->addSpacing(10);
+
+  TQHBoxLayout *l_hbox = new TQHBoxLayout( d->l_right );
+
+  //
+  // The add to custom colors button
+  //
+  TQPushButton *button = new TQPushButton( page );
+  button->setText(i18n("&Add to Custom Colors"));
+  l_hbox->addWidget(button, 0, AlignLeft);
+  connect( button, TQT_SIGNAL( clicked()), TQT_SLOT( slotAddToCustomColors()));
+
+  //
+  // The color picker button
+  //
+  button = new TQPushButton( page );
+  button->setPixmap( BarIcon("colorpicker"));
+  l_hbox->addWidget(button, 0, AlignHCenter );
+  connect( button, TQT_SIGNAL( clicked()), TQT_SLOT( slotColorPicker()));
+
+  //
+  // a little space between
+  //
+  d->l_right->addSpacing(10);
+
+  //
+  // and now the entry fields and the patch (=colored box)
+  //
+  TQGridLayout *l_grid = new TQGridLayout( d->l_right, 2, 3);
+
+  l_grid->setColStretch(2, 1);
+
+  label = new TQLabel( page );
+  label->setText(i18n("Name:"));
+  l_grid->addWidget(TQT_TQWIDGET(label), 0, 1, Qt::AlignLeft);
+
+  d->colorName = new TQLabel( page );
+  l_grid->addWidget(TQT_TQWIDGET(d->colorName), 0, 2, Qt::AlignLeft);
+
+  label = new TQLabel( page );
+  label->setText(i18n("HTML:"));
+  l_grid->addWidget(TQT_TQWIDGET(label), 1, 1, Qt::AlignLeft);
+
+  d->htmlName = new KLineEdit( page );
+  d->htmlName->setMaxLength( 13 ); // Qt's TQColor allows 12 hexa-digits
+  d->htmlName->setText("#FFFFFF"); // But HTML uses only 6, so do not worry about the size
+  w = d->htmlName->fontMetrics().width(TQString::tqfromLatin1("#DDDDDDD"));
+  d->htmlName->setFixedWidth(w);
+  l_grid->addWidget(TQT_TQWIDGET(d->htmlName), 1, 2, Qt::AlignLeft);
+
+  connect( d->htmlName, TQT_SIGNAL( textChanged(const TQString &) ),
+      TQT_SLOT( slotHtmlChanged() ) );
+
+  d->patch = new KColorPatch( page );
+  d->patch->setFixedSize(48, 48);
+  l_grid->addMultiCellWidget(TQT_TQWIDGET(d->patch), 0, 1, 0, 0, Qt::AlignHCenter | Qt::AlignVCenter);
+  connect( d->patch, TQT_SIGNAL( colorChanged( const TQColor&)),
+	   TQT_SLOT( setColor( const TQColor&)));
+
+  tl_layout->activate();
+  page->setMinimumSize( page->tqsizeHint() );
+
+  readSettings();
+  d->bRecursion = false;
+  d->bEditHsv = false;
+  d->bEditRgb = false;
+  d->bEditHtml = false;
+
+  disableResize();
+  KColor col;
+  col.setHsv( 0, 0, 255 );
+  _setColor( col );
+
+  d->htmlName->installEventFilter(this);
+  d->hsSelector->installEventFilter(this);
+  d->hsSelector->setAcceptDrops(true);
+}
+
+KColorDialog::~KColorDialog()
+{
+#ifdef Q_WS_X11
+    if (d->bColorPicking)
+        qt_set_x11_event_filter(d->oldfilter);
+#endif
+    delete d;
+}
+
+bool
+KColorDialog::eventFilter( TQObject *obj, TQEvent *ev )
+{
+    if ((TQT_BASE_OBJECT(obj) == TQT_BASE_OBJECT(d->htmlName)) || (TQT_BASE_OBJECT(obj) == TQT_BASE_OBJECT(d->hsSelector)))
+    switch(ev->type())
+    {
+      case TQEvent::DragEnter:
+      case TQEvent::DragMove:
+      case TQEvent::DragLeave:
+      case TQEvent::Drop:
+      case TQEvent::DragResponse:
+            tqApp->sendEvent(d->patch, ev);
+            return true;
+      default:
+            break;
+    }
+    return KDialogBase::eventFilter(obj, ev);
+}
+
+void
+KColorDialog::setDefaultColor( const TQColor& col )
+{
+    if ( !d->cbDefaultColor )
+    {
+        //
+        // a little space between
+        //
+        d->l_right->addSpacing(10);
+
+        //
+        // and the "default color" checkbox, under all items on the right side
+        //
+        d->cbDefaultColor = new TQCheckBox( i18n( "Default color" ), mainWidget() );
+        d->cbDefaultColor->setChecked(true);
+
+        d->l_right->addWidget( d->cbDefaultColor );
+
+        mainWidget()->setMaximumSize( QWIDGETSIZE_MAX, QWIDGETSIZE_MAX ); // cancel setFixedSize()
+        d->tl_layout->activate();
+        mainWidget()->setMinimumSize( mainWidget()->tqsizeHint() );
+        disableResize();
+
+        connect( d->cbDefaultColor, TQT_SIGNAL( clicked() ), TQT_SLOT( slotDefaultColorClicked() ) );
+    }
+
+    d->defaultColor = col;
+
+    slotDefaultColorClicked();
+}
+
+TQColor KColorDialog::defaultColor() const
+{
+    return d->defaultColor;
+}
+
+void KColorDialog::slotDefaultColorClicked()
+{
+    if ( d->cbDefaultColor->isChecked() )
+    {
+        d->selColor = d->defaultColor;
+        showColor( d->selColor, i18n( "-default-" ) );
+    } else
+    {
+        showColor( d->selColor, TQString::null );
+    }
+}
+
+void
+KColorDialog::readSettings()
+{
+  KConfigGroup group( KGlobal::config(), "Colors" );
+
+  TQString palette = group.readEntry("CurrentPalette");
+  d->table->setPalette(palette);
+}
+
+void
+KColorDialog::slotWriteSettings()
+{
+  KConfigGroup group( KGlobal::config(), "Colors" );
+
+  TQString palette = d->table->palette();
+  if (!group.hasDefault("CurrentPalette") &&
+      (d->table->palette() == d->originalPalette))
+  {
+     group.revertToDefault("CurrentPalette");
+  }
+  else
+  {
+     group.writeEntry("CurrentPalette", d->table->palette());
+  }
+}
+
+TQColor
+KColorDialog::color() const
+{
+  if ( d->cbDefaultColor && d->cbDefaultColor->isChecked() )
+     return TQColor();
+  if ( d->selColor.isValid() )
+    d->table->addToRecentColors( d->selColor );
+  return d->selColor;
+}
+
+void KColorDialog::setColor( const TQColor &col )
+{
+  _setColor( col );
+}
+
+//
+// static function to display dialog and return color
+//
+int KColorDialog::getColor( TQColor &theColor, TQWidget *parent )
+{
+  KColorDialog dlg( parent, "Color Selector", true );
+  if ( theColor.isValid() )
+    dlg.setColor( theColor );
+  int result = dlg.exec();
+
+  if ( result == Accepted )
+  {
+    theColor = dlg.color();
+  }
+
+  return result;
+}
+
+//
+// static function to display dialog and return color
+//
+int KColorDialog::getColor( TQColor &theColor, const TQColor& defaultCol, TQWidget *parent )
+{
+  KColorDialog dlg( parent, "Color Selector", true );
+  dlg.setDefaultColor( defaultCol );
+  dlg.setColor( theColor );
+  int result = dlg.exec();
+
+  if ( result == Accepted )
+    theColor = dlg.color();
+
+  return result;
+}
+
+void KColorDialog::slotRGBChanged( void )
+{
+  if (d->bRecursion) return;
+  int red = d->redit->value();
+  int grn = d->gedit->value();
+  int blu = d->bedit->value();
+
+  if ( red > 255 || red < 0 ) return;
+  if ( grn > 255 || grn < 0 ) return;
+  if ( blu > 255 || blu < 0 ) return;
+
+  KColor col;
+  col.setRgb( red, grn, blu );
+  d->bEditRgb = true;
+  _setColor( col );
+  d->bEditRgb = false;
+}
+
+void KColorDialog::slotHtmlChanged( void )
+{
+  if (d->bRecursion || d->htmlName->text().isEmpty()) return;
+
+  TQString strColor( d->htmlName->text() );
+
+  // Assume that a user does not want to type the # all the time
+  if ( strColor[0] != '#' )
+  {
+    bool signalsblocked = d->htmlName->signalsBlocked();
+    d->htmlName->blockSignals(true);
+    strColor.prepend("#");
+    d->htmlName->setText(strColor);
+    d->htmlName->blockSignals(signalsblocked);
+  }
+
+  const TQColor color( strColor );
+
+  if ( color.isValid() )
+  {
+    KColor col( color );
+    d->bEditHtml = true;
+    _setColor( col );
+    d->bEditHtml = false;
+  }
+}
+
+void KColorDialog::slotHSVChanged( void )
+{
+  if (d->bRecursion) return;
+  int hue = d->hedit->value();
+  int sat = d->sedit->value();
+  int val = d->vedit->value();
+
+  if ( hue > 359 || hue < 0 ) return;
+  if ( sat > 255 || sat < 0 ) return;
+  if ( val > 255 || val < 0 ) return;
+
+  KColor col;
+  col.setHsv( hue, sat, val );
+  d->bEditHsv = true;
+  _setColor( col );
+  d->bEditHsv = false;
+}
+
+void KColorDialog::slotHSChanged( int h, int s )
+{
+  int _h, _s, v;
+  d->selColor.hsv(&_h, &_s, &v);
+  if (v < 0)
+     v = 0;
+  KColor col;
+  col.setHsv( h, s, v );
+  _setColor( col );
+}
+
+void KColorDialog::slotVChanged( int v )
+{
+  int h, s, _v;
+  d->selColor.hsv(&h, &s, &_v);
+  KColor col;
+  col.setHsv( h, s, v );
+  _setColor( col );
+}
+
+void KColorDialog::slotColorSelected( const TQColor &color )
+{
+  _setColor( color );
+}
+
+void KColorDialog::slotAddToCustomColors( )
+{
+  d->table->addToCustomColors( d->selColor );
+}
+
+void KColorDialog::slotColorSelected( const TQColor &color, const TQString &name )
+{
+  _setColor( color, name);
+}
+
+void KColorDialog::slotColorDoubleClicked
+(
+  const TQColor  & color,
+  const TQString & name
+)
+{
+  _setColor(color, name);
+  accept();
+}
+
+void KColorDialog::_setColor(const KColor &color, const TQString &name)
+{
+  if (color.isValid())
+  {
+     if (d->cbDefaultColor && d->cbDefaultColor->isChecked())
+        d->cbDefaultColor->setChecked(false);
+     d->selColor = color;
+  }
+  else
+  {
+     if (d->cbDefaultColor && d->cbDefaultColor->isChecked())
+        d->cbDefaultColor->setChecked(true);
+     d->selColor = d->defaultColor;
+  }
+
+  showColor( d->selColor, name );
+
+  emit colorSelected( d->selColor );
+}
+
+// show but don't set into selColor, nor emit colorSelected
+void KColorDialog::showColor( const KColor &color, const TQString &name )
+{
+  d->bRecursion = true;
+
+  if (name.isEmpty())
+     d->colorName->setText( i18n("-unnamed-"));
+  else
+     d->colorName->setText( name );
+
+  d->patch->setColor( color );
+
+  setRgbEdit( color );
+  setHsvEdit( color );
+  setHtmlEdit( color );
+
+  int h, s, v;
+  color.hsv( &h, &s, &v );
+  d->hsSelector->setValues( h, s );
+  d->valuePal->blockSignals(true);
+  d->valuePal->setHue( h );
+  d->valuePal->setSaturation( s );
+  d->valuePal->setValue( v );
+  d->valuePal->updateContents();
+  d->valuePal->blockSignals(false);
+  d->valuePal->tqrepaint( false );
+  d->bRecursion = false;
+}
+
+
+static TQWidget *kde_color_dlg_widget = 0;
+
+#ifdef Q_WS_X11
+static int kde_color_dlg_handler(XEvent *event)
+{
+    if (event->type == ButtonRelease)
+    {
+        TQMouseEvent e( TQEvent::MouseButtonRelease, TQPoint(),
+                       TQPoint(event->xmotion.x_root, event->xmotion.y_root) , 0, 0 );
+        TQApplication::sendEvent( kde_color_dlg_widget, &e );
+        return true;
+    }
+    return false;
+}
+#endif
+void
+KColorDialog::slotColorPicker()
+{
+    d->bColorPicking = true;
+#ifdef Q_WS_X11
+    d->oldfilter = qt_set_x11_event_filter(kde_color_dlg_handler);
+#endif
+    kde_color_dlg_widget = this;
+    grabMouse( tqcrossCursor );
+    grabKeyboard();
+}
+
+void
+KColorDialog::mouseReleaseEvent( TQMouseEvent *e )
+{
+  if (d->bColorPicking)
+  {
+     d->bColorPicking = false;
+#ifdef Q_WS_X11
+     qt_set_x11_event_filter(d->oldfilter);
+     d->oldfilter = 0;
+#endif
+     releaseMouse();
+     releaseKeyboard();
+     _setColor( grabColor( e->globalPos() ) );
+     return;
+  }
+  KDialogBase::mouseReleaseEvent( e );
+}
+
+TQColor
+KColorDialog::grabColor(const TQPoint &p)
+{
+    TQWidget *desktop = TQT_TQWIDGET(TQApplication::desktop());
+    TQPixmap pm = TQPixmap::grabWindow( desktop->winId(), p.x(), p.y(), 1, 1);
+    TQImage i = pm.convertToImage();
+    return i.pixel(0,0);
+}
+
+void
+KColorDialog::keyPressEvent( TQKeyEvent *e )
+{
+  if (d->bColorPicking)
+  {
+     if (e->key() == Key_Escape)
+     {
+        d->bColorPicking = false;
+#ifdef Q_WS_X11
+        qt_set_x11_event_filter(d->oldfilter);
+        d->oldfilter = 0;
+#endif
+        releaseMouse();
+        releaseKeyboard();
+     }
+     e->accept();
+     return;
+  }
+  KDialogBase::keyPressEvent( e );
+}
+
+void KColorDialog::setRgbEdit( const KColor &col )
+{
+  if (d->bEditRgb) return;
+  int r, g, b;
+  col.rgb( &r, &g, &b );
+
+  d->redit->setValue( r );
+  d->gedit->setValue( g );
+  d->bedit->setValue( b );
+}
+
+void KColorDialog::setHtmlEdit( const KColor &col )
+{
+  if (d->bEditHtml) return;
+  int r, g, b;
+  col.rgb( &r, &g, &b );
+  TQString num;
+
+  num.sprintf("#%02X%02X%02X", r,g,b);
+  d->htmlName->setText( num );
+}
+
+
+void KColorDialog::setHsvEdit( const KColor &col )
+{
+  if (d->bEditHsv) return;
+  int h, s, v;
+  col.hsv( &h, &s, &v );
+
+  d->hedit->setValue( h );
+  d->sedit->setValue( s );
+  d->vedit->setValue( v );
+}
+
+void KHSSelector::virtual_hook( int id, void* data )
+{ KXYSelector::virtual_hook( id, data ); }
+
+void KValueSelector::virtual_hook( int id, void* data )
+{ KSelector::virtual_hook( id, data ); }
+
+void KPaletteTable::virtual_hook( int, void* )
+{ /*BASE::virtual_hook( id, data );*/ }
+
+void KColorCells::virtual_hook( int, void* )
+{ /*BASE::virtual_hook( id, data );*/ }
+
+void KColorPatch::virtual_hook( int, void* )
+{ /*BASE::virtual_hook( id, data );*/ }
+
+void KColorDialog::virtual_hook( int id, void* data )
+{ KDialogBase::virtual_hook( id, data ); }
+
+
+#include "kcolordialog.moc"
+//#endif