EditProfileDialog.cpp 40 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
/*
    Copyright (C) 2007 by Robert Knight <robertknight@gmail.com>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program 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 General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301  USA.
*/

20 21 22
// Own
#include "EditProfileDialog.h"

23
// Qt
Dirk Mueller's avatar
Dirk Mueller committed
24 25 26 27 28
#include <QtGui/QKeyEvent>
#include <QtGui/QBrush>
#include <QtGui/QPainter>
#include <QtGui/QStandardItem>
#include <QtCore/QDebug>
29
#include <QtCore/QTextCodec>
30
#include <QtGui/QTextEdit>
31 32 33
#include <QtGui/QLinearGradient>
#include <QtGui/QRadialGradient>

34 35
#include <QtCore/QTimeLine>

36
// KDE
37
#include <kcodecaction.h>
38 39
#include <KFontDialog>
#include <KIcon>
40
#include <KIconDialog>
41
#include <KDirSelectDialog>
42
#include <KUrlCompletion>
43
#include <KWindowSystem>
44 45 46

// Konsole
#include "ColorScheme.h"
47
#include "ColorSchemeEditor.h"
48
#include "ui_EditProfileDialog.h"
49 50
#include "KeyBindingEditor.h"
#include "KeyboardTranslator.h"
51
#include "Profile.h"
52
#include "SessionManager.h"
53
#include "ShellCommand.h"
54
#include "TabTitleFormatAction.h"
55 56 57

using namespace Konsole;

