TimeSlotPage_wdgt.cpp

/***************************************************************************
 *   Copyright (C) 2006 by Graeme Foster                                   *
 *   email    foster.graeme@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.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#include "TimeSlotPage_wdgt.h"
#include "TimeSlotItem.h"

TimeSlotPageWidget::TimeSlotPageWidget(ControlPanel * window
                                           ,QWidget * widgetParent
                                      ,QBoxLayout * layoutParent
                                      ,dbListManager * dataLists)
: RootPageWidget(window, widgetParent, layoutParent, dataLists)
{
        wdgt.setupUi(this);
        wdgt.cbxInst->init(dataLists);
        createActions();
        selectedTimeSlot = 0;
        KeyModifier = Qt::NoModifier;
}

void TimeSlotPageWidget::createActions()
{
        wdgt.grpWeekDay->installEventFilter(this);
        wdgt.grpWeekend->installEventFilter(this);
        
        connect (wdgt.cbxInst, SIGNAL(currentIndexChanged(QString)), this, SLOT(cbxInstSelected(QString)));
        connect (wdgt.btnAddSlots, SIGNAL(clicked()), this, SLOT(addSlotsClicked()));
        connect (wdgt.tblTimeSlots, SIGNAL(clicked(QModelIndex)), this, SLOT(TimeSlotClicked(QModelIndex)));
}

void TimeSlotPageWidget::toggleWeekDay(bool)
{
        toggleCheckBox(wdgt.chkMonday);
        toggleCheckBox(wdgt.chkTuesday);
        toggleCheckBox(wdgt.chkWednesday);
        toggleCheckBox(wdgt.chkThursday);
        toggleCheckBox(wdgt.chkFriday);
}

void TimeSlotPageWidget::toggleWeekend(bool)
{
        toggleCheckBox(wdgt.chkSaturday);
        toggleCheckBox(wdgt.chkSunday);
}

void TimeSlotPageWidget::toggleCheckBox(QCheckBox * chk)
{
        if (chk->checkState() == Qt::Unchecked)
                chk->setCheckState(Qt::Checked);
        else
                chk->setCheckState(Qt::Unchecked);
}

void TimeSlotPageWidget::cbxInstSelected(QString name)
{
        instObj = dataLists->getInstFromName(name);
        if (instObj == 0)
                wdgt.tblTimeSlots->setModel(0);
        else
        {
                TimeSlotModel * model = new TimeSlotModel(dataLists, instObj);
                dataLists->registerModel(model
                                        ,dbListManager::regTimeSlot
                                        );
                wdgt.tblTimeSlots->setModel(model);
        }
}

void TimeSlotPageWidget::addSlotsClicked()
{
        QString msg;
        mainWindow->statusBar()->showMessage("Adding slots...");
        if (validateData(&msg))
                addSlots();
        else
                mainWindow->statusBar()->showMessage(msg);
}

void TimeSlotPageWidget::TimeSlotClicked(const QModelIndex & index)
{
        QString msg;
        selectedTimeSlot = static_cast<DailyTimeSlotItem*>(index.internalPointer());
        TimeSlot * tsObj = selectedTimeSlot->getItemData(index.column());
        TimeSlotModel * tsModel = static_cast<TimeSlotModel*>(wdgt.tblTimeSlots->model());
        Qt::KeyboardModifiers mod = QApplication::keyboardModifiers ();
        if (mod == Qt::ControlModifier)
        {
                if (tsObj == 0)
                {
                        msg = tsModel->cellHeading(index.row(), index.column());
                        QString day = tsModel->DayHeading(index.row());
                        int duration = 0;
                        QTime startTime = tsModel->StartTimeHeading(index.column());
                        QTime finishTime = tsModel->FinishTimeHeading(index.column());
                        duration = startTime.secsTo(finishTime) / 60;
                        int result = addTimeSlot(instObj, TimeSlot::getDays(day), duration, startTime);
                        if (result == -30)
                                msg = tr("The slot overlaps with another and cannot be added");
                }
                else
                        selectedTimeSlot->deleteItem(index.column());
        }
        else
        {
                if (tsObj == 0)
                        msg = "Ctrl + Click to add this timeslot";
                else
                        msg = "Ctrl + Click to remove the timeslot " + tsObj->getDescription();
        }
        mainWindow->statusBar()->showMessage(msg);
}

bool TimeSlotPageWidget::validateData(QString *msg)
{
        bool valid = true;
        valid = validateDay(msg);
        
        QString name = wdgt.cbxInst->currentText();
        instObj = dataLists->getInstFromName(name);
        if (instObj == 0)
        {
                if (!msg->isNull())
                        msg->append("; ");
                msg->append("You must select an institute");
                valid = false;
        }
        
        duration = wdgt.edtDuration->text().toInt();
        if (duration == 0)
        {
                if (!msg->isNull())
                        msg->append("; ");
                msg->append("The duration is missing");
                valid = false;
        }
        int startTimeHour = wdgt.edtStartTimeHour->text().toInt();
        int startTimeMin  = wdgt.edtStartTimeMin->text().toInt();
        startTime = QTime(startTimeHour, startTimeMin);
        if (startTimeHour == 0 && startTimeMin == 0)
        {
                if (!msg->isNull())
                        msg->append("; ");
                msg->append("The start time is missing");
                valid = false;
        }
        if (!startTime.isValid())
        {
                if (!msg->isNull())
                        msg->append("; ");
                msg->append("The start time is not valid");
                valid = false;
        }
                
        repeat = wdgt.edtRepeat->text().toInt();
        if (repeat == 0)
        {
                if (!msg->isNull())
                        msg->append("; ");
                msg->append("The times to repeat is missing");
                valid = false;
        }
        return valid;
}

bool TimeSlotPageWidget::validateDay(QString *msg)
{
        selectedDays.clear();
        if (wdgt.chkMonday->checkState()==Qt::Checked)
                selectedDays << TimeSlot::Monday;
        if (wdgt.chkTuesday->checkState()==Qt::Checked)
                selectedDays << TimeSlot::Tuesday;
        if (wdgt.chkWednesday->checkState()==Qt::Checked)
                selectedDays << TimeSlot::Wednesday;
        if (wdgt.chkThursday->checkState()==Qt::Checked)
                selectedDays << TimeSlot::Thursday;
        if (wdgt.chkFriday->checkState()==Qt::Checked)
                selectedDays << TimeSlot::Friday;
        if (wdgt.chkSaturday->checkState()==Qt::Checked)
                selectedDays << TimeSlot::Saturday;
        if (wdgt.chkSunday->checkState()==Qt::Checked)
                selectedDays << TimeSlot::Sunday;
        if (selectedDays.empty())
        {
                if (!msg->isNull())
                        msg->append("; ");
                msg->append("Please select at least one day");
        }
        return !selectedDays.isEmpty();
}

void TimeSlotPageWidget::addSlots()
{
        int slotCount = 0;
        int result;
        int overlap = 0;
        QString msg;
        QSetIterator<TimeSlot::days> itr(selectedDays);
        while (itr.hasNext())
        {
                TimeSlot::days thisDay = itr.next();
                for (int i=0; i<repeat; i++)
                {
                        addTimeSlot(instObj, thisDay, duration, startTime,i);
                        if (result == -30)
                                overlap++;
                        if (result >= 0)
                                slotCount++;
                }
        }
        msg = tr("Slots added ") + QString::number(slotCount);
        if (overlap== 1)
                msg += tr(". An overlapping slot was ignored.");
        if (overlap > 1)
                msg += tr(". ") + QString::number(overlap) + tr(" overlapping slots were ignored.");
        mainWindow->statusBar()->showMessage(msg);
}

int TimeSlotPageWidget::addTimeSlot(Institute * inst, TimeSlot::days theDay, int duration, QTime startTime, int offset)
{
        TimeSlot * timeslot;
        timeslot = new TimeSlot(DataClass::NOT_ON_DB
                               ,inst
                               ,theDay
                               ,duration
                               ,startTime.addSecs(offset*duration*60));
        int result = timeslot->save(TimeSlot::insertSQL, TimeSlot::updateSQL, TimeSlot::errorSQL);
        if (result >= 0)
        {
                TimeSlotItem * tsiObj = new TimeSlotItem(timeslot);
                QModelIndex index = QModelIndex();
                dataLists->insert(tsiObj, dataLists->TimeSlotList(),index, tsiObj->getItemData()->dcCompareCI);
        }
        update(); // get the widget to repaint itself.
        return result;
}

bool TimeSlotPageWidget::eventFilter(QObject * target, QEvent * event)
{
        if (event->type() == QEvent::MouseButtonPress)
        {
                if (target == wdgt.grpWeekend)
                        toggleWeekend(true);
                if (target == wdgt.grpWeekDay)
                        toggleWeekDay(true);
        }
        return  QWidget::eventFilter(target, event);
}

---