EditProfileDialog.cpp 40.4 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
    : KDialog(parent)
Robert Knight's avatar
 
Robert Knight committed
60
    , _colorSchemeAnimationTimeLine(0)
61
{
62
    setCaption(i18n("Edit Profile"));
63 64
    setButtons( KDialog::Ok | KDialog::Cancel | KDialog::Apply | KDialog::Default );

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

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

70 71 72 73 74 75 76 77 78 79 80
    // 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() );
81
    connect( _ui->tabWidget , SIGNAL(currentChanged(int)) , this , 
Robert Knight's avatar
 
Robert Knight committed
82
            SLOT(preparePage(int)) );
83

84
    _tempProfile = new Profile;
85 86

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

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

    // 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();
113 114 115 116
}
void EditProfileDialog::accept()
{
    save();
117
    unpreviewAll();
118
    KDialog::accept(); 
119
}
Robert Knight's avatar
 
Robert Knight committed
120 121 122 123
void EditProfileDialog::updateCaption(const QString& profileName)
{
    setCaption( i18n("Edit Profile \"%1\"",profileName) );
}
124
void EditProfileDialog::setProfile(const QString& key)
125
{
126
    _profileKey = key;
127

128
    const Profile* info = SessionManager::instance()->profile(key);
129 130 131

    Q_ASSERT( info );

132
    // update caption
Robert Knight's avatar
 
Robert Knight committed
133
    updateCaption(info->name());
134

135 136 137 138 139
    // 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);
Robert Knight's avatar
 
Robert Knight committed
140
    preparePage( _ui->tabWidget->currentIndex() );
141

142 143 144 145 146
    if ( _tempProfile )
    {
        delete _tempProfile;
        _tempProfile = new Profile;
    }
147
}
148 149 150 151
const Profile* EditProfileDialog::lookupProfile() const
{
    return SessionManager::instance()->profile(_profileKey);
}
Robert Knight's avatar
 
Robert Knight committed
152
void EditProfileDialog::preparePage(int page)
153
{
154
    const Profile* info = lookupProfile();
155

156
    Q_ASSERT( _pageNeedsUpdate.count() > page );
157 158
    Q_ASSERT( info );

Robert Knight's avatar
 
Robert Knight committed
159 160
    QWidget* pageWidget = _ui->tabWidget->widget(page);
    
161
    if ( _pageNeedsUpdate[page] )
162 163 164
    {
       if ( pageWidget == _ui->generalTab )
            setupGeneralPage(info);
165 166
       else if ( pageWidget == _ui->tabsTab )
            setupTabsPage(info);
167 168 169 170 171 172 173 174 175 176 177
       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);

178
        _pageNeedsUpdate[page] = false;
179
    }
Robert Knight's avatar
 