58
EditProfileDialog::EditProfileDialog(QWidget* parent)
59 60
    : KDialog(parent)
{
61
    setCaption(i18n("Edit Profile"));
62 63
    setButtons( KDialog::Ok | KDialog::Cancel | KDialog::Apply | KDialog::Default );

64 65
    connect( this , SIGNAL(applyClicked()) , this , SLOT(save()) );

66
    _ui = new Ui::EditProfileDialog();
67
    _ui->setupUi(mainWidget());
68

69 70 71 72 73 74 75 76 77 78 79
    // there are various setupXYZPage() methods to load the items
    // for each page and update their states to match the profile
    // being edited.
    //
    // these are only called when needed ( ie. when the user clicks
    // the tab to move to that page ).
    //
    // the _pageNeedsUpdate vector keeps track of the pages that have
    // not been updated since the last profile change and will need
    // to be refreshed when the user switches to them
    _pageNeedsUpdate.resize( _ui->tabWidget->count() );
80 81 82
    connect( _ui->tabWidget , SIGNAL(currentChanged(int)) , this , 
            SLOT(ensurePageLoaded(int)) );

83
    _tempProfile = new Profile;
84 85

    qDebug() << "Is modal = " << isModal();
86
}
87
EditProfileDialog::~EditProfileDialog()
88 89
{
    delete _ui;
90 91
    delete _tempProfile;
}
92
void EditProfileDialog::save()
93
{
94 95
    if ( _tempProfile->isEmpty() )
        return;
96 97

    SessionManager::instance()->changeProfile(_profileKey,_tempProfile->setProperties());
98 99 100 101 102 103 104 105 106 107 108 109 110 111

    // ensure that these settings are not undone by a call
    // to unpreview()
    QHashIterator<Profile::Property,QVariant> iter(_tempProfile->setProperties());
    while ( iter.hasNext() )
    {
        iter.next();
        _previewedProperties.remove(iter.key());
    }
}
void EditProfileDialog::reject()
{
    unpreviewAll();
    KDialog::reject();
112 113 114 115
}
void EditProfileDialog::accept()
{
    save();
116
    unpreviewAll();
117
    KDialog::accept(); 
118
}
119
void EditProfileDialog::setProfile(const QString& key)
120
{
121
    _profileKey = key;
122

123
    const Profile* info = SessionManager::instance()->profile(key);
124 125 126

    Q_ASSERT( info );

127
    // update caption
128
    setCaption( i18n("Edit Profile \"%1\"",info->name()) );
129

130 131 132 133 134
    // mark each page of the dialog as out of date
    // and force an update of the currently visible page
    //
    // the other pages will be updated as necessary
    _pageNeedsUpdate.fill(true);
135 136
    ensurePageLoaded( _ui->tabWidget->currentIndex() );

137 138 139 140 141
    if ( _tempProfile )
    {
        delete _tempProfile;
        _tempProfile = new Profile;
    }
142
}
143 144 145 146
const Profile* EditProfileDialog::lookupProfile() const
{
    return SessionManager::instance()->profile(_profileKey);
}
147 148
void EditProfileDialog::ensurePageLoaded(int page)
{
149
    const Profile* info = lookupProfile();
150

151
    Q_ASSERT( _pageNeedsUpdate.count() > page );
152 153
    Q_ASSERT( info );

154
    if ( _pageNeedsUpdate[page] )
155 156 157 158 159
    {
       QWidget* pageWidget = _ui->tabWidget->widget(page);

       if ( pageWidget == _ui->generalTab )
            setupGeneralPage(info);
160 161
       else if ( pageWidget == _ui->tabsTab )
            setupTabsPage(info);
162 163 164 165 166 167 168 169 170 171 172
       else if ( pageWidget == _ui->appearanceTab )
            setupAppearancePage(info);
       else if ( pageWidget == _ui->scrollingTab )
            setupScrollingPage(info);
       else if ( pageWidget == _ui->keyboardTab )
            setupKeyboardPage(info);
       else if ( pageWidget == _ui->advancedTab )
            setupAdvancedPage(info);
       else
           Q_ASSERT(false);

173
        _pageNeedsUpdate[page] = false;
174 175
    }
}
176
void EditProfileDialog::setupGeneralPage(const Profile* info)
177
{
178 179

    // basic profile options
180
    _ui->profileNameEdit->setText( info->name() );
181 182 183

    ShellCommand command( info->command() , info->arguments() );
    _ui->commandEdit->setText( command.fullCommand() );
184 185

    KUrlCompletion* exeCompletion = new KUrlCompletion(KUrlCompletion::ExeCompletion);
186
    exeCompletion->setDir(QString());
187
    _ui->commandEdit->setCompletionObject( exeCompletion );
188
    _ui->initialDirEdit->setText( info->defaultWorkingDirectory() );
189 190
    _ui->initialDirEdit->setCompletionObject( new KUrlCompletion(KUrlCompletion::DirCompletion) );
    _ui->initialDirEdit->setClearButtonShown(true);
191
    _ui->dirSelectButton->setIcon( KIcon("folder-open") );
192
    _ui->iconSelectButton->setIcon( KIcon(info->icon()) );
193

194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236
    // window options
    _ui->showMenuBarButton->setChecked( info->property(Profile::ShowMenuBar).value<bool>() );

    // signals and slots
    connect( _ui->dirSelectButton , SIGNAL(clicked()) , this , SLOT(selectInitialDir()) );
    connect( _ui->iconSelectButton , SIGNAL(clicked()) , this , SLOT(selectIcon()) );

    connect( _ui->profileNameEdit , SIGNAL(textChanged(const QString&)) , this ,
            SLOT(profileNameChanged(const QString&)) );
    connect( _ui->initialDirEdit , SIGNAL(textChanged(const QString&)) , this , 
            SLOT(initialDirChanged(const QString&)) );
    connect(_ui->commandEdit , SIGNAL(textChanged(const QString&)) , this ,
            SLOT(commandChanged(const QString&)) ); 
    
    connect(_ui->showMenuBarButton , SIGNAL(toggled(bool)) , this , 
            SLOT(showMenuBar(bool)) );

    connect(_ui->environmentEditButton , SIGNAL(clicked()) , this , 
            SLOT(showEnvironmentEditor()) );
}
void EditProfileDialog::showEnvironmentEditor()
{
    const Profile* info = lookupProfile();

    KDialog* dialog = new KDialog(this);
    QTextEdit* edit = new QTextEdit(dialog);

    QStringList currentEnvironment = info->property(Profile::Environment).value<QStringList>();

    edit->setPlainText( currentEnvironment.join("\n") );
    dialog->setPlainCaption(i18n("Edit Environment"));
    dialog->setMainWidget(edit);

    if ( dialog->exec() == QDialog::Accepted )
    {
        QStringList newEnvironment = edit->toPlainText().split('\n');
        _tempProfile->setProperty(Profile::Environment,newEnvironment);
    }

    dialog->deleteLater();
}
void EditProfileDialog::setupTabsPage(const Profile* info)
{
237 238 239
    // tab title format
    _ui->tabTitleEdit->setClearButtonShown(true);
    _ui->remoteTabTitleEdit->setClearButtonShown(true);
240 241 242 243
    _ui->tabTitleEdit->setText( info->property(Profile::LocalTabTitleFormat).value<QString>() );
    _ui->remoteTabTitleEdit->setText( 
            info->property(Profile::RemoteTabTitleFormat).value<QString>());

244
    // tab options
245
    int tabMode = info->property(Profile::TabBarMode).value<int>();
246
    int tabPosition = info->property(Profile::TabBarPosition).value<int>();
247

248 249 250 251 252 253 254 255 256 257 258 259 260 261
    // note: Items should be in the same order as the 
    // Profile::TabBarModeEnum enum
    _ui->tabBarVisibilityCombo->addItems( QStringList() << i18n("Always hide tab bar")
                                                        << i18n("Show tab bar when needed") 
                                                        << i18n("Always show tab bar") );
    _ui->tabBarVisibilityCombo->setCurrentIndex(tabMode);

    // note: Items should be in the same order as the
    // Profile::TabBarPositionEnum enum
    _ui->tabBarPositionCombo->addItems( QStringList() << i18n("Below terminal displays")
                                                      << i18n("Above terminal displays") );

    _ui->tabBarPositionCombo->setCurrentIndex(tabPosition);

262
    // signals and slots
263 264 265 266
    connect( _ui->tabBarVisibilityCombo , SIGNAL(activated(int)) , this , 
             SLOT(tabBarVisibilityChanged(int)) );
    connect( _ui->tabBarPositionCombo , SIGNAL(activated(int)) , this ,
             SLOT(tabBarPositionChanged(int)) );
267

268 269 270 271
    connect(_ui->tabTitleEdit , SIGNAL(textChanged(const QString&)) , this ,
            SLOT(tabTitleFormatChanged(const QString&)) );
    connect(_ui->remoteTabTitleEdit , SIGNAL(textChanged(const QString&)) , this ,
            SLOT(remoteTabTitleFormatChanged(const QString&)));
272

273 274 275 276 277 278 279 280 281 282 283 284
    // menus for local and remote tab title dynamic elements
    TabTitleFormatAction* localTabTitleAction = new TabTitleFormatAction(this);
    localTabTitleAction->setContext(Session::LocalTabTitle);
    _ui->tabTitleEditButton->setMenu(localTabTitleAction->menu());
    connect( localTabTitleAction , SIGNAL(dynamicElementSelected(const QString&)) , 
            this , SLOT(insertTabTitleText(const QString&)) );

    TabTitleFormatAction* remoteTabTitleAction = new TabTitleFormatAction(this);
    remoteTabTitleAction->setContext(Session::RemoteTabTitle);
    _ui->remoteTabTitleEditButton->setMenu(remoteTabTitleAction->menu());
    connect( remoteTabTitleAction , SIGNAL(dynamicElementSelected(const QString&)) ,
           this , SLOT(insertRemoteTabTitleText(const QString&)) ); 
285
}
286 287 288 289 290 291 292 293
void EditProfileDialog::tabBarVisibilityChanged(int newValue)
{
    _tempProfile->setProperty( Profile::TabBarMode , newValue );
}
void EditProfileDialog::tabBarPositionChanged(int newValue)
{
    _tempProfile->setProperty( Profile::TabBarPosition , newValue );
}
294 295 296 297 298 299 300 301
void EditProfileDialog::insertTabTitleText(const QString& text)
{
    _ui->tabTitleEdit->insert(text);
}
void EditProfileDialog::insertRemoteTabTitleText(const QString& text)
{
    _ui->remoteTabTitleEdit->insert(text);
}
302 303 304 305
void EditProfileDialog::showMenuBar(bool show)
{
    _tempProfile->setProperty(Profile::ShowMenuBar,show);
}
306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333
void EditProfileDialog::tabTitleFormatChanged(const QString& format)
{
    _tempProfile->setProperty(Profile::LocalTabTitleFormat,format);
}
void EditProfileDialog::remoteTabTitleFormatChanged(const QString& format)
{
    _tempProfile->setProperty(Profile::RemoteTabTitleFormat,format);
}

