You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdenetwork/ksirc/colorpicker.cpp

340 lines
10 KiB

/* This file is part of the KDE project
Copyright (C) 2001 Simon Hausmann <hausmann@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.
*/
#include "colorpicker.h"
#include "ksopts.h"
#include <tqlayout.h>
#include <tqpainter.h>
#include <tqvbox.h>
#include <tqstyle.h>
#include <tqlineedit.h>
#include <tqlabel.h>
#include <tqpushbutton.h>
#include <tdelocale.h>
ColorPicker::ColorPicker( TQWidget *parent, const char *name )
: KDialogBase( parent, name, true /*modal*/, i18n( "Pick Color" ),
KDialogBase::Ok | KDialogBase::Cancel,
KDialogBase::Cancel ),
m_foregroundColor( -1 ), m_backgroundColor( -1 )
{
TQVBox *mainWidget = makeVBoxMainWidget();
TQWidget *sampleBox = new TQWidget( mainWidget );
TQHBoxLayout *sampleLayout = new TQHBoxLayout( sampleBox );
TQLabel *preview = new TQLabel( i18n( "Preview:" ), sampleBox );
sampleLayout->addWidget( preview );
m_sample = new TQLineEdit( i18n( "Sample Text" ), sampleBox );
m_sample->setFocusPolicy( TQ_NoFocus );
m_sample->setSizePolicy( TQSizePolicy( TQSizePolicy::Minimum,
m_sample->sizePolicy().verData() ) );
sampleLayout->addWidget( m_sample );
sampleLayout->addStretch();
TQHBox *box = new TQHBox( mainWidget );
TQLabel *description = new TQLabel( i18n( "&Foreground:" ), box );
ColorBar *foregroundColor = new ColorBar( ksopts->ircColors.toValueVector(), box );
description->setBuddy( foregroundColor );
box = new TQHBox( mainWidget );
description = new TQLabel( i18n( "&Background:" ), box );
ColorBar *backgroundColor = new ColorBar( ksopts->ircColors.toValueVector(), box );
description->setBuddy( backgroundColor );
TQPushButton *ok = actionButton( KDialogBase::Ok );
TQPushButton *cancel = actionButton( KDialogBase::Cancel );
setTabOrder( foregroundColor, backgroundColor );
setTabOrder( backgroundColor, ok );
setTabOrder( ok, cancel );
ok->setAutoDefault( false );
cancel->setAutoDefault( false );
connect( foregroundColor, TQT_SIGNAL( colorPicked( int ) ),
this, TQT_SLOT( setForegroundColor( int ) ) );
connect( backgroundColor, TQT_SIGNAL( colorPicked( int ) ),
this, TQT_SLOT( setBackgroundColor( int ) ) );
ok->setEnabled( false );
updateSample();
}
TQString ColorPicker::colorString() const
{
assert( m_foregroundColor != -1 );
TQString res( TQString::number( m_foregroundColor ) );
if ( m_backgroundColor != -1 )
{
res += ',';
res += TQString::number( m_backgroundColor );
}
return res;
}
void ColorPicker::setForegroundColor( int col )
{
TQPushButton * ok =actionButton( KDialogBase::Ok );
assert( ok );
ok->setEnabled( true );
m_foregroundColor = col;
updateSample();
}
void ColorPicker::setBackgroundColor( int col )
{
m_backgroundColor = col;
updateSample();
}
void ColorPicker::updateSample()
{
TQColorGroup cg( colorGroup() );
TQColor col = ksopts->textColor;
if ( m_foregroundColor != -1 )
col = ksopts->ircColors[ m_foregroundColor ];
cg.setColor( TQColorGroup::Foreground, col );
cg.setColor( TQColorGroup::Text, col );
if ( m_backgroundColor != -1 )
{
col = ksopts->ircColors[ m_backgroundColor ];
cg.setColor( TQColorGroup::Background, col );
cg.setColor( TQColorGroup::Base, col );
}
m_sample->setPalette( TQPalette( cg, cg, cg ) );
}
ColorBar::ColorBar( const TQValueVector<TQColor> &colors, TQWidget *parent,
const char *name )
: TQFrame( parent, name, WStaticContents | WRepaintNoErase ),
m_currentCell( -1 ), m_focusedCell( - 1 ), m_colors( colors ),
m_cellSize( 0 )
{
setFrameStyle( StyledPanel | Sunken );
updateCellSize();
setFocusPolicy( TQ_StrongFocus );
}
void ColorBar::drawContents( TQPainter *p )
{
int x = contentsRect().x();
int y = contentsRect().y();
for ( unsigned int i = 0; i < m_colors.size(); ++i, x += m_cellSize )
{
bool isCurrentCell = ( m_currentCell != -1 &&
i == static_cast<uint>( m_currentCell ) );
bool isFocusedCell = ( m_focusedCell != -1 &&
i == static_cast<uint>( m_focusedCell ) );
drawCell( p, x, y, m_colors[ i ], TQString::number( i ),
isFocusedCell, isCurrentCell );
}
}
void ColorBar::keyPressEvent( TQKeyEvent *ev )
{
if ( m_focusedCell == -1 ) {
TQFrame::keyPressEvent( ev );
return;
}
switch ( ev->key() )
{
case Key_Left:
if ( m_focusedCell > 1 )
m_focusedCell--;
update();
ev->accept();
return;
case Key_Right:
if ( static_cast<uint>( m_focusedCell ) < m_colors.size() - 1 )
m_focusedCell++;
update();
ev->accept();
return;
case Key_Enter:
case Key_Return:
case Key_Space:
setCurrentCell( m_focusedCell );
update();
ev->accept();
return;
default: break;
}
TQFrame::keyPressEvent( ev );
}
void ColorBar::focusInEvent( TQFocusEvent *ev )
{
if ( ev->reason() == TQFocusEvent::Tab ||
ev->reason() == TQFocusEvent::Backtab )
m_focusedCell = 0;
TQFrame::focusInEvent( ev );
}
void ColorBar::focusOutEvent( TQFocusEvent *ev )
{
if ( ev->reason() == TQFocusEvent::Tab ||
ev->reason() == TQFocusEvent::Backtab ||
ev->reason() == TQFocusEvent::Mouse )
m_focusedCell = -1;
TQFrame::focusOutEvent( ev );
}
void ColorBar::fontChange( const TQFont &oldFont )
{
updateCellSize();
TQFrame::fontChange( oldFont );
}
void ColorBar::styleChange( TQStyle &oldStyle )
{
updateCellSize();
TQFrame::styleChange( oldStyle );
}
bool ColorBar::focusNextPrevChild( bool next )
{
if ( next )
{
assert( m_focusedCell != -1 );
if ( static_cast<uint>( m_focusedCell ) < m_colors.size() - 1 )
{
m_focusedCell++;
update();
return true;
}
return TQFrame::focusNextPrevChild( next );
}
if ( m_focusedCell > 1 )
{
m_focusedCell--;
update();
return true;
}
return TQFrame::focusNextPrevChild( next );
}
void ColorBar::mousePressEvent( TQMouseEvent *ev )
{
const TQPoint &p = ev->pos();
if ( contentsRect().contains( p ) )
{
m_focusedCell = p.x() / m_cellSize;
update();
}
TQFrame::mousePressEvent( ev );
}
void ColorBar::mouseReleaseEvent( TQMouseEvent *ev )
{
if ( m_focusedCell != -1 )
{
setCurrentCell( m_focusedCell );
update();
}
TQFrame::mouseReleaseEvent( ev );
}
void ColorBar::updateCellSize()
{
setLineWidth( style().pixelMetric( TQStyle::PM_DefaultFrameWidth, this ) );
TQFontMetrics metrics( font() );
m_cellSize = metrics.width( TQString::number( m_colors.size() ) ) +
( s_indicatorSize * 2 ) +
( s_focusSize * 2 ) +
( s_innerMargin * 2 );
setFixedSize( TQSize( ( m_colors.size() * m_cellSize ) + ( frameWidth() * 2 ),
m_cellSize + ( frameWidth() * 2 ) ) );
}
void ColorBar::setCurrentCell( int cell )
{
m_currentCell = cell;
emit colorPicked( cell );
}
void ColorBar::drawCell( TQPainter *p, int x, int y, const TQColor &color,
const TQString &text, bool isFocusedCell,
bool isCurrentCell )
{
p->fillRect( x, y, m_cellSize, m_cellSize, color );
TQColor penColor = black;
// ### hack
if ( color.red() < 127 && color.green() < 127 && color.blue() < 127 )
penColor = white;
p->setPen( penColor );
if ( isCurrentCell )
{
p->fillRect( x, y, m_cellSize, s_indicatorSize, penColor );
p->fillRect( x, y + s_indicatorSize,
s_indicatorSize, m_cellSize - ( 2 * s_indicatorSize ), penColor );
p->fillRect( x, y + m_cellSize - s_indicatorSize,
m_cellSize, s_indicatorSize, penColor );
p->fillRect( x + m_cellSize - s_indicatorSize, y + s_indicatorSize,
s_indicatorSize, m_cellSize - ( 2 * s_indicatorSize ), penColor );
}
if ( isFocusedCell )
{
int focusRectSize = m_cellSize - ( 2 * s_indicatorSize );
p->fillRect( x + s_indicatorSize, y + s_indicatorSize,
focusRectSize, s_focusSize, penColor );
p->fillRect( x + s_indicatorSize, y + s_indicatorSize + s_focusSize,
s_focusSize, focusRectSize - ( 2 * s_focusSize ), penColor );
p->fillRect( x + s_indicatorSize,
y + m_cellSize - s_indicatorSize - s_focusSize,
focusRectSize, s_focusSize, penColor );
p->fillRect( x + m_cellSize - s_indicatorSize - s_focusSize,
y + s_indicatorSize + s_focusSize,
s_focusSize, focusRectSize - ( 2 * s_focusSize ), penColor );
}
TQFontMetrics metrics( p->font() );
int offset = ( m_cellSize / 2 ) - ( metrics.width( text ) / 2 );
p->drawText( x + offset, y + s_focusSize + s_indicatorSize +
+ metrics.ascent(), text );
}
#include "colorpicker.moc"