Robert Knight committed
180 181 182 183 184 185 186 187 188

    // start page entry animation for color schemes
    if ( pageWidget == _ui->appearanceTab )
            _colorSchemeAnimationTimeLine->start();
}
void EditProfileDialog::selectProfileName()
{
    _ui->profileNameEdit->selectAll();
    _ui->profileNameEdit->setFocus();
189
}
190
void EditProfileDialog::setupGeneralPage(const Profile* info)
191
{
192 193

    // basic profile options
194
    _ui->profileNameEdit->setText( info->name() );
195 196 197

    ShellCommand command( info->command() , info->arguments() );
    _ui->commandEdit->setText( command.fullCommand() );
198 199

    KUrlCompletion* exeCompletion = new KUrlCompletion(KUrlCompletion::ExeCompletion);
200
    exeCompletion->setDir(QString());
201
    _ui->commandEdit->setCompletionObject( exeCompletion );
202
    _ui->initialDirEdit->setText( info->defaultWorkingDirectory() );
203 204
    _ui->initialDirEdit->setCompletionObject( new KUrlCompletion(KUrlCompletion::DirCompletion) );
    _ui->initialDirEdit->setClearButtonShown(true);
205
    _ui->dirSelectButton->setIcon( KIcon("folder-open") );
206
    _ui->iconSelectButton->setIcon( KIcon(info->icon()) );
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 237 238 239 240 241 242 243 244 245 246 247 248 249 250
    // 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)
{
251 252 253
    // tab title format
    _ui->tabTitleEdit->setClearButtonShown(true);
    _ui->remoteTabTitleEdit->setClearButtonShown(true);
254 255 256 257
    _ui->tabTitleEdit->setText( info->property(Profile::LocalTabTitleFormat).value<QString>() );
    _ui->remoteTabTitleEdit->setText( 
            info->property(Profile::RemoteTabTitleFormat).value<QString>());

258
    // tab options
259
    int tabMode = info->property(Profile::TabBarMode).value<int>();
260
    int tabPosition = info->property(Profile::TabBarPosition).value<int>();
261

262 263 264 265 266 267 268 269 270 271 272 273 274 275
    // 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);

276
    // signals and slots
277 278 279 280
    connect( _ui->tabBarVisibilityCombo , SIGNAL(activated(int)) , this , 
             SLOT(tabBarVisibilityChanged(int)) );
    connect( _ui->tabBarPositionCombo , SIGNAL(activated(int)) , this ,
             SLOT(tabBarPositionChanged(int)) );
281

282 283 284 285
    connect(_ui->tabTitleEdit , SIGNAL(textChanged(const QString&)) , this ,
            SLOT(tabTitleFormatChanged(const QString&)) );
    connect(_ui->remoteTabTitleEdit , SIGNAL(textChanged(const QString&)) , this ,
            SLOT(remoteTabTitleFormatChanged(const QString&)));
286

287 288 289 290 291 292 293 294 295 296 297 298
    // 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&)) ); 
299
}
300 301 302 303 304 305 306 307
void EditProfileDialog::tabBarVisibilityChanged(int newValue)
{
    _tempProfile->setProperty( Profile::TabBarMode , newValue );
}
void EditProfileDialog::tabBarPositionChanged(int newValue)
{
    _tempProfile->setProperty( Profile::TabBarPosition , newValue );
}
308 309 310 311 312 313 314 315
void EditProfileDialog::insertTabTitleText(const QString& text)
{
    _ui->tabTitleEdit->insert(text);
}
void EditProfileDialog::insertRemoteTabTitleText(const QString& text)
{
    _ui->remoteTabTitleEdit->insert(text);
}
316 317 318 319
void EditProfileDialog::showMenuBar(bool show)
{
    _tempProfile->setProperty(Profile::ShowMenuBar,show);
}
320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
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);
Robert Knight's avatar
 
Robert Knight committed
341
    updateCaption(_tempProfile->name());
342 343 344 345 346 347 348
}
void EditProfileDialog::initialDirChanged(const QString& dir)
{
    _tempProfile->setProperty(Profile::Directory,dir);
}
void EditProfileDialog::commandChanged(const QString& command)
{
349 350
    ShellCommand shellCommand(command);

351
    //TODO Split into command and arguments
352 353
    _tempProfile->setProperty(Profile::Command,shellCommand.command());
    _tempProfile->setProperty(Profile::Arguments,shellCommand.arguments());
354 355 356 357 358 359 360 361 362 363
}
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());
364
}
365
void EditProfileDialog::setupAppearancePage(const Profile* info)
366 367
{
    // setup color list
368
    updateColorSchemeList(true);
369

370 371
    ColorSchemeViewDelegate* delegate = new ColorSchemeViewDelegate(this);

Robert Knight's avatar
 
Robert Knight committed
372 373
    _colorSchemeAnimationTimeLine = new QTimeLine( 500 , this );
    delegate->setEntryTimeLine(_colorSchemeAnimationTimeLine);
374

Robert Knight's avatar
 
Robert Knight committed
375
    connect( _colorSchemeAnimationTimeLine , SIGNAL(valueChanged(qreal)) , this ,
376 377 378
             SLOT(colorSchemeAnimationUpdate()) );

    _ui->colorSchemeList->setItemDelegate(delegate);
379 380 381
    _ui->colorSchemeList->setMouseTracking(true);
    _ui->colorSchemeList->installEventFilter(this);

382 383
    connect( _ui->colorSchemeList , SIGNAL(doubleClicked(const QModelIndex&)) , this ,
            SLOT(colorSchemeSelected()) );
384 385 386
    connect( _ui->colorSchemeList , SIGNAL(entered(const QModelIndex&)) , this , 
            SLOT(previewColorScheme(const QModelIndex&)) );

387 388
    connect( _ui->selectColorSchemeButton , SIGNAL(clicked()) , this , 
            SLOT(colorSchemeSelected()) );
389 390 391 392 393 394
    connect( _ui->editColorSchemeButton , SIGNAL(clicked()) , this , 
            SLOT(editColorScheme()) );
    connect( _ui->removeColorSchemeButton , SIGNAL(clicked()) , this ,
            SLOT(removeColorScheme()) );
    connect( _ui->newColorSchemeButton , SIGNAL(clicked()) , this , 
            SLOT(newColorScheme()) );
395

396
    // setup font preview
397
    const QFont& font = info->font();
398
    updateFontPreviewLabel(font);
399 400 401 402 403 404
    _ui->fontSizeSlider->setValue( font.pointSize() );

    connect( _ui->fontSizeSlider , SIGNAL(valueChanged(int)) , this ,
             SLOT(setFontSize(int)) );
    connect( _ui->editFontButton , SIGNAL(clicked()) , this ,
             SLOT(showFontDialog()) );
405 406 407 408 409 410 411
}
void EditProfileDialog::colorSchemeAnimationUpdate()
{
    QAbstractItemModel* model = _ui->colorSchemeList->model();

    for ( int i = model->rowCount() ; i >= 0 ; i-- )
        _ui->colorSchemeList->update( model->index(i,0) );
412
}
413 414 415 416 417
void EditProfileDialog::updateFontPreviewLabel(const QFont& font)
{
    _ui->fontPreviewLabel->setFont(font);
    _ui->fontPreviewLabel->setText(i18n("%1, size %2",font.family(),font.pointSize()));
}
418
void EditProfileDialog::updateColorSchemeList(bool selectCurrentScheme)
419 420 421
{
    delete _ui->colorSchemeList->model();

422
    const QString& name = lookupProfile()->colorScheme();
423 424 425 426 427 428
    const ColorScheme* currentScheme = ColorSchemeManager::instance()->findColorScheme(name);

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

429 430
    QStandardItem* selectedItem = 0;

431 432 433 434 435 436 437 438
    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 )