void EditProfileDialog::selectIcon()
{
    const QString& icon = KIconDialog::getIcon();
    if (!icon.isEmpty())
    {
        _ui->iconSelectButton->setIcon( KIcon(icon) );
        _tempProfile->setProperty(Profile::Icon,icon);
    }
}
void EditProfileDialog::profileNameChanged(const QString& text)
{
    _tempProfile->setProperty(Profile::Name,text);
}
void EditProfileDialog::initialDirChanged(const QString& dir)
{
    _tempProfile->setProperty(Profile::Directory,dir);
}
void EditProfileDialog::commandChanged(const QString& command)
{
334 335
    ShellCommand shellCommand(command);

336
    //TODO Split into command and arguments
337 338
    _tempProfile->setProperty(Profile::Command,shellCommand.command());
    _tempProfile->setProperty(Profile::Arguments,shellCommand.arguments());
339 340 341 342 343 344 345 346 347 348
}
void EditProfileDialog::selectInitialDir()
{
    const KUrl& url = KDirSelectDialog::selectDirectory(_ui->initialDirEdit->text(),
                                                        true,
                                                        0L,
                                                        i18n("Select Initial Directory"));

    if ( !url.isEmpty() )
        _ui->initialDirEdit->setText(url.path());
349
}
350
void EditProfileDialog::setupAppearancePage(const Profile* info)
351 352
{
    // setup color list
353
    updateColorSchemeList(true);
354

355 356
    ColorSchemeViewDelegate* delegate = new ColorSchemeViewDelegate(this);

357
    QTimeLine* timeLine = new QTimeLine( 500 , this );
358 359 360 361 362 363
    delegate->setEntryTimeLine(timeLine);

    connect( timeLine , SIGNAL(valueChanged(qreal)) , this ,
             SLOT(colorSchemeAnimationUpdate()) );

    _ui->colorSchemeList->setItemDelegate(delegate);
364 365 366
    _ui->colorSchemeList->setMouseTracking(true);
    _ui->colorSchemeList->installEventFilter(this);

367 368
    connect( _ui->colorSchemeList , SIGNAL(doubleClicked(const QModelIndex&)) , this ,
            SLOT(colorSchemeSelected()) );
369 370 371
    connect( _ui->colorSchemeList , SIGNAL(entered(const QModelIndex&)) , this , 
            SLOT(previewColorScheme(const QModelIndex&)) );

372 373
    connect( _ui->selectColorSchemeButton , SIGNAL(clicked()) , this , 
            SLOT(colorSchemeSelected()) );
374 375 376 377 378 379
    connect( _ui->editColorSchemeButton , SIGNAL(clicked()) , this , 
            SLOT(editColorScheme()) );
    connect( _ui->removeColorSchemeButton , SIGNAL(clicked()) , this ,
            SLOT(removeColorScheme()) );
    connect( _ui->newColorSchemeButton , SIGNAL(clicked()) , this , 
            SLOT(newColorScheme()) );
380

381
    // setup font preview
382
    const QFont& font = info->font();
383
    updateFontPreviewLabel(font);
384 385 386 387 388 389
    _ui->fontSizeSlider->setValue( font.pointSize() );

    connect( _ui->fontSizeSlider , SIGNAL(valueChanged(int)) , this ,
             SLOT(setFontSize(int)) );
    connect( _ui->editFontButton , SIGNAL(clicked()) , this ,
             SLOT(showFontDialog()) );
390 391 392 393 394 395 396 397 398 399

    // start entry animation
    timeLine->start();
}
void EditProfileDialog::colorSchemeAnimationUpdate()
{
    QAbstractItemModel* model = _ui->colorSchemeList->model();

    for ( int i = model->rowCount() ; i >= 0 ; i-- )
        _ui->colorSchemeList->update( model->index(i,0) );
400
}
401 402 403 404 405
void EditProfileDialog::updateFontPreviewLabel(const QFont& font)
{
    _ui->fontPreviewLabel->setFont(font);
    _ui->fontPreviewLabel->setText(i18n("%1, size %2",font.family(),font.pointSize()));
}
406
void EditProfileDialog::updateColorSchemeList(bool selectCurrentScheme)
407 408 409
{
    delete _ui->colorSchemeList->model();

410
    const QString& name = lookupProfile()->colorScheme();
411 412 413 414 415 416
    const ColorScheme* currentScheme = ColorSchemeManager::instance()->findColorScheme(name);

    QStandardItemModel* model = new QStandardItemModel(this);
    QList<const ColorScheme*> schemeList = ColorSchemeManager::instance()->allColorSchemes();
    QListIterator<const ColorScheme*> schemeIter(schemeList);

417 418
    QStandardItem* selectedItem = 0;

419 420 421 422 423 424 425 426
    while (schemeIter.hasNext())
    {
        const ColorScheme* colors = schemeIter.next();
        QStandardItem* item = new QStandardItem(colors->description());
        item->setData( QVariant::fromValue(colors) ,  Qt::UserRole + 1);
        item->setFlags( item->flags() | Qt::ItemIsUserCheckable );
        
        if ( colors == currentScheme )
427
        {
428
           item->setCheckState( Qt::Checked );
429 430
           selectedItem = item;   
        }
431 432 433 434 435 436
        else 
            item->setCheckState( Qt::Unchecked );

        model->appendRow(item);
    }

437 438
    model->sort(0);

439 440
    _ui->colorSchemeList->setModel(model);

441 442
#if 0
    if ( selectCurrentScheme )
443 444
        _ui->colorSchemeList->selectionModel()->select(
                       selectedItem->index() , QItemSelectionModel::Select
445 446
                     );
#endif
447 448 449
}
void EditProfileDialog::updateKeyBindingsList()
{
450 451
    KeyboardTranslatorManager* keyManager = KeyboardTranslatorManager::instance();

452 453
    delete _ui->keyBindingList->model();

454
    const QString& name = lookupProfile()
455
                                    ->property(Profile::KeyBindings).value<QString>();
456

457
    const KeyboardTranslator* currentTranslator = keyManager->findTranslator(name);
458 459 460 461 462
    
    qDebug() << "Current translator = " << currentTranslator << ", name: " << name;

    QStandardItemModel* model = new QStandardItemModel(this);

463
    QList<QString> translatorNames = keyManager->allTranslators();
464 465 466 467 468
    QListIterator<QString> iter(translatorNames);
    while (iter.hasNext())
    {
        const QString& name = iter.next();

469
        const KeyboardTranslator* translator = keyManager->findTranslator(name);
470

471 472
        qDebug() << "Translator:" << translator << ", name = " << 
            translator->name() << "description = " << 
473 474 475 476 477
            translator->description();

        // TODO Use translator->description() here
        QStandardItem* item = new QStandardItem(translator->description());
        item->setData(QVariant::fromValue(translator),Qt::UserRole+1);
478
        item->setIcon( KIcon("keyboard") );
479 480 481 482 483 484 485 486 487 488
        item->setFlags( item->flags() | Qt::ItemIsUserCheckable );

        if ( translator == currentTranslator )
            item->setCheckState( Qt::Checked );
        else
            item->setCheckState( Qt::Unchecked );

        model->appendRow(item);
    }

489 490
    model->sort(0);

491 492
    _ui->keyBindingList->setModel(model);
}
493 494 495 496
bool EditProfileDialog::eventFilter( QObject* watched , QEvent* event )
{
    if ( watched == _ui->colorSchemeList && event->type() == QEvent::Leave )
    {
497 498 499 500
        if ( _tempProfile->isPropertySet(Profile::ColorScheme) )
            preview(Profile::ColorScheme,_tempProfile->colorScheme());
        else
            unpreview(Profile::ColorScheme);
501 502 503 504
    }

    return KDialog::eventFilter(watched,event);
}
505
void EditProfileDialog::unpreviewAll()
506
{
Robert Knight's avatar
 
Robert Knight committed
507
    //qDebug() << "unpreviewing";
508 509 510 511 512 513

    QHash<Profile::Property,QVariant> map;
    QHashIterator<int,QVariant> iter(_previewedProperties);
    while ( iter.hasNext() )
    {
        iter.next();
514
        map.insert((Profile::Property)iter.key(),iter.value());
515 516 517
    }

    // undo any preview changes
518
    if ( !map.isEmpty() )
519 520 521 522 523 524 525 526 527 528 529 530 531
        SessionManager::instance()->changeProfile(_profileKey,map,false);
}
void EditProfileDialog::unpreview(int property)
{
    if (!_previewedProperties.contains(property))
        return;

    QHash<Profile::Property,QVariant> map;
    map.insert((Profile::Property)property,_previewedProperties[property]);
    SessionManager::instance()->changeProfile(_profileKey,map,false); 

    _previewedProperties.remove(property);
}
Robert Knight's avatar
Robert Knight committed
532
void EditProfileDialog::preview(int property , const QVariant& value)
533 534 535 536
{
    QHash<Profile::Property,QVariant> map;
    map.insert((Profile::Property)property,value);

537
    const Profile* original = lookupProfile();
538 539 540 541 542 543 544 545 546 547 548 549 550

    if (!_previewedProperties.contains(property))    
        _previewedProperties.insert(property , original->property((Profile::Property)property) );

    // temporary change to color scheme
    SessionManager::instance()->changeProfile( _profileKey , map , false);
}
void EditProfileDialog::previewColorScheme(const QModelIndex& index)
{
    const QString& name = index.data(Qt::UserRole+1).value<const ColorScheme*>()->name();

    preview( Profile::ColorScheme , name );
}
551 552
void EditProfileDialog::removeColorScheme()
{
553 554 555 556 557 558 559 560
    QModelIndexList selected = _ui->colorSchemeList->selectionModel()->selectedIndexes();

    if ( !selected.isEmpty() )
    {
        const QString& name = selected.first().data(Qt::UserRole+1).value<const ColorScheme*>()->name();
        ColorSchemeManager::instance()->deleteColorScheme(name);
        _ui->colorSchemeList->model()->removeRow(selected.first().row());
    }
561
}
562
void EditProfileDialog::showColorSchemeEditor(bool isNewScheme)
563 564 565
{    
    QModelIndexList selected = _ui->colorSchemeList->selectionModel()->selectedIndexes();

566 567
    QAbstractItemModel* model = _ui->colorSchemeList->model();
    QModelIndex index;
568
    if ( !selected.isEmpty() )
569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589
        index = selected.first();
    else
        index = model->index(0,0); // use the first item in the list

    const ColorScheme* colors = model->data(index,Qt::UserRole+1).value<const ColorScheme*>();

    KDialog* dialog = new KDialog(this);

    if ( isNewScheme )
        dialog->setCaption(i18n("New Color Scheme"));
    else
        dialog->setCaption(i18n("Edit Color Scheme"));

    ColorSchemeEditor* editor = new ColorSchemeEditor;
    dialog->setMainWidget(editor);
    editor->setup(colors);

    if ( isNewScheme )
        editor->setDescription(i18n("New Color Scheme"));
        
    if ( dialog->exec() == QDialog::Accepted )
590
    {
591
        ColorScheme* newScheme = new ColorScheme(*editor->colorScheme());
592

593 594 595
        // if this is a new color scheme, pick a name based on the description
        if ( isNewScheme )
            newScheme->setName(newScheme->description());
596

597 598 599
        ColorSchemeManager::instance()->addColorScheme( newScheme );
        
        updateColorSchemeList();
600

601
        const Profile* profile = lookupProfile(); 
602
        const QString& currentScheme = profile->colorScheme();
603

604 605 606 607
        // the next couple of lines may seem slightly odd,
        // but they force any open views based on the current profile
        // to update their color schemes
        if ( newScheme->name() == currentScheme )
608
        {
609
            _tempProfile->setProperty(Profile::ColorScheme,newScheme->name());
610
            preview(Profile::ColorScheme,newScheme->name());
611 612 613 614 615 616 617 618 619 620 621
        }
    }
}
void EditProfileDialog::newColorScheme()
{
    showColorSchemeEditor(true);    
}
void EditProfileDialog::editColorScheme()
{
    showColorSchemeEditor(false);
}
622 623 624 625 626 627 628
void EditProfileDialog::colorSchemeSelected()
{
    QModelIndexList selected = _ui->colorSchemeList->selectionModel()->selectedIndexes();

    if ( !selected.isEmpty() )
    {
        QAbstractItemModel* model = _ui->colorSchemeList->model();
629
        const ColorScheme* colors = model->data(selected.first(),Qt::UserRole+1).value<const ColorScheme*>();
630 631 632

        _tempProfile->setProperty(Profile::ColorScheme,colors->name());

633 634 635 636 637 638
        changeCheckedItem(model,selected.first());
    }
}
void EditProfileDialog::setupKeyboardPage(const Profile* info)
{
    // setup translator list
639 640
 
    updateKeyBindingsList(); 
641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668

    connect( _ui->keyBindingList , SIGNAL(doubleClicked(const QModelIndex&)) , this , 
            SLOT(keyBindingSelected()) );
    connect( _ui->selectKeyBindingsButton , SIGNAL(clicked()) , this , 
            SLOT(keyBindingSelected()) );
    connect( _ui->newKeyBindingsButton , SIGNAL(clicked()) , this ,
            SLOT(newKeyBinding()) );
    connect( _ui->editKeyBindingsButton , SIGNAL(clicked()) , this , 
          SLOT(editKeyBinding()) );  
    connect( _ui->removeKeyBindingsButton , SIGNAL(clicked()) , this ,
            SLOT(removeKeyBinding()) );
}
void EditProfileDialog::keyBindingSelected()
{
    QModelIndexList selected = _ui->keyBindingList->selectionModel()->selectedIndexes();

    if ( !selected.isEmpty() )
    {
        QAbstractItemModel* model = _ui->keyBindingList->model();
        const KeyboardTranslator* translator = model->data(selected.first(),Qt::UserRole+1)
                                                .value<const KeyboardTranslator*>();
        _tempProfile->setProperty(Profile::KeyBindings,translator->name());

        changeCheckedItem(model,selected.first()); 
    }
}
void EditProfileDialog::changeCheckedItem( QAbstractItemModel* model , const QModelIndex& to )
{
669 670
        // uncheck current active item
        QModelIndexList list = model->match( model->index(0,0) , Qt::CheckStateRole , Qt::Checked );
671 672 673 674
       
        QListIterator<QModelIndex> iter(list);
        while ( iter.hasNext() ) 
            model->setData( iter.next() , Qt::Unchecked , Qt::CheckStateRole ); 
675 676

        // check new active item
677 678 679 680 681 682 683 684 685 686 687 688 689
        model->setData( to , Qt::Checked , Qt::CheckStateRole );
}
void EditProfileDialog::removeKeyBinding()
{
    QModelIndexList selected = _ui->keyBindingList->selectionModel()->selectedIndexes();

    if ( !selected.isEmpty() )
    {
        const QString& name = selected.first().data(Qt::UserRole+1).value<const KeyboardTranslator*>()->name();
        KeyboardTranslatorManager::instance()->deleteTranslator(name);
        _ui->keyBindingList->model()->removeRow(selected.first().row());   
    }
}
690
void EditProfileDialog::showKeyBindingEditor(bool isNewTranslator)
691 692
{
    QModelIndexList selected = _ui->keyBindingList->selectionModel()->selectedIndexes();
693
    QAbstractItemModel* model = _ui->keyBindingList->model();
694

695
    QModelIndex index;
696
    if ( !selected.isEmpty() )
697 698 699
        index = selected.first();
    else
        index = model->index(0,0); // Use first item if there is no selection
700 701


702 703 704
    const KeyboardTranslator* translator = model->data(index,
                                            Qt::UserRole+1).value<const KeyboardTranslator*>();
    KDialog* dialog = new KDialog(this);
705

706 707 708 709
    if ( isNewTranslator )
        dialog->setCaption(i18n("New Key Binding List"));
    else
        dialog->setCaption(i18n("Edit Key Binding List"));
710

711 712
    KeyBindingEditor* editor = new KeyBindingEditor;
    dialog->setMainWidget(editor);
713 714 715
    
    if ( translator )
        editor->setup(translator);
716 717 718 719 720 721 722 723 724 725

    if ( isNewTranslator )
        editor->setDescription(i18n("New Key Binding List"));

    if ( dialog->exec() == QDialog::Accepted )
    {
        KeyboardTranslator* newTranslator = new KeyboardTranslator(*editor->translator());

        if ( isNewTranslator )
            newTranslator->setName(newTranslator->description());
726

727 728 729
        qDebug() << "Adding new or modified translator to manager" << 
            newTranslator->name() << ", " << newTranslator->description();

730
        KeyboardTranslatorManager::instance()->addTranslator( newTranslator );
731

732 733
        updateKeyBindingsList();
        
734
        const QString& currentTranslator = lookupProfile()
735
                                        ->property(Profile::KeyBindings).value<QString>();
736

737 738 739
        if ( newTranslator->name() == currentTranslator )
        {
            _tempProfile->setProperty(Profile::KeyBindings,newTranslator->name());
740
        }
741 742
    }
}
743 744 745 746 747
void EditProfileDialog::newKeyBinding()
{
    showKeyBindingEditor(true);
}
void EditProfileDialog::editKeyBinding()
748
{
749
    showKeyBindingEditor(false);
750
}
Robert Knight's avatar
Robert Knight committed
751
void EditProfileDialog::setupCombo( ComboOption* options , const Profile* profile )
752
{
Robert Knight's avatar
Robert Knight committed
753
    while ( options->button != 0 )
754
    {
Robert Knight's avatar
Robert Knight committed
755 756 757 758 759 760 761 762 763 764 765 766
        options->button->setChecked( profile->property((Profile::Property)options->property).value<bool>() );
        connect( options->button , SIGNAL(toggled(bool)) , this , options->slot );

        ++options;
    }
}
void EditProfileDialog::setupRadio( RadioOption* possible , int actual )
{
    while (possible->button != 0)
    {
        if ( possible->property == actual )
            possible->button->setChecked(true);
767
        else
Robert Knight's avatar
Robert Knight committed
768 769 770 771
            possible->button->setChecked(false);
   
        connect( possible->button , SIGNAL(clicked()) , this , possible->slot );

772 773
        ++possible;
    }
774
}
775 776

