calendarview.h

/*
    This file is part of KOrganizer.
 
    Copyright (c) 2000,2001,2003,2004 Cornelius Schumacher <schumacher@kde.org>
    Copyright (C) 2003-2004 Reinhold Kainhofer <reinhold@kainhofer.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.
 
    As a special exception, permission is given to link this program
    with any edition of TQt, and distribute the resulting executable,
    without including the source code for TQt in the source distribution.
*/
#ifndef CALENDARVIEW_H
#define CALENDARVIEW_H
 
#include <tqwidget.h>
#include <tqptrlist.h>
#include <tqmap.h>
#include <tdefile.h>
#include <korganizer/koeventviewer.h>
#include <libkcal/scheduler.h>
#include <kdemacros.h>
 
#include "koglobals.h"
#include "interfaces/korganizer/calendarviewbase.h"
 
class TQWidgetStack;
class TQSplitter;
 
class KOViewManager;
class KODialogManager;
class KOTodoView;
class KOEventEditor;
class DateNavigatorContainer;
class DateNavigator;
class KOIncidenceEditor;
class ResourceView;
class NavigatorBar;
class DateChecker;
 
namespace KOrg { class History; class IncidenceChangerBase; }
class HTMLExportSettings;
 
using namespace KOrg;
using namespace KCal;
 
class CalendarViewExtension : public TQWidget
{
  public:
    CalendarViewExtension( TQWidget *parent, const char *name = 0 )
      : TQWidget( parent, name ) {}
 
    class Factory
    {
      public:
        virtual CalendarViewExtension *create( TQWidget *parent ) = 0;
    };
};
 
class TDE_EXPORT CalendarView : public KOrg::CalendarViewBase, public Calendar::Observer
{
    TQ_OBJECT
  
  public:
    CalendarView( TQWidget *parent = 0, const char *name = 0 );
    virtual ~CalendarView();
 
    class CalendarViewVisitor : public IncidenceBase::Visitor
    {
      public:
        CalendarViewVisitor() : mView( 0 ) {}
        bool act( IncidenceBase *incidence, CalendarView *view )
        {
          mView = view;
          return incidence->accept( *this );
        }
      protected:
        CalendarView *mView;
    };
 
    class CanDeleteIncidenceVisitor : public CalendarViewVisitor
    {
      protected:
        bool visit( Event *event ) { return mView->deleteEvent( event ); }
        bool visit( Todo *todo ) { return mView->deleteTodo( todo ); }
        bool visit( Journal *journal ) { return mView->deleteJournal( journal ); }
    };
 
    void setCalendar( Calendar * );
    Calendar *calendar();
 
    TQPair<ResourceCalendar *, TQString> viewSubResourceCalendar();
 
    KOrg::History *history() const { return mHistory; }
 
    KOViewManager *viewManager() const { return mViewManager; }
    KODialogManager *dialogManager() const { return mDialogManager; }
 
    TQWidgetStack *viewStack() const { return mRightFrame; }
    TQWidget *leftFrame() const { return mLeftFrame; }
    NavigatorBar *navigatorBar() const { return mNavigatorBar; }
    DateNavigator *dateNavigator() const { return mDateNavigator; }
 
    KOIncidenceEditor *editorDialog( Incidence* ) const;
    IncidenceChangerBase *incidenceChanger() const { return mChanger; }
 
    TQDate startDate();
    TQDate endDate();
 
 
    void addView( KOrg::BaseView * );
    void showView( KOrg::BaseView * );
 
    void addExtension( CalendarViewExtension::Factory * );
 
    Incidence *currentSelection();
    Incidence *selectedIncidence();
    TQString currentFilterName() const;
 
  signals:
    void configChanged();
    void categoriesChanged();
    void closingDown();
    void closed( TQWidget * );
 
    void modifiedChanged( bool );
 
    void readOnlyChanged( bool );
 
    void changeNavStringPrev( const TQString & );
    void changeNavStringNext( const TQString & );
 
    void organizerEventsSelected( bool );
    void groupEventsSelected( bool );
    void incidenceSelected( Incidence *incidence, const TQDate &date );
    void todoSelected( bool );
    void subtodoSelected( bool );
 
    void dayPassed( const TQDate & );
    void cancelAttendees( Incidence * );
 
 
    void pasteEnabled( bool );
    void statusMessage( const TQString & );
 
    void calendarViewExpanded( bool );
 
    void autoArchivingSettingsModified();
 
    void newIncidenceChanger( IncidenceChangerBase* );
    void exportHTML( HTMLExportSettings* );
 
    void newFilterListSignal( const TQStringList & );
    void selectFilterSignal( int );
    void filterChanged();
 
  public slots:
    void updateConfig( const TQCString& );
    void updateCategories();
 
 
    bool openCalendar( const TQString &filename, bool merge = false );
 
    bool saveCalendar( const TQString &filename );
 