439
        {
440
           item->setCheckState( Qt::Checked );
441 442
           selectedItem = item;   
        }
443 444 445 446 447 448
        else 
            item->setCheckState( Qt::Unchecked );

        model->appendRow(item);
    }

449 450
    model->sort(0);

451 452
    _ui->colorSchemeList->setModel(model);

453 454
#if 0
    if ( selectCurrentScheme )
455 456
        _ui->colorSchemeList->selectionModel()->select(
                       selectedItem->index() , QItemSelectionModel::Select
457 458
                     );
#endif
459 460 461
}
void EditProfileDialog::updateKeyBindingsList()
{
462 463
    KeyboardTranslatorManager* keyManager = KeyboardTranslatorManager::instance();

464 465
    delete _ui->keyBindingList->model();

466
    const QString& name = lookupProfile()
467
                                    ->property(Profile::KeyBindings).value<QString>();
468

469
    const KeyboardTranslator* currentTranslator = keyManager->findTranslator(name);
470 471 472 473 474
    
    qDebug() << "Current translator = " << currentTranslator << ", name: " << name;

    QStandardItemModel* model = new QStandardItemModel(this);

475
    QList<QString> translatorNames = keyManager->allTranslators();
476 477 478 479 480
    QListIterator<QString> iter(translatorNames);
    while (iter.hasNext())
    {
        const QString& name = iter.next();

481
        const KeyboardTranslator* translator = keyManager->findTranslator(name);
482

483 484
        qDebug() << "Translator:" << translator << ", name = " << 
            translator->name() << "description = " << 
485 486 487 488 489
            translator->description();

        // TODO Use translator->description() here
        QStandardItem* item = new QStandardItem(translator->description());
        item->setData(QVariant::fromValue(translator),Qt::UserRole+1);
490
        item->setIcon( KIcon("keyboard") );
491 492 493 494 495 496 497 498 499 500
        item->setFlags( item->flags() | Qt::ItemIsUserCheckable );

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

        model->appendRow(item);
    }

501 502
    model->sort(0);

503 504
    _ui->keyBindingList->setModel(model);
}
505 506 507 508
bool EditProfileDialog::eventFilter( QObject* watched , QEvent* event )
{
    if ( watched == _ui->colorSchemeList && event->type() == QEvent::Leave )
    {
509 510 511 512
        if ( _tempProfile->isPropertySet(Profile::ColorScheme) )
            preview(Profile::ColorScheme,_tempProfile->colorScheme());
        else
            unpreview(Profile::ColorScheme);
513 514 515 516
    }

    return KDialog::eventFilter(watched,event);
}
517
void EditProfileDialog::unpreviewAll()
518
{
Robert Knight's avatar
 
Robert Knight committed
519
    //qDebug() << "unpreviewing";
520 521 522 523 524 525

    QHash<Profile::Property,QVariant> map;
    QHashIterator<int,QVariant> iter(_previewedProperties);
    while ( iter.hasNext() )
    {
        iter.next();
526
        map.insert((Profile::Property)iter.key(),iter.value());
527 528 529
    }

    // undo any preview changes
530
    if ( !map.isEmpty() )
531 532 533 534 535 536 537 538 539 540 541 542 543
        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
544
void EditProfileDialog::preview(int property , const QVariant& value)
545 546 547 548
{
    QHash<Profile::Property,QVariant> map;
    map.insert((Profile::Property)property,value);

549
    const Profile* original = lookupProfile();
550 551 552 553 554 555 556 557 558 559 560 561 562

    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 );
}
563 564
void EditProfileDialog::removeColorScheme()
{
565 566 567 568 569 570 571 572
    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());
    }