void EditProfileDialog::setupScrollingPage(const Profile* profile)
777
{
778 779 780
    // setup scrollbar radio
    int scrollBarPosition = profile->property(Profile::ScrollBarPosition).value<int>();
   
Robert Knight's avatar
Robert Knight committed
781 782 783 784 785
    RadioOption positions[] = { {_ui->scrollBarHiddenButton,Profile::ScrollBarHidden,SLOT(hideScrollBar())},
                                {_ui->scrollBarLeftButton,Profile::ScrollBarLeft,SLOT(showScrollBarLeft())},
                                {_ui->scrollBarRightButton,Profile::ScrollBarRight,SLOT(showScrollBarRight())},
                                {0,0,0} 
                              }; 
786

Robert Knight's avatar
Robert Knight committed
787
    setupRadio( positions , scrollBarPosition );
788 789 790 791
   
    // setup scrollback type radio
    int scrollBackType = profile->property(Profile::HistoryMode).value<int>();
    
Robert Knight's avatar
Robert Knight committed
792 793 794 795 796
    RadioOption types[] = { {_ui->disableScrollbackButton,Profile::DisableHistory,SLOT(noScrollBack())},
                            {_ui->fixedScrollbackButton,Profile::FixedSizeHistory,SLOT(fixedScrollBack())},
                            {_ui->unlimitedScrollbackButton,Profile::UnlimitedHistory,SLOT(unlimitedScrollBack())},
                            {0,0,0} };
    setupRadio( types , scrollBackType ); 
797 798 799 800 801 802 803
    
    // setup scrollback line count spinner
    _ui->scrollBackLinesSpinner->setValue( profile->property(Profile::HistorySize).value<int>() );

    // signals and slots
    connect( _ui->scrollBackLinesSpinner , SIGNAL(valueChanged(int)) , this , 
            SLOT(scrollBackLinesChanged(int)) );
804 805
}