    void closeCalendar();
 
    void archiveCalendar();
 
    void showIncidence();
    void editIncidence();
    bool editIncidence( const TQString &uid );
    bool editIncidence( const TQString &uid, const TQDate &date );
    void deleteIncidence();
 
    bool addIncidence( const TQString &ical );
 
    void connectIncidenceEditor( KOIncidenceEditor *editor );
 
    void newEvent();
    void newEvent( ResourceCalendar *res, const TQString &subRes );
    void newEvent( ResourceCalendar *res, const TQString &subRes,
                   const TQDate &startDt );
    void newEvent( ResourceCalendar *res, const TQString &subRes,
                   const TQDateTime &startDt );
    void newEvent( ResourceCalendar *res, const TQString &subRes,
                   const TQDateTime &startDt, const TQDateTime &EndDt,
                   bool allDay = false );
    void newEvent( ResourceCalendar *res, const TQString &subRes,
                   const TQString &summary,
                   const TQString &description = TQString(),
                   const TQStringList &attachment = TQStringList(),
                   const TQStringList &attendees = TQStringList(),
                   const TQStringList &attachmentMimetypes = TQStringList(),
                   bool inlineAttachment = false );
 
    void showIncidence( Incidence *, const TQDate & );
    bool editIncidence( Incidence *incidence, const TQDate &date, bool isCounter = false );
    void deleteIncidence( Incidence *, bool force = false );
    void cutIncidence( Incidence * );
    void copyIncidence( Incidence *);
    void pasteIncidence();
 
    void deleteSubTodosIncidence ( Todo *todo );
    void deleteTodoIncidence ( Todo *todo, bool force = false );
    bool deleteEvent( Event * ) { return true; }
    bool deleteTodo( Todo * ) {return true; }
    bool deleteJournal( Journal * ) { return true; }
    bool deleteIncidence( const TQString &uid, bool force = false );
 
    void newTodo();
    void newTodo( ResourceCalendar *res, const TQString &subRes );
    void newTodo( ResourceCalendar *res, const TQString &subRes,
                  const TQDate &date );
    void newSubTodo();
    void newSubTodo( Todo * );
 
    void newTodo( ResourceCalendar *res, const TQString &subRes,
                  const TQString &summary,
                  const TQString &description = TQString(),
                  const TQStringList &attachments = TQStringList(),
                  const TQStringList &attendees = TQStringList(),
                  const TQStringList &attachmentMimetypes = TQStringList(),
                  bool inlineAttachment = false, bool createTask = false );
 
    void newJournal();
    void newJournal( ResourceCalendar *res, const TQString &subRes );
    void newJournal( ResourceCalendar *res, const TQString &subRes,
                     const TQDate &date );
    void newJournal( ResourceCalendar *res, const TQString &subRes,
                     const TQString &text, const TQDate &date = TQDate() );
 
    void toggleAlarm( Incidence * );
    void dissociateOccurrence( Incidence *, const TQDate & );
    void dissociateFutureOccurrence( Incidence *, const TQDate & );
 
 
    void checkClipboard();
 
    void readSettings();
 
    void writeSettings();
 
    void readFilterSettings( TDEConfig *config );
 
    void writeFilterSettings( TDEConfig *config );
 
    void changeIncidenceDisplay( Incidence *, int );
 
    void incidenceAdded( Incidence * );
    void incidenceChanged( Incidence *oldEvent, Incidence *newEvent,
                           KOGlobals::WhatChanged modification );
    void incidenceToBeDeleted( Incidence *incidence );
    void incidenceDeleted( Incidence * );
    void startMultiModify( const TQString &text );
    void endMultiModify();
 
    void editCanceled( Incidence * );
 
    void updateView( const TQDate &start, const TQDate &end );
    void updateView();
 
    void updateUnmanagedViews();
 
    void edit_cut();
 
    void edit_copy();
 
    void edit_paste();
 
    void edit_options();
 
    void print();
 
    void exportWeb();
 
    void exportICalendar();
 
    void exportVCalendar();
 
    void appointment_show();
    void appointment_edit();
    void appointment_delete();
 
    /* frees the selected to-do's children from it's relation, update the view */
    void todo_unsub();
 
    /* frees an incidence's children from it's relation, without update the view
       Works with any incidence type, although currently we only pass to-dos
    */
    bool incidence_unsub( Incidence *inc );
 
    bool makeSubTodosIndependent ( );
 
    bool makeChildrenIndependent( Incidence *inc );
 
    void takeOverEvent();
 
    void takeOverCalendar();
 
    bool isModified();
    void setModified( bool modified = true );
 
    bool isReadOnly();
    void setReadOnly( bool readOnly = true );
 
    void eventUpdated( Incidence * );
 