573
}
574
void EditProfileDialog::showColorSchemeEditor(bool isNewScheme)
575 576 577
{    
    QModelIndexList selected = _ui->colorSchemeList->selectionModel()->selectedIndexes();

578 579
    QAbstractItemModel* model = _ui->colorSchemeList->model();
    QModelIndex index;
580
    if ( !selected.isEmpty() )
581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601
        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 )
602
    {
603
        ColorScheme* newScheme = new ColorScheme(*editor->colorScheme());
604

605 606 607
        // if this is a new color scheme, pick a name based on the description
        if ( isNewScheme )
            newScheme->setName(newScheme->description());
608

609 610 611
        ColorSchemeManager::instance()->addColorScheme( newScheme );
        
        updateColorSchemeList();
612

613
        const Profile* profile = lookupProfile(); 
614
        const QString& currentScheme = profile->colorScheme();
615

616 617 618 619
        // 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 )
620
        {
621
            _tempProfile->setProperty(Profile::ColorScheme,newScheme->name());
622
            preview(Profile::ColorScheme,newScheme->name());
623 624 625 626 627 628 629 630 631 632 633
        }
    }
}
void EditProfileDialog::newColorScheme()
{
    showColorSchemeEditor(true);    
}
void EditProfileDialog::editColorScheme()
{
    showColorSchemeEditor(false);
}
634 635 636 637 638 639 640
void EditProfileDialog::colorSchemeSelected()
{
    QModelIndexList selected = _ui->colorSchemeList->selectionModel()->selectedIndexes();

    if ( !selected.isEmpty() )
    {
        QAbstractItemModel* model = _ui->colorSchemeList->model();
641
        const ColorScheme* colors = model->data(selected.first(),Qt::UserRole+1).value<const ColorScheme*>();
642 643 644

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

645 646 647 648 649 650
        changeCheckedItem(model,selected.first());
    }
}
void EditProfileDialog::setupKeyboardPage(const Profile* info)
{
    // setup translator list
651 652
 
    updateKeyBindingsList(); 
653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680

    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 )
{
681 682
        // uncheck current active item
        QModelIndexList list = model->match( model->index(0,0) , Qt::CheckStateRole , Qt::Checked );
683 684 685 686
       
        QListIterator<QModelIndex> iter(list);
        while ( iter.hasNext() ) 
            model->setData( iter.next() , Qt::Unchecked , Qt::CheckStateRole ); 
687 688

        // check new active item
689 690 691 692 693 694 695 696 697 698 699 700 701
        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());   
    }
}
702
void EditProfileDialog::showKeyBindingEditor(bool isNewTranslator)
703 704
{
    QModelIndexList selected = _ui->keyBindingList->selectionModel()->selectedIndexes();
705
    QAbstractItemModel* model = _ui->keyBindingList->model();
706

707
    QModelIndex index;
708
    if ( !selected.isEmpty() )
709 710 711
        index = selected.first();
    else
        index = model->index(0,0); // Use first item if there is no selection
712 713


714 715 716
    const KeyboardTranslator* translator = model->data(index,
                                            Qt::UserRole+1).value<const KeyboardTranslator*>();
    KDialog* dialog = new KDialog(this);
717

718 719 720 721
    if ( isNewTranslator )
        dialog->setCaption(i18n("New Key Binding List"));
    else
        dialog->setCaption(i18n("Edit Key Binding List"));
722

723 724
    KeyBindingEditor* editor = new KeyBindingEditor;
    dialog->setMainWidget(editor);
725 726 727
    
    if ( translator )
        editor->setup(translator);
728 729 730 731 732 733 734 735 736 737

    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());
738

739 740 741
        qDebug() << "Adding new or modified translator to manager" << 
            newTranslator->name() << ", " << newTranslator->description();

742
        KeyboardTranslatorManager::instance()->addTranslator( newTranslator );
743

744 745
        updateKeyBindingsList();
        
746
        const QString& currentTranslator = lookupProfile()
747
                                        ->property(Profile::KeyBindings).value<QString>();
748