806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835
void EditProfileDialog::scrollBackLinesChanged(int lineCount)
{
    _tempProfile->setProperty(Profile::HistorySize , lineCount);
}
void EditProfileDialog::noScrollBack()
{
    _tempProfile->setProperty(Profile::HistoryMode , Profile::DisableHistory);
}
void EditProfileDialog::fixedScrollBack()
{
    _tempProfile->setProperty(Profile::HistoryMode , Profile::FixedSizeHistory);
}
void EditProfileDialog::unlimitedScrollBack()
{
    _tempProfile->setProperty(Profile::HistoryMode , Profile::UnlimitedHistory );
}
void EditProfileDialog::hideScrollBar()
{
    _tempProfile->setProperty(Profile::ScrollBarPosition , Profile::ScrollBarHidden );
}
void EditProfileDialog::showScrollBarLeft()
{
    _tempProfile->setProperty(Profile::ScrollBarPosition , Profile::ScrollBarLeft );
}
void EditProfileDialog::showScrollBarRight()
{
    _tempProfile->setProperty(Profile::ScrollBarPosition , Profile::ScrollBarRight );
}
void EditProfileDialog::setupAdvancedPage(const Profile* profile)
{
Robert Knight's avatar
Robert Knight committed
836 837 838 839 840 841 842 843 844 845 846
    ComboOption  options[] = { { _ui->enableBlinkingTextButton , Profile::BlinkingTextEnabled , 
                                 SLOT(toggleBlinkingText(bool)) },
                               { _ui->enableFlowControlButton , Profile::FlowControlEnabled ,
                                 SLOT(toggleFlowControl(bool)) },
                               { _ui->enableResizeWindowButton , Profile::AllowProgramsToResizeWindow ,
                                 SLOT(toggleResizeWindow(bool)) },
                               { _ui->enableBlinkingCursorButton , Profile::BlinkingCursorEnabled ,
                                 SLOT(toggleBlinkingCursor(bool)) },
                               { 0 , 0 , 0 }
                             };
    setupCombo( options , profile );
847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870

    // interaction options
    _ui->wordCharacterEdit->setText( profile->property(Profile::WordCharacters).value<QString>() );

    connect( _ui->wordCharacterEdit , SIGNAL(textChanged(const QString&)) , this , 
            SLOT(wordCharactersChanged(const QString&)) );

    // cursor options
    if ( profile->property(Profile::UseCustomCursorColor).value<bool>() )
        _ui->customCursorColorButton->setChecked(true);
    else
        _ui->autoCursorColorButton->setChecked(true);

    _ui->customColorSelectButton->setColor( profile->property(Profile::CustomCursorColor).value<QColor>() );

    connect( _ui->customCursorColorButton , SIGNAL(clicked()) , this , SLOT(customCursorColor()) );
    connect( _ui->autoCursorColorButton , SIGNAL(clicked()) , this , SLOT(autoCursorColor()) );
    connect( _ui->customColorSelectButton , SIGNAL(changed(const QColor&)) , 
            SLOT(customCursorColorChanged(const QColor&)) );

    int shape = profile->property(Profile::CursorShape).value<int>();
    _ui->cursorShapeCombo->setCurrentIndex(shape);

    connect( _ui->cursorShapeCombo , SIGNAL(activated(int)) , this , SLOT(setCursorShape(int)) ); 
871 872 873 874 875 876 877 878 879 880 881 882 883 884 885

    // encoding options
    QAction* codecAction = new KCodecAction(this);
    _ui->selectEncodingButton->setMenu( codecAction->menu() );
    connect( codecAction , SIGNAL(triggered(QTextCodec*)) , this , SLOT(setDefaultCodec(QTextCodec*)) );

    _ui->characterEncodingLabel->setText( profile->property(Profile::DefaultEncoding).value<QString>() );

}
void EditProfileDialog::setDefaultCodec(QTextCodec* codec)
{
    QString name = QString(codec->name());

    _tempProfile->setProperty(Profile::DefaultEncoding,name);
    _ui->characterEncodingLabel->setText(codec->name());
886 887 888 889
}
void EditProfileDialog::customCursorColorChanged(const QColor& color)
{
    _tempProfile->setProperty(Profile::CustomCursorColor,color);
890 891 892

    // ensure that custom cursor colors are enabled
    _ui->customCursorColorButton->click();
893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908
}
void EditProfileDialog::wordCharactersChanged(const QString& text)
{
    _tempProfile->setProperty(Profile::WordCharacters,text);
}
void EditProfileDialog::autoCursorColor()
{
    _tempProfile->setProperty(Profile::UseCustomCursorColor,false);
}
void EditProfileDialog::customCursorColor()
{
    _tempProfile->setProperty(Profile::UseCustomCursorColor,true);
}
void EditProfileDialog::setCursorShape(int index)
{
    _tempProfile->setProperty(Profile::CursorShape,index);
909 910 911 912
}
void EditProfileDialog::toggleBlinkingCursor(bool enable)
{
    _tempProfile->setProperty(Profile::BlinkingCursorEnabled,enable);
913 914 915 916 917 918 919 920 921 922 923 924 925
}
void EditProfileDialog::toggleBlinkingText(bool enable)
{
    _tempProfile->setProperty(Profile::BlinkingTextEnabled,enable);
}
void EditProfileDialog::toggleFlowControl(bool enable)
{
    _tempProfile->setProperty(Profile::FlowControlEnabled,enable);
}
void EditProfileDialog::toggleResizeWindow(bool enable)
{
    _tempProfile->setProperty(Profile::AllowProgramsToResizeWindow,enable);
}
926
void EditProfileDialog::fontSelected(const QFont& font)
927
{
Robert Knight's avatar
 
Robert Knight committed
928
   //qDebug() << "font selected";
929 930 931 932 933 934 935 936 937
   QSlider* slider = _ui->fontSizeSlider;
   
   _ui->fontSizeSlider->setRange( qMin(slider->minimum(),font.pointSize()) ,
                                  qMax(slider->maximum(),font.pointSize()) );
   _ui->fontSizeSlider->setValue(font.pointSize());
   _ui->fontPreviewLabel->setFont(font);

   _tempProfile->setProperty(Profile::Font,font);
   preview(Profile::Font,font);
938
}
939
void EditProfileDialog::showFontDialog()
940 941 942 943 944
{
    //TODO Only permit selection of mono-spaced fonts.  
    // the KFontDialog API does not appear to have a means to do this
    // at present.
    QFont currentFont = _ui->fontPreviewLabel->font();
945
   
946 947
    KFontDialog* dialog = new KFontDialog(this);
    dialog->setFont(currentFont);
948

949 950
    connect( dialog , SIGNAL(fontSelected(const QFont&)) , this , SLOT(fontSelected(const QFont&)) );
    dialog->show(); 
951
}
952
void EditProfileDialog::setFontSize(int pointSize)
953 954 955
{
    QFont newFont = _ui->fontPreviewLabel->font();
    newFont.setPointSize(pointSize);
956
    updateFontPreviewLabel(newFont);
957 958

    _tempProfile->setProperty(Profile::Font,newFont);
959 960

    preview(Profile::Font,newFont);
961 962 963 964 965 966
}
ColorSchemeViewDelegate::ColorSchemeViewDelegate(QObject* parent)
 : QAbstractItemDelegate(parent)
{

}
967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995

