/***************************************************************************
                          settingsdialog.cpp  -  description
                             -------------------
    begin                : Sat May 11 2002
    copyright            : (C) 2002 by Kevin Hessels
    email                : khessels@shaw.ca
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/

#include <qcheckbox.h>
#include <qslider.h>
#include <qspinbox.h>
#include <qlayout.h>
#include <qtimer.h>
#include <qcombobox.h>
#include <qlineedit.h>

#include <kdebug.h>
#include <kconfig.h>
#include <kiconloader.h>
#include <klocale.h>

#include "cfgdata.h"
#include "channelwidgetimpl.h"
#include "devicewidgetimpl.h"
#include "generalwidget.h"
#include "picturewidget.h"
#include "pluginwidgetimpl.h"
#include "qtvision.h"
#include "settingsdialog.h"

#include "settingsdialog.moc"

SettingsDialog::SettingsDialog(QWidget *parent, char *name, bool modal, 
                               ConfigData *currConfig, QtVision *qtvision)
               :KDialogBase(IconList, i18n("Settings"), 
                            Help | Default | Apply | Ok | Cancel, Ok, parent,
                            name, modal, true), m_inputValid(true), 
                            newConfig(0L), qtv(qtvision)
{
    kdDebug() << "SettingsDialog::SettingsDialog: constructor" << endl;
    
    setHelp("kwintv3/settings.html", QString::null);        // FIXME ??
    
    if (qtvision) {
        newConfig = new ConfigData (qtvision->configHandle());
    } else {
        newConfig = new ConfigData(0L);
    }
    
    *newConfig = *currConfig;

    _ptimer = new QTimer(this, "Picture Cfg Timer");
    connect(_ptimer, SIGNAL(timeout()), this, SLOT(updatePicture()));
    setupGeneralPage();
    setupDevicePage();
    setupPicturePage();
    setupChannelsPage();
    setupPluginsPage();

    setGeneralOptions(newConfig);
    setDeviceOptions(newConfig);
    setPictureOptions(newConfig);
    setChannelOptions(newConfig);
    setPluginOptions(newConfig);

    setInitialSize(QSize(702, 490), false);
    _ptimer->start(500);
    return;
} // SettingsDialog constructor


SettingsDialog::~SettingsDialog()
{
    delete newConfig;
    delete _ptimer;
    return;
} // SettingsDialog destructor

void SettingsDialog::setCurrentDevice()
{
    if (!deviceWidgetImpl)
        return;

    deviceWidgetImpl->setCurrentDevice();
    return;
} // setCurrentDevice


/***************************************************************************
*
* Private Functions
*
***************************************************************************/

void SettingsDialog::setupGeneralPage()
{
    QWidget *page0 = addPage(i18n("General"), i18n("Configure the general settings here"),
                           BarIcon("misc", KIcon::SizeMedium));
    generalWidget = new GeneralWidget(page0);
    QGridLayout *grid = new QGridLayout(page0, 1, 1);
    grid->addWidget(generalWidget, 0, 0);
    return;
} // setupGeneralPage


void SettingsDialog::setupDevicePage()
{
    QWidget *page1 = addPage(i18n("Device"), i18n("Configure the device settings here"),
                           BarIcon("kcmpci", KIcon::SizeMedium));
    deviceWidgetImpl = new DeviceWidgetImpl(page1, newConfig, qtv);
    deviceWidgetImpl->setCurrentDevice();
    QGridLayout *grid = new QGridLayout(page1, 1, 1);
    grid->addWidget(deviceWidgetImpl, 0, 0);
    return;
} // setupDevicePage


void SettingsDialog::setupPicturePage()
{
    QWidget *page2 = addPage(i18n("Picture"), i18n("Configure the picture settings here"),
                           BarIcon("colorize", KIcon::SizeMedium));
    pictureWidget = new PictureWidget(page2);

    connect(pictureWidget->_hue, SIGNAL(valueChanged(int)), this, SLOT(slotHueChanged(int)));
    connect(pictureWidget->_colour, SIGNAL(valueChanged(int)), this, SLOT(slotColourChanged(int)));
    connect(pictureWidget->_brightness, SIGNAL(valueChanged(int)), this, SLOT(slotBrightnessChanged(int)));
    connect(pictureWidget->_whiteness, SIGNAL(valueChanged(int)), this, SLOT(slotWhitenessChanged(int)));
    connect(pictureWidget->_contrast, SIGNAL(valueChanged(int)), this, SLOT(slotContrastChanged(int)));
    QGridLayout *grid = new QGridLayout(page2, 1, 1);
    grid->addWidget(pictureWidget, 0, 0);
    return;
} // setupPicturePage