749 750 751
        if ( newTranslator->name() == currentTranslator )
        {
            _tempProfile->setProperty(Profile::KeyBindings,newTranslator->name());
752
        }
753 754
    }
}
755 756 757 758 759
void EditProfileDialog::newKeyBinding()
{
    showKeyBindingEditor(true);
}
void EditProfileDialog::editKeyBinding()
760
{
761
    showKeyBindingEditor(false);
762
}
Robert Knight's avatar
Robert Knight committed
763
void EditProfileDialog::setupCombo( ComboOption* options , const Profile* profile )
764
{
Robert Knight's avatar
Robert Knight committed
765
    while ( options->button != 0 )
766
    {
Robert Knight's avatar
Robert Knight committed
767 768 769 770 771 772 773 774 775 776 777 778
        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);
779
        else
Robert Knight's avatar
Robert Knight committed
780 781 782 783
            possible->button->setChecked(false);
   
        connect( possible->button , SIGNAL(clicked()) , this , possible->slot );

784 785
        ++possible;
    }
786
}
787 788

void EditProfileDialog::setupScrollingPage(const Profile* profile)
789
{
790 791 792
    // setup scrollbar radio
    int scrollBarPosition = profile->property(Profile::ScrollBarPosition).value<int>();
   
Robert Knight's avatar
Robert Knight committed
793 794 795 796 797
    RadioOption positions[] = { {_ui->scrollBarHiddenButton,Profile::ScrollBarHidden,SLOT(hideScrollBar())},
                                {_ui->scrollBarLeftButton,Profile::ScrollBarLeft,SLOT(showScrollBarLeft())},
                                {_ui->scrollBarRightButton,Profile::ScrollBarRight,SLOT(showScrollBarRight())},
                                {0,0,0} 
                              }; 
798

Robert Knight's avatar
Robert Knight committed
799
    setupRadio( positions , scrollBarPosition );
800 801 802 803
   
    // setup scrollback type radio
    int scrollBackType = profile->property(Profile::HistoryMode).value<int>();
    
Robert Knight's avatar
Robert Knight committed
804 805 806 807 808
    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 ); 
809 810 811 812 813 814 815
    
    // 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)) );
816 817
}

818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847
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
848 849 850 851 852 853 854 855 856 857 858
    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 );
859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882

    // 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)) ); 
883 884 885 886 887 888 889 890 891 892 893 894 895 896 897

    // 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());
898 899 900 901
}
void EditProfileDialog::customCursorColorChanged(const QColor& color)
{
    _tempProfile->setProperty(Profile::CustomCursorColor,color);
902 903 904

    // ensure that custom cursor colors are enabled
    _ui->customCursorColorButton->click();
905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920
}
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);
921 922 923 924
}
void EditProfileDialog::toggleBlinkingCursor(bool enable)
{
    _tempProfile->setProperty(Profile::BlinkingCursorEnabled,enable);
925 926 927 928 929 930 931 932 933 934 935 936 937
}
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);
}
938
void EditProfileDialog::fontSelected(const QFont& font)
939
{
Robert Knight's avatar
 
Robert Knight committed
940
   //qDebug() << "font selected";
941 942 943 944 945 946 947 948 949
   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);
950
}
951
void EditProfileDialog::showFontDialog()
952 953 954 955 956
{
    //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();
957
   
958 959
    KFontDialog* dialog = new KFontDialog(this);
    dialog->setFont(currentFont);
960

961 962
    connect( dialog , SIGNAL(fontSelected(const QFont&)) , this , SLOT(fontSelected(const QFont&)) );
    dialog->show(); 
963
}
964
void EditProfileDialog::setFontSize(int pointSize)
965 966 967
{
    QFont newFont = _ui->fontPreviewLabel->font();
    newFont.setPointSize(pointSize);
968
    updateFontPreviewLabel(newFont);
969 970

    _tempProfile->setProperty(Profile::Font,newFont);
971 972

    preview(Profile::Font,newFont);
973 974 975 976 977 978
}
ColorSchemeViewDelegate::ColorSchemeViewDelegate(QObject* parent)
 : QAbstractItemDelegate(parent)
{

}
979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007

#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

1008 1009 1010 1011 1012
void ColorSchemeViewDelegate::setEntryTimeLine(QTimeLine* timeLine)
{
    _entryTimeLine = timeLine;
}

1013 1014 1015
void ColorSchemeViewDelegate::paint(QPainter* painter, const QStyleOptionViewItem& option,
                       const QModelIndex& index) const
{
1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031
    // 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() );
    }

1032
    const ColorScheme* scheme = index.data(Qt::UserRole + 1).value<const ColorScheme*>();
1033