#if 0
QWidget* ColorSchemeViewDelegate::createEditor(QWidget* parent, const QStyleOptionViewItem& option, 
                                  const QModelIndex& index) const
{
    QWidget* holder = new QWidget(parent);
    QVBoxLayout* layout = new QVBoxLayout;

    QWidget* selectButton = new QPushButton(i18n("Use Color Scheme"));
    QWidget* editButton = new QPushButton(i18n("Edit..."));

    layout->setMargin(0);

    layout->addWidget(selectButton);
    layout->addWidget(editButton);

    holder->setLayout(layout);

    int width = holder->sizeHint().width();

    int left = option.rect.right() - width - 10;
    int top = option.rect.top();

    holder->move( left , top );

    return holder;
}
#endif

996 997 998 999 1000
void ColorSchemeViewDelegate::setEntryTimeLine(QTimeLine* timeLine)
{
    _entryTimeLine = timeLine;
}

1001 1002 1003
void ColorSchemeViewDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option,
                       const QModelIndex& index) const
{
1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019
    // entry animation
    //
    // note that the translation occurs for each item drawn, but the 
    // painter is not reset between painting items.  this means that when
    // the items are painted in order ( as occurs when the list is first
    // shown ), there is a visually pleasing staggering of items as they
    // enter.
    if ( _entryTimeLine != 0 )
    {
        qreal value = 1.0-_entryTimeLine->currentValue();
        painter->translate(  value * 
                             option.rect.width() , 0 );

        painter->setOpacity( _entryTimeLine->currentValue() );
    }

1020
    const ColorScheme* scheme = index.data(Qt::UserRole + 1).value<const ColorScheme*>();
1021 1022 1023

    Q_ASSERT(scheme);

1024 1025
    bool transparencyAvailable = KWindowSystem::compositingActive();

1026 1027
    painter->setRenderHint( QPainter::Antialiasing );

1028
    // draw background
1029
    painter->setPen( QPen(scheme->foregroundColor() , 1) );
1030 1031 1032 1033

    // radial gradient for background
    // from a lightened version of the scheme's background color in the center to
    // a darker version at the outer edge
1034
    QColor color = scheme->backgroundColor();
1035 1036 1037 1038 1039 1040
    QRectF backgroundRect = QRectF(option.rect).adjusted(1.5,1.5,-1.5,-1.5);
  
    QRadialGradient backgroundGradient(backgroundRect.center() , backgroundRect.width() / 2);
    backgroundGradient.setColorAt( 0 , color.lighter(105) );
    backgroundGradient.setColorAt( 1 , color.darker(115) );
   
1041 1042 1043 1044 1045
    const int backgroundRectXRoundness = 4;
    const int backgroundRectYRoundness = 30;

    QPainterPath backgroundRectPath(backgroundRect.topLeft());
    backgroundRectPath.addRoundRect( backgroundRect , backgroundRectXRoundness , backgroundRectYRoundness );