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.
2290 lines
78 KiB
2290 lines
78 KiB
15 years ago
|
/* This file is part of the KDE project
|
||
|
Copyright (C) 1998, 1999 Reginald Stadlbauer <reggie@kde.org>
|
||
|
Copyright (C) 2005 Martin Ellis <martin.ellis@kdemail.net>
|
||
|
Copyright (C) 2006 Thomas Zander <zander@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 "KoParagDia.h"
|
||
|
#include "KoParagDia_p.h"
|
||
|
#include "KoDocument.h"
|
||
|
#include "KoTextFormat.h"
|
||
|
#include "KoTextParag.h"
|
||
|
#include "KoTextDocument.h"
|
||
|
#include "KoTextZoomHandler.h"
|
||
|
#include "KoParagDecorationTab.h"
|
||
|
|
||
|
#include <KoCharSelectDia.h>
|
||
|
#include <KoUnitWidgets.h>
|
||
|
#include <kcolorbutton.h>
|
||
|
#include <kdebug.h>
|
||
|
#include <kiconloader.h>
|
||
|
#include <klocale.h>
|
||
|
#include <knumvalidator.h>
|
||
|
#include <KoGlobal.h>
|
||
|
#include <qgroupbox.h>
|
||
|
#include <knuminput.h>
|
||
|
#include <kdeversion.h>
|
||
|
#include <kpushbutton.h>
|
||
|
#include <kcombobox.h>
|
||
|
|
||
|
#include <qcheckbox.h>
|
||
|
#include <qcombobox.h>
|
||
|
#include <qhbuttongroup.h>
|
||
|
#include <qlabel.h>
|
||
|
#include <qradiobutton.h>
|
||
|
#include <qvbox.h>
|
||
|
#include <qhbox.h>
|
||
|
#include <qtooltip.h>
|
||
|
#include <qlayout.h>
|
||
|
#include <qapplication.h>
|
||
|
#include <qwidgetstack.h>
|
||
|
|
||
|
KoCounterStyleWidget::KoCounterStyleWidget( bool displayDepth, bool onlyStyleTypeLetter, bool disableAll, QWidget * parent, const char* name )
|
||
|
:QWidget( parent, name ),
|
||
|
stylesList()
|
||
|
{
|
||
|
noSignals = true;
|
||
|
styleBuffer = 999;
|
||
|
QVBoxLayout *vbox = new QVBoxLayout( this,0, 0/*KDialog::marginHint(), KDialog::spacingHint()*/ );
|
||
|
gStyle = new QGroupBox( i18n( "St&yle" ), this, "styleLayout" );
|
||
|
vbox->addWidget( gStyle);
|
||
|
QGridLayout * grid = new QGridLayout(gStyle, 12, 5, KDialog::marginHint(), KDialog::spacingHint());
|
||
|
grid->addRowSpacing(0, fontMetrics().height()/2);
|
||
|
|
||
|
makeCounterRepresenterList( stylesList, onlyStyleTypeLetter );
|
||
|
|
||
|
lstStyle = new QListBox( gStyle, "styleListBox" );
|
||
|
grid->addMultiCellWidget( lstStyle, 1, 11, 0, 0);
|
||
|
fillStyleCombo();
|
||
|
connect( lstStyle, SIGNAL( selectionChanged() ), this, SLOT( numStyleChanged() ) );
|
||
|
|
||
|
|
||
|
QLabel *lPrefix = new QLabel( gStyle, "lPrefix" );
|
||
|
lPrefix->setText( i18n( "Pre&fix text:" ) );
|
||
|
grid->addWidget( lPrefix, 1, 1);
|
||
|
|
||
|
sPrefix = new QLineEdit( gStyle, "sPrefix" );
|
||
|
lPrefix->setBuddy( sPrefix );
|
||
|
grid->addWidget( sPrefix, 1, 2);
|
||
|
|
||
|
QLabel *lSuffix = new QLabel( gStyle, "lSuffix" );
|
||
|
lSuffix->setText( i18n( "Suffi&x text:" ) );
|
||
|
grid->addWidget( lSuffix, 1, 3);
|
||
|
|
||
|
sSuffix = new QLineEdit( gStyle, "sSuffix" );
|
||
|
lSuffix->setBuddy( sSuffix );
|
||
|
grid->addWidget( sSuffix, 1, 4 );
|
||
|
|
||
|
lStart = new QLabel( gStyle, "lStart" );
|
||
|
lStart->setText( i18n( "&Start at:" ) );
|
||
|
grid->addWidget( lStart, 2, 1 );
|
||
|
|
||
|
|
||
|
spnDepth = new QSpinBox( 0, 15, 1, gStyle );
|
||
|
if ( displayDepth )
|
||
|
grid->addWidget( spnDepth, 3, 2 );
|
||
|
else
|
||
|
spnDepth->hide();
|
||
|
|
||
|
spnDisplayLevels = new QSpinBox( 0, 15, 1, gStyle );
|
||
|
spnDisplayLevels->setMinValue( 1 );
|
||
|
if ( displayDepth )
|
||
|
grid->addWidget( spnDisplayLevels, 3, 4 );
|
||
|
else
|
||
|
spnDisplayLevels->hide();
|
||
|
|
||
|
|
||
|
QHBoxLayout *customCharBox = new QHBoxLayout(0, 0, 6);
|
||
|
lCustom = new QLabel( i18n( "Custo&m character:" ), gStyle, "custom char label" );
|
||
|
customCharBox->addWidget( lCustom );
|
||
|
|
||
|
bCustom = new QPushButton( "", gStyle, "bCustom" );
|
||
|
lCustom->setBuddy( bCustom );
|
||
|
customCharBox->addWidget( bCustom );
|
||
|
connect( bCustom, SIGNAL( clicked() ), this, SLOT( selectCustomBullet() ) );
|
||
|
|
||
|
QSpacerItem* spacer_2 = new QSpacerItem( 0, 0, QSizePolicy::Expanding, QSizePolicy::Minimum );
|
||
|
customCharBox->addItem( spacer_2 );
|
||
|
|
||
|
grid->addMultiCellLayout(customCharBox, 4, 4, 1, 4, Qt::AlignLeft);
|
||
|
|
||
|
spnStart = new KoSpinBox( gStyle );
|
||
|
spnStart->setMinValue ( 1);
|
||
|
lStart->setBuddy( spnStart );
|
||
|
grid->addWidget( spnStart, 2, 2);
|
||
|
|
||
|
lAlignment = new QLabel( gStyle, "lAlignment" );
|
||
|
lAlignment->setText( i18n( "Counter alignment:" ) );
|
||
|
grid->addWidget( lAlignment, 2, 3 );
|
||
|
|
||
|
cbAlignment = new KComboBox( gStyle, "cbAlignment" );
|
||
|
cbAlignment->insertItem(i18n("Align Auto"));
|
||
|
cbAlignment->insertItem(i18n("Align Left"));
|
||
|
cbAlignment->insertItem(i18n("Align Right"));
|
||
|
cbAlignment->setCurrentItem(0);
|
||
|
grid->addWidget( cbAlignment, 2, 4 );
|
||
|
|
||
|
QLabel *lDepth = new QLabel( gStyle, "lDepth" );
|
||
|
lDepth->setText( i18n( "&Depth:" ) );
|
||
|
lDepth->setBuddy( spnDepth );
|
||
|
if ( displayDepth )
|
||
|
grid->addWidget( lDepth, 3, 1 );
|
||
|
else
|
||
|
lDepth->hide();
|
||
|
|
||
|
QLabel *lDisplayLevels = new QLabel( gStyle );
|
||
|
lDisplayLevels->setText( i18n( "Display le&vels:" ) );
|
||
|
lDisplayLevels->setBuddy( spnDisplayLevels );
|
||
|
if ( displayDepth )
|
||
|
grid->addWidget( lDisplayLevels, 3, 3 );
|
||
|
else
|
||
|
lDisplayLevels->hide();
|
||
|
|
||
|
cbRestart = new QCheckBox( i18n( "&Restart numbering at this paragraph" ), gStyle );
|
||
|
grid->addMultiCellWidget( cbRestart, 5, 5, 1, 3 );
|
||
|
|
||
|
if ( onlyStyleTypeLetter )
|
||
|
{
|
||
|
lCustom->hide();
|
||
|
bCustom->hide();
|
||
|
cbRestart->hide();
|
||
|
}
|
||
|
|
||
|
|
||
|
connect( cbRestart, SIGNAL( toggled(bool) ), this, SLOT( restartChanged(bool) ) );
|
||
|
|
||
|
connect( sSuffix, SIGNAL( textChanged (const QString &) ), this, SLOT( suffixChanged(const QString &) ) );
|
||
|
connect( sPrefix, SIGNAL( textChanged (const QString &) ), this, SLOT( prefixChanged(const QString &) ) );
|
||
|
connect( spnStart, SIGNAL( valueChanged (int) ), this, SLOT( startChanged(int) ) );
|
||
|
connect( spnDepth, SIGNAL( valueChanged (int) ), this, SLOT( depthChanged(int) ) );
|
||
|
connect( spnDisplayLevels, SIGNAL( valueChanged (int) ), this, SLOT( displayLevelsChanged(int) ) );
|
||
|
connect( cbAlignment, SIGNAL( activated (const QString&) ), this, SLOT( alignmentChanged(const QString&) ) );
|
||
|
noSignals = false;
|
||
|
if ( disableAll )
|
||
|
{
|
||
|
gStyle->setEnabled( false );
|
||
|
lstStyle->setEnabled( false );
|
||
|
sSuffix->setEnabled( false );
|
||
|
sPrefix->setEnabled( false );
|
||
|
bCustom->setEnabled( false );
|
||
|
spnStart->setEnabled( false );
|
||
|
spnDepth->setEnabled( false );
|
||
|
spnDisplayLevels->setEnabled( false );
|
||
|
lStart->setEnabled( false );
|
||
|
lCustom->setEnabled( false );
|
||
|
cbRestart->setEnabled( false );
|
||
|
cbAlignment->setEnabled( false );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void KoCounterStyleWidget::alignmentChanged(const QString& s)
|
||
|
{
|
||
|
int a;
|
||
|
if(s==i18n("Align Left"))
|
||
|
a=Qt::AlignLeft;
|
||
|
else if(s==i18n("Align Right"))
|
||
|
a=Qt::AlignRight;
|
||
|
else if(s==i18n("Align Auto"))
|
||
|
a=Qt::AlignAuto;
|
||
|
else {
|
||
|
kdError()<<"Not Implemented"<<endl;
|
||
|
return;
|
||
|
}
|
||
|
m_counter.setAlignment(a);
|
||
|
emit sig_alignmentChanged(a);
|
||
|
}
|
||
|
|
||
|
void KoCounterStyleWidget::setCounter( const KoParagCounter& counter )
|
||
|
{
|
||
|
noSignals = true;
|
||
|
KoParagCounter::Style st = counter.style();
|
||
|
m_counter = counter;
|
||
|
// Huh? doesn't the line above do this already?
|
||
|
//m_counter.setStyle( st );
|
||
|
changeKWSpinboxType( st);
|
||
|
displayStyle( st );
|
||
|
noSignals = false;
|
||
|
}
|
||
|
|
||
|
void KoCounterStyleWidget::changeKWSpinboxType(KoParagCounter::Style st) {
|
||
|
switch(st)
|
||
|
{
|
||
|
case KoParagCounter::STYLE_NONE:
|
||
|
spnStart->setCounterType(KoSpinBox::NONE);
|
||
|
break;
|
||
|
case KoParagCounter::STYLE_NUM:
|
||
|
spnStart->setCounterType(KoSpinBox::NUM);
|
||
|
break;
|
||
|
case KoParagCounter::STYLE_ALPHAB_L:
|
||
|
spnStart->setCounterType(KoSpinBox::ALPHAB_L);
|
||
|
break;
|
||
|
case KoParagCounter::STYLE_ALPHAB_U:
|
||
|
spnStart->setCounterType(KoSpinBox::ALPHAB_U);
|
||
|
break;
|
||
|
case KoParagCounter::STYLE_ROM_NUM_L:
|
||
|
spnStart->setCounterType(KoSpinBox::ROM_NUM_L);
|
||
|
break;
|
||
|
case KoParagCounter::STYLE_ROM_NUM_U:
|
||
|
spnStart->setCounterType(KoSpinBox::ROM_NUM_U);
|
||
|
break;
|
||
|
default:
|
||
|
spnStart->setCounterType(KoSpinBox::NONE);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void KoCounterStyleWidget::fillStyleCombo(KoParagCounter::Numbering type) {
|
||
|
if(lstStyle==NULL) return;
|
||
|
noSignals=true;
|
||
|
unsigned int cur = lstStyle->currentItem();
|
||
|
lstStyle->clear();
|
||
|
QPtrListIterator<StyleRepresenter> style( stylesList );
|
||
|
while ( style.current() ) {
|
||
|
if(style.current()->style() == KoParagCounter::STYLE_NONE) {
|
||
|
if(type == KoParagCounter::NUM_NONE)
|
||
|
lstStyle->insertItem( style.current()->name() );
|
||
|
}
|
||
|
else if(type == KoParagCounter::NUM_LIST || !style.current()->isBullet())
|
||
|
if(type != KoParagCounter::NUM_NONE)
|
||
|
lstStyle->insertItem( style.current()->name() );
|
||
|
++style;
|
||
|
}
|
||
|
|
||
|
if(styleBuffer <= lstStyle->count())
|
||
|
lstStyle->setCurrentItem(styleBuffer);
|
||
|
else
|
||
|
if(cur <= lstStyle->count())
|
||
|
lstStyle->setCurrentItem(cur);
|
||
|
|
||
|
if(cur > lstStyle->count()) {
|
||
|
styleBuffer = cur;
|
||
|
}
|
||
|
noSignals=false;
|
||
|
}
|
||
|
|
||
|
void KoCounterStyleWidget::displayStyle( KoParagCounter::Style style )
|
||
|
{
|
||
|
unsigned int i = 0;
|
||
|
while ( stylesList.count() > i && stylesList.at(i)->style() != style )
|
||
|
++i;
|
||
|
lstStyle->setCurrentItem(i);
|
||
|
|
||
|
bCustom->setText( m_counter.customBulletCharacter() );
|
||
|
if ( !m_counter.customBulletFont().isEmpty() )
|
||
|
bCustom->setFont( QFont( m_counter.customBulletFont() ) );
|
||
|
|
||
|
sPrefix->setText( m_counter.prefix() );
|
||
|
sSuffix->setText( m_counter.suffix() );
|
||
|
|
||
|
spnDepth->setValue( m_counter.depth() );
|
||
|
spnDisplayLevels->setValue( m_counter.displayLevels() );
|
||
|
spnStart->setValue( m_counter.startNumber() );
|
||
|
|
||
|
cbRestart->setChecked( m_counter.restartCounter() );
|
||
|
if(m_counter.alignment()==Qt::AlignLeft)
|
||
|
cbAlignment->setCurrentText(i18n("Align Left"));
|
||
|
else if(m_counter.alignment()==Qt::AlignRight)
|
||
|
cbAlignment->setCurrentText(i18n("Align Right"));
|
||
|
else if(m_counter.alignment()==Qt::AlignAuto)
|
||
|
cbAlignment->setCurrentText(i18n("Align Auto"));
|
||
|
else
|
||
|
kdError()<<"Not Implemented"<<endl;
|
||
|
}
|
||
|
|
||
|
void KoCounterStyleWidget::display( const KoParagLayout & lay ) {
|
||
|
KoParagCounter::Style style = KoParagCounter::STYLE_NONE;
|
||
|
if ( lay.counter )
|
||
|
{
|
||
|
style=lay.counter->style();
|
||
|
m_counter = *lay.counter;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_counter = KoParagCounter();
|
||
|
}
|
||
|
styleBuffer = 999;
|
||
|
|
||
|
numTypeChanged( m_counter.numbering() );
|
||
|
emit sig_numTypeChanged( m_counter.numbering() );
|
||
|
|
||
|
displayStyle( style );
|
||
|
}
|
||
|
|
||
|
|
||
|
void KoCounterStyleWidget::numTypeChanged( int nType ) {
|
||
|
m_counter.setNumbering( static_cast<KoParagCounter::Numbering>( nType ) );
|
||
|
gStyle->setEnabled( m_counter.numbering() != KoParagCounter::NUM_NONE );
|
||
|
fillStyleCombo(m_counter.numbering());
|
||
|
bool state=m_counter.numbering()==KoParagCounter::NUM_LIST;
|
||
|
bCustom->setEnabled(state);
|
||
|
lCustom->setEnabled(state);
|
||
|
}
|
||
|
|
||
|
|
||
|
void KoCounterStyleWidget::makeCounterRepresenterList( QPtrList<StyleRepresenter>& stylesList, bool onlyStyleTypeLetter )
|
||
|
{
|
||
|
stylesList.setAutoDelete( true );
|
||
|
stylesList.append( new StyleRepresenter(i18n( "Arabic Numbers" )
|
||
|
, KoParagCounter::STYLE_NUM));
|
||
|
stylesList.append( new StyleRepresenter(i18n( "Lower Alphabetical" )
|
||
|
, KoParagCounter::STYLE_ALPHAB_L ));
|
||
|
stylesList.append( new StyleRepresenter(i18n( "Upper Alphabetical" )
|
||
|
, KoParagCounter::STYLE_ALPHAB_U ));
|
||
|
stylesList.append( new StyleRepresenter(i18n( "Lower Roman Numbers" )
|
||
|
, KoParagCounter::STYLE_ROM_NUM_L ));
|
||
|
stylesList.append( new StyleRepresenter(i18n( "Upper Roman Numbers" )
|
||
|
, KoParagCounter::STYLE_ROM_NUM_U ));
|
||
|
if ( !onlyStyleTypeLetter )
|
||
|
{
|
||
|
stylesList.append( new StyleRepresenter(i18n( "Disc Bullet" )
|
||
|
, KoParagCounter::STYLE_DISCBULLET , true));
|
||
|
stylesList.append( new StyleRepresenter(i18n( "Square Bullet" )
|
||
|
, KoParagCounter::STYLE_SQUAREBULLET , true));
|
||
|
stylesList.append( new StyleRepresenter(i18n( "Box Bullet" )
|
||
|
, KoParagCounter::STYLE_BOXBULLET , true));
|
||
|
stylesList.append( new StyleRepresenter(i18n( "Circle Bullet" )
|
||
|
, KoParagCounter::STYLE_CIRCLEBULLET , true));
|
||
|
stylesList.append( new StyleRepresenter(i18n( "Custom Bullet" )
|
||
|
, KoParagCounter::STYLE_CUSTOMBULLET , true));
|
||
|
}
|
||
|
stylesList.append( new StyleRepresenter(i18n( "None" ), KoParagCounter::STYLE_NONE));
|
||
|
}
|
||
|
|
||
|
|
||
|
void KoCounterStyleWidget::selectCustomBullet() {
|
||
|
unsigned int i = 0;
|
||
|
while ( stylesList.count() > i && stylesList.at(i)->style() != KoParagCounter::STYLE_CUSTOMBULLET )
|
||
|
++i;
|
||
|
lstStyle->setCurrentItem(i);
|
||
|
|
||
|
QString f = m_counter.customBulletFont();
|
||
|
if ( f.isEmpty() )
|
||
|
f = "symbol";
|
||
|
QChar c = m_counter.customBulletCharacter();
|
||
|
|
||
|
if ( KoCharSelectDia::selectChar( f, c ) ) {
|
||
|
emit changeCustomBullet( f, c );
|
||
|
m_counter.setCustomBulletFont( f );
|
||
|
m_counter.setCustomBulletCharacter( c );
|
||
|
if ( !f.isEmpty() )
|
||
|
bCustom->setFont( QFont( f ) );
|
||
|
bCustom->setText( c );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void KoCounterStyleWidget::numStyleChanged() {
|
||
|
if ( noSignals )
|
||
|
return;
|
||
|
// We selected another style from the list box.
|
||
|
styleBuffer = 999;
|
||
|
StyleRepresenter *sr = stylesList.at(lstStyle->currentItem());
|
||
|
emit changeStyle( sr->style() );
|
||
|
m_counter.setStyle( sr->style() );
|
||
|
bool isNumbered = !sr->isBullet() && !sr->style() == KoParagCounter::STYLE_NONE;
|
||
|
lStart->setEnabled( isNumbered );
|
||
|
spnStart->setEnabled( isNumbered );
|
||
|
cbRestart->setEnabled( isNumbered );
|
||
|
spnDisplayLevels->setEnabled( isNumbered );
|
||
|
changeKWSpinboxType(sr->style() );
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
KoSpinBox::KoSpinBox( QWidget * parent, const char * name )
|
||
|
: QSpinBox(parent,name)
|
||
|
{
|
||
|
m_Etype=NONE;
|
||
|
//max value supported by roman number
|
||
|
setMaxValue ( 3999 );
|
||
|
}
|
||
|
KoSpinBox::~KoSpinBox( )
|
||
|
{
|
||
|
}
|
||
|
|
||
|
KoSpinBox::KoSpinBox( int minValue, int maxValue, int step ,
|
||
|
QWidget * parent , const char * name )
|
||
|
: QSpinBox(minValue, maxValue,step ,
|
||
|
parent , name)
|
||
|
{
|
||
|
m_Etype=NONE;
|
||
|
}
|
||
|
|
||
|
void KoSpinBox::setCounterType(counterType _type)
|
||
|
{
|
||
|
m_Etype=_type;
|
||
|
editor()->setText(mapValueToText(value()));
|
||
|
}
|
||
|
|
||
|
|
||
|
QString KoSpinBox::mapValueToText( int value )
|
||
|
{
|
||
|
if(value==0 && m_Etype==NUM)
|
||
|
return QString("0");
|
||
|
else if(value==0 && m_Etype!=NUM)
|
||
|
return QString::null;
|
||
|
switch(m_Etype)
|
||
|
{
|
||
|
case NUM:
|
||
|
return QString::number(value);
|
||
|
case ALPHAB_L:
|
||
|
return KoParagCounter::makeAlphaLowerNumber( value );
|
||
|
case ALPHAB_U:
|
||
|
return KoParagCounter::makeAlphaUpperNumber( value );
|
||
|
case ROM_NUM_L:
|
||
|
return KoParagCounter::makeRomanNumber( value );
|
||
|
case ROM_NUM_U:
|
||
|
return KoParagCounter::makeRomanNumber( value ).upper();
|
||
|
case NONE:
|
||
|
default:
|
||
|
return QString::null;
|
||
|
}
|
||
|
//never here
|
||
|
return QString::null;
|
||
|
}
|
||
|
|
||
|
int KoSpinBox::mapTextToValue( bool * ok )
|
||
|
{
|
||
|
int ret;
|
||
|
QString txt = text();
|
||
|
|
||
|
*ok = TRUE;
|
||
|
switch(m_Etype)
|
||
|
{
|
||
|
case NUM:
|
||
|
ret = txt.toInt ( ok );
|
||
|
break;
|
||
|
case ALPHAB_L:
|
||
|
ret = KoParagCounter::fromAlphaLowerNumber( txt.lower() );
|
||
|
break;
|
||
|
case ALPHAB_U:
|
||
|
ret = KoParagCounter::fromAlphaUpperNumber( txt.upper() );
|
||
|
break;
|
||
|
case ROM_NUM_L:
|
||
|
ret = KoParagCounter::fromRomanNumber( txt.lower() );
|
||
|
break;
|
||
|
case ROM_NUM_U:
|
||
|
ret = KoParagCounter::fromRomanNumber( txt.lower() ); // _not_ upper()
|
||
|
break;
|
||
|
case NONE:
|
||
|
default:
|
||
|
ret = -1;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
if (ret == -1)
|
||
|
*ok = FALSE;
|
||
|
|
||
|
return ret;
|
||
|
}
|
||
|
|
||
|
|
||
|
/******************************************************************/
|
||
|
/* class KPagePreview */
|
||
|
/******************************************************************/
|
||
|
|
||
|
KPagePreview::KPagePreview( QWidget* parent, const char* name )
|
||
|
: QGroupBox( i18n( "Preview" ), parent, name )
|
||
|
{
|
||
|
left = 0;
|
||
|
right = 0;
|
||
|
first = 0;
|
||
|
spacing = 0;
|
||
|
before = 0;
|
||
|
after = 0;
|
||
|
}
|
||
|
|
||
|
void KPagePreview::drawContents( QPainter* p )
|
||
|
{
|
||
|
int wid = 148;
|
||
|
int hei = 210;
|
||
|
int _x = ( width() - wid ) / 5;
|
||
|
int _y = ( height() - hei ) / 5;
|
||
|
|
||
|
int dl = convert(left);
|
||
|
int dr = convert(right);
|
||
|
|
||
|
//first+left because firstlineIndent is relative to leftIndent
|
||
|
int df = convert(first + left);
|
||
|
|
||
|
int spc = convert(spacing);
|
||
|
|
||
|
// draw page
|
||
|
p->setPen( QPen( black ) );
|
||
|
p->setBrush( QBrush( black ) );
|
||
|
|
||
|
p->drawRect( _x + 1, _y + 1, wid, hei );
|
||
|
|
||
|
p->setBrush( QBrush( white ) );
|
||
|
p->drawRect( _x, _y, wid, hei );
|
||
|
|
||
|
// draw parags
|
||
|
p->setPen( NoPen );
|
||
|
p->setBrush( QBrush( lightGray ) );
|
||
|
|
||
|
for ( int i = 1; i <= 4; i++ )
|
||
|
p->drawRect( _x + 6, _y + 6 + ( i - 1 ) * 12 + 2, wid - 12 - ( ( i / 4 ) * 4 == i ? 50 : 0 ), 6 );
|
||
|
|
||
|
p->setBrush( QBrush( darkGray ) );
|
||
|
|
||
|
for ( int i = 5; i <= 8; i++ )
|
||
|
{
|
||
|
QRect rect( ( i == 5 ? df : dl ) + _x + 6, _y + 6 + ( i - 1 ) * 12 + 2 + ( i - 5 ) * spc + static_cast<int>( before / 2 ),
|
||
|
wid - 12 - ( ( i / 4 ) * 4 == i ? 50 : 0 ) - ( ( i == 12 ? 0 : dr ) + ( i == 5 ? df : dl ) ), 6);
|
||
|
|
||
|
if(rect.width ()>=0)
|
||
|
p->drawRect( rect );
|
||
|
}
|
||
|
p->setBrush( QBrush( lightGray ) );
|
||
|
|
||
|
for ( int i = 9; i <= 12; i++ )
|
||
|
p->drawRect( _x + 6, _y + 6 + ( i - 1 ) * 12 + 2 + 3 * spc +
|
||
|
static_cast<int>( before / 2 ) + static_cast<int>( after / 2 ),
|
||
|
wid - 12 - ( ( i / 4 ) * 4 == i ? 50 : 0 ), 6 );
|
||
|
|
||
|
}
|
||
|
|
||
|
int KPagePreview::convert(double input) {
|
||
|
if(input < 1) return 0;
|
||
|
if(input <= 5) return 3;
|
||
|
if(input <= 10) return 4 + static_cast<int>( (input-5) / 2.5 );
|
||
|
if(input <= 20) return 6 + static_cast<int>( (input-10) / 4 );
|
||
|
if(input <= 100) return 10 + static_cast<int>( (input-20) / 8 );
|
||
|
return static_cast<int>( input / 5);
|
||
|
}
|
||
|
|
||
|
/******************************************************************/
|
||
|
/* class KPagePreview2 */
|
||
|
/******************************************************************/
|
||
|
|
||
|
KPagePreview2::KPagePreview2( QWidget* parent, const char* name )
|
||
|
: QGroupBox( i18n( "Preview" ), parent, name )
|
||
|
{
|
||
|
align = Qt::AlignLeft;
|
||
|
}
|
||
|
|
||
|
void KPagePreview2::drawContents( QPainter* p )
|
||
|
{
|
||
|
int wid = 148;
|
||
|
int hei = 210;
|
||
|
int _x = ( width() - wid ) / 2;
|
||
|
int _y = ( height() - hei ) / 2;
|
||
|
|
||
|
// draw page
|
||
|
p->setPen( QPen( black ) );
|
||
|
p->setBrush( QBrush( black ) );
|
||
|
|
||
|
p->drawRect( _x + 1, _y + 1, wid, hei );
|
||
|
|
||
|
p->setBrush( QBrush( white ) );
|
||
|
p->drawRect( _x, _y, wid, hei );
|
||
|
|
||
|
// draw parags
|
||
|
p->setPen( NoPen );
|
||
|
p->setBrush( QBrush( lightGray ) );
|
||
|
|
||
|
for ( int i = 1; i <= 4; i++ )
|
||
|
p->drawRect( _x + 6, _y + 6 + ( i - 1 ) * 12 + 2, wid - 12 - ( ( i / 4 ) * 4 == i ? 50 : 0 ), 6 );
|
||
|
|
||
|
p->setBrush( QBrush( darkGray ) );
|
||
|
|
||
|
int __x = 0, __w = 0;
|
||
|
for ( int i = 5; i <= 8; i++ ) {
|
||
|
switch ( i ) {
|
||
|
case 5: __w = wid - 12;
|
||
|
break;
|
||
|
case 6: __w = wid - 52;
|
||
|
break;
|
||
|
case 7: __w = wid - 33;
|
||
|
break;
|
||
|
case 8: __w = wid - 62;
|
||
|
default: break;
|
||
|
}
|
||
|
|
||
|
switch ( align ) {
|
||
|
case Qt::AlignAuto:
|
||
|
case Qt::AlignLeft:
|
||
|
__x = _x + 6;
|
||
|
break;
|
||
|
case Qt::AlignHCenter:
|
||
|
__x = _x + ( wid - __w ) / 2;
|
||
|
break;
|
||
|
case Qt::AlignRight:
|
||
|
__x = _x + ( wid - __w ) - 6;
|
||
|
break;
|
||
|
case Qt::AlignJustify:
|
||
|
{
|
||
|
if ( i < 8 ) __w = wid - 12;
|
||
|
__x = _x + 6;
|
||
|
} break;
|
||
|
}
|
||
|
|
||
|
p->drawRect( __x, _y + 6 + ( i - 1 ) * 12 + 2 + ( i - 5 ), __w, 6 );
|
||
|
}
|
||
|
|
||
|
p->setBrush( QBrush( lightGray ) );
|
||
|
|
||
|
for ( int i = 9; i <= 12; i++ )
|
||
|
p->drawRect( _x + 6, _y + 6 + ( i - 1 ) * 12 + 2 + 3, wid - 12 - ( ( i / 4 ) * 4 == i ? 50 : 0 ), 6 );
|
||
|
|
||
|
}
|
||
|
|
||
|
/******************************************************************/
|
||
|
/* class KoBorderPreview */
|
||
|
/******************************************************************/
|
||
|
|
||
|
|
||
|
KoBorderPreview::KoBorderPreview( QWidget* parent, const char* name )
|
||
|
:QFrame(parent,name)
|
||
|
{
|
||
|
}
|
||
|
|
||
|
void KoBorderPreview::mousePressEvent( QMouseEvent *_ev )
|
||
|
{
|
||
|
emit choosearea(_ev);
|
||
|
}
|
||
|
|
||
|
void KoBorderPreview::setBorder( KoBorder::BorderType which, const KoBorder& border)
|
||
|
{
|
||
|
switch( which ) {
|
||
|
case KoBorder::TopBorder:
|
||
|
setTopBorder( border );
|
||
|
break;
|
||
|
case KoBorder::BottomBorder:
|
||
|
setBottomBorder( border );
|
||
|
break;
|
||
|
case KoBorder::LeftBorder:
|
||
|
setLeftBorder( border );
|
||
|
break;
|
||
|
case KoBorder::RightBorder:
|
||
|
setRightBorder( border );
|
||
|
break;
|
||
|
default:
|
||
|
kdError() << "KoBorderPreview: unknown border type" << endl;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void KoBorderPreview::drawContents( QPainter* painter )
|
||
|
{
|
||
|
QRect r = contentsRect();
|
||
|
QFontMetrics fm( font() );
|
||
|
|
||
|
painter->fillRect( r.x() + fm.width( 'W' ), r.y() + fm.height(), r.width() - 2 * fm.width( 'W' ),
|
||
|
r.height() - 2 * fm.height(), white );
|
||
|
painter->setClipRect( r.x() + fm.width( 'W' ), r.y() + fm.height(), r.width() - 2 * fm.width( 'W' ),
|
||
|
r.height() - 2 * fm.height() );
|
||
|
|
||
|
bool leftdouble = m_leftBorder.width() > 0 && m_leftBorder.getStyle() == KoBorder::DOUBLE_LINE;
|
||
|
bool rightdouble = m_rightBorder.width() > 0 && m_rightBorder.getStyle() == KoBorder::DOUBLE_LINE;
|
||
|
bool topdouble = m_topBorder.width() > 0 && m_topBorder.getStyle() == KoBorder::DOUBLE_LINE;
|
||
|
bool bottomdouble = m_bottomBorder.width() > 0 && m_bottomBorder.getStyle() == KoBorder::DOUBLE_LINE;
|
||
|
|
||
|
if ( m_topBorder.width() > 0 ) {
|
||
|
painter->setPen( setBorderPen( m_topBorder ) );
|
||
|
painter->drawLine( r.x() + 20, r.y() + 30, r.right() - 19, r.y() + 30 );
|
||
|
if ( m_topBorder.getStyle()==KoBorder::DOUBLE_LINE)
|
||
|
painter->drawLine( int(r.x() + 20 + ( leftdouble ? m_leftBorder.width() + 1 : 0) ),
|
||
|
int(r.y() + 30 + m_topBorder.width()+1),
|
||
|
int(r.right() - 19 - ( rightdouble ? m_rightBorder.width() + 1 : 0) ),
|
||
|
int(r.y() + 30 + m_topBorder.width()+1)
|
||
|
);
|
||
|
}
|
||
|
|
||
|
if ( m_bottomBorder.width() > 0 ) {
|
||
|
painter->setPen( setBorderPen( m_bottomBorder ) );
|
||
|
painter->drawLine( r.x() + 20, r.bottom() - 30, r.right() - 19, r.bottom() - 30 );
|
||
|
if ( m_bottomBorder.getStyle()==KoBorder::DOUBLE_LINE)
|
||
|
painter->drawLine( int(r.x() + 20 + ( leftdouble ? m_leftBorder.width() + 1 : 0) ),
|
||
|
int(r.bottom() - 30 - m_bottomBorder.width()-1),
|
||
|
int(r.right() - 19 - ( rightdouble ? m_rightBorder.width() + 1 : 0) ),
|
||
|
int(r.bottom() - 30 - m_bottomBorder.width() - 1)
|
||
|
);
|
||
|
}
|
||
|
|
||
|
if ( m_leftBorder.width() > 0 ) {
|
||
|
painter->setPen( setBorderPen( m_leftBorder ) );
|
||
|
painter->drawLine( r.x() + 20, r.y() + 30, r.x() + 20, r.bottom() - 29 );
|
||
|
if ( m_leftBorder.getStyle()==KoBorder::DOUBLE_LINE)
|
||
|
painter->drawLine( int(r.x() + 20 + m_leftBorder.width() +1),
|
||
|
int(r.y() + 30 + ( topdouble ? m_topBorder.width() + 1 : 0) ),
|
||
|
int(r.x() + 20 + m_leftBorder.width() +1),
|
||
|
int(r.bottom() - 29 - ( bottomdouble ? m_bottomBorder.width() + 1 : 0) )
|
||
|
);
|
||
|
}
|
||
|
|
||
|
if ( m_rightBorder.width() > 0 ) {
|
||
|
painter->setPen( setBorderPen( m_rightBorder ) );
|
||
|
painter->drawLine( r.right() - 20, r.y() + 30, r.right() - 20, r.bottom() - 29 );
|
||
|
if ( m_rightBorder.getStyle()==KoBorder::DOUBLE_LINE)
|
||
|
painter->drawLine( int(r.right() - 20 - m_rightBorder.width() - 1 ),
|
||
|
int(r.y() + 30 + ( topdouble ? m_topBorder.width() + 1 : 0) ),
|
||
|
int(r.right() - 20 - m_rightBorder.width() - 1),
|
||
|
int(r.bottom() - 29 - ( bottomdouble ? m_bottomBorder.width() + 1 : 0) )
|
||
|
);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
QPen KoBorderPreview::setBorderPen( KoBorder _brd )
|
||
|
{
|
||
|
QPen pen( black, 1, SolidLine );
|
||
|
|
||
|
pen.setWidth( static_cast<int>( _brd.penWidth() ) );
|
||
|
pen.setColor( _brd.color );
|
||
|
|
||
|
switch ( _brd.getStyle() ) {
|
||
|
case KoBorder::SOLID:
|
||
|
pen.setStyle( SolidLine );
|
||
|
break;
|
||
|
case KoBorder::DASH:
|
||
|
pen.setStyle( DashLine );
|
||
|
break;
|
||
|
case KoBorder::DOT:
|
||
|
pen.setStyle( DotLine );
|
||
|
break;
|
||
|
case KoBorder::DASH_DOT:
|
||
|
pen.setStyle( DashDotLine );
|
||
|
break;
|
||
|
case KoBorder::DASH_DOT_DOT:
|
||
|
pen.setStyle( DashDotDotLine );
|
||
|
break;
|
||
|
case KoBorder::DOUBLE_LINE:
|
||
|
pen.setStyle( SolidLine );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
return QPen( pen );
|
||
|
}
|
||
|
|
||
|
/******************************************************************/
|
||
|
/* Class: KoStylePreview. Previewing text with style ;) */
|
||
|
/******************************************************************/
|
||
|
class MyFlow : public KoTextFlow {
|
||
|
public:
|
||
|
MyFlow(QWidget *parent, KoTextZoomHandler *zoom) {
|
||
|
m_parent = parent;
|
||
|
m_zoomHandler = zoom;
|
||
|
}
|
||
|
int availableHeight() const {
|
||
|
return m_zoomHandler->pixelToLayoutUnitY(m_parent->height());
|
||
|
}
|
||
|
private:
|
||
|
QWidget *m_parent;
|
||
|
KoTextZoomHandler *m_zoomHandler;
|
||
|
};
|
||
|
|
||
|
KoStylePreview::KoStylePreview( const QString& title, const QString& text, QWidget* parent, const char* name )
|
||
|
: QGroupBox( title, parent, name )
|
||
|
{
|
||
|
setMinimumHeight(80);
|
||
|
m_zoomHandler = new KoTextZoomHandler;
|
||
|
QFont font = KoGlobal::defaultFont();
|
||
|
m_textdoc = new KoTextDocument( m_zoomHandler, new KoTextFormatCollection( font, QColor(), KGlobal::locale()->language(), false ) );
|
||
|
|
||
|
m_textdoc->setFlow( new MyFlow(this, m_zoomHandler) );
|
||
|
//m_textdoc->setWidth( KoTextZoomHandler::ptToLayoutUnitPt( 1000 ) );
|
||
|
KoTextParag * parag = m_textdoc->firstParag();
|
||
|
parag->insert( 0, text );
|
||
|
}
|
||
|
|
||
|
KoStylePreview::~KoStylePreview()
|
||
|
{
|
||
|
delete m_textdoc;
|
||
|
delete m_zoomHandler;
|
||
|
}
|
||
|
|
||
|
void KoStylePreview::setCounter( const KoParagCounter & counter )
|
||
|
{
|
||
|
KoTextParag * parag = m_textdoc->firstParag();
|
||
|
parag->setCounter( counter );
|
||
|
repaint( true );
|
||
|
}
|
||
|
|
||
|
void KoStylePreview::setStyle( KoParagStyle * style )
|
||
|
{
|
||
|
KoTextParag * parag = m_textdoc->firstParag();
|
||
|
parag->applyStyle( style );
|
||
|
repaint(true);
|
||
|
}
|
||
|
|
||
|
void KoStylePreview::drawContents( QPainter *painter )
|
||
|
{
|
||
|
painter->save();
|
||
|
QRect r = contentsRect();
|
||
|
//kdDebug(32500) << "KoStylePreview::drawContents contentsRect=" << DEBUGRECT(r) << endl;
|
||
|
|
||
|
QRect whiteRect( r.x() + 10, r.y() + 10,
|
||
|
r.width() - 20, r.height() - 20 );
|
||
|
QColorGroup cg = QApplication::palette().active();
|
||
|
painter->fillRect( whiteRect, cg.brush( QColorGroup::Base ) );
|
||
|
|
||
|
KoTextParag * parag = m_textdoc->firstParag();
|
||
|
int widthLU = m_zoomHandler->pixelToLayoutUnitX( whiteRect.width() - 2 ); // keep one pixel border horizontally
|
||
|
if ( m_textdoc->width() != widthLU )
|
||
|
{
|
||
|
// For centering to work, and to even get word wrapping when the thing is too big :)
|
||
|
m_textdoc->setWidth( widthLU );
|
||
|
parag->invalidate(0);
|
||
|
}
|
||
|
|
||
|
parag->format();
|
||
|
QRect textRect = parag->pixelRect( m_zoomHandler );
|
||
|
|
||
|
// Center vertically, but not horizontally, to keep the parag alignment working,
|
||
|
textRect.moveTopLeft( QPoint( whiteRect.x(),
|
||
|
whiteRect.y() + ( whiteRect.height() - textRect.height() ) / 2 ) );
|
||
|
// Move it from the left border a little
|
||
|
textRect.rLeft() += 4;
|
||
|
textRect.rRight() += 4;
|
||
|
//kdDebug(32500) << "KoStylePreview::drawContents textRect=" << DEBUGRECT(textRect)
|
||
|
// << " textSize=" << textSize.width() << "," << textSize.height() << endl;
|
||
|
painter->setClipRect( textRect.intersect( whiteRect ) );
|
||
|
painter->translate( textRect.x(), textRect.y() );
|
||
|
|
||
|
m_textdoc->drawWYSIWYG( painter, 0, 0, textRect.width(), textRect.height(), cg, m_zoomHandler );
|
||
|
painter->restore();
|
||
|
}
|
||
|
|
||
|
KoIndentSpacingWidget::KoIndentSpacingWidget( KoUnit::Unit unit, double _frameWidth,QWidget * parent, const char * name )
|
||
|
: KoParagLayoutWidget( KoParagDia::PD_SPACING, parent, name ), m_unit( unit )
|
||
|
{
|
||
|
QString unitName = KoUnit::unitName( m_unit );
|
||
|
QGridLayout *mainGrid = new QGridLayout( this, 3, 2, KDialog::marginHint(), KDialog::spacingHint() );
|
||
|
|
||
|
// mainGrid gives equal space to each groupbox, apparently
|
||
|
// I tried setRowStretch but the result is awful (much space between them and not equal!)
|
||
|
// Any other way (in order to make the 2nd, the one with a single checkbox, a bit
|
||
|
// smaller than the other 3) ? (DF)
|
||
|
|
||
|
|
||
|
// --------------- indent ---------------
|
||
|
double frameWidth=_frameWidth;
|
||
|
QString length;
|
||
|
if(frameWidth==-1) {
|
||
|
frameWidth=9999;
|
||
|
} else {
|
||
|
length=i18n("Frame width: %1 %2")
|
||
|
.arg(KoUnit::toUserStringValue(frameWidth,m_unit))
|
||
|
.arg(KoUnit::unitName(m_unit));
|
||
|
frameWidth=KoUnit::toUserValue(frameWidth,m_unit);
|
||
|
}
|
||
|
|
||
|
QGroupBox * indentFrame = new QGroupBox( i18n( "Indent" ), this );
|
||
|
QGridLayout * indentGrid = new QGridLayout( indentFrame, 5, 2, KDialog::marginHint(), KDialog::spacingHint() );
|
||
|
|
||
|
QLabel * lLimit = new QLabel(length , indentFrame );
|
||
|
if(frameWidth!=-1)
|
||
|
{
|
||
|
lLimit->setAlignment( AlignRight );
|
||
|
indentGrid->addWidget( lLimit, 1,0 );
|
||
|
}
|
||
|
|
||
|
QLabel * lLeft = new QLabel( i18n("&Left:"), indentFrame );
|
||
|
lLeft->setAlignment( Qt::AlignVCenter | Qt::AlignRight );
|
||
|
indentGrid->addWidget( lLeft, 1, 0 );
|
||
|
|
||
|
eLeft = new KoUnitDoubleSpinBox( indentFrame, 0, 9999, 1, 0.0, m_unit );
|
||
|
lLeft->setBuddy( eLeft );
|
||
|
indentGrid->addWidget( eLeft, 1, 1 );
|
||
|
connect( eLeft, SIGNAL( valueChangedPt(double ) ), this, SLOT( leftChanged( double ) ) );
|
||
|
|
||
|
QLabel * lRight = new QLabel( i18n("&Right:"), indentFrame );
|
||
|
lRight->setAlignment( Qt::AlignVCenter | Qt::AlignRight );
|
||
|
indentGrid->addWidget( lRight, 2, 0 );
|
||
|
|
||
|
eRight = new KoUnitDoubleSpinBox( indentFrame, 0, 9999, 1, 0.0, m_unit );
|
||
|
lRight->setBuddy( eRight );
|
||
|
indentGrid->addWidget( eRight, 2, 1 );
|
||
|
connect( eRight, SIGNAL( valueChangedPt( double ) ), this, SLOT( rightChanged( double ) ) );
|
||
|
|
||
|
QLabel * lFirstLine = new QLabel( i18n("&First line:"), indentFrame );
|
||
|
lFirstLine->setAlignment( Qt::AlignVCenter | Qt::AlignRight );
|
||
|
indentGrid->addWidget( lFirstLine, 3, 0 );
|
||
|
|
||
|
eFirstLine = new KoUnitDoubleSpinBox( indentFrame, -9999, 9999, 1, 0.0, m_unit );
|
||
|
lFirstLine->setBuddy( eFirstLine );
|
||
|
connect( eFirstLine, SIGNAL( valueChangedPt( double ) ), this, SLOT( firstChanged( double ) ) );
|
||
|
indentGrid->addWidget( eFirstLine, 3, 1 );
|
||
|
|
||
|
// grid row spacing
|
||
|
indentGrid->addRowSpacing( 0, fontMetrics().height() / 2 ); // groupbox title
|
||
|
for ( int i = 1 ; i < indentGrid->numRows() ; ++i )
|
||
|
indentGrid->setRowStretch( i, 1 );
|
||
|
mainGrid->addWidget( indentFrame, 0, 0 );
|
||
|
|
||
|
// --------------- line spacing ---------------
|
||
|
QGroupBox * spacingFrame = new QGroupBox( i18n( "Line &Spacing" ), this, "spacingFrame" );
|
||
|
QGridLayout * spacingGrid = new QGridLayout( spacingFrame, 2, 1,
|
||
|
KDialog::marginHint(), KDialog::spacingHint() );
|
||
|
|
||
|
cSpacing = new QComboBox( false, spacingFrame, "" );
|
||
|
// Keep order in sync with lineSpacingType() and display()
|
||
|
cSpacing->insertItem( i18n( "Line spacing value", "Single" ) );
|
||
|
cSpacing->insertItem( i18n( "Line spacing value", "1.5 Lines" ) );
|
||
|
cSpacing->insertItem( i18n( "Line spacing value", "Double" ) );
|
||
|
cSpacing->insertItem( i18n( "Proportional") ); // LS_MULTIPLE, called Proportional like in OO
|
||
|
cSpacing->insertItem( i18n( "Line Distance (%1)" ).arg(unitName) ); // LS_CUSTOM
|
||
|
cSpacing->insertItem( i18n( "At Least (%1)" ).arg(unitName) );
|
||
|
cSpacing->insertItem( i18n( "Fixed (%1)").arg(unitName) ); // LS_FIXED
|
||
|
|
||
|
connect( cSpacing, SIGNAL( activated( int ) ), this, SLOT( spacingActivated( int ) ) );
|
||
|
spacingGrid->addWidget( cSpacing, 1, 0 );
|
||
|
|
||
|
sSpacingStack = new QWidgetStack( spacingFrame );
|
||
|
|
||
|
eSpacing = new KoUnitDoubleSpinBox( spacingFrame, 0, 9999, CM_TO_POINT(1),
|
||
|
0.0, m_unit );
|
||
|
eSpacing->setRange( 0, 9999, 1, false);
|
||
|
connect( eSpacing, SIGNAL( valueChanged( double ) ), this, SLOT( spacingChanged( double ) ) );
|
||
|
eSpacingPercent = new KIntNumInput( 100, spacingFrame );
|
||
|
eSpacingPercent->setRange( 0, 1000, 10, false );
|
||
|
eSpacingPercent->setSuffix( " %" );
|
||
|
connect( eSpacingPercent, SIGNAL( valueChanged( int ) ), this, SLOT( spacingChanged( int ) ) );
|
||
|
|
||
|
sSpacingStack->addWidget( eSpacing );
|
||
|
sSpacingStack->addWidget( eSpacingPercent );
|
||
|
spacingGrid->addWidget( sSpacingStack, 1, 1 );
|
||
|
|
||
|
// grid row spacing
|
||
|
spacingGrid->addRowSpacing( 0, fontMetrics().height() / 2 ); // groupbox title
|
||
|
for ( int i = 1 ; i < spacingGrid->numRows() ; ++i )
|
||
|
spacingGrid->setRowStretch( i, 1 );
|
||
|
mainGrid->addWidget( spacingFrame, 1, 0 );
|
||
|
|
||
|
eSpacing->setEnabled( true );
|
||
|
|
||
|
// --------------- paragraph spacing ---------------
|
||
|
QGroupBox * pSpaceFrame = new QGroupBox( i18n( "Para&graph Space" ), this, "pSpaceFrame" );
|
||
|
QGridLayout * pSpaceGrid = new QGridLayout( pSpaceFrame, 3, 2,
|
||
|
KDialog::marginHint(), KDialog::spacingHint() );
|
||
|
|
||
|
QLabel * lBefore = new QLabel( i18n("Before:"), pSpaceFrame );
|
||
|
lBefore->setAlignment( AlignRight );
|
||
|
pSpaceGrid->addWidget( lBefore, 1, 0 );
|
||
|
|
||
|
eBefore = new KoUnitDoubleSpinBox( pSpaceFrame, 0, 9999, CM_TO_POINT(1), 0.0, m_unit );
|
||
|
eBefore->setRange( 0 , 9999, 1, false);
|
||
|
connect( eBefore, SIGNAL( valueChanged( double ) ), this, SLOT( beforeChanged( double ) ) );
|
||
|
pSpaceGrid->addWidget( eBefore, 1, 1 );
|
||
|
|
||
|
QLabel * lAfter = new QLabel( i18n("After:"), pSpaceFrame );
|
||
|
lAfter->setAlignment( AlignRight );
|
||
|
pSpaceGrid->addWidget( lAfter, 2, 0 );
|
||
|
|
||
|
eAfter = new KoUnitDoubleSpinBox( pSpaceFrame, 0, 9999, 1, 0.0, m_unit );
|
||
|
eAfter->setRange( 0, 9999, 1, false);
|
||
|
connect( eAfter, SIGNAL( valueChanged( double ) ), this, SLOT( afterChanged( double ) ) );
|
||
|
pSpaceGrid->addWidget( eAfter, 2, 1 );
|
||
|
|
||
|
// grid row spacing
|
||
|
pSpaceGrid->addRowSpacing( 0, fontMetrics().height() / 2 ); // groupbox title
|
||
|
for ( int i = 1 ; i < pSpaceGrid->numRows() ; ++i )
|
||
|
pSpaceGrid->setRowStretch( i, 1 );
|
||
|
mainGrid->addWidget( pSpaceFrame, 2, 0 );
|
||
|
|
||
|
// --------------- preview --------------------
|
||
|
prev1 = new KPagePreview( this, "KPagePreview" );
|
||
|
mainGrid->addMultiCellWidget( prev1, 0, mainGrid->numRows()-1, 1, 1 );
|
||
|
|
||
|
mainGrid->setColStretch( 1, 1 );
|
||
|
//mainGrid->setRowStretch( 4, 1 );
|
||
|
}
|
||
|
|
||
|
double KoIndentSpacingWidget::leftIndent() const
|
||
|
{
|
||
|
return QMAX(0, eLeft->value() );
|
||
|
}
|
||
|
|
||
|
double KoIndentSpacingWidget::rightIndent() const
|
||
|
{
|
||
|
return QMAX(0,eRight->value() );
|
||
|
}
|
||
|
|
||
|
double KoIndentSpacingWidget::firstLineIndent() const
|
||
|
{
|
||
|
return eFirstLine->value();
|
||
|
}
|
||
|
|
||
|
double KoIndentSpacingWidget::spaceBeforeParag() const
|
||
|
{
|
||
|
return QMAX(0, eBefore->value() );
|
||
|
}
|
||
|
|
||
|
double KoIndentSpacingWidget::spaceAfterParag() const
|
||
|
{
|
||
|
return QMAX(0, eAfter->value() );
|
||
|
}
|
||
|
|
||
|
KoParagLayout::SpacingType KoIndentSpacingWidget::lineSpacingType() const
|
||
|
{
|
||
|
int index = cSpacing->currentItem();
|
||
|
switch ( index ) {
|
||
|
case 0:
|
||
|
return KoParagLayout::LS_SINGLE;
|
||
|
case 1:
|
||
|
return KoParagLayout::LS_ONEANDHALF;
|
||
|
case 2:
|
||
|
return KoParagLayout::LS_DOUBLE;
|
||
|
case 3:
|
||
|
return KoParagLayout::LS_MULTIPLE;
|
||
|
case 4:
|
||
|
return KoParagLayout::LS_CUSTOM;
|
||
|
case 5:
|
||
|
return KoParagLayout::LS_AT_LEAST;
|
||
|
case 6:
|
||
|
return KoParagLayout::LS_FIXED;
|
||
|
default:
|
||
|
kdError(32500) << "Error in KoIndentSpacingWidget::lineSpacingType" << endl;
|
||
|
return KoParagLayout::LS_SINGLE;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
double KoIndentSpacingWidget::lineSpacing() const
|
||
|
{
|
||
|
return (lineSpacingType() == KoParagLayout::LS_MULTIPLE)
|
||
|
? QMAX( 1, eSpacingPercent->value() ) / 100.0
|
||
|
: QMAX( 0, eSpacing->value() );
|
||
|
}
|
||
|
|
||
|
|
||
|
void KoIndentSpacingWidget::display( const KoParagLayout & lay )
|
||
|
{
|
||
|
double _left = lay.margins[QStyleSheetItem::MarginLeft];
|
||
|
eLeft->changeValue( _left );
|
||
|
//prev1->setLeft( _left ); done by leftChanged() below
|
||
|
leftChanged( _left ); // sets min value for eFirstLine
|
||
|
|
||
|
double _right = lay.margins[QStyleSheetItem::MarginRight];
|
||
|
eRight->changeValue( _right );
|
||
|
prev1->setRight( _right );
|
||
|
|
||
|
double _first = lay.margins[QStyleSheetItem::MarginFirstLine];
|
||
|
eFirstLine->changeValue( _first );
|
||
|
prev1->setFirst( _first );
|
||
|
|
||
|
double _before = lay.margins[QStyleSheetItem::MarginTop];
|
||
|
eBefore->changeValue( _before );
|
||
|
prev1->setBefore( _before );
|
||
|
|
||
|
double _after = lay.margins[QStyleSheetItem::MarginBottom];
|
||
|
eAfter->changeValue( _after );
|
||
|
prev1->setAfter( _after );
|
||
|
|
||
|
double _spacing = lay.lineSpacingValue();
|
||
|
KoParagLayout::SpacingType _type = lay.lineSpacingType;
|
||
|
switch ( _type ) {
|
||
|
case KoParagLayout::LS_SINGLE: // single
|
||
|
cSpacing->setCurrentItem( 0 );
|
||
|
break;
|
||
|
case KoParagLayout::LS_ONEANDHALF:
|
||
|
cSpacing->setCurrentItem( 1 );
|
||
|
break;
|
||
|
case KoParagLayout::LS_DOUBLE:
|
||
|
cSpacing->setCurrentItem( 2 );
|
||
|
break;
|
||
|
case KoParagLayout::LS_MULTIPLE:
|
||
|
cSpacing->setCurrentItem( 3 );
|
||
|
break;
|
||
|
case KoParagLayout::LS_CUSTOM:
|
||
|
cSpacing->setCurrentItem( 4 );
|
||
|
break;
|
||
|
case KoParagLayout::LS_AT_LEAST:
|
||
|
cSpacing->setCurrentItem( 5 );
|
||
|
break;
|
||
|
case KoParagLayout::LS_FIXED:
|
||
|
cSpacing->setCurrentItem( 6 );
|
||
|
break;
|
||
|
default:
|
||
|
cSpacing->setCurrentItem( 0 );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
updateLineSpacing( _type );
|
||
|
eSpacing->setValue( (_type == KoParagLayout::LS_MULTIPLE) ? QMAX( 1, _spacing )
|
||
|
: KoUnit::toUserValue( _spacing, m_unit ) );
|
||
|
eSpacingPercent->setValue( ( _type == KoParagLayout::LS_MULTIPLE ) ? qRound( _spacing * 100 ) : 100 );
|
||
|
}
|
||
|
|
||
|
void KoIndentSpacingWidget::save( KoParagLayout & lay )
|
||
|
{
|
||
|
lay.setLineSpacingValue(lineSpacing());
|
||
|
lay.lineSpacingType = lineSpacingType();
|
||
|
lay.margins[QStyleSheetItem::MarginLeft] = leftIndent();
|
||
|
lay.margins[QStyleSheetItem::MarginRight] = rightIndent();
|
||
|
lay.margins[QStyleSheetItem::MarginFirstLine] = firstLineIndent();
|
||
|
lay.margins[QStyleSheetItem::MarginTop] = spaceBeforeParag();
|
||
|
lay.margins[QStyleSheetItem::MarginBottom] = spaceAfterParag();
|
||
|
}
|
||
|
|
||
|
QString KoIndentSpacingWidget::tabName()
|
||
|
{
|
||
|
return i18n( "Indent && S&pacing" );
|
||
|
}
|
||
|
|
||
|
void KoIndentSpacingWidget::leftChanged( double val )
|
||
|
{
|
||
|
prev1->setLeft( val );
|
||
|
// The minimum first-line margin is -leftMargin() (where leftMargin>=0)
|
||
|
eFirstLine->setMinValue( -QMAX( 0, val ) );
|
||
|
}
|
||
|
|
||
|
void KoIndentSpacingWidget::rightChanged( double val )
|
||
|
{
|
||
|
prev1->setRight( val );
|
||
|
}
|
||
|
|
||
|
void KoIndentSpacingWidget::firstChanged( double val )
|
||
|
{
|
||
|
prev1->setFirst( val );
|
||
|
}
|
||
|
|
||
|
void KoIndentSpacingWidget::updateLineSpacing( KoParagLayout::SpacingType _type )
|
||
|
{
|
||
|
bool needsValue = (_type != KoParagLayout::LS_SINGLE &&
|
||
|
_type != KoParagLayout::LS_ONEANDHALF &&
|
||
|
_type != KoParagLayout::LS_DOUBLE);
|
||
|
|
||
|
if ( _type == KoParagLayout::LS_MULTIPLE )
|
||
|
{
|
||
|
sSpacingStack->raiseWidget( eSpacingPercent );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
sSpacingStack->raiseWidget( eSpacing );
|
||
|
}
|
||
|
eSpacing->setEnabled( needsValue );
|
||
|
if ( needsValue )
|
||
|
prev1->setSpacing( eSpacing->value() );
|
||
|
else
|
||
|
{
|
||
|
prev1->setSpacing( _type == KoParagLayout::LS_ONEANDHALF ? 8 :
|
||
|
_type == KoParagLayout::LS_DOUBLE ? 16 :0 );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void KoIndentSpacingWidget::spacingActivated( int /*_index*/ )
|
||
|
{
|
||
|
updateLineSpacing( lineSpacingType() );
|
||
|
if ( eSpacing->isEnabled() ) // i.e. needsValue = true
|
||
|
eSpacing->setFocus();
|
||
|
}
|
||
|
|
||
|
void KoIndentSpacingWidget::spacingChanged( double _val )
|
||
|
{
|
||
|
prev1->setSpacing( _val );
|
||
|
}
|
||
|
|
||
|
void KoIndentSpacingWidget::spacingChanged( int _val )
|
||
|
{
|
||
|
prev1->setSpacing( _val / 100.0 );
|
||
|
}
|
||
|
|
||
|
void KoIndentSpacingWidget::beforeChanged( double _val )
|
||
|
{
|
||
|
prev1->setBefore( KoUnit::fromUserValue( _val, m_unit ) );
|
||
|
}
|
||
|
|
||
|
void KoIndentSpacingWidget::afterChanged( double _val )
|
||
|
{
|
||
|
prev1->setAfter( KoUnit::fromUserValue( _val, m_unit ) );
|
||
|
}
|
||
|
|
||
|
|
||
|
KoParagAlignWidget::KoParagAlignWidget( bool breakLine, QWidget * parent, const char * name )
|
||
|
: KoParagLayoutWidget( KoParagDia::PD_ALIGN, parent, name )
|
||
|
{
|
||
|
QGridLayout *grid = new QGridLayout( this, 3, 2, KDialog::marginHint(), KDialog::spacingHint() );
|
||
|
|
||
|
QVGroupBox * AlignGroup = new QVGroupBox( i18n( "Alignment" ), this );
|
||
|
|
||
|
rLeft = new QRadioButton( i18n( "&Left" ), AlignGroup );
|
||
|
connect( rLeft, SIGNAL( clicked() ), this, SLOT( alignLeft() ) );
|
||
|
|
||
|
rCenter = new QRadioButton( i18n( "C&enter" ), AlignGroup );
|
||
|
connect( rCenter, SIGNAL( clicked() ), this, SLOT( alignCenter() ) );
|
||
|
|
||
|
rRight = new QRadioButton( i18n( "&Right" ), AlignGroup );
|
||
|
connect( rRight, SIGNAL( clicked() ), this, SLOT( alignRight() ) );
|
||
|
|
||
|
rJustify = new QRadioButton( i18n( "&Justify" ), AlignGroup );
|
||
|
connect( rJustify, SIGNAL( clicked() ), this, SLOT( alignJustify() ) );
|
||
|
|
||
|
clearAligns();
|
||
|
rLeft->setChecked( true );
|
||
|
|
||
|
grid->addWidget(AlignGroup, 0, 0);
|
||
|
|
||
|
// --------------- End of page /frame ---------------
|
||
|
QGroupBox * endFramePage = new QGroupBox( i18n( "Behavior at &End of Frame/Page" ), this );
|
||
|
QGridLayout * endFramePageGrid = new QGridLayout( endFramePage, 4, 1,
|
||
|
KDialog::marginHint(), KDialog::spacingHint() );
|
||
|
|
||
|
cKeepLinesTogether = new QCheckBox( i18n("&Keep lines together"),endFramePage);
|
||
|
endFramePageGrid->addWidget( cKeepLinesTogether, 1, 0 );
|
||
|
cHardBreakBefore = new QCheckBox( i18n("Insert break before paragraph"),endFramePage);
|
||
|
endFramePageGrid->addWidget( cHardBreakBefore, 2, 0 );
|
||
|
cHardBreakAfter = new QCheckBox( i18n("Insert break after paragraph"),endFramePage);
|
||
|
endFramePageGrid->addWidget( cHardBreakAfter, 3, 0 );
|
||
|
|
||
|
endFramePageGrid->addRowSpacing( 0, fontMetrics().height() / 2 ); // groupbox title
|
||
|
for ( int i = 0 ; i < endFramePageGrid->numRows()-1 ; ++i )
|
||
|
endFramePageGrid->setRowStretch( 0, 0 );
|
||
|
endFramePageGrid->setRowStretch( endFramePageGrid->numRows()-1, 1 );
|
||
|
grid->addWidget( endFramePage, 2, 0 );
|
||
|
|
||
|
endFramePage->setEnabled(breakLine);
|
||
|
|
||
|
// --------------- preview --------------------
|
||
|
prev2 = new KPagePreview2( this, "KPagePreview2" );
|
||
|
grid->addMultiCellWidget( prev2, 0, 2, 1, 1 );
|
||
|
|
||
|
// --------------- main grid ------------------
|
||
|
grid->setColStretch( 1, 1 );
|
||
|
grid->setRowStretch( 1, 1 );
|
||
|
}
|
||
|
|
||
|
int KoParagAlignWidget::pageBreaking() const
|
||
|
{
|
||
|
int pb = 0;
|
||
|
if ( cKeepLinesTogether->isChecked() )
|
||
|
pb |= KoParagLayout::KeepLinesTogether;
|
||
|
if ( cHardBreakBefore->isChecked() )
|
||
|
pb |= KoParagLayout::HardFrameBreakBefore;
|
||
|
if ( cHardBreakAfter->isChecked() )
|
||
|
pb |= KoParagLayout::HardFrameBreakAfter;
|
||
|
return pb;
|
||
|
}
|
||
|
|
||
|
|
||
|
void KoParagAlignWidget::display( const KoParagLayout & lay )
|
||
|
{
|
||
|
int align = lay.alignment;
|
||
|
prev2->setAlign( align );
|
||
|
|
||
|
clearAligns();
|
||
|
switch ( align ) {
|
||
|
case Qt::AlignAuto: // see KoView::setAlign
|
||
|
case Qt::AlignLeft:
|
||
|
rLeft->setChecked( true );
|
||
|
break;
|
||
|
case Qt::AlignHCenter:
|
||
|
rCenter->setChecked( true );
|
||
|
break;
|
||
|
case Qt::AlignRight:
|
||
|
rRight->setChecked( true );
|
||
|
break;
|
||
|
case Qt::AlignJustify:
|
||
|
rJustify->setChecked( true );
|
||
|
}
|
||
|
|
||
|
cKeepLinesTogether->setChecked( lay.pageBreaking & KoParagLayout::KeepLinesTogether );
|
||
|
cHardBreakBefore->setChecked( lay.pageBreaking & KoParagLayout::HardFrameBreakBefore );
|
||
|
cHardBreakAfter->setChecked( lay.pageBreaking & KoParagLayout::HardFrameBreakAfter );
|
||
|
// ## preview support for end-of-frame ?
|
||
|
}
|
||
|
|
||
|
void KoParagAlignWidget::save( KoParagLayout & lay )
|
||
|
{
|
||
|
lay.alignment = align();
|
||
|
lay.pageBreaking = pageBreaking();
|
||
|
}
|
||
|
|
||
|
int KoParagAlignWidget::align() const
|
||
|
{
|
||
|
if ( rLeft->isChecked() ) return Qt::AlignLeft;
|
||
|
else if ( rCenter->isChecked() ) return Qt::AlignHCenter;
|
||
|
else if ( rRight->isChecked() ) return Qt::AlignRight;
|
||
|
else if ( rJustify->isChecked() ) return Qt::AlignJustify;
|
||
|
|
||
|
return Qt::AlignLeft;
|
||
|
}
|
||
|
|
||
|
QString KoParagAlignWidget::tabName()
|
||
|
{
|
||
|
return i18n( "General &Layout" );
|
||
|
}
|
||
|
|
||
|
void KoParagAlignWidget::alignLeft()
|
||
|
{
|
||
|
prev2->setAlign( Qt::AlignLeft );
|
||
|
clearAligns();
|
||
|
rLeft->setChecked( true );
|
||
|
}
|
||
|
|
||
|
void KoParagAlignWidget::alignCenter()
|
||
|
{
|
||
|
prev2->setAlign( Qt::AlignHCenter );
|
||
|
clearAligns();
|
||
|
rCenter->setChecked( true );
|
||
|
}
|
||
|
|
||
|
void KoParagAlignWidget::alignRight()
|
||
|
{
|
||
|
prev2->setAlign( Qt::AlignRight );
|
||
|
clearAligns();
|
||
|
rRight->setChecked( true );
|
||
|
}
|
||
|
|
||
|
void KoParagAlignWidget::alignJustify()
|
||
|
{
|
||
|
prev2->setAlign( Qt::AlignJustify );
|
||
|
clearAligns();
|
||
|
rJustify->setChecked( true );
|
||
|
}
|
||
|
|
||
|
void KoParagAlignWidget::clearAligns()
|
||
|
{
|
||
|
rLeft->setChecked( false );
|
||
|
rCenter->setChecked( false );
|
||
|
rRight->setChecked( false );
|
||
|
rJustify->setChecked( false );
|
||
|
}
|
||
|
|
||
|
////////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
KoParagDecorationWidget::KoParagDecorationWidget( QWidget * parent,
|
||
|
const char * name )
|
||
|
: KoParagLayoutWidget( KoParagDia::PD_DECORATION, parent, name )
|
||
|
{
|
||
|
QVBoxLayout *tabLayout = new QVBoxLayout( this );
|
||
|
wDeco = new KoParagDecorationTab( this );
|
||
|
tabLayout->add( wDeco );
|
||
|
|
||
|
// Set up Border Style combo box
|
||
|
wDeco->cbBorderStyle->insertItem( KoBorder::getStyle( KoBorder::SOLID ) );
|
||
|
wDeco->cbBorderStyle->insertItem( KoBorder::getStyle( KoBorder::DASH ) );
|
||
|
wDeco->cbBorderStyle->insertItem( KoBorder::getStyle( KoBorder::DOT ) );
|
||
|
wDeco->cbBorderStyle->insertItem( KoBorder::getStyle( KoBorder::DASH_DOT ) );
|
||
|
wDeco->cbBorderStyle->insertItem( KoBorder::getStyle( KoBorder::DASH_DOT_DOT ) );
|
||
|
wDeco->cbBorderStyle->insertItem( KoBorder::getStyle( KoBorder::DOUBLE_LINE ) );
|
||
|
|
||
|
// Set up Border Width combo box
|
||
|
for( unsigned int i = 1; i <= 10; i++ )
|
||
|
wDeco->cbBorderWidth->insertItem(QString::number(i));
|
||
|
|
||
|
// Setup the border toggle buttons, and merge checkbox
|
||
|
connect( wDeco->bBorderLeft, SIGNAL( toggled( bool ) ),
|
||
|
this, SLOT( brdLeftToggled( bool ) ) );
|
||
|
connect( wDeco->bBorderRight, SIGNAL( toggled( bool ) ),
|
||
|
this, SLOT( brdRightToggled( bool ) ) );
|
||
|
connect( wDeco->bBorderTop, SIGNAL( toggled( bool ) ),
|
||
|
this, SLOT( brdTopToggled( bool ) ) );
|
||
|
connect( wDeco->bBorderBottom, SIGNAL( toggled( bool ) ),
|
||
|
this, SLOT( brdBottomToggled( bool ) ) );
|
||
|
connect( wDeco->cbJoinBorder, SIGNAL( toggled( bool ) ),
|
||
|
this, SLOT( brdJoinToggled( bool ) ) );
|
||
|
|
||
|
// Set up Border preview widget
|
||
|
wPreview = new KoBorderPreview( wDeco->borderPreview );
|
||
|
QVBoxLayout *previewLayout = new QVBoxLayout( wDeco->borderPreview );
|
||
|
previewLayout->addWidget( wPreview );
|
||
|
connect( wPreview, SIGNAL( choosearea(QMouseEvent * ) ),
|
||
|
this, SLOT( slotPressEvent(QMouseEvent *) ) );
|
||
|
}
|
||
|
|
||
|
///////
|
||
|
// Current GUI selections
|
||
|
KoBorder::BorderStyle KoParagDecorationWidget::curBorderStyle() const
|
||
|
{
|
||
|
QString selection = wDeco->cbBorderStyle->currentText();
|
||
|
return KoBorder::getStyle( selection );
|
||
|
}
|
||
|
|
||
|
unsigned int KoParagDecorationWidget::curBorderWidth() const {
|
||
|
return wDeco->cbBorderWidth->currentText().toUInt();
|
||
|
}
|
||
|
|
||
|
QColor KoParagDecorationWidget::curBorderColor() const {
|
||
|
return wDeco->bBorderColor->color();
|
||
|
}
|
||
|
///////
|
||
|
|
||
|
// Check whether a border is the same as that selected in the GUI
|
||
|
bool KoParagDecorationWidget::borderChanged( const KoBorder& border ) {
|
||
|
return (unsigned int)border.penWidth() != curBorderWidth() ||
|
||
|
border.color != curBorderColor() ||
|
||
|
border.getStyle() != curBorderStyle();
|
||
|
}
|
||
|
|
||
|
// Set a given border according to the values selected in the GUI
|
||
|
void KoParagDecorationWidget::updateBorder( KoBorder& border )
|
||
|
{
|
||
|
border.setPenWidth( curBorderWidth() );
|
||
|
border.color = curBorderColor();
|
||
|
border.setStyle( curBorderStyle () );
|
||
|
}
|
||
|
|
||
|
void KoParagDecorationWidget::clickedBorderPreview( KoBorder& border,
|
||
|
KoBorder::BorderType position,
|
||
|
KPushButton *corresponding )
|
||
|
{
|
||
|
if ( borderChanged( border ) && corresponding->isOn() ) {
|
||
|
updateBorder( border );
|
||
|
wPreview->setBorder( position, border );
|
||
|
}
|
||
|
else
|
||
|
corresponding->setOn( !corresponding->isOn() );
|
||
|
}
|
||
|
|
||
|
// Establish which border position was clicked in the border preview,
|
||
|
// and update the appropriate border
|
||
|
void KoParagDecorationWidget::slotPressEvent(QMouseEvent *_ev)
|
||
|
{
|
||
|
const int OFFSETX = 15;
|
||
|
const int OFFSETY = 7;
|
||
|
const int Ko_SPACE = 30;
|
||
|
|
||
|
QRect r = wPreview->contentsRect();
|
||
|
QRect rect(r.x() + OFFSETX, r.y() + OFFSETY,
|
||
|
r.width() - OFFSETX, r.y() + OFFSETY + Ko_SPACE);
|
||
|
if(rect.contains(QPoint(_ev->x(),_ev->y())))
|
||
|
{
|
||
|
clickedBorderPreview( m_topBorder, KoBorder::TopBorder,
|
||
|
wDeco->bBorderTop );
|
||
|
}
|
||
|
|
||
|
rect.setCoords(r.x() + OFFSETX, r.height() - OFFSETY - Ko_SPACE,
|
||
|
r.width() - OFFSETX, r.height() - OFFSETY);
|
||
|
if(rect.contains(QPoint(_ev->x(),_ev->y())))
|
||
|
{
|
||
|
clickedBorderPreview( m_bottomBorder, KoBorder::BottomBorder,
|
||
|
wDeco->bBorderBottom );
|
||
|
}
|
||
|
|
||
|
rect.setCoords(r.x() + OFFSETX, r.y() + OFFSETY,
|
||
|
r.x() + Ko_SPACE + OFFSETX, r.height() - OFFSETY);
|
||
|
if(rect.contains(QPoint(_ev->x(),_ev->y())))
|
||
|
{
|
||
|
clickedBorderPreview( m_leftBorder, KoBorder::LeftBorder,
|
||
|
wDeco->bBorderLeft );
|
||
|
}
|
||
|
|
||
|
rect.setCoords(r.width() - OFFSETX - Ko_SPACE, r.y() + OFFSETY,
|
||
|
r.width() - OFFSETX, r.height() - OFFSETY);
|
||
|
if(rect.contains(QPoint(_ev->x(),_ev->y())))
|
||
|
{
|
||
|
clickedBorderPreview( m_rightBorder, KoBorder::RightBorder,
|
||
|
wDeco->bBorderRight );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void KoParagDecorationWidget::display( const KoParagLayout & lay )
|
||
|
{
|
||
|
wDeco->bBackgroundColor->setColor( lay.backgroundColor );
|
||
|
|
||
|
m_leftBorder = lay.leftBorder;
|
||
|
m_rightBorder = lay.rightBorder;
|
||
|
m_topBorder = lay.topBorder;
|
||
|
m_bottomBorder = lay.bottomBorder;
|
||
|
m_joinBorder = lay.joinBorder;
|
||
|
|
||
|
wDeco->bBorderLeft->blockSignals( true );
|
||
|
wDeco->bBorderRight->blockSignals( true );
|
||
|
wDeco->bBorderTop->blockSignals( true );
|
||
|
wDeco->bBorderBottom->blockSignals( true );
|
||
|
updateBorders();
|
||
|
wDeco->bBorderLeft->blockSignals( false );
|
||
|
wDeco->bBorderRight->blockSignals( false );
|
||
|
wDeco->bBorderTop->blockSignals( false );
|
||
|
wDeco->bBorderBottom->blockSignals( false );
|
||
|
}
|
||
|
|
||
|
void KoParagDecorationWidget::updateBorders()
|
||
|
{
|
||
|
wDeco->bBorderLeft->setOn( m_leftBorder.penWidth() > 0 );
|
||
|
wDeco->bBorderRight->setOn( m_rightBorder.penWidth() > 0 );
|
||
|
wDeco->bBorderTop->setOn( m_topBorder.penWidth() > 0 );
|
||
|
wDeco->bBorderBottom->setOn( m_bottomBorder.penWidth() > 0 );
|
||
|
wDeco->cbJoinBorder->setChecked( m_joinBorder );
|
||
|
wPreview->setLeftBorder( m_leftBorder );
|
||
|
wPreview->setRightBorder( m_rightBorder );
|
||
|
wPreview->setTopBorder( m_topBorder );
|
||
|
wPreview->setBottomBorder( m_bottomBorder );
|
||
|
}
|
||
|
|
||
|
|
||
|
void KoParagDecorationWidget::save( KoParagLayout & lay )
|
||
|
{
|
||
|
lay.backgroundColor = wDeco->bBackgroundColor->color();
|
||
|
lay.topBorder = m_topBorder;
|
||
|
lay.bottomBorder = m_bottomBorder;
|
||
|
lay.leftBorder = m_leftBorder;
|
||
|
lay.rightBorder = m_rightBorder;
|
||
|
lay.joinBorder = m_joinBorder;
|
||
|
}
|
||
|
|
||
|
QColor KoParagDecorationWidget::backgroundColor() const {
|
||
|
return wDeco->bBackgroundColor->color();
|
||
|
}
|
||
|
|
||
|
QString KoParagDecorationWidget::tabName() {
|
||
|
// Why D&e..? Because &De.. conflicts with &Delete in
|
||
|
// the style manager.
|
||
|
return i18n( "D&ecorations" );
|
||
|
}
|
||
|
|
||
|
void KoParagDecorationWidget::brdLeftToggled( bool _on )
|
||
|
{
|
||
|
if ( !_on )
|
||
|
m_leftBorder.setPenWidth(0);
|
||
|
else {
|
||
|
m_leftBorder.setPenWidth( curBorderWidth() );
|
||
|
m_leftBorder.color = curBorderColor();
|
||
|
m_leftBorder.setStyle( curBorderStyle() );
|
||
|
}
|
||
|
wPreview->setLeftBorder( m_leftBorder );
|
||
|
}
|
||
|
|
||
|
void KoParagDecorationWidget::brdRightToggled( bool _on )
|
||
|
{
|
||
|
if ( !_on )
|
||
|
m_rightBorder.setPenWidth(0);
|
||
|
else {
|
||
|
m_rightBorder.setPenWidth( curBorderWidth() );
|
||
|
m_rightBorder.color = curBorderColor();
|
||
|
m_rightBorder.setStyle( curBorderStyle() );
|
||
|
}
|
||
|
wPreview->setRightBorder( m_rightBorder );
|
||
|
}
|
||
|
|
||
|
void KoParagDecorationWidget::brdTopToggled( bool _on )
|
||
|
{
|
||
|
if ( !_on )
|
||
|
m_topBorder.setPenWidth(0);
|
||
|
else {
|
||
|
m_topBorder.setPenWidth( curBorderWidth() );
|
||
|
m_topBorder.color = curBorderColor();
|
||
|
m_topBorder.setStyle( curBorderStyle() );
|
||
|
}
|
||
|
wPreview->setTopBorder( m_topBorder );
|
||
|
}
|
||
|
|
||
|
void KoParagDecorationWidget::brdBottomToggled( bool _on )
|
||
|
{
|
||
|
if ( !_on )
|
||
|
m_bottomBorder.setPenWidth ( 0 );
|
||
|
else {
|
||
|
m_bottomBorder.setPenWidth( curBorderWidth() );
|
||
|
m_bottomBorder.color = curBorderColor();
|
||
|
m_bottomBorder.setStyle( curBorderStyle() );
|
||
|
}
|
||
|
wPreview->setBottomBorder( m_bottomBorder );
|
||
|
}
|
||
|
|
||
|
void KoParagDecorationWidget::brdJoinToggled( bool _on ) {
|
||
|
m_joinBorder = _on;
|
||
|
}
|
||
|
////////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
|
||
|
KoParagCounterWidget::KoParagCounterWidget( bool disableAll, QWidget * parent, const char * name )
|
||
|
: KoParagLayoutWidget( KoParagDia::PD_NUMBERING, parent, name )
|
||
|
{
|
||
|
|
||
|
QVBoxLayout *Form1Layout = new QVBoxLayout( this );
|
||
|
Form1Layout->setSpacing( KDialog::spacingHint() );
|
||
|
Form1Layout->setMargin( KDialog::marginHint() );
|
||
|
|
||
|
gNumbering = new QButtonGroup( this, "numberingGroup" );
|
||
|
gNumbering->setTitle( i18n( "Numbering" ) );
|
||
|
gNumbering->setColumnLayout(0, Qt::Vertical );
|
||
|
gNumbering->layout()->setSpacing( 0 );
|
||
|
gNumbering->layout()->setMargin( 0 );
|
||
|
QHBoxLayout *numberingGroupLayout = new QHBoxLayout( gNumbering->layout() );
|
||
|
numberingGroupLayout->setAlignment( Qt::AlignTop );
|
||
|
numberingGroupLayout->setSpacing( KDialog::spacingHint() );
|
||
|
numberingGroupLayout->setMargin( KDialog::marginHint() );
|
||
|
|
||
|
// What type of numbering is required?
|
||
|
QRadioButton *rNone = new QRadioButton( gNumbering, "rNone" );
|
||
|
rNone->setText( i18n( "&None" ) );
|
||
|
numberingGroupLayout->addWidget( rNone );
|
||
|
|
||
|
gNumbering->insert( rNone , KoParagCounter::NUM_NONE);
|
||
|
|
||
|
QRadioButton *rList = new QRadioButton( gNumbering, "rList" );
|
||
|
rList->setText( i18n( "&List" ) );
|
||
|
gNumbering->insert( rList , KoParagCounter::NUM_LIST);
|
||
|
numberingGroupLayout->addWidget( rList );
|
||
|
|
||
|
QRadioButton *rChapter = new QRadioButton( gNumbering, "rChapter" );
|
||
|
rChapter->setText( i18n( "Chapt&er" ) );
|
||
|
gNumbering->insert( rChapter , KoParagCounter::NUM_CHAPTER);
|
||
|
numberingGroupLayout->addWidget( rChapter );
|
||
|
Form1Layout->addWidget( gNumbering );
|
||
|
connect( gNumbering, SIGNAL( clicked( int ) ), this, SLOT( numTypeChanged( int ) ) );
|
||
|
|
||
|
m_styleWidget = new KoCounterStyleWidget( true, false, disableAll, this );
|
||
|
|
||
|
connect( m_styleWidget, SIGNAL( sig_suffixChanged (const QString &) ), this, SLOT( suffixChanged(const QString &) ) );
|
||
|
connect( m_styleWidget, SIGNAL( sig_prefixChanged (const QString &) ), this, SLOT( prefixChanged(const QString &) ) );
|
||
|
connect( m_styleWidget, SIGNAL( sig_startChanged(int) ), this, SLOT( startChanged(int) ) );
|
||
|
connect( m_styleWidget, SIGNAL( sig_restartChanged(bool) ), this, SLOT( restartChanged(bool) ) );
|
||
|
connect( m_styleWidget, SIGNAL( sig_depthChanged (int) ), this, SLOT( depthChanged(int) ) );
|
||
|
connect( m_styleWidget, SIGNAL( sig_displayLevelsChanged (int) ), this, SLOT( displayLevelsChanged(int) ) );
|
||
|
connect( m_styleWidget, SIGNAL( sig_alignmentChanged (int) ), this, SLOT( alignmentChanged(int) ) );
|
||
|
connect( m_styleWidget, SIGNAL( changeCustomBullet( const QString & , QChar ) ), this, SLOT( slotChangeCustomBullet( const QString & , QChar ) ) );
|
||
|
|
||
|
connect( m_styleWidget, SIGNAL( sig_numTypeChanged( int ) ), this, SLOT( numTypeChanged(int ) ) );
|
||
|
connect( m_styleWidget, SIGNAL( changeStyle( KoParagCounter::Style ) ), this, SLOT( styleChanged (KoParagCounter::Style ) ) );
|
||
|
|
||
|
Form1Layout->addWidget( m_styleWidget );
|
||
|
|
||
|
|
||
|
preview = new KoStylePreview( i18n( "Preview" ), i18n("Normal paragraph text"), this, "counter preview" );
|
||
|
Form1Layout->addWidget( preview );
|
||
|
if ( disableAll)
|
||
|
{
|
||
|
gNumbering->setEnabled( false);
|
||
|
preview->setEnabled( false );
|
||
|
}
|
||
|
|
||
|
QSpacerItem* spacer = new QSpacerItem( 0, 0, QSizePolicy::Minimum, QSizePolicy::Expanding);
|
||
|
Form1Layout->addItem( spacer );
|
||
|
}
|
||
|
|
||
|
void KoParagCounterWidget::styleChanged( KoParagCounter::Style st )
|
||
|
{
|
||
|
m_counter.setStyle( st );
|
||
|
updatePreview();
|
||
|
}
|
||
|
|
||
|
void KoParagCounterWidget::slotChangeCustomBullet( const QString & f, QChar c)
|
||
|
{
|
||
|
m_counter.setCustomBulletFont( f );
|
||
|
m_counter.setCustomBulletCharacter( c );
|
||
|
preview->setCounter( m_counter );
|
||
|
}
|
||
|
|
||
|
QString KoParagCounterWidget::tabName() {
|
||
|
return i18n( "B&ullets/Numbers" );
|
||
|
}
|
||
|
|
||
|
void KoParagCounterWidget::numTypeChanged( int nType ) {
|
||
|
// radio buttons pressed to change numbering type
|
||
|
m_counter.setNumbering( static_cast<KoParagCounter::Numbering>( nType ) );
|
||
|
preview->setEnabled( m_counter.numbering() != KoParagCounter::NUM_NONE );
|
||
|
m_styleWidget->numTypeChanged( nType );
|
||
|
|
||
|
updatePreview();
|
||
|
}
|
||
|
|
||
|
void KoParagCounterWidget::display( const KoParagLayout & lay ) {
|
||
|
KoParagCounter::Style style = KoParagCounter::STYLE_NONE;
|
||
|
if ( lay.counter )
|
||
|
{
|
||
|
style=lay.counter->style();
|
||
|
m_counter = *lay.counter;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_counter = KoParagCounter();
|
||
|
}
|
||
|
gNumbering->setButton( m_counter.numbering() );
|
||
|
preview->setStyle( lay.style );
|
||
|
preview->setCounter( m_counter );
|
||
|
m_styleWidget->display( lay );
|
||
|
}
|
||
|
|
||
|
void KoParagCounterWidget::updatePreview() {
|
||
|
preview->setCounter(m_counter);
|
||
|
preview->repaint(true);
|
||
|
}
|
||
|
|
||
|
void KoParagCounterWidget::save( KoParagLayout & lay ) {
|
||
|
/* m_counter.setDepth(spnDepth->value());
|
||
|
m_counter.setStartNumber(spnStart->value());
|
||
|
m_counter.setPrefix(sPrefix->text());
|
||
|
m_counter.setSuffix(sSuffix->text()); */
|
||
|
|
||
|
if ( lay.counter )
|
||
|
*lay.counter = m_counter;
|
||
|
else
|
||
|
lay.counter = new KoParagCounter( m_counter );
|
||
|
}
|
||
|
|
||
|
KoTabulatorsLineEdit::KoTabulatorsLineEdit( QWidget *parent, double lower, double upper, double step, double value /*= 0.0*/, KoUnit::Unit unit /*= KoUnit::U_PT*/, unsigned int precision /*= 2*/, const char *name /*= 0*/ )
|
||
|
: KoUnitDoubleSpinBox ( parent, lower, upper, step, value, unit, precision, name )
|
||
|
{
|
||
|
setRange( 0, 9999, 1, false);
|
||
|
}
|
||
|
|
||
|
void KoTabulatorsLineEdit::keyPressEvent ( QKeyEvent *ke )
|
||
|
{
|
||
|
if( ke->key() == QKeyEvent::Key_Return ||
|
||
|
ke->key() == QKeyEvent::Key_Enter )
|
||
|
{
|
||
|
emit keyReturnPressed();
|
||
|
return;
|
||
|
}
|
||
|
KoUnitDoubleSpinBox::keyPressEvent (ke);
|
||
|
}
|
||
|
|
||
|
KoParagTabulatorsWidget::KoParagTabulatorsWidget( KoUnit::Unit unit, double frameWidth,QWidget * parent, const char * name )
|
||
|
: KoParagLayoutWidget( KoParagDia::PD_TABS, parent, name ), m_unit(unit) {
|
||
|
QString length;
|
||
|
if(frameWidth==-1) {
|
||
|
frameWidth=9999;
|
||
|
m_toplimit=9999;
|
||
|
} else {
|
||
|
m_toplimit=frameWidth;
|
||
|
length=i18n("Frame width: %1 %2")
|
||
|
.arg(KoUnit::toUserStringValue(frameWidth,m_unit))
|
||
|
.arg(KoUnit::unitName(m_unit));
|
||
|
frameWidth=KoUnit::toUserValue(frameWidth,m_unit);
|
||
|
}
|
||
|
QVBoxLayout* Form1Layout = new QVBoxLayout( this );
|
||
|
Form1Layout->setSpacing( KDialog::spacingHint() );
|
||
|
Form1Layout->setMargin( KDialog::marginHint() );
|
||
|
|
||
|
QHBoxLayout* Layout13 = new QHBoxLayout;
|
||
|
Layout13->setSpacing( KDialog::spacingHint() );
|
||
|
Layout13->setMargin( 0 ); //?
|
||
|
|
||
|
lstTabs = new QListBox( this);
|
||
|
lstTabs->insertItem( "mytabvalue" );
|
||
|
lstTabs->setMaximumSize( QSize( 300, 32767 ) );
|
||
|
Layout13->addWidget( lstTabs );
|
||
|
|
||
|
editLayout = new QVBoxLayout;
|
||
|
editLayout->setSpacing( KDialog::spacingHint() );
|
||
|
editLayout->setMargin( 0 ); //?
|
||
|
|
||
|
gPosition = new QGroupBox( this, "gPosition" );
|
||
|
gPosition->setTitle( i18n( "Po&sition" ) );
|
||
|
gPosition->setColumnLayout(0, Qt::Vertical );
|
||
|
gPosition->layout()->setSpacing( 0 );
|
||
|
gPosition->layout()->setMargin( 0 );
|
||
|
QVBoxLayout* GroupBox2Layout = new QVBoxLayout( gPosition->layout() );
|
||
|
GroupBox2Layout->setAlignment( Qt::AlignTop );
|
||
|
GroupBox2Layout->setSpacing( KDialog::spacingHint() );
|
||
|
GroupBox2Layout->setMargin( KDialog::marginHint() );
|
||
|
|
||
|
QHBoxLayout* Layout5 = new QHBoxLayout;
|
||
|
Layout5->setSpacing( KDialog::spacingHint() );
|
||
|
Layout5->setMargin( 0 ); //?
|
||
|
|
||
|
sTabPos = new KoTabulatorsLineEdit( gPosition, 0, 9999, 1, 0.0, m_unit );
|
||
|
sTabPos->setRange( 0, 9999, 1 );
|
||
|
sTabPos->setMaximumSize( QSize( 100, 32767 ) );
|
||
|
Layout5->addWidget( sTabPos );
|
||
|
QSpacerItem* spacer = new QSpacerItem( 20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum );
|
||
|
Layout5->addItem( spacer );
|
||
|
GroupBox2Layout->addLayout( Layout5 );
|
||
|
editLayout->addWidget( gPosition );
|
||
|
|
||
|
QLabel* TextLabel1 = new QLabel( gPosition );
|
||
|
QString unitDescription = KoUnit::unitDescription( m_unit );
|
||
|
TextLabel1->setText( length );
|
||
|
GroupBox2Layout->addWidget( TextLabel1 );
|
||
|
|
||
|
bgAlign = new QButtonGroup( this );
|
||
|
bgAlign->setTitle( i18n( "Alignment" ) );
|
||
|
bgAlign->setColumnLayout(0, Qt::Vertical );
|
||
|
bgAlign->layout()->setSpacing( 0 );
|
||
|
bgAlign->layout()->setMargin( 0 );
|
||
|
QVBoxLayout* ButtonGroup1Layout = new QVBoxLayout( bgAlign->layout() );
|
||
|
ButtonGroup1Layout->setAlignment( Qt::AlignTop );
|
||
|
ButtonGroup1Layout->setSpacing( KDialog::spacingHint() );
|
||
|
ButtonGroup1Layout->setMargin( KDialog::marginHint() );
|
||
|
|
||
|
rAlignLeft = new QRadioButton( bgAlign );
|
||
|
rAlignLeft->setText( i18n( "&Left" ) );
|
||
|
ButtonGroup1Layout->addWidget( rAlignLeft );
|
||
|
|
||
|
rAlignCentre = new QRadioButton( bgAlign );
|
||
|
rAlignCentre->setText( i18n( "C&enter" ) );
|
||
|
ButtonGroup1Layout->addWidget( rAlignCentre );
|
||
|
|
||
|
rAlignRight = new QRadioButton( bgAlign );
|
||
|
rAlignRight->setText( i18n( "&Right" ) );
|
||
|
ButtonGroup1Layout->addWidget( rAlignRight );
|
||
|
|
||
|
QHBoxLayout* Layout8 = new QHBoxLayout;
|
||
|
Layout8->setSpacing( KDialog::spacingHint() );
|
||
|
Layout8->setMargin( 0 );
|
||
|
|
||
|
rAlignVar = new QRadioButton( bgAlign );
|
||
|
rAlignVar->setText( i18n( "On followin&g character: " ) );
|
||
|
Layout8->addWidget( rAlignVar );
|
||
|
|
||
|
sAlignChar = new QLineEdit( bgAlign);
|
||
|
sAlignChar->setMaximumSize( QSize( 60, 32767 ) );
|
||
|
sAlignChar->setText(QString(KGlobal::locale()->decimalSymbol()[0]));
|
||
|
Layout8->addWidget( sAlignChar );
|
||
|
QSpacerItem* spacer_2 = new QSpacerItem( 20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum );
|
||
|
Layout8->addItem( spacer_2 );
|
||
|
ButtonGroup1Layout->addLayout( Layout8 );
|
||
|
editLayout->addWidget( bgAlign );
|
||
|
|
||
|
gTabLeader = new QGroupBox( this, "gTabLeader" );
|
||
|
gTabLeader->setTitle( i18n( "Tab Leader" ) );
|
||
|
QVBoxLayout* GroupBox5Layout = new QVBoxLayout( gTabLeader );
|
||
|
GroupBox5Layout->setAlignment( Qt::AlignTop );
|
||
|
GroupBox5Layout->setSpacing( KDialog::spacingHint() );
|
||
|
GroupBox5Layout->setMargin( KDialog::marginHint() );
|
||
|
GroupBox5Layout->addSpacing( fontMetrics().height() / 2 ); // groupbox title
|
||
|
|
||
|
QLabel* TextLabel1_2 = new QLabel( gTabLeader );
|
||
|
TextLabel1_2->setText( i18n( "The space a tab uses can be filled with a pattern." ) );
|
||
|
GroupBox5Layout->addWidget( TextLabel1_2 );
|
||
|
|
||
|
QGridLayout *fillingGrid = new QGridLayout( 0L, 2, 2, 0, KDialog::spacingHint() );
|
||
|
|
||
|
QLabel* TextLabel2 = new QLabel( gTabLeader);
|
||
|
TextLabel2->setText( i18n( "&Filling:" ) );
|
||
|
TextLabel2->setAlignment( AlignRight );
|
||
|
fillingGrid->addWidget( TextLabel2, 0, 0 );
|
||
|
|
||
|
cFilling = new QComboBox( FALSE, gTabLeader);
|
||
|
cFilling->insertItem( i18n( "Blank" ) );
|
||
|
cFilling->insertItem( "_ _ _ _ _ _"); // DOT
|
||
|
cFilling->insertItem( "_________"); // SOLID
|
||
|
cFilling->insertItem( "___ ___ __"); // DASH
|
||
|
cFilling->insertItem( "___ _ ___ _"); // DASH_DOT
|
||
|
cFilling->insertItem( "___ _ _ ___"); // DASH_DOT_DOT
|
||
|
TextLabel2->setBuddy( cFilling );
|
||
|
fillingGrid->addWidget( cFilling, 0, 1 );
|
||
|
|
||
|
QLabel * TextLabel3 = new QLabel( i18n("&Width:"), gTabLeader );
|
||
|
TextLabel3->setAlignment( AlignRight );
|
||
|
fillingGrid->addWidget( TextLabel3, 1, 0 );
|
||
|
|
||
|
eWidth = new KoUnitDoubleSpinBox( gTabLeader );
|
||
|
eWidth->setMinValue(0.01);
|
||
|
eWidth->setUnit( m_unit );
|
||
|
TextLabel3->setBuddy( eWidth );
|
||
|
fillingGrid->addWidget( eWidth, 1, 1 );
|
||
|
|
||
|
GroupBox5Layout->addLayout( fillingGrid );
|
||
|
editLayout->addWidget( gTabLeader );
|
||
|
QSpacerItem* spacer_4 = new QSpacerItem( 20, 20, QSizePolicy::Minimum, QSizePolicy::Expanding );
|
||
|
editLayout->addItem( spacer_4 );
|
||
|
Layout13->addLayout( editLayout );
|
||
|
Form1Layout->addLayout( Layout13 );
|
||
|
|
||
|
QHBoxLayout* Layout4 = new QHBoxLayout;
|
||
|
Layout4->setSpacing( KDialog::spacingHint() );
|
||
|
Layout4->setMargin( 0 );
|
||
|
|
||
|
bNew = new QPushButton( this);
|
||
|
bNew->setText( i18n( "&New" ) );
|
||
|
Layout4->addWidget( bNew );
|
||
|
|
||
|
bDelete = new QPushButton( this);
|
||
|
bDelete->setText( i18n( "&Delete" ) );
|
||
|
Layout4->addWidget( bDelete );
|
||
|
|
||
|
bDeleteAll = new QPushButton( this);
|
||
|
bDeleteAll->setText( i18n( "Delete All" ) );
|
||
|
Layout4->addWidget( bDeleteAll );
|
||
|
|
||
|
QSpacerItem* spacer_5 = new QSpacerItem( 20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum );
|
||
|
Layout4->addItem( spacer_5 );
|
||
|
Form1Layout->addLayout( Layout4 );
|
||
|
|
||
|
//signal valueChanged passes value which the user see (unlike the value() function)
|
||
|
//so fromUserValue has to be used in slotTabValueChanged
|
||
|
connect(sTabPos,SIGNAL(valueChanged(double)), this, SLOT(slotTabValueChanged(double )));
|
||
|
connect(sTabPos,SIGNAL( keyReturnPressed()),this,SLOT(newClicked()));
|
||
|
connect(sAlignChar,SIGNAL(textChanged( const QString & )), this, SLOT(slotAlignCharChanged( const QString & )));
|
||
|
connect(bNew,SIGNAL(clicked ()),this,SLOT(newClicked()));
|
||
|
connect(bDelete,SIGNAL(clicked ()),this,SLOT(deleteClicked()));
|
||
|
connect(bDeleteAll,SIGNAL(clicked ()),this,SLOT(deleteAllClicked()));
|
||
|
connect(bgAlign,SIGNAL(clicked (int)),this,SLOT(updateAlign(int)));
|
||
|
connect(cFilling,SIGNAL(activated (int)),this,SLOT(updateFilling(int)));
|
||
|
connect(eWidth,SIGNAL(valueChangedPt( double ) ),this,SLOT(updateWidth()));
|
||
|
connect(lstTabs,SIGNAL(highlighted (int)),this,SLOT(setActiveItem(int)));
|
||
|
noSignals=false;
|
||
|
}
|
||
|
|
||
|
void KoParagTabulatorsWidget::slotTabValueChanged( double val ) {
|
||
|
if(noSignals) return;
|
||
|
noSignals=true;
|
||
|
//see comment where this slot is connected
|
||
|
m_tabList[lstTabs->currentItem()].ptPos = KoUnit::fromUserValue( val, m_unit );
|
||
|
|
||
|
lstTabs->changeItem(tabToString(m_tabList[lstTabs->currentItem()]), lstTabs->currentItem());
|
||
|
|
||
|
sortLists();
|
||
|
noSignals=false;
|
||
|
}
|
||
|
|
||
|
void KoParagTabulatorsWidget::slotAlignCharChanged( const QString &/*_text*/ ) {
|
||
|
// select align 3 and update data structures.
|
||
|
bgAlign->setButton(3);
|
||
|
m_tabList[lstTabs->currentItem()].alignChar=sAlignChar->text()[0];
|
||
|
m_tabList[lstTabs->currentItem()].type=T_DEC_PNT;
|
||
|
}
|
||
|
|
||
|
void KoParagTabulatorsWidget::newClicked() {
|
||
|
int selected=lstTabs->currentItem();
|
||
|
KoTabulator newTab;
|
||
|
if(selected < 0) {
|
||
|
newTab.ptPos=0;
|
||
|
newTab.type=T_LEFT;
|
||
|
newTab.filling=TF_BLANK;
|
||
|
newTab.ptWidth=0.5;
|
||
|
m_tabList.append(newTab);
|
||
|
lstTabs->insertItem(tabToString(newTab));
|
||
|
lstTabs->setCurrentItem(0);
|
||
|
} else {
|
||
|
double pos = m_tabList[selected].ptPos;
|
||
|
double add=1.0;
|
||
|
if(m_unit==KoUnit::U_INCH) // inches are 25 times as big as mm, take it easy with adding..
|
||
|
add=0.1;
|
||
|
|
||
|
pos=pos + KoUnit::fromUserValue( add, m_unit );
|
||
|
if(pos<m_toplimit)
|
||
|
{
|
||
|
newTab.ptPos=pos + KoUnit::fromUserValue( add, m_unit );
|
||
|
newTab.type=m_tabList[selected].type;
|
||
|
newTab.filling=m_tabList[selected].filling;
|
||
|
newTab.ptWidth=m_tabList[selected].ptWidth;
|
||
|
m_tabList.insert(m_tabList.at(selected), newTab);
|
||
|
lstTabs->insertItem( tabToString(newTab), selected);
|
||
|
lstTabs->setCurrentItem(lstTabs->findItem(tabToString(newTab)));
|
||
|
sortLists();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void KoParagTabulatorsWidget::deleteClicked() {
|
||
|
int selected = lstTabs->currentItem();
|
||
|
if (selected < 0) return;
|
||
|
noSignals=true;
|
||
|
sTabPos->changeValue(0.0);
|
||
|
noSignals=false;
|
||
|
lstTabs->removeItem(selected);
|
||
|
m_tabList.remove(m_tabList[selected]);
|
||
|
if(lstTabs->count() >0) {
|
||
|
lstTabs->setCurrentItem(QMIN(static_cast<unsigned int>(selected), lstTabs->count()-1 ));
|
||
|
} else {
|
||
|
bDeleteAll->setEnabled(false);
|
||
|
bDelete->setEnabled(false);
|
||
|
gPosition->setEnabled(false);
|
||
|
bgAlign->setEnabled(false);
|
||
|
gTabLeader->setEnabled(false);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void KoParagTabulatorsWidget::deleteAllClicked()
|
||
|
{
|
||
|
noSignals=true;
|
||
|
sTabPos->changeValue(0.0);
|
||
|
noSignals=false;
|
||
|
lstTabs->clear();
|
||
|
m_tabList.clear();
|
||
|
bDeleteAll->setEnabled(false);
|
||
|
bDelete->setEnabled(false);
|
||
|
gPosition->setEnabled(false);
|
||
|
bgAlign->setEnabled(false);
|
||
|
gTabLeader->setEnabled(false);
|
||
|
}
|
||
|
|
||
|
void KoParagTabulatorsWidget::setActiveItem(int selected) {
|
||
|
if(noSignals) return;
|
||
|
if(selected < 0) return;
|
||
|
noSignals=true;
|
||
|
KoTabulator *selectedTab = &m_tabList[selected];
|
||
|
switch( selectedTab->type) {
|
||
|
case T_CENTER:
|
||
|
bgAlign->setButton(1); break;
|
||
|
case T_RIGHT:
|
||
|
bgAlign->setButton(2); break;
|
||
|
case T_DEC_PNT:
|
||
|
bgAlign->setButton(3);
|
||
|
sAlignChar->setText(QString(selectedTab->alignChar));
|
||
|
break;
|
||
|
case T_LEFT:
|
||
|
default:
|
||
|
bgAlign->setButton(0);
|
||
|
}
|
||
|
switch( selectedTab->filling) {
|
||
|
case TF_DOTS:
|
||
|
cFilling->setCurrentItem(1); break;
|
||
|
case TF_LINE:
|
||
|
cFilling->setCurrentItem(2); break;
|
||
|
case TF_DASH:
|
||
|
cFilling->setCurrentItem(3); break;
|
||
|
case TF_DASH_DOT:
|
||
|
cFilling->setCurrentItem(4); break;
|
||
|
case TF_DASH_DOT_DOT:
|
||
|
cFilling->setCurrentItem(5); break;
|
||
|
case TF_BLANK:
|
||
|
default:
|
||
|
cFilling->setCurrentItem(0);
|
||
|
}
|
||
|
eWidth->changeValue( selectedTab->ptWidth );
|
||
|
sTabPos->setValue( KoUnit::toUserValue(selectedTab->ptPos, m_unit));
|
||
|
bDelete->setEnabled(true);
|
||
|
bDeleteAll->setEnabled(true);
|
||
|
gPosition->setEnabled(true);
|
||
|
bgAlign->setEnabled(true);
|
||
|
gTabLeader->setEnabled(true);
|
||
|
noSignals=false;
|
||
|
}
|
||
|
|
||
|
void KoParagTabulatorsWidget::setCurrentTab( double tabPos ) {
|
||
|
KoTabulatorList::ConstIterator it = m_tabList.begin();
|
||
|
for ( int i = 0; it != m_tabList.end(); ++it, ++i )
|
||
|
if ( (*it).ptPos == tabPos ) {
|
||
|
lstTabs->setCurrentItem(i);
|
||
|
setActiveItem( i );
|
||
|
return;
|
||
|
}
|
||
|
kdWarning() << "KoParagTabulatorsWidget::setCurrentTab: no tab found at pos=" << tabPos << endl;
|
||
|
}
|
||
|
|
||
|
QString KoParagTabulatorsWidget::tabToString(const KoTabulator &tab) {
|
||
|
return KoUnit::toUserStringValue( tab.ptPos, m_unit);
|
||
|
}
|
||
|
|
||
|
void KoParagTabulatorsWidget::updateAlign(int selected) {
|
||
|
KoTabulator *selectedTab = &m_tabList[lstTabs->currentItem()];
|
||
|
|
||
|
switch( selected) {
|
||
|
case 1:
|
||
|
selectedTab->type=T_CENTER; break;
|
||
|
case 2:
|
||
|
selectedTab->type=T_RIGHT; break;
|
||
|
case 3:
|
||
|
selectedTab->type=T_DEC_PNT;
|
||
|
selectedTab->alignChar=sAlignChar->text()[0];
|
||
|
break;
|
||
|
case 0:
|
||
|
default:
|
||
|
selectedTab->type=T_LEFT;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void KoParagTabulatorsWidget::updateFilling(int selected) {
|
||
|
KoTabulator *selectedTab = &m_tabList[lstTabs->currentItem()];
|
||
|
|
||
|
switch( selected) {
|
||
|
case 1:
|
||
|
selectedTab->filling=TF_DOTS; break;
|
||
|
case 2:
|
||
|
selectedTab->filling=TF_LINE; break;
|
||
|
case 3:
|
||
|
selectedTab->filling=TF_DASH; break;
|
||
|
case 4:
|
||
|
selectedTab->filling=TF_DASH_DOT; break;
|
||
|
case 5:
|
||
|
selectedTab->filling=TF_DASH_DOT_DOT; break;
|
||
|
case 0:
|
||
|
default:
|
||
|
selectedTab->filling=TF_BLANK;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void KoParagTabulatorsWidget::updateWidth() {
|
||
|
KoTabulator *selectedTab = &m_tabList[lstTabs->currentItem()];
|
||
|
selectedTab->ptWidth = QMAX( 0, eWidth->value() );
|
||
|
}
|
||
|
|
||
|
void KoParagTabulatorsWidget::sortLists() {
|
||
|
|
||
|
noSignals=true;
|
||
|
qHeapSort( m_tabList );
|
||
|
|
||
|
// we could just sort the listView, but to make sure we never have any problems with
|
||
|
// inconsistent lists, just re-add..
|
||
|
QString curValue=lstTabs->currentText();
|
||
|
lstTabs->clear();
|
||
|
KoTabulatorList::ConstIterator it = m_tabList.begin();
|
||
|
for ( ; it != m_tabList.end(); ++it )
|
||
|
lstTabs->insertItem( KoUnit::toUserStringValue( (*it).ptPos, m_unit ) );
|
||
|
|
||
|
lstTabs->setCurrentItem(lstTabs->findItem(curValue));
|
||
|
noSignals=false;
|
||
|
}
|
||
|
|
||
|
void KoParagTabulatorsWidget::display( const KoParagLayout &lay ) {
|
||
|
m_tabList.clear();
|
||
|
lstTabs->clear();
|
||
|
m_tabList = lay.tabList();
|
||
|
KoTabulatorList::ConstIterator it = m_tabList.begin();
|
||
|
for ( ; it != m_tabList.end(); ++it )
|
||
|
lstTabs->insertItem( KoUnit::toUserStringValue( (*it).ptPos, m_unit ) );
|
||
|
|
||
|
if(lstTabs->count() > 0)
|
||
|
lstTabs->setCurrentItem(0);
|
||
|
else {
|
||
|
bDelete->setEnabled(false);
|
||
|
bDeleteAll->setEnabled(false);
|
||
|
gPosition->setEnabled(false);
|
||
|
bgAlign->setEnabled(false);
|
||
|
gTabLeader->setEnabled(false);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void KoParagTabulatorsWidget::save( KoParagLayout & lay ) {
|
||
|
lay.setTabList( m_tabList );
|
||
|
}
|
||
|
|
||
|
QString KoParagTabulatorsWidget::tabName() {
|
||
|
return i18n( "&Tabulators" );
|
||
|
}
|
||
|
|
||
|
/******************************************************************/
|
||
|
/* Class: KoParagDia */
|
||
|
/******************************************************************/
|
||
|
KoParagDia::KoParagDia( QWidget* parent, const char* name,
|
||
|
int flags, KoUnit::Unit unit, double _frameWidth, bool breakLine, bool disableAll )
|
||
|
: KDialogBase(Tabbed, QString::null, Ok | Cancel | User1 | Apply, Ok, parent, name, true )
|
||
|
{
|
||
|
m_decorationsWidget = 0;
|
||
|
m_flags = flags;
|
||
|
setButtonText( KDialogBase::User1, i18n("Reset") );
|
||
|
|
||
|
if ( m_flags & PD_SPACING )
|
||
|
{
|
||
|
QVBox * page = addVBoxPage( i18n( "Indent && S&pacing" ) );
|
||
|
m_indentSpacingWidget = new KoIndentSpacingWidget( unit,_frameWidth,page, "indent-spacing" );
|
||
|
m_indentSpacingWidget->layout()->setMargin(0);
|
||
|
}
|
||
|
if ( m_flags & PD_ALIGN )
|
||
|
{
|
||
|
QVBox * page = addVBoxPage( i18n( "General &Layout" ) );
|
||
|
m_alignWidget = new KoParagAlignWidget( breakLine, page, "align" );
|
||
|
m_alignWidget->layout()->setMargin(0);
|
||
|
}
|
||
|
if ( m_flags & PD_DECORATION )
|
||
|
{
|
||
|
QVBox * page = addVBoxPage( i18n( "D&ecorations" ) );
|
||
|
m_decorationsWidget = new KoParagDecorationWidget( page, "decorations");
|
||
|
m_decorationsWidget->layout()->setMargin(0);
|
||
|
}
|
||
|
if ( m_flags & PD_NUMBERING )
|
||
|
{
|
||
|
QVBox * page = addVBoxPage( i18n( "B&ullets/Numbers" ) );
|
||
|
m_counterWidget = new KoParagCounterWidget( disableAll , page, "numbers" );
|
||
|
m_counterWidget->layout()->setMargin(0);
|
||
|
}
|
||
|
if ( m_flags & PD_TABS )
|
||
|
{
|
||
|
QVBox * page = addVBoxPage( i18n( "&Tabulators" ) );
|
||
|
m_tabulatorsWidget = new KoParagTabulatorsWidget( unit,_frameWidth, page, "tabs");
|
||
|
m_tabulatorsWidget->layout()->setMargin(0);
|
||
|
}
|
||
|
|
||
|
connect( this, SIGNAL( user1Clicked() ), this, SLOT(slotReset()));
|
||
|
setInitialSize( QSize(630, 500) );
|
||
|
}
|
||
|
|
||
|
KoParagDia::~KoParagDia()
|
||
|
{
|
||
|
}
|
||
|
|
||
|
void KoParagDia::slotApply()
|
||
|
{
|
||
|
emit applyParagStyle();
|
||
|
}
|
||
|
|
||
|
void KoParagDia::slotOk()
|
||
|
{
|
||
|
slotApply();
|
||
|
KDialogBase::slotOk();
|
||
|
}
|
||
|
|
||
|
void KoParagDia::setCurrentPage( int page )
|
||
|
{
|
||
|
switch( page )
|
||
|
{
|
||
|
case PD_SPACING:
|
||
|
showPage( pageIndex( m_indentSpacingWidget->parentWidget() ) );
|
||
|
break;
|
||
|
case PD_ALIGN:
|
||
|
showPage( pageIndex( m_alignWidget->parentWidget() ) );
|
||
|
break;
|
||
|
case PD_DECORATION:
|
||
|
showPage( pageIndex( m_decorationsWidget->parentWidget() ) );
|
||
|
break;
|
||
|
case PD_NUMBERING:
|
||
|
showPage( pageIndex( m_counterWidget->parentWidget() ) );
|
||
|
break;
|
||
|
case PD_TABS:
|
||
|
showPage( pageIndex( m_tabulatorsWidget->parentWidget() ) );
|
||
|
break;
|
||
|
default:
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void KoParagDia::setParagLayout( const KoParagLayout & lay )
|
||
|
{
|
||
|
m_indentSpacingWidget->display( lay );
|
||
|
m_alignWidget->display( lay );
|
||
|
m_decorationsWidget->display( lay );
|
||
|
m_counterWidget->display( lay );
|
||
|
m_tabulatorsWidget->display( lay );
|
||
|
oldLayout = lay;
|
||
|
}
|
||
|
|
||
|
void KoParagDia::slotReset()
|
||
|
{
|
||
|
if( m_indentSpacingWidget )
|
||
|
m_indentSpacingWidget->display( oldLayout );
|
||
|
if( m_alignWidget )
|
||
|
m_alignWidget->display( oldLayout );
|
||
|
if ( m_decorationsWidget )
|
||
|
m_decorationsWidget->display( oldLayout );
|
||
|
if( m_counterWidget )
|
||
|
m_counterWidget->display( oldLayout );
|
||
|
if( m_tabulatorsWidget )
|
||
|
m_tabulatorsWidget->display( oldLayout );
|
||
|
}
|
||
|
|
||
|
bool KoParagDia::isCounterChanged() const
|
||
|
{
|
||
|
if ( oldLayout.counter ) // We had a counter
|
||
|
return ! ( *oldLayout.counter == counter() );
|
||
|
else // We had no counter -> changed if we have one now
|
||
|
return counter().numbering() != KoParagCounter::NUM_NONE;
|
||
|
}
|
||
|
|
||
|
int KoParagDia::changedFlags() const
|
||
|
{
|
||
|
return paragLayout().compare( oldLayout );
|
||
|
}
|
||
|
|
||
|
KoParagLayout KoParagDia::paragLayout() const
|
||
|
{
|
||
|
KoParagLayout newLayout;
|
||
|
newLayout.setLineSpacingValue( lineSpacing() );
|
||
|
newLayout.lineSpacingType = lineSpacingType();
|
||
|
newLayout.setTabList( tabListTabulator() );
|
||
|
newLayout.alignment = align();
|
||
|
newLayout.margins[QStyleSheetItem::MarginFirstLine] = firstLineIndent();
|
||
|
newLayout.margins[QStyleSheetItem::MarginLeft] = leftIndent();
|
||
|
newLayout.margins[QStyleSheetItem::MarginRight] = rightIndent();
|
||
|
newLayout.margins[QStyleSheetItem::MarginTop] = spaceBeforeParag();
|
||
|
newLayout.margins[QStyleSheetItem::MarginBottom] = spaceAfterParag();
|
||
|
newLayout.pageBreaking = pageBreaking();
|
||
|
newLayout.leftBorder = leftBorder();
|
||
|
newLayout.rightBorder = rightBorder();
|
||
|
newLayout.topBorder = topBorder();
|
||
|
newLayout.bottomBorder = bottomBorder();
|
||
|
newLayout.joinBorder = joinBorder();
|
||
|
newLayout.backgroundColor = backgroundColor();
|
||
|
newLayout.counter = new KoParagCounter( counter() );
|
||
|
return newLayout;
|
||
|
}
|
||
|
|
||
|
#include "KoParagDia.moc"
|
||
|
#include "KoParagDia_p.moc"
|