kptcalendarpanel.cpp

/* This file is part of the KDE project
    Copyright (C) 1997 Tim D. Gilman (tdgilman@best.org)
              (C) 1998-2001 Mirko Boehm (mirko@kde.org)
              (C) 2004 Dag Andersen <danders@get2net.dk>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/
 
/* This is based on KDatePicker. */
 
#include "kptcalendarpanel.h"
#include "kptdatetable.h"
#include "kptcalendar.h"
 
 
#include <tdeglobal.h>
#include <tdeapplication.h>
#include <tdelocale.h>
#include <kcalendarsystem.h> 
#include <kiconloader.h>
#include <tqframe.h>
#include <tqpainter.h>
#include <tqdialog.h>
#include <tqstyle.h>
#include <tqtoolbutton.h>
#include <tqtooltip.h>
#include <tqfont.h>
#include <klineedit.h>
#include <tqvalidator.h>
#include <kdebug.h>
#include <knotifyclient.h>
 
namespace KPlato
{
 
class CalendarPanel::CalendarPanelPrivate
{
public:
    CalendarPanelPrivate() : closeButton(0L), selectWeek(0L) {}
 
    TQToolButton *closeButton;
    TQToolButton *selectWeek;
};
 
 
CalendarPanel::CalendarPanel(TQWidget *parent, TQDate dt, const char *name, WFlags f)
  : TQFrame(parent,name, f)
{
  init( dt );
}
 
CalendarPanel::CalendarPanel( TQWidget *parent, const char *name )
  : TQFrame(parent,name)
{
    init( TQDate::currentDate() );
}
 
void CalendarPanel::init( const TQDate &dt )
{
  yearForward = new TQToolButton(this);
  yearBackward = new TQToolButton(this);
  monthForward = new TQToolButton(this);
  monthBackward = new TQToolButton(this);
  selectMonth = new TQToolButton(this);
  selectYear = new TQToolButton(this);
  line = new KLineEdit(this);
  val = new DateValidator(this);
  table = new DateTable(this, dt, "Calendar table", 0);
  fontsize = 10;
 
  d = new CalendarPanelPrivate();
  d->selectWeek = new TQToolButton( this );
 
  TQToolTip::add(yearForward, i18n("Next year"));
  TQToolTip::add(yearBackward, i18n("Previous year"));
  TQToolTip::add(monthForward, i18n("Next month"));
  TQToolTip::add(monthBackward, i18n("Previous month"));
  TQToolTip::add(d->selectWeek, i18n("Select a week"));
  TQToolTip::add(selectMonth, i18n("Select a month"));
  TQToolTip::add(selectYear, i18n("Select a year"));
 
  // -----
  setFontSize(10);
  line->setValidator(val);
  line->installEventFilter( this );
  yearForward->setPixmap(BarIcon(TQString::fromLatin1("2rightarrow")));
  yearBackward->setPixmap(BarIcon(TQString::fromLatin1("2leftarrow")));
  monthForward->setPixmap(BarIcon(TQString::fromLatin1("1rightarrow")));
  monthBackward->setPixmap(BarIcon(TQString::fromLatin1("1leftarrow")));
  setDate(dt); // set button texts
  connect(table, TQ_SIGNAL(dateChanged(TQDate)), TQ_SLOT(dateChangedSlot(TQDate)));
  connect(table, TQ_SIGNAL(tableClicked()), TQ_SLOT(tableClickedSlot()));
  connect(monthForward, TQ_SIGNAL(clicked()), TQ_SLOT(monthForwardClicked()));
  connect(monthBackward, TQ_SIGNAL(clicked()), TQ_SLOT(monthBackwardClicked()));
  connect(yearForward, TQ_SIGNAL(clicked()), TQ_SLOT(yearForwardClicked()));
  connect(yearBackward, TQ_SIGNAL(clicked()), TQ_SLOT(yearBackwardClicked()));
  connect(d->selectWeek, TQ_SIGNAL(clicked()), TQ_SLOT(selectWeekClicked()));
  connect(selectMonth, TQ_SIGNAL(clicked()), TQ_SLOT(selectMonthClicked()));
  connect(selectYear, TQ_SIGNAL(clicked()), TQ_SLOT(selectYearClicked()));
  connect(line, TQ_SIGNAL(returnPressed()), TQ_SLOT(lineEnterPressed()));
 
  connect(table, TQ_SIGNAL(weekdaySelected(int)), TQ_SLOT(slotWeekdaySelected(int)));
  connect(table, TQ_SIGNAL(weekSelected(int, int)), TQ_SLOT(slotWeekSelected(int, int)));
  connect(table, TQ_SIGNAL(selectionCleared()), TQ_SLOT(slotSelectionCleared()));
 
  table->setFocus();
}
 
CalendarPanel::~CalendarPanel()
{
  delete d;
}
 
bool
CalendarPanel::eventFilter(TQObject *o, TQEvent *e )
{
   if ( e->type() == TQEvent::KeyPress ) {
      TQKeyEvent *k = (TQKeyEvent *)e;
 
      if ( (k->key() == TQt::Key_Prior) ||
           (k->key() == TQt::Key_Next)  ||
           (k->key() == TQt::Key_Up)    ||
           (k->key() == TQt::Key_Down) )
       {
          TQApplication::sendEvent( table, e );
          table->setFocus();
          return true; // eat event
       }
   }
   return TQFrame::eventFilter( o, e );
}
 
void
CalendarPanel::resizeEvent(TQResizeEvent*)
{
    TQWidget *buttons[] = {
    yearBackward,
        monthBackward,
        selectMonth,
        selectYear,
        monthForward,
        yearForward,
        d->closeButton
    };
    const int NoOfButtons=sizeof(buttons)/sizeof(buttons[0]);
    TQSize sizes[NoOfButtons];
    int buttonHeight=0;
    int count;
    int w=0;
    int x=0;
    // ----- calculate button row height:
    for(count=0; count<NoOfButtons; ++count) {
        if ( buttons[count] ) { // closeButton may be 0L
            sizes[count]=buttons[count]->sizeHint();
            buttonHeight=TQMAX(buttonHeight, sizes[count].height());
        }
        else
            sizes[count] = TQSize(0,0); // closeButton
    }
 
    // ----- calculate size of the month button:
    for(count=0; count<NoOfButtons; ++count) {
        if(buttons[count]==selectMonth) {
            TQSize metricBound = style().sizeFromContents(TQStyle::CT_ToolButton, selectMonth, maxMonthRect);
            sizes[count].setWidth(TQMAX(metricBound.width(), maxMonthRect.width()+2*TQApplication::style().pixelMetric(TQStyle::PM_ButtonMargin)));
        }
    }
    // ----- center buttons
    w=0;
    for(count=0; count<NoOfButtons; ++count)
    {
        w +=sizes[count].width();
    }
    x = (TQMAX(w, width())-w)/2;
 
    // ----- place the buttons:
    for(count=0; count<NoOfButtons; ++count)
    {
        w=sizes[count].width();
        if ( buttons[count] )
            buttons[count]->setGeometry(x, 0, w, buttonHeight);
        x+=w;
    }
    // ----- place the line edit for direct input:
    sizes[0]=line->sizeHint();
    int week_width=d->selectWeek->fontMetrics().width(i18n("Week XX"))+((d->closeButton != 0L) ? 50 : 20);
    line->setGeometry(0, height()-sizes[0].height(), width()-week_width, sizes[0].height());
    d->selectWeek->setGeometry(width()-week_width, height()-sizes[0].height(), week_width, sizes[0].height());
    // ----- adjust the table:
    table->setGeometry(0, buttonHeight, width(),
               height()-buttonHeight-sizes[0].height());
}
 
void
CalendarPanel::dateChangedSlot(TQDate date)
{
    //kdDebug() << "CalendarPanel::dateChangedSlot: date changed (" << date.year() << "/" << date.month() << "/" << date.day() << ")." << endl;
    line->setText(TDEGlobal::locale()->formatDate(date, true));
    d->selectWeek->setText(i18n("Week %1").arg(weekOfYear(date)));
    selectMonth->setText(TDEGlobal::locale()->calendar()->monthName(date.month(), false));
    selectYear->setText(date.toString("yyyy"));
    emit(dateChanged(date));
}
 
void
CalendarPanel::tableClickedSlot()
{
  //kdDebug() << "CalendarPanel::tableClickedSlot: table clicked." << endl;
  emit(dateSelected(table->getDate()));
  emit(tableClicked());
}
 
const TQDate&
CalendarPanel::getDate() const
{
  return table->getDate();
}
 
const TQDate &
CalendarPanel::date() const
{
    return table->getDate();
}
 
bool
CalendarPanel::setDate(const TQDate& date)
{
    if(date.isValid()) {
    TQString temp;
    // -----
    table->setDate(date);
    d->selectWeek->setText(i18n("Week %1").arg(weekOfYear(date)));
    selectMonth->setText(TDEGlobal::locale()->calendar()->monthName(date.month(), false));
    temp.setNum(date.year());
    selectYear->setText(temp);
    line->setText(TDEGlobal::locale()->formatDate(date, true));
    return true;
    } else {
    kdDebug() << "CalendarPanel::setDate: refusing to set invalid date." << endl;
    return false;
    }
}
 
void
CalendarPanel::monthForwardClicked()
{
    setDate( table->getDate().addMonths(1) );
}
 
void
CalendarPanel::monthBackwardClicked()
{
    setDate( table->getDate().addMonths(-1) );
}
 
void
CalendarPanel::yearForwardClicked()
{
    setDate( table->getDate().addYears(1) );
}
 
void
CalendarPanel::yearBackwardClicked()
{
    setDate( table->getDate().addYears(-1) );
}
 
void
CalendarPanel::selectWeekClicked()
{
  int week;
  PopupFrame* popup = new PopupFrame(this);
  DateInternalWeekSelector* picker = new DateInternalWeekSelector(fontsize, popup);
  // -----
  picker->resize(picker->sizeHint());
  popup->setMainWidget(picker);
  connect(picker, TQ_SIGNAL(closeMe(int)), popup, TQ_SLOT(close(int)));
  picker->setFocus();
  if(popup->exec(d->selectWeek->mapToGlobal(TQPoint(0, d->selectWeek->height()))))
    {
      TQDate date;
      int year;
      // -----
      week=picker->getWeek();
      date=table->getDate();
      year=date.year();
      // ----- find the first selectable day in this week (hacky solution :)
      date.setYMD(year, 1, 1);
      while (weekOfYear(date)>50)
          date=date.addDays(1);
      while (weekOfYear(date)<week && (week!=53 || (week==53 &&
            (weekOfYear(date)!=52 || weekOfYear(date.addDays(1))!=1))))
          date=date.addDays(1);
      if (week==53 && weekOfYear(date)==52)
          while (weekOfYear(date.addDays(-1))==52)
              date=date.addDays(-1);
      // ----- set this date
      setDate(date);
    } else {
         KNotifyClient::beep();
    }
  delete popup;
}
 
void
CalendarPanel::selectMonthClicked()
{
  int month;
  PopupFrame* popup = new PopupFrame(this);
  DateInternalMonthPicker* picker = new DateInternalMonthPicker(fontsize, popup);
  // -----
  picker->resize(picker->sizeHint());
  popup->setMainWidget(picker);
  picker->setFocus();
  connect(picker, TQ_SIGNAL(closeMe(int)), popup, TQ_SLOT(close(int)));
  if(popup->exec(selectMonth->mapToGlobal(TQPoint(0, selectMonth->height()))))
    {
      TQDate date;
      int day;
      // -----
      month=picker->getResult();
      date=table->getDate();
      day=date.day();
      // ----- construct a valid date in this month:
      date.setYMD(date.year(), month, 1);
      date.setYMD(date.year(), month, TQMIN(day, date.daysInMonth()));
      // ----- set this month
      setDate(date);
    } else {
      KNotifyClient::beep();
    }
  delete popup;
}
 
void
CalendarPanel::selectYearClicked()
{
  int year;
  PopupFrame* popup = new PopupFrame(this);
  DateInternalYearSelector* picker = new DateInternalYearSelector(fontsize, popup);
  // -----
  picker->resize(picker->sizeHint());
  popup->setMainWidget(picker);
  connect(picker, TQ_SIGNAL(closeMe(int)), popup, TQ_SLOT(close(int)));
  picker->setFocus();
  if(popup->exec(selectYear->mapToGlobal(TQPoint(0, selectMonth->height()))))
    {
      TQDate date;
      int day;
      // -----
      year=picker->getYear();
      date=table->getDate();
      day=date.day();
      // ----- construct a valid date in this month:
      date.setYMD(year, date.month(), 1);
      date.setYMD(year, date.month(), TQMIN(day, date.daysInMonth()));
      // ----- set this month
      setDate(date);
    } else {
      KNotifyClient::beep();
    }
  delete popup;
}
 
void
CalendarPanel::setEnabled(bool enable)
{
  TQWidget *widgets[]= {
    yearForward, yearBackward, monthForward, monthBackward,
    selectMonth, selectYear,
    line, table, d->selectWeek };
  const int Size=sizeof(widgets)/sizeof(widgets[0]);
  int count;
  // -----
  for(count=0; count<Size; ++count)
    {
      widgets[count]->setEnabled(enable);
    }
    table->setEnabled(enable);
}
 
void
CalendarPanel::lineEnterPressed()
{
  TQDate temp;
  // -----
  if(val->date(line->text(), temp)==TQValidator::Acceptable)
    {
        //kdDebug() << "CalendarPanel::lineEnterPressed: valid date entered." << endl;
        emit(dateEntered(temp));
        setDate(temp);
    } else {
      KNotifyClient::beep();
      //kdDebug() << "CalendarPanel::lineEnterPressed: invalid date entered." << endl;
    }
}
 
TQSize
CalendarPanel::sizeHint() const
{
  TQSize tableSize=table->sizeHint();
  TQWidget *buttons[]={
    yearBackward,
    monthBackward,
    selectMonth,
    selectYear,
    monthForward,
    yearForward,
    d->closeButton
  };
  const int NoOfButtons=sizeof(buttons)/sizeof(buttons[0]);
  TQSize sizes[NoOfButtons];
  int cx=0, cy=0, count;
  // ----- store the size hints:
    for(count=0; count<NoOfButtons; ++count) {
        if ( buttons[count] )
            sizes[count]=buttons[count]->sizeHint();
        else
            sizes[count] = TQSize(0,0);
 
        if(buttons[count]==selectMonth) {
            TQSize metricBound = style().sizeFromContents(TQStyle::CT_ToolButton, selectMonth, maxMonthRect);
            cx+=TQMAX(metricBound.width(), maxMonthRect.width()+2*TQApplication::style().pixelMetric(TQStyle::PM_ButtonMargin));
        } else {
            cx+=sizes[count].width();
        }
        cy=TQMAX(sizes[count].height(), cy);
    }
    // ----- calculate width hint:
    cx=TQMAX(cx, tableSize.width()); // line edit ignored
    // ----- calculate height hint:
    cy+=tableSize.height()+line->sizeHint().height();
    return TQSize(cx, cy);
}
 
void
CalendarPanel::setFontSize(int s)
{
  TQWidget *buttons[]= {
    // yearBackward,
    // monthBackward,
    selectMonth,
    selectYear,
    // monthForward,
    // yearForward
  };
  const int NoOfButtons=sizeof(buttons)/sizeof(buttons[0]);
  int count;
  TQFont font;
  TQRect r;
  // -----
  fontsize=s;
  for(count=0; count<NoOfButtons; ++count)
    {
      font=buttons[count]->font();
      font.setPointSize(s);
      buttons[count]->setFont(font);
    }
  TQFontMetrics metrics(selectMonth->fontMetrics());
  for(int i=1; i <= 12; ++i)
    { // maxMonthRect is used by sizeHint()
      r=metrics.boundingRect(TDEGlobal::locale()->calendar()->monthName(i, false));
      maxMonthRect.setWidth(TQMAX(r.width(), maxMonthRect.width()));
      maxMonthRect.setHeight(TQMAX(r.height(),  maxMonthRect.height()));
    }
  table->setFontSize(s);
}
 
void
CalendarPanel::setCloseButton( bool enable )
{
    if ( enable == (d->closeButton != 0L) )
        return;
 
    if ( enable ) {
        d->closeButton = new TQToolButton( this );
        TQToolTip::add(d->closeButton, i18n("Close"));
        d->closeButton->setPixmap( SmallIcon("remove") );
        connect( d->closeButton, TQ_SIGNAL( clicked() ),
                 topLevelWidget(), TQ_SLOT( close() ) );
    }
    else {
        delete d->closeButton;
        d->closeButton = 0L;
    }
    
    updateGeometry();
}
 
bool CalendarPanel::hasCloseButton() const
{
    return (d->closeButton != 0L);
}
 
int CalendarPanel::weekOfYear(TQDate date)
{
    // Calculate ISO 8601 week number (taken from glibc/Gnumeric)
    int year, week, wday, jan1wday, nextjan1wday;
    TQDate jan1date, nextjan1date;
 
    year=date.year();
    wday=date.dayOfWeek();
 
    jan1date=TQDate(year,1,1);
    jan1wday=jan1date.dayOfWeek();
 
    week = (date.dayOfYear()-1 + jan1wday-1)/7 + ((jan1wday-1) == 0 ? 1 : 0);
 
    /* Does date belong to last week of previous year? */
    if ((week == 0) && (jan1wday > 4 /*THURSDAY*/)) {
        TQDate tmpdate=TQDate(year-1,12,31);
        return weekOfYear(tmpdate);
    }
 
    if ((jan1wday <= 4 /*THURSDAY*/) && (jan1wday > 1 /*MONDAY*/))
        week++;
 
    if (week == 53) {
        nextjan1date=TQDate(year+1, 1, 1);
        nextjan1wday = nextjan1date.dayOfWeek();
        if (nextjan1wday <= 4 /*THURSDAY*/)
            week = 1;
    }
 
    return week;
}
 
void CalendarPanel::slotWeekdaySelected(int day) {
    //kdDebug()<<k_funcinfo<<endl;
    emit weekdaySelected(day);
}
 
void CalendarPanel::slotWeekSelected(int week, int year) {
    //kdDebug()<<k_funcinfo<<endl;
    emit weekSelected(week, year);
}
 
void CalendarPanel::setCalendar(Calendar *cal) {
    //kdDebug()<<k_funcinfo<<endl;
    table->clear();
    if (cal) {
        table->setMarkedWeekdays(cal->weekdaysMap());
        TQPtrListIterator<CalendarDay> it = cal->days();
        //kdDebug()<<k_funcinfo<<"Days="<<it.count()<<endl;
        for (; it.current(); ++it) {
            if (it.current()->state() != Map::None) {
                table->addMarkedDate(it.current()->date(), it.current()->state());
            //kdDebug()<<k_funcinfo<<"Added day: "<<it.current()->date().toString()<<"="<<it.current()->state()<<endl;
            }
        }
        setEnabled(true);
        table->setFocus();
    }
}
 
DateMap  CalendarPanel::selectedDates() {
    return table->selectedDates();
}
 
IntMap  CalendarPanel::selectedWeekdays() {
    return table->selectedWeekdays();
}
 
DateMap  CalendarPanel::markedDates() {
    return table->markedDates();
}
 
IntMap  CalendarPanel::markedWeekdays() {
    return table->markedWeekdays();
}
 
void CalendarPanel::clear() {
    table->clear();
    setEnabled(false);
}
 
void CalendarPanel::markSelected(int state) {
    table->markSelected(state);
 }
 
void CalendarPanel::slotSelectionCleared() {
    emit selectionCleared();
 }
 
void CalendarPanel::virtual_hook( int /*id*/, void* /*data*/ )
{ /*BASE::virtual_hook( id, data );*/ }
 
}  //KPlato namespace
 
#include "kptcalendarpanel.moc"