void SettingsDialog::setupChannelsPage()
{
    QWidget *page3 = addPage(i18n("Channels"), i18n("Configure the channel settings here"),
                             BarIcon("queue", KIcon::SizeMedium));
    channelWidgetImpl = new ChannelWidgetImpl(page3, qtv);
    QGridLayout *grid = new QGridLayout(page3, 1, 1);
    grid->addWidget(channelWidgetImpl, 0, 0);

    connect(qtv, SIGNAL(deviceChanged(QVSourcePlugin *)), this, SLOT(slotDeviceChanged(QVSourcePlugin *)));
    
    if (!qtv->device() || !qtv->device()->isTuner())
        channelWidgetImpl->setEnabled(false);
    else
        channelWidgetImpl->setEnabled(true);
    return;
} // setupChannelsPage

void SettingsDialog::setupPluginsPage()
{
    QWidget *page4 = addPage(i18n("Plugins"), i18n("Configure plugins here"),
                             BarIcon("energy", KIcon::SizeMedium));
    pluginWidgetImpl = new PluginWidgetImpl(page4, qtv);
    QGridLayout *grid = new QGridLayout(page4, 1, 1);
    grid->addWidget(pluginWidgetImpl, 0, 0);
    return;
} // setupPluginsPage


void SettingsDialog::setGeneralOptions(ConfigData *cfg)
{
    generalWidget->_mirror->setChecked(cfg->mirror);
    generalWidget->_maxRes->setChecked(cfg->maxResolution);
    generalWidget->_landscape->setChecked(cfg->landscape);
    generalWidget->_autoStart->setChecked(cfg->autoStart);
    generalWidget->_frameRate->setValue(cfg->frameRate);
    generalWidget->_fixAR->setChecked(cfg->fixAR);
    generalWidget->_aspectCombo->setCurrentItem(cfg->ARmode);
    generalWidget->_disableScreenSaver->setChecked(cfg->disableScreenSaver);
    generalWidget->_saverCombo->setCurrentItem(cfg->screenSaverMode);
    generalWidget->_useListingsURL->setChecked(cfg->useListingsURL);
    generalWidget->_listingsURL->setText(cfg->listingsURL);
    generalWidget->_delayOnChange->setValue(cfg->volumeRestoreDelay);
    generalWidget->_stayOnTop->setChecked(cfg->stayOnTop);
    
    generalWidget->_videoDesktopEnabled->setChecked(cfg->videoDesktopEnabled);
    return;
} // setGenralOptions


void SettingsDialog::setDeviceOptions(ConfigData * /*cfg*/)
{

    return;
} // setDeviceOptions


void SettingsDialog::setPictureOptions(ConfigData *cfg)
{
    pictureWidget->_hue->setValue(cfg->hue);
    pictureWidget->_colour->setValue(cfg->colour);
    pictureWidget->_brightness->setValue(cfg->brightness);
    pictureWidget->_whiteness->setValue(cfg->whiteness);
    pictureWidget->_contrast->setValue(cfg->contrast);
    pictureWidget->_autoScale->setChecked(cfg->autoScaleEnabled);
    return;
} // setPictureOptions


void SettingsDialog::setChannelOptions(ConfigData *cfg)
{
    channelWidgetImpl->showSelected->setChecked(cfg->showSelectedOnly);
    return;
} // setChannelOptions

void SettingsDialog::setPluginOptions(ConfigData * /*cfg*/)
{
    return;
} // setPluginOptions



bool SettingsDialog::checkValues()
{
    // add any necessary checks for user input here, as required....

    return(true);
} // checkValues


/***************************************************************************
*
* Protected Slots
*
***************************************************************************/

void SettingsDialog::slotCancel()
{
    // qtv->channels()->reload();
    KDialogBase::slotCancel();
}