    /* iTIP scheduling actions */
    void schedule_publish( Incidence *incidence = 0 );
    void schedule_request( Incidence *incidence = 0 );
    void schedule_refresh( Incidence *incidence = 0 );
    void schedule_cancel( Incidence *incidence = 0 );
    void schedule_add( Incidence *incidence = 0 );
    void schedule_reply( Incidence *incidence = 0 );
    void schedule_counter( Incidence *incidence = 0 );
    void schedule_declinecounter( Incidence *incidence = 0 );
    void schedule_forward( Incidence *incidence = 0 );
    void mailFreeBusy( int daysToPublish = 30 );
    void uploadFreeBusy();
 
    void openAddressbook();
 
    void editFilters();
 
    void updateFilter();
 
    void showIntro();
 
    void showDateNavigator( bool );
    void showTodoView( bool );
    void showEventViewer( bool );
 
    void goDate( const TQDate& date );
 
    void showDate( const TQDate &date );
 
    void goToday();
 
    void goNext();
 
    void goPrevious();
 
    void toggleExpand();
    void showLeftFrame( bool show = true );
 
    void dialogClosing( Incidence * );
 
    void processMainViewSelection( Incidence *incidence, const TQDate &date );
    void processTodoListSelection( Incidence *incidence, const TQDate &date );
 
    void processIncidenceSelection( Incidence *incidence, const TQDate &date );
 
    void purgeCompleted();
 
    void slotAutoArchivingSettingsModified() { emit autoArchivingSettingsModified(); }
 
    void showErrorMessage( const TQString & );
    void schedule( Scheduler::Method, Incidence *incidence );
    void addIncidenceOn( Incidence *, const TQDate & );
    void moveIncidenceTo( Incidence *, const TQDate & );
    void filterActivated( int filterNum );
 
    void resourcesChanged();
 
    void selectWeek( const TQDate & );
 
  protected slots:
    void showDates( const KCal::DateList &, const TQDate &preferredMonth = TQDate() );
 
  public:
    // show a standard warning
    // returns KMsgBox::yesNoCancel()
    int msgCalModified();
 
    void adaptNavigationUnits();
 
    TQDate activeIncidenceDate();
 
    TQDate activeDate( bool fallbackToToday = false );
 
    Incidence* singleOccurrenceOrAll( Incidence *inc,
                                      KOGlobals::OccurrenceAction userAction,
                                      KOGlobals::WhichOccurrences &chosenOption,
                                      const TQDate &itemDate = TQDate(),
                                      const bool commitToCalendar = false );
 
  protected:
    void setIncidenceChanger( IncidenceChangerBase *changer );
 
//     // returns KMsgBox::OKCancel()
    int msgItemDelete( Incidence *incidence );
 
    Todo *selectedTodo();
 
    void warningChangeFailed( Incidence * );
    void checkForFilteredChange( Incidence *incidence );
    void dateTimesForNewEvent( TQDateTime &startDt, TQDateTime &endDt, bool &allDay );
    KOEventEditor *newEventEditor( ResourceCalendar *res, const TQString &subRes,
                                   const TQDateTime &startDtParam = TQDateTime(),
                                   const TQDateTime &endDtParam = TQDateTime() ,
                                   bool allDayParam = false );
 
  private:
    void init();
 
    Incidence *incToSendToClipboard( bool cut );
 
    void calendarModified( bool, Calendar * );
    // Helper function for purgeCompleted that recursively purges a todo and
    // its subitems. If it cannot delete a completed todo (because it has
    // uncompleted subitems), notAllPurged is set to true.
    bool purgeCompletedSubTodos( Todo* todo, bool &notAllPurged );
 
    void getIncidenceHierarchy( Incidence *inc, Incidence::List &incidences );
 
    KOrg::History *mHistory;
 
    TQSplitter    *mPanner;
    TQSplitter    *mLeftSplitter;
    TQWidget      *mLeftFrame;
    TQWidgetStack *mRightFrame;
 
    // This navigator bar is used when in full window month view
    // It has nothing to do with the date navigator
    NavigatorBar *mNavigatorBar;
 
    DateNavigatorContainer *mDateNavigatorContainer;
 
 
    TQPtrList<CalendarViewExtension> mExtensions;
 
    Calendar *mCalendar;
 
    DateNavigator *mDateNavigator;
    DateChecker *mDateChecker;
 
    KOEventViewer *mEventViewer;
    KOViewManager *mViewManager;
    KODialogManager *mDialogManager;
 
    // Calendar filters
    TQPtrList<CalFilter> mFilters;
    CalFilter *mCurrentFilter;
 
    // various housekeeping variables.
    bool            mModified; // flag indicating if calendar is modified
    bool            mReadOnly; // flag indicating if calendar is read-only
 
    Incidence *mSelectedIncidence;
    TQDate mSaveDate;
 
    KOTodoView *mTodoList;
    TQMap<Incidence*,KOIncidenceEditor*> mDialogList;
 
    KOrg::IncidenceChangerBase *mChanger;
};
 
 
 
 
#endif