void SettingsDialog::slotApply()
{
    if (!checkValues()) {
        m_inputValid = false;
        return;
    } // if

    // Apply the general options
    newConfig->frameRate = generalWidget->_frameRate->value();
    newConfig->autoStart = generalWidget->_autoStart->isChecked();
    newConfig->landscape = generalWidget->_landscape->isChecked();
    newConfig->maxResolution = generalWidget->_maxRes->isChecked();
    newConfig->videoDesktopEnabled = generalWidget->_videoDesktopEnabled->isChecked();
    newConfig->stayOnTop = generalWidget->_stayOnTop->isChecked();
    newConfig->mirror = generalWidget->_mirror->isChecked();
    newConfig->fixAR = generalWidget->_fixAR->isChecked();
    newConfig->ARmode = generalWidget->_aspectCombo->currentItem();
    newConfig->disableScreenSaver = generalWidget->_disableScreenSaver->isChecked();
    newConfig->screenSaverMode = generalWidget->_saverCombo->currentItem();
    newConfig->useListingsURL = generalWidget->_useListingsURL->isChecked();
    newConfig->listingsURL = generalWidget->_listingsURL->text();
    newConfig->volumeRestoreDelay = generalWidget->_delayOnChange->value();
    
    // Apply the device options
    if (deviceWidgetImpl->deviceChanged()) {
        // only restart capture if the device or source was modified.
        deviceWidgetImpl->device(qtv);
        qtv->startCapture();
    } // if

    // Apply the picture options
    newConfig->hue = pictureWidget->_hue->value();
    newConfig->colour = pictureWidget->_colour->value();
    newConfig->brightness = pictureWidget->_brightness->value();
    newConfig->whiteness = pictureWidget->_whiteness->value();
    newConfig->contrast = pictureWidget->_contrast->value();
    newConfig->autoScaleEnabled = pictureWidget->_autoScale->isChecked();

    // Apply the channel options
    newConfig->showSelectedOnly = channelWidgetImpl->showSelected->isChecked();
    channelWidgetImpl->updateChannels();
    qtv->channels()->save();

    // Apply the plugin options
    pluginWidgetImpl->applyPlugins(qtv->configHandle());

    emit optionsModified(newConfig);
    return;
} // slotApply


void SettingsDialog::slotDefault()
{
    switch(activePageIndex()) {
        case page_general:
            newConfig->defaultsGeneral();
            setGeneralOptions(newConfig);
            break;
        case page_device:
            newConfig->defaultsDevice();
            setDeviceOptions(newConfig);
            break;
        case page_picture:
            newConfig->defaultsPicture();
            setPictureOptions(newConfig);
            break;
        case page_channels:
            newConfig->defaultsChannels();
            setChannelOptions(newConfig);
            break;
        case page_plugins:
            setPluginOptions(newConfig);
            break;
    } // switch
    return;
} // slotDefault


void SettingsDialog::slotHelp()
{
    KDialogBase::slotHelp();
    return;
} // slotHelp


void SettingsDialog::slotOk()
{
    m_inputValid = true;
    slotApply();

    if (m_inputValid)
        accept();
    return;
} // slotOk

/***************************************************************************
*
* Private Slots
*
***************************************************************************/

void SettingsDialog::slotHueChanged(int hue)
{
    emit hueChanged(hue);
    return;
} // slotHueChanged


void SettingsDialog::slotColourChanged(int colour)
{
    emit colourChanged(colour);
    return;
} // slotColourChanged


void SettingsDialog::slotBrightnessChanged(int brightness)
{
    emit brightnessChanged(brightness);
    return;
} // slotBrightnessChanged


void SettingsDialog::slotWhitenessChanged(int whiteness)
{
    emit whitenessChanged(whiteness);
    return;
} // slotWhitenessChanged


void SettingsDialog::slotContrastChanged(int contrast)
{
    emit contrastChanged(contrast);
    return;
} // slotContrastChanged


void SettingsDialog::slotDeviceChanged(QVSourcePlugin *)
{
    if ((!channelWidgetImpl) || (!qtv->device()))
        return;

    if (!qtv->device()->isTuner())
        channelWidgetImpl->setEnabled(false);
    else
        channelWidgetImpl->setEnabled(true);
    return;
} // slotDeviceChanged


void SettingsDialog::updatePicture()
{
    if (!qtv->device())
        return;
    if (pictureWidget->_hue->value() != qtv->hue())
        pictureWidget->_hue->setValue(qtv->hue());
    if (pictureWidget->_colour->value() != qtv->colour())
        pictureWidget->_colour->setValue(qtv->colour());
    if (pictureWidget->_brightness->value() != qtv->brightness())
         pictureWidget->_brightness->setValue(qtv->brightness());
    if (pictureWidget->_whiteness->value() != qtv->whiteness())
         pictureWidget->_whiteness->setValue(qtv->whiteness());
    if (pictureWidget->_contrast->value() != qtv->contrast())
         pictureWidget->_contrast->setValue(qtv->contrast());
}