rubberband fix

author: zautrix <zautrix> 2005-04-21 12:32:52 (UTC)
committer: zautrix <zautrix> 2005-04-21 12:32:52 (UTC)
commit: 0a13a3490ec3bf4735e3435f80f58fa7d50b4448 (patch) (unidiff)
tree: c7f28c49b52e479f47da0dce9f0bfe9189ecdca4
parent: 4d96d7b681ce99d76746a843c289b75f5e7dba64 (diff)
download: kdepimpi-0a13a3490ec3bf4735e3435f80f58fa7d50b4448.zip
kdepimpi-0a13a3490ec3bf4735e3435f80f58fa7d50b4448.tar.gz
kdepimpi-0a13a3490ec3bf4735e3435f80f58fa7d50b4448.tar.bz2
3 files changed, 22 insertions, 6 deletions
diff --git a/korganizer/komonthview.cpp b/korganizer/komonthview.cpp
index 7927307..8ee1363 100644
--- a/korganizer/komonthview.cpp
+++ b/korganizer/komonthview.cpp
@@ -1,2086 +1,2086 @@
 /*
  This file is part of KOrganizer.
  Copyright (c) 2000,2001 Cornelius Schumacher <schumacher@kde.org>
  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 <qpopupmenu.h>
 #include <qfont.h>
 #include <qfontmetrics.h>
 #include <qkeycode.h>
 #include <qhbox.h>
 #include <qvbox.h>
 #include <qwidgetstack.h>
 #include <qpushbutton.h>
 #include <qtooltip.h>
 #include <qpainter.h>
 #include <qtimer.h>
 #include <qwhatsthis.h>
 #ifndef DESKTOP_VERSION
 #include <qpe/qpeapplication.h>
 #else
 #include <qapplication.h>
 #endif
 #include <kdebug.h>
 #include <klocale.h>
 #include <kglobal.h>
 #include <kconfig.h>
 #include <kiconloader.h>
 #include <kcalendarsystem.h>
 #ifndef KORG_NOPRINTER
 #include "calprinter.h"
 #endif
 #include "koprefs.h"
 #ifndef KORG_NOPLUGINS
 #include "kocore.h"
 #endif
 #include "koglobals.h"
 #include <libkcal/kincidenceformatter.h>
 #include "komonthview.h"
 #define PIXMAP_SIZE 5
 #ifdef DESKTOP_VERSION
 QToolTipGroup *MonthViewCell::mToolTipGroup = 0; 
 #endif
 class KNOWhatsThis :public QWhatsThis
 {
 public:
    KNOWhatsThis( KNoScrollListBox* sbox ) : QWhatsThis( sbox ), _wid( sbox) { };
    //~KNOWhatsThis( ) {qDebug("~KNOWhatsThis( ) "); };
 protected:
    virtual QString text( const QPoint& p)
    {
        return _wid->getWhatsThisText(p) ;
    };
 private:
    KNoScrollListBox* _wid;
  
 };
 
 KNoScrollListBox::KNoScrollListBox(QWidget *parent,const char *name)
    : QListBox(parent, name, WRepaintNoErase)
 {
 #ifndef DESKTOP_VERSION
    QPEApplication::setStylusOperation( viewport(), QPEApplication::RightOnHold );
 #endif 
    mWT = new KNOWhatsThis(this);
    resetOnFocusIn = true;
    setVScrollBarMode(QScrollView::AlwaysOff);
    setHScrollBarMode(QScrollView::AlwaysOff);
 }
 KNoScrollListBox::~KNoScrollListBox()
 {
 #if QT_VERSION >= 0x030000
 #else
    delete mWT;
 #endif 
 }
 void KNoScrollListBox::focusInEvent ( QFocusEvent * e )
 {
    QListBox::focusInEvent ( e );
    if ( count() ){
        int ci = currentItem();
        if ( ci < 0 ) ci = 0;
    
        setCurrentItem( ci );
        setSelected ( ci, true ); 
        emit highlighted( item ( ci ) );
 
        resetOnFocusIn = true;
        if (  KOPrefs::instance()->mEnableMonthScroll || KOPrefs::instance()->mMonthViewWeek ) {
            QListBoxItem *fi =  firstItem ();
            if (fi ) {
                int ihei = fi->height( this );
                int hei = numRows ()  * ihei;
                if ( hei < height() - horizontalScrollBar()->height () ) {
                    setVScrollBarMode(QScrollView::AlwaysOff);
                }
                else 
                    setVScrollBarMode(QScrollView::Auto);
                if ( ihei *3 > height() ) {
                    setHScrollBarMode(QScrollView::AlwaysOff);
                }
                else {
                    setHScrollBarMode(QScrollView::Auto);
                }
            } else {
                setVScrollBarMode(QScrollView::Auto);
                setHScrollBarMode(QScrollView::Auto);
            }
        } 
    }
 }
 void KNoScrollListBox::focusOutEvent ( QFocusEvent * e )
 {
    int i =  currentItem ();
    if ( i >= 0 ) {
        setSelected ( i, false ); 
    }
    QListBox::focusOutEvent ( e ); 
    setVScrollBarMode(QScrollView::AlwaysOff);
    setHScrollBarMode(QScrollView::AlwaysOff);
 }
 QString KNoScrollListBox::getWhatsThisText(QPoint p) 
 {
    QListBoxItem* item = itemAt ( p );
    if ( ! item ) {
        return i18n("Click in the cell\nto add an event!");
    }
    return KIncidenceFormatter::instance()->getFormattedText(((MonthViewItem*) item)->incidence(),
                                                                  KOPrefs::instance()->mWTshowDetails,
                                                                  KOPrefs::instance()->mWTshowCreated,
                                                                  KOPrefs::instance()->mWTshowChanged);
 }
 void KNoScrollListBox::keyPressEvent(QKeyEvent *e)
 {
    //qDebug("KNoScrollListBox::keyPressEvent ");
    switch(e->key()) {
    case Key_Right:
        if ( e->state() == Qt::ControlButton||  e->state() == Qt::ShiftButton  )
        {
            e->ignore();
            return;
        }
        scrollBy(10,0);
        break;
    case Key_Left:
        if (e->state() == Qt::ControlButton||  e->state() == Qt::ShiftButton )
        {
            e->ignore();
            return;
        }
        scrollBy(-10,0);
        break;
    case Key_Up:
        if( e->state() == Qt::ControlButton||  e->state() == Qt::ShiftButton)  {
            e->ignore();
            break;
        }
        if ( count() ) { 
            if ( currentItem() == 0 ) {
                emit prevCell();
            } else {
                setCurrentItem((currentItem()+count()-1)%count());
                if(!itemVisible(currentItem())) {
                    if((unsigned int) currentItem() == (count()-1)) {
                        setTopItem(currentItem()-numItemsVisible()+1);
                    } else {
                        setTopItem(topItem()-1);
                    }
                }
            }
        }
        break;
    case Key_Down:
        if(e->state() == Qt::ControlButton||  e->state() == Qt::ShiftButton)  {
            e->ignore();
            break;
        }
        if ( count () ) { 
            if ( currentItem()+1 == count () ) {
                emit nextCell();
            } else {
                setCurrentItem((currentItem()+1)%count());
                if(!itemVisible(currentItem())) {
                    if(currentItem() == 0) {
                        setTopItem(0);
                    } else {
                        setTopItem(topItem()+1);
                    }
                }
            }
        }
        break;
    case Key_I:
        QTimer::singleShot( 1, this, SLOT ( oneDown() ) );
        e->ignore();
        break; 
    case Key_Return:
    case Key_Enter:
        {
            if ( currentItem() >= 0 ) {
                emit doubleClicked( item( currentItem() ) );
                e->accept();
            } else {
                e->ignore();
            }
        }
        break;
    case Key_Shift:
        emit shiftDown();
        break;
    default:
        e->ignore();
        break;
    }
 }
 void KNoScrollListBox::oneDown()
 {
    if ( count () ) {  
        if ( currentItem()+1 == count () ) {
            emit nextCell();
        } else {
            resetOnFocusIn = false;
            setCurrentItem((currentItem()+1)%count());
            if(!itemVisible(currentItem())) {
                if(currentItem() == 0) {
                    setTopItem(0);
                } else {
                    setTopItem(topItem()+1);
                }
            }
        }
    }
 }
 void KNoScrollListBox::keyReleaseEvent(QKeyEvent *e)
 {
    switch(e->key()) {
    case Key_Shift:
        emit shiftUp();
        break;
    default:
        break;
    }
 }
 void KNoScrollListBox::mousePressEvent(QMouseEvent *e)
 {
    QListBox::mousePressEvent(e);
    if(e->button() == RightButton) {
        emit rightClick();
    }
 }
 MonthViewItem::MonthViewItem( Incidence *incidence, QDate qd, const QString & s)
    : QListBoxItem()
 {
    mblockRepaint = true;
    setText( s );
    mMultiday = 0; 
    mIncidence = incidence;
    mDate = qd;
    mRecur = false;
    mAlarm = false;
    mReply = false;
    mInfo = false;
    mdayPos = 0;
    isWeekItem = KOPrefs::instance()->mMonthViewWeek;
 }
 void MonthViewItem::recycle( Incidence *incidence, QDate qd, const QString & s)
 {
    setText( s );
    mMultiday = 0; 
    mIncidence = incidence;
    mDate = qd;
    mRecur = false;
    mAlarm = false;
    mReply = false;
    mInfo = false; 
    mdayPos = 0;
 }
 void MonthViewItem::paint(QPainter *p)
 {
    if ( mblockRepaint ) {
        return;
    }
 #if QT_VERSION >= 0x030000
    bool sel = isSelected();
 #else
    bool sel = selected();
 #endif 
    if (KOPrefs::instance()->mMonthViewUsesCategoryColor)
        {
            p->setBackgroundColor( palette().color( QPalette::Normal,  \
                                                    sel ? QColorGroup::Highlight : QColorGroup::Background ) );
            p->eraseRect( 0, 0, listBox()->maxItemWidth(), height( listBox() ) );
        }
    int x = 1;
    //int y = 3;//(height() - mRecurPixmap.height()) /2; 
    int size = PIXMAP_SIZE;
    if ( QApplication::desktop()->width() < 300 )
        size = 3;
    int heihei = height( listBox () );
    int y = (heihei - size -1 ) /2; 
    if ( KOPrefs::instance()->mMonthShowIcons ) {
        if ( mInfo ) { 
            p->fillRect ( x, y,size,size, Qt::darkGreen );
            x += size + 1;
        }
        if ( mRecur ) {
            p->fillRect ( x, y,size,size, Qt::blue );
            x += size + 1;
        }
        if ( mAlarm ) {
            p->fillRect ( x, y,size,size, Qt::red );
            x += size + 1;
        }
        if ( mReply ) {
            p->fillRect ( x, y,size,size, Qt::yellow );
            x += size + 1;
        }
    }
    if ( mMultiday ) { 
        int yyy = y+(size/2);
        int sizeM = size+2;
        p->setBrush( QBrush::SolidPattern );
        p->drawLine ( x+1, yyy, x +sizeM +sizeM/2-1, yyy ) ;
        if ( mMultiday == 2 || mMultiday == 3 ) { 
            QPointArray pa ( 3 );
            pa.setPoint (0,  x, yyy );
            pa.setPoint (1,  x+sizeM/2, yyy+sizeM/2 );
            pa.setPoint (2,  x+sizeM/2, yyy-sizeM/2 );
            p->drawPolygon( pa );
        }
        if ( mMultiday == 2 || mMultiday == 1 ) { 
            QPointArray pa ( 3 );
            pa.setPoint (0,  x+sizeM +sizeM/2, yyy );
            pa.setPoint (1,  x+sizeM, yyy+sizeM/2 );
            pa.setPoint (2,  x+sizeM, yyy-sizeM/2 );
            p->drawPolygon( pa );
        }
        if ( mMultiday == 1 ) {  
            // p->fillRect (  x, yyy-sizeM/2+1, sizeM/2, size, QBrush ( QBrush::SolidPattern   ) );
           
            p->drawLine (  x+1, yyy-sizeM/2,  x+1, yyy+sizeM/2 );
        }
        if (  mMultiday == 3 ) { 
            // p->fillRect (  x+sizeM, yyy-sizeM/2+1, sizeM/2, size, QBrush ( QBrush::SolidPattern   ) );
            p->drawLine (  x+sizeM +sizeM/2-1, yyy-sizeM/2,  x+sizeM +sizeM/2-1, yyy+sizeM/2 );
           
        }
        x += sizeM/2 + 1;
        x += sizeM + 1;
    }
    if ( mIncidence->type() == "Todo" ){
        Todo* td = ( Todo* ) mIncidence;
        if ( td->isCompleted() ) {
            int half = size/2;
            p->drawLine ( x, heihei/2, x +half , heihei/2 +half ) ;
            p->drawLine (  x +half , heihei/2 +half ,  x +half+half +2 , heihei/2  -2 ) ;
            x += half+half + 4;
        } else {
            int val = td->percentComplete()/20;
            p->fillRect ( x+1, y-2, val ,size+4,Qt::black );
            p->drawRect ( x, y-2,7,size+4);
            x += size + 3;
        }
    }
    QFontMetrics fm = p->fontMetrics();
    int yPos;
    int pmheight = size;
    if( pmheight < fm.height() )
        yPos = fm.ascent() + fm.leading()/2;
    else
        yPos = pmheight/2 - fm.height()/2  + fm.ascent();
    p->setPen( palette().color( QPalette::Normal, sel ? \
                                QColorGroup::HighlightedText : QColorGroup::Foreground ) );
    if ( KOPrefs::instance()->mMonthShowTimes || isWeekItem) {
        p->drawText( x, yPos, text() );
        if ( mIncidence->cancelled() ) {
            int wid = fm.width( text() );
            p->drawLine( x, heihei/2 ,x+wid, heihei/2 );
        }
    } else {
        QString pText = text();
        if( pText.mid(2,1) == ":" )
            pText =  pText.mid( 6 );
        p->drawText( x, yPos,  pText );
        if ( mIncidence->cancelled() ) {
            int wid = fm.width( pText );
            p->drawLine( x, heihei/2 ,x+wid, heihei/2 );
        }
    }  
 }
 int MonthViewItem::height(const QListBox *lb) const
 {
    int ret = 10;
    if ( lb )
        ret = lb->fontMetrics().lineSpacing()+1;
    return ret;
 }
 int MonthViewItem::width(const QListBox *lb) const
 { 
    if( KOPrefs::instance()->mEnableMonthScroll || isWeekItem ) {
        int size = PIXMAP_SIZE;
        if ( QApplication::desktop()->width() < 300 )
            size = 3;
        int x = 1; 
        if ( KOPrefs::instance()->mMonthShowIcons ) {
            if ( mInfo ) {
                x += size + 1;
            }
            if( mRecur ) {
                x += size+1;
            }
            if( mAlarm ) {
                x += size+1;
            }
            if( mReply ) {
                x += size+1;
            }
        }
        if( mMultiday ) {
            x += size+1+2+size/2;
        }
        return( x + lb->fontMetrics().width( text() ) + 1 );
    }
    if ( ! lb )
        return 10;
    return lb->width();
 }
 MonthViewCell::MonthViewCell( KOMonthView *parent,QWidget* par )
    : KNoScrollListBox( par ),
      mMonthView( parent )
 {
    //QVBoxLayout *topLayout = new QVBoxLayout( this );
    currentPalette = 0; 
    // mLabel = new QLabel( this );QPushButton 
    mLabel = new QPushButton( this );
    //mLabel->setFrameStyle( QFrame::Panel | QFrame::Plain );
    //mLabel->setLineWidth( 1 );
    //mLabel->setAlignment( AlignCenter );
    mLabel->setFlat( true );
    mLabel->setFocusPolicy(NoFocus); 
    //mItemList = new KNoScrollListBox( this );
    setMinimumSize( 10, 10 );
    setFrameStyle( QFrame::Panel | QFrame::Plain );
    setLineWidth( 1 );
    //topLayout->addWidget( mItemList );
    mLabel->raise();
    // QColor( 0,0,255 )    QColor( 160,1600,255 )
    mStandardPalette = palette();
    mStandardPalette.setColor(QColorGroup::Base, mStandardPalette.color( QPalette::Normal, QColorGroup::Background ) );
    enableScrollBars( false );
    updateConfig();
    //connect( mLabel, SIGNAL( clicked( )), SLOT( newEvent() ));
    connect( mLabel, SIGNAL( clicked( )), SLOT( showDay() ));
    connect( this , SIGNAL( doubleClicked( QListBoxItem *) ),
             SLOT( defaultAction( QListBoxItem * ) ) );
    connect( this, SIGNAL( rightButtonPressed( QListBoxItem *,
                                                    const QPoint &) ),
             SLOT( contextMenu( QListBoxItem * ) ) );
    connect( this, SIGNAL( highlighted( QListBoxItem *) ),
             SLOT( selection( QListBoxItem * ) ) );
   
    /* 
    connect( this, SIGNAL( clicked( QListBoxItem * ) ),
             SLOT( selection( QListBoxItem * ) ) ); 
    */
 }
 #ifdef DESKTOP_VERSION
 QToolTipGroup *MonthViewCell::toolTipGroup()
 {
    if (!mToolTipGroup) mToolTipGroup = new QToolTipGroup(0);
    return mToolTipGroup;
 }
 #endif
 
 void MonthViewCell::setDate( const QDate &date )
 {
    //  kdDebug() << "MonthViewCell::setDate(): " << date.toString() << endl;
    mDate = date;
 
    //resizeEvent( 0 );
 }
 QDate MonthViewCell::date() const
 {
    return mDate;
 }
 void MonthViewCell::setPrimary( bool primary )
 {
    mPrimary = primary;
    //setMyPalette();
 }
 void MonthViewCell::setMyPalette()
 {
   
    if ( mHoliday) {
        if ( currentPalette == 1 ) return;
        mLabel->setPalette( QPalette ( mHolidayPalette.color( QPalette::Normal,QColorGroup::Base),mHolidayPalette.color(QPalette::Normal,QColorGroup::Base )  ));
        setPalette( mHolidayPalette );
        //mLabel->setPalette( mHolidayPalette );
        currentPalette = 1;
    } else {
        if ( mPrimary ) {
            if ( currentPalette == 2 ) return;
            mLabel->setPalette( QPalette ( mPrimaryPalette.color( QPalette::Normal,QColorGroup::Base),mPrimaryPalette.color(QPalette::Normal,QColorGroup::Base )  ));
            //mLabel->setPalette( mPrimaryPalette );
            setPalette( mPrimaryPalette );
            currentPalette = 2;
        } else {
            if ( currentPalette == 3 ) return;
            setPalette( mNonPrimaryPalette );
             mLabel->setPalette( QPalette ( mNonPrimaryPalette.color( QPalette::Normal,QColorGroup::Base),mNonPrimaryPalette.color(QPalette::Normal,QColorGroup::Base )  ));
             //mLabel->setPalette( mNonPrimaryPalette );;
             currentPalette = 3;
        }
    }
    //QPalette pal = palette();
    
    //mLabel->setPalette( QPalette ( pal.color( QPalette::Normal,QColorGroup::Base),pal.color(QPalette::Normal,QColorGroup::Base )  ));
 }
 QPalette  MonthViewCell::getPalette ()
 {
    if ( !KOPrefs::instance()->mMonthViewUsesDayColors )
        return mStandardPalette;
    if ( mHoliday) {
        return mHolidayPalette ;
    } else {
        if ( mPrimary ) {
            return mPrimaryPalette ;
        } 
    }
    return mNonPrimaryPalette; 
 }
 bool MonthViewCell::isPrimary() const
 {
    return mPrimary;
 }
 void MonthViewCell::setHoliday( bool holiday )
 {
    mHoliday = holiday; 
    //setMyPalette();
 }
 void MonthViewCell::setHoliday( const QString &holiday )
 {
    mHolidayString = holiday;
    if ( !holiday.isEmpty() ) {
        setHoliday( true );
    }
 }
 void MonthViewCell::startUpdateCell()
 {
    mdayCount = 0;
    setFocusPolicy(NoFocus); 
    if ( !mMonthView->isUpdatePossible() )
        return;
    MonthViewItem *mitem = (MonthViewItem*) firstItem ();
    while ( mitem ) {
        mitem->setBlockRepaint( true );
        mitem = (MonthViewItem *)mitem->next();
    }
    if ( mAvailItemList.count() > 20 ) {
        mAvailItemList.setAutoDelete( true );
        mAvailItemList.clear();
        mAvailItemList.setAutoDelete( false );
    }
   
    setPrimary( mDate.month()%2 );
    setHoliday( KOGlobals::self()->calendarSystem()->dayOfWeek(mDate) == KOGlobals::self()->calendarSystem()->weekDayOfPray() || ( mDate.dayOfWeek() == 6 ) && KOPrefs::instance()-> mExcludeSaturdays);
    if ( mDate == QDate::currentDate()  ) {
        setLineWidth( 3 );
    } else {
        setLineWidth( 1 );
    }
    MonthViewItem* CurrentAvailItem = (MonthViewItem*) firstItem ();
    //clear(); 
    while ( CurrentAvailItem ) {
            MonthViewItem *item = CurrentAvailItem;
            CurrentAvailItem = (MonthViewItem *)item->next();
            mAvailItemList.append( item ); 
            takeItem ( item );
    }
 #ifdef DESKTOP_VERSION
    QToolTip::remove(this); 
 #endif 
    mToolTip.clear(); 
    //qApp->processEvents();
 #if 0
    if ( !mHolidayString.isEmpty() ) {
        MonthViewItem *item = new MonthViewItem( 0, mDate, mHolidayString );
        item->setPalette( mHolidayPalette );
        insertItem( item );
        mToolTip.append ( mHolidayString ); 
    }
 #endif
 }
 int MonthViewCell::insertEvent(Event *event)
 {
    bool useToolTips = true;
 #ifndef DESKTOP_VERSION
    useToolTips = false;
 #endif    
    QString mToolTipText;
    setFocusPolicy(WheelFocus); 
        if ( !(event->doesRecur() == Recurrence::rNone) ) {
            if ( !KOPrefs::instance()->mMonthDailyRecur && event->doesRecur() == Recurrence::rDaily )
                return mdayCount;
            else
                if ( !KOPrefs::instance()->mMonthWeeklyRecur && event->doesRecur() == Recurrence::rWeekly )
                    return mdayCount;
        }
        
        if ( event->isHoliday()) {
            setHoliday( true );
            if ( mDate.dayOfWeek() == 7 )
                setLineWidth( 3 );
        }
        QString text;
        int multiday = 0;// 1 = start, 2 = midddle, 3 = end day
        if (event->isMultiDay()) {
            QString prefix = "<->";multiday = 2; 
            QString time;
            if ( event->doesRecur() ) {
                if ( event->recursOn( mDate) ) {
                    prefix ="->" ;multiday = 1;
                }
                else {
                    int days =  event->dtStart().date().daysTo ( event->dtEnd().date() );
                    if ( event->recursOn( mDate.addDays( -days)) ) {
                        prefix ="<-" ;multiday = 3;
                    }
                } 
            } else {
                if (mDate == event->dtStart().date()) {
                    prefix ="->" ;multiday = 1;
                } else if (mDate == event->dtEnd().date()) {
                    prefix ="<-" ;multiday = 3;
                }
            }
            if ( !event->doesFloat() ) {
                if ( mDate == event->dtStart().date () )
                    time = KGlobal::locale()->formatTime(event->dtStart().time())+" ";
                else if ( mDate == event->dtEnd().date () )
                    time = KGlobal::locale()->formatTime(event->dtEnd().time())+" ";
            }
            text = time + event->summary();
            if ( useToolTips )
                mToolTipText += prefix + text;
        } else {
            if (event->doesFloat()) {
                text = event->summary();
                if ( useToolTips )
                    mToolTipText += text;
            }
            else {
                text = KGlobal::locale()->formatTime(event->dtStart().time());
                text += " " + event->summary();
                if ( useToolTips )
                    mToolTipText +=  KGlobal::locale()->formatTime(event->dtStart().time()) +"-"+KGlobal::locale()->formatTime(event->dtEnd().time())+" " + event->summary();
            }
        }
        if ( useToolTips && ! event->location().isEmpty() ) {
            mToolTipText += " (" + event->location() +")";
        }
        MonthViewItem *item ;
        
        if ( mAvailItemList.count() ) {
            item = mAvailItemList.first();
            mAvailItemList.remove( item );
            item->recycle( event, mDate, text );
        } else {
            item = new MonthViewItem( event, mDate, text );
        }
        
        QPalette pal;
        if (KOPrefs::instance()->mMonthViewUsesCategoryColor) {    
            QStringList categories = event->categories();
            QString cat = categories.first();
            if ( KOPrefs::instance()->mMonthViewUsesForegroundColor ) {
                pal = getPalette();
                if (cat.isEmpty()) {
                    pal.setColor(QColorGroup::Foreground,KOPrefs::instance()->mEventColor);
                } else {
                    pal.setColor(QColorGroup::Foreground, *(KOPrefs::instance()->categoryColor(cat)));
                }
            } else {
                if (cat.isEmpty()) {
                    pal = QPalette(KOPrefs::instance()->mEventColor, KOPrefs::instance()->mEventColor);
                } else {
                    pal = QPalette(*(KOPrefs::instance()->categoryColor(cat)), *(KOPrefs::instance()->categoryColor(cat)));
                } 
            }
           
        } else {
            pal = mStandardPalette ;
        }
        item->setPalette( pal );
        item->setRecur( event->recurrence()->doesRecur() );
        item->setAlarm( event->isAlarmEnabled() && multiday < 2 );
        item->setMoreInfo( event->description().length() > 0  );
 #ifdef DESKTOP_VERSION
        Attendee *me = event->attendeeByMails(KOPrefs::instance()->mAdditionalMails,
                                              KOPrefs::instance()->email());
        if ( me != 0 ) {
            if ( me->status() == Attendee::NeedsAction && me->RSVP())
                item->setReply(true && multiday < 2);
            else
                item->setReply(false);
        } else
            item->setReply(false);
 #endif
        item->setMultiDay( multiday );
        if ( multiday ) {
            insertItem( item ,mdayCount);
            ++mdayCount;
        } else {
            uint i;
            int pos = mdayCount;
            for ( i = mdayCount; i < count();++i ) {
                QListBoxItem* it = this->item ( i );
-                if ( text < it->text() ) {
+                if ( it && text < it->text() ) {
                    pos = i;
                    break;
                }
                ++pos;
            }
            insertItem( item ,pos);
        }
        if ( useToolTips ) {
            mToolTip.append( mToolTipText );
        }
        return mdayCount;
 }
 void MonthViewCell::insertTodo(Todo *todo)
 {
    setFocusPolicy(WheelFocus); 
      QString text;
        if (todo->hasDueDate()) {
            if (!todo->doesFloat()) {
                text += KGlobal::locale()->formatTime(todo->dtDue().time());
                text += " ";
            }
        }
        text += todo->summary();
        MonthViewItem *item ;
        if ( mAvailItemList.count() ) {
            item = mAvailItemList.first();
            mAvailItemList.remove( item );
            item->recycle( todo, mDate, text );
        } else {
            item = new MonthViewItem( todo, mDate, text );
        }
        //MonthViewItem *item = new MonthViewItem( todo, mDate, text );
        //item->setPalette( mStandardPalette );
        QPalette pal;
        if (KOPrefs::instance()->mMonthViewUsesCategoryColor) {    
            QStringList categories = todo->categories();
            QString cat = categories.first();
            if ( KOPrefs::instance()->mMonthViewUsesForegroundColor ) {
                pal = getPalette();
                if (cat.isEmpty()) {
                    pal.setColor(QColorGroup::Foreground,KOPrefs::instance()->mEventColor);
                } else {
                    pal.setColor(QColorGroup::Foreground, *(KOPrefs::instance()->categoryColor(cat)));
                }
            } else {
                if (cat.isEmpty()) {
                    pal = QPalette(KOPrefs::instance()->mEventColor, KOPrefs::instance()->mEventColor);
                } else {
                    pal = QPalette(*(KOPrefs::instance()->categoryColor(cat)), *(KOPrefs::instance()->categoryColor(cat)));
                } 
            }
           
        } else {
            pal = mStandardPalette ;
        }
        item->setPalette( pal );
        item->setRecur( todo->recurrence()->doesRecur() );
        item->setAlarm( todo->isAlarmEnabled() );
        item->setMoreInfo( todo->description().length() > 0  );
        insertItem( item , count());
 #ifdef DESKTOP_VERSION
        mToolTip.append( text ); 
 #endif
 }
 void MonthViewCell::repaintfinishUpdateCell()
 {
    MonthViewItem *mitem = (MonthViewItem*) firstItem ();
    while ( mitem ) {
        mitem->setBlockRepaint( false );
        updateItem ( mitem );
        mitem = (MonthViewItem *)mitem->next();
    }
 }
 void MonthViewCell::finishUpdateCell()
 {
   
    
 #ifdef DESKTOP_VERSION
    if (mToolTip.count() > 0 ) {
        mToolTip.sort();
        QToolTip::add(this,mToolTip.join("\n"),toolTipGroup(),"");
    }
 #endif
    //sort();
    //setMyPalette(); 
    setMyPalette();
  
    resizeEvent( 0 ); 
 }
 void MonthViewCell::updateCell()
 {
    if ( !mMonthView->isUpdatePossible() )
        return;
    startUpdateCell();
    //mLabel->setMaximumWidth( width() - mItemList->lineWidth()*2);
    QPtrList<Event> events = mMonthView->calendar()->events( mDate, true );
    Event *event;
    for( event = events.first(); event; event = events.next() ) { // for event
        insertEvent(event);
    }
    // insert due todos
    QPtrList<Todo> todos = mMonthView->calendar()->todos( mDate );
    Todo *todo;
    for(todo = todos.first(); todo; todo = todos.next()) {
        insertTodo( todo );
    }
    finishUpdateCell();
    // if ( isVisible())
    //qApp->processEvents();
 }
 void MonthViewCell::updateConfig( bool bigFont ) // = false
 {
    if ( bigFont ) {
        QFont fo = KOPrefs::instance()->mMonthViewFont;
        int ps = fo.pointSize() + 2;
        if ( ps < 18 )
            ps += 2;
        fo.setPointSize( ps ); 
        setFont( fo );
    } else
        setFont( KOPrefs::instance()->mMonthViewFont );
    QFontMetrics fm( font() );
    mLabelSize = fm.size( 0, "30" ) + QSize( 4, 2 );
    mLabelBigSize = fm.size( 0, "Mag 30" ) + QSize( 2, 2 );
    mHolidayPalette = mStandardPalette;
    mPrimaryPalette = mStandardPalette;
    mNonPrimaryPalette = mStandardPalette;
    if ( KOPrefs::instance()->mMonthViewUsesDayColors ) {
        mHolidayPalette.setColor(QColorGroup::Base, KOPrefs::instance()->mMonthViewHolidayColor  );
        mHolidayPalette.setColor(QColorGroup::Background, KOPrefs::instance()->mMonthViewHolidayColor  );
        mHolidayPalette.setColor(QColorGroup::Foreground,  KOPrefs::instance()->mMonthViewHolidayColor.dark());
        mPrimaryPalette.setColor(QColorGroup::Foreground,KOPrefs::instance()->mMonthViewOddColor.dark());
        mPrimaryPalette.setColor(QColorGroup::Base,KOPrefs::instance()->mMonthViewOddColor);
        mPrimaryPalette.setColor(QColorGroup::Background,KOPrefs::instance()->mMonthViewOddColor);
        mNonPrimaryPalette.setColor(QColorGroup::Foreground,KOPrefs::instance()->mMonthViewEvenColor.dark());
        mNonPrimaryPalette.setColor(QColorGroup::Base,KOPrefs::instance()->mMonthViewEvenColor); 
        mNonPrimaryPalette.setColor(QColorGroup::Background,KOPrefs::instance()->mMonthViewEvenColor); 
    }
    //updateCell(); 
 }
 void MonthViewCell::enableScrollBars( bool enabled )
 {
    
    return;
    if ( enabled ) {
        QListBoxItem *fi =  firstItem ();
        if (fi ) {
            int ihei = fi->height( this );
            int hei = numRows ()  * ihei;
            if ( hei < height() - horizontalScrollBar()->height () ) {
                setVScrollBarMode(QScrollView::AlwaysOff);
            }
            else 
                setVScrollBarMode(QScrollView::Auto);
            if ( ihei *3 > height() ) {
                setHScrollBarMode(QScrollView::AlwaysOff);
            }
            else {
                setHScrollBarMode(QScrollView::Auto);
            }
        } else {
            setVScrollBarMode(QScrollView::Auto);
            setHScrollBarMode(QScrollView::Auto);
        }
    } else {
        setVScrollBarMode(QScrollView::AlwaysOff);
        setHScrollBarMode(QScrollView::AlwaysOff);
    }
 }
 Incidence *MonthViewCell::selectedIncidence()
 {
    int index = currentItem();
    if ( index < 0 ) return 0;
  
    MonthViewItem *mitem =
        static_cast<MonthViewItem *>( item( index ) );
    if ( !mitem ) return 0;
  
    return mitem->incidence();
 }
 QDate MonthViewCell::selectedIncidenceDate()
 {
    QDate qd;
    int index = currentItem();
    if ( index < 0 ) return qd;
  
    MonthViewItem *mitem =
        static_cast<MonthViewItem *>( item( index ) );
    if ( !mitem ) return qd;
  
    return mitem->incidenceDate();
 }
 void MonthViewCell::deselect()
 {
    clearSelection();
    enableScrollBars( false );
    // updateCell();
 }
 void MonthViewCell::select()
 {
    ;// updateCell();
 }
 void MonthViewCell::resizeEvent ( QResizeEvent * e )
 {
    if ( !mMonthView->isUpdatePossible() )
        return;
    //qDebug("++++++++++++++MonthViewCell::resizeEvent %d %d ", width(), height());
    deselect();
    mLabel->setMaximumHeight( height() - lineWidth()*2 );
    
    QString text;
    mLabel->setText( text );
    bool smallDisplay = QApplication::desktop()->width() < 320 && KOPrefs::instance()->mMonthViewSatSunTog;
    if ( KOPrefs::instance()->mMonthViewWeek || KOGlobals::self()->calendarSystem()->day( mDate ) == 1 || (mDate.dayOfWeek() == 7 && !smallDisplay ) || KOPrefs::instance()->mMonthShowShort) { 
        text = KOGlobals::self()->calendarSystem()->monthName( mDate, true ) + " ";
        mLabel->resize( mLabelBigSize  );
        text += QString::number( KOGlobals::self()->calendarSystem()->day(mDate) );
    } else {
        mLabel->resize( mLabelSize );
        text += QString::number( KOGlobals::self()->calendarSystem()->day(mDate) );
    }
    mLabel->setText( text );
    int size = height() - mLabel->height() - lineWidth()-1;
    //qDebug("LW %d ", lineWidth());
    if ( size > 0 )
        verticalScrollBar()->setMaximumHeight( size );
    size = width() - mLabel->width() -lineWidth()-1;
    if ( size > 0 )
        horizontalScrollBar()->setMaximumWidth( size );
    mLabel->move( width()-lineWidth() - mLabel->width(), height()-lineWidth() - mLabel->height() );
    //mLabel->setMaximumWidth( width() - mItemList->lineWidth()*2);
    // mItemList->resize ( width(), height () ); 
    if ( e )
        KNoScrollListBox::resizeEvent (  e );
 }
 void MonthViewCell::defaultAction( QListBoxItem *item )
 {
  
    if ( !item ) {
        QDateTime dt( date(), QTime( KOPrefs::instance()->mStartTime, 0 ) );
        emit newEventSignal( dt );
        return;
    }
    MonthViewItem *eventItem = static_cast<MonthViewItem *>( item );
    Incidence *incidence = eventItem->incidence();
    if ( incidence ) mMonthView->defaultAction( incidence );
 }
 void MonthViewCell::showDay()
 {
    emit showDaySignal( date() );
 }
 void MonthViewCell::newEvent()
 {
    QDateTime dt( date(), QTime( KOPrefs::instance()->mStartTime, 0 ) );
    emit newEventSignal( dt );
 }
 void MonthViewCell::cellClicked( QListBoxItem *item )
 {
    mMonthView->setSelectedCell( this );
    if ( item == 0 ) {
        QDateTime dt( date(), QTime( KOPrefs::instance()->mStartTime, 0 ) );
        emit newEventSignal( dt );
        return;
    }
 }
 void MonthViewCell::contextMenu( QListBoxItem *item )
 {
    mMonthView->setPopupCell( this );
    if ( !item )  {
        mMonthView->showContextMenu( 0 );
        return;
    }
    MonthViewItem *eventItem = static_cast<MonthViewItem *>( item );
    Incidence *incidence = eventItem->incidence();
    if ( incidence ) mMonthView->showContextMenu( incidence );
 }
 void MonthViewCell::selection( QListBoxItem *item )
 {
    if ( !item ) return;
    mMonthView->setSelectedCell( this );
 }
 // *******************************************************************************
 // *******************************************************************************
 // *******************************************************************************
 KOMonthView::KOMonthView(Calendar *calendar, QWidget *parent, const char *name)
    : KOEventView( calendar, parent, name ),
      mDaysPerWeek( 7 ), mNumWeeks( 6 ), mNumCells( mDaysPerWeek * mNumWeeks ),
      mWidthLongDayLabel( 0 ), mSelectedCell( 0 )
 {
    mFlagKeyPressed = false;
    mShortDayLabelsM = false;
    mShortDayLabelsW = false;
    skipResize = false;
    clPending = true;
    mPopupCell = 0;
    mNavigatorBar = new NavigatorBar( QDate::currentDate(), this, "useBigPixmaps" );
    mWidStack = new QWidgetStack( this );
    QVBoxLayout* hb = new QVBoxLayout( this );
    mMonthView = new QWidget( mWidStack );
    mWeekView = new QWidget( mWidStack );
 #if QT_VERSION >= 0x030000
    mWidStack->addWidget(mMonthView );
    mWidStack->addWidget(mWeekView  );
 #else
    mWidStack->addWidget( mMonthView, 1 );
    mWidStack->addWidget( mWeekView , 1 );
 #endif
    hb->addWidget( mNavigatorBar );
    hb->addWidget( mWidStack );
    mShowWeekView = KOPrefs::instance()->mMonthViewWeek;
    updatePossible = false;
    //updatePossible = true;
    mCells.setAutoDelete( true );
    mShowSatSunComp = KOPrefs::instance()->mMonthViewSatSunTog ;
    mDayLabels.resize( mDaysPerWeek );
    mDayLabelsW.resize( mDaysPerWeek );
    QFont bfont = font();
    if ( QApplication::desktop()->width() < 650 ) {
        bfont.setPointSize( bfont.pointSize() - 2 );
    }
    bfont.setBold( true );
    int i;
  
    for( i = 0; i < mDaysPerWeek; i++ ) {
        QLabel *label = new QLabel( mMonthView );
        label->setFont(bfont);
        label->setFrameStyle(QFrame::Panel|QFrame::Raised);
        label->setLineWidth(1);
        label->setAlignment(AlignCenter);
        mDayLabels.insert( i, label );
        label = new QLabel( mWeekView );
        label->setFont(bfont);
        label->setFrameStyle(QFrame::Panel|QFrame::Raised);
        label->setLineWidth(1);
        label->setAlignment(AlignCenter);
        mDayLabelsW.insert( i, label );
    }
    bfont.setBold( false );
    mWeekLabels.resize( mNumWeeks+1 );
    mWeekLabelsW.resize( 2 );
    for( i = 0; i < mNumWeeks+1; i++ ) {
        KOWeekButton *label = new KOWeekButton( mMonthView );
        label->setFocusPolicy(NoFocus); 
        label->setFont(bfont);
        connect( label, SIGNAL( selectWeekNum ( int )),this, SLOT( selectInternalWeekNum ( int ))   );  
        label->setFlat(true);
        QWhatsThis::add(label,i18n("Click on the week number to\nshow week zoomed"));
        //label->setFrameStyle(QFrame::Panel|QFrame::Raised);
        //label->setLineWidth(1);
        //label->setAlignment(AlignCenter);
        mWeekLabels.insert( i, label );
    }
    mWeekLabels[mNumWeeks]->setText( i18n("W"));
    mWeekLabels[mNumWeeks]->setFocusPolicy(WheelFocus);
    QWhatsThis::add(mWeekLabels[mNumWeeks],i18n("Click on this to\nselect week number"));
    
    for( i = 0; i < 1+1; i++ ) {
        KOWeekButton *label = new KOWeekButton( mWeekView );
        label->setFocusPolicy(NoFocus); 
        label->setFont(bfont);
        connect( label, SIGNAL( selectWeekNum ( int )),this, SLOT( selectInternalWeekNum ( int ))   );  
        label->setFlat(true);
        QWhatsThis::add(label,i18n("Click on the week number to\nshow week zoomed"));
        //label->setFrameStyle(QFrame::Panel|QFrame::Raised);
        //label->setLineWidth(1);
        //label->setAlignment(AlignCenter);
        mWeekLabelsW.insert( i, label );
    }
    mWeekLabelsW[1]->setText( i18n("W"));
    mWeekLabelsW[1]->setFocusPolicy(WheelFocus); 
    int row, col;
    mCells.resize( mNumCells );
    for( row = 0; row < mNumWeeks; ++row ) {
        for( col = 0; col < mDaysPerWeek; ++col ) {
            MonthViewCell *cell = new MonthViewCell( this, mMonthView );
            mCells.insert( row * mDaysPerWeek + col, cell );
            connect( cell, SIGNAL( defaultAction( Incidence * ) ),
                     SLOT( defaultAction( Incidence * ) ) );
            connect( cell, SIGNAL( newEventSignal( QDateTime ) ),
                     SIGNAL( newEventSignal( QDateTime ) ) );
            connect( cell, SIGNAL( showDaySignal( QDate ) ),
                     SIGNAL( showDaySignal( QDate ) ) );
            connect( cell, SIGNAL( nextCell() ),
                     SLOT( nextCell() ) );
            connect( cell, SIGNAL( prevCell() ),
                     SLOT( prevCell() ) );
        }
    }
    mCellsW.resize( mDaysPerWeek );
    for( col = 0; col < mDaysPerWeek; ++col ) {
        MonthViewCell *cell = new MonthViewCell( this, mWeekView );
        mCellsW.insert( col, cell );
        connect( cell, SIGNAL( defaultAction( Incidence * ) ),
                 SLOT( defaultAction( Incidence * ) ) );
        connect( cell, SIGNAL( newEventSignal( QDateTime ) ),
                 SIGNAL( newEventSignal( QDateTime ) ) );
        connect( cell, SIGNAL( showDaySignal( QDate ) ),
                 SIGNAL( showDaySignal( QDate ) ) );
        connect( cell, SIGNAL( nextCell() ),
                 SLOT( nextCell() ) );
        connect( cell, SIGNAL( prevCell() ),
                 SLOT( prevCell() ) );
        cell->updateConfig(KOPrefs::instance()->mMonthViewUsesBigFont );
    }
    //connect( mWeekLabels[mNumWeeks], SIGNAL( clicked() ), SLOT( switchView() ) );
    mContextMenu = eventPopup();
    mContextMenu->addAdditionalItem(QIconSet(QPixmap()),
                                  i18n("New Event..."),this,
                                  SLOT(slotNewEvent()),false);
    mContextMenu->addAdditionalItem(QIconSet(QPixmap()),
                                  i18n("New Todo..."),this,
                                  SLOT(slotNewTodo()),false);
    mContextMenu->addAdditionalItem(QIconSet(QPixmap()),
                                  i18n("Journal"),this,
                                  SLOT(slotEditJournal()),false);
    QString pathString = "";
    if ( !KOPrefs::instance()->mToolBarMiniIcons ) {
        if ( QApplication::desktop()->width() < 480 )
            pathString += "icons16/";
    } else
        pathString += "iconsmini/";
    mNewItemMenu = new QPopupMenu( this );
    mNewItemMenu->insertItem( SmallIcon( pathString +"newevent" ), i18n("New Event..."),this, SLOT(slotNewEvent()));
    mNewItemMenu->insertItem( SmallIcon( pathString +"newtodo" ),i18n("New Todo..."),this,SLOT(slotNewTodo()),false);
    mNewItemMenu->insertItem( SmallIcon( pathString +"journal" ),i18n("Journal"),this,SLOT(slotEditJournal()),false);
    // updateConfig(); //useless here...
    // ... but we need mWidthLongDayLabel computed
    QFontMetrics fontmetric(mDayLabels[0]->font());
    mWidthLongDayLabel = 0;
    for (int i = 0; i < 7; i++) {
        int width = fontmetric.width(KOGlobals::self()->calendarSystem()->weekDayName(i+1));
        if ( width > mWidthLongDayLabel ) mWidthLongDayLabel = width;
    }
    //mWeekLabels[mNumWeeks]->setText( i18n("W"));
 #if 0
    if ( mShowWeekView )
        mWidStack->raiseWidget( mWeekView );
    else
        mWidStack->raiseWidget( mMonthView );
 #endif
    emit incidenceSelected( 0 );
    mComputeLayoutTimer = new QTimer( this );
    connect (mComputeLayoutTimer ,SIGNAL(timeout()), this, SLOT ( slotComputeLayout()));
 #ifndef DESKTOP_VERSION
    resize( QApplication::desktop()->size() );
 #else
    resize(640, 480 );
    updatePossible = true;
 #endif
    computeLayout();
    if ( mShowWeekView )
        mWidStack->raiseWidget( mWeekView );
    else
        mWidStack->raiseWidget( mMonthView );
 }
 KOMonthView::~KOMonthView()
 {
    delete mContextMenu;
 }
 void KOMonthView::selectInternalWeekNum ( int n )
 {
    switchView();  
    if ( !KOPrefs::instance()->mMonthViewWeek )
        emit selectMonth ();
    else
        emit selectWeekNum ( n );
 }
 int KOMonthView::currentWeek()
 {
    if ( mShowWeekView )
        return mWeekLabelsW[0]->getWeekNum();
    return mWeekLabels[0]->getWeekNum();
 }
 void KOMonthView::switchView()
 {
    if ( selectedCell( ) )
        selectedCell()->deselect();
    mShowWeekView = !mShowWeekView;
    KOPrefs::instance()->mMonthViewWeek = mShowWeekView;
    if ( clPending ) {
      computeLayout();
      updateConfig();
    }
    if ( mShowWeekView )
        mWidStack->raiseWidget( mWeekView );
    else
        mWidStack->raiseWidget( mMonthView ); 
    clPending = false;
 }
 int KOMonthView::maxDatesHint()
 {
    return mNumCells;
 }
 int KOMonthView::currentDateCount()
 {
    return mNumCells;
 }
 QPtrList<Incidence> KOMonthView::selectedIncidences()
 {
    QPtrList<Incidence> selected;
    if ( mSelectedCell ) {
        Incidence *incidence = mSelectedCell->selectedIncidence();
        if ( incidence ) selected.append( incidence );
    }
    return selected;
 }
 DateList KOMonthView::selectedDates()
 {
    DateList selected;
    if ( mSelectedCell ) {
        QDate qd = mSelectedCell->selectedIncidenceDate();
        if ( qd.isValid() ) selected.append( qd );
    }
    return selected;
 }
 void KOMonthView::printPreview(CalPrinter *calPrinter, const QDate &fd,
                               const QDate &td)
 {
 #ifndef KORG_NOPRINTER
    calPrinter->preview(CalPrinter::Month, fd, td);
 #endif
 }
 void KOMonthView::updateConfig()
 {
 
    int mWeekStartsMonday = KGlobal::locale()->weekStartsMonday();
    if ( mShowWeekView || KOPrefs::instance()->mMonthViewSatSunTog ) {
        mWeekStartsMonday = true;
    } 
    QFontMetrics fontmetric(mDayLabels[0]->font());
    mWidthLongDayLabel = 0;
    for (int i = 0; i < 7; i++) {
        int width = fontmetric.width(KOGlobals::self()->calendarSystem()->weekDayName(i+1));
        if ( width > mWidthLongDayLabel ) mWidthLongDayLabel = width;
    }
    bool temp = mShowSatSunComp ;
    mShowSatSunComp = KOPrefs::instance()->mMonthViewSatSunTog ;
    if ( !  mShowWeekView ) {
        if ( temp != KOPrefs::instance()->mMonthViewSatSunTog )
            computeLayout();
    }
    updateDayLabels();
    //qDebug("KOMonthView::updateConfig() %d %d %d ",height(), mDayLabels[0]->sizeHint().height() ,mNumWeeks);
    //int cellHeight = (height() - mDayLabels[0]->sizeHint().height()) /mNumWeeks;
    //resizeEvent( 0 );
    for (uint i = 0; i < mCells.count(); ++i) {
        mCells[i]->updateConfig();
    }
    for (uint i = 0; i < mCellsW.count(); ++i) {
        mCellsW[i]->updateConfig(KOPrefs::instance()->mMonthViewUsesBigFont);
    }
 #ifdef DESKTOP_VERSION
    MonthViewCell::toolTipGroup()->setEnabled(KOPrefs::instance()->mEnableToolTips); 
 #endif
    updateView();
 }
 void KOMonthView::updateDayLabels()
 {
  
    QPtrVector<QLabel> *mDayLabelsT;
    mDayLabelsT = &mDayLabelsW;
    for (int i = 0; i < 7; i++) {
       {
            bool show = mShortDayLabelsW;
            if ( i > 4 && mShowSatSunComp && mWidthLongDayLabel > (*mDayLabelsT)[i]->width()  )
                show = true;
            (*mDayLabelsT)[i]->setText(KOGlobals::self()->calendarSystem()->weekDayName(i+1,show));
        }
    }
    mDayLabelsT = &mDayLabels;
    for (int i = 0; i < 7; i++) {
        if (KGlobal::locale()->weekStartsMonday() || KOPrefs::instance()->mMonthViewSatSunTog ) {
            bool show = mShortDayLabelsM;
            if ( i > 4 && mShowSatSunComp && mWidthLongDayLabel > (*mDayLabelsT)[i]->width()  )
                show = true;
            (*mDayLabelsT)[i]->setText(KOGlobals::self()->calendarSystem()->weekDayName(i+1,show));
        } else {
            if (i==0) (*mDayLabelsT)[i]->setText(KOGlobals::self()->calendarSystem()->weekDayName(7,mShortDayLabelsM));
            else (*mDayLabelsT)[i]->setText(KOGlobals::self()->calendarSystem()->weekDayName(i,mShortDayLabelsM));
        }
    }
 }
 void KOMonthView::showDates(const QDate &start, const QDate &)
 {
    //  kdDebug() << "KOMonthView::showDates(): " << start.toString() << endl;
    QPtrVector<MonthViewCell> *cells;
    QPtrVector<QLabel> *dayLabels;
    QPtrVector<KOWeekButton> *weekLabels;
    int weekNum = 6;
    mStartDate = start;
    if ( mShowWeekView ) {
        weekNum = 1;
        cells = &mCellsW;
        dayLabels = &mDayLabelsW;
        weekLabels = &mWeekLabelsW;
        if ( !KGlobal::locale()->weekStartsMonday() ) {
            mStartDate = mStartDate.addDays( 1 );
        }
    } else {
        cells = &mCells;
        dayLabels = &mDayLabels;
        weekLabels = &mWeekLabels;
    }
    int mWeekStartsMonday =  KGlobal::locale()->weekStartsMonday();
    if ( mShowWeekView || KOPrefs::instance()->mMonthViewSatSunTog ) {
        mWeekStartsMonday = true;
    } 
    int startWeekDay = mWeekStartsMonday ? 1 : 7;
    while( KOGlobals::self()->calendarSystem()->dayOfWeek(mStartDate) != startWeekDay ) {
        mStartDate = mStartDate.addDays( -1 );
    }
    bool primary = false;
    uint i;
    for( i = 0; i < (*cells).size(); ++i ) {
        QDate date = mStartDate.addDays( i );
        (*cells)[i]->setDate( date );
 #ifndef KORG_NOPLUGINS
        // add holiday, if present
        QString hstring(KOCore::self()->holiday(date));
        (*cells)[i]->setHoliday( hstring );
 #endif
    }
    QDate date = mStartDate.addDays( mWeekStartsMonday ? 3 : 4 );
    for( i = 0; i < weekNum; ++i ) {
        int wno;
        // remember, according to ISO 8601, the first week of the year is the
        // first week that contains a thursday.  Thus we must subtract off 4,
        // not just 1.
        int dayOfYear = date.dayOfYear();
        if (dayOfYear % 7 != 0)
            wno = dayOfYear / 7 + 1;
        else
            wno =dayOfYear / 7;
        (*weekLabels)[i]->setWeekNum( wno );
        date = date.addDays( 7 );
    }
    updateView();
 }
 void KOMonthView::showEvents(QPtrList<Event>)
 {
    qDebug("KOMonthView::selectEvents is not implemented yet. ");
 }
 void KOMonthView::changeEventDisplay(Event *, int)
 {
    // this should be re-written to be much more efficient, but this
    // quick-and-dirty-hack gets the job done for right now.
    //qDebug("KOMonthView::changeEventDisplay ");
    updateView();
 }
 void KOMonthView::updateView()
 { 
    if ( !updatePossible )
        return;
    //qDebug("UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU ");
    //QTime ti;
    //ti.start();
    clearSelection();
    QPtrVector<MonthViewCell> *cells;
    if ( mShowWeekView ) {
        cells = &mCellsW;
    } else {
        cells = &mCells;
    }
 #if 1
    int i;
    int timeSpan = (*cells).size()-1;
    if ( KOPrefs::instance()->mMonthViewWeek )         
        timeSpan = 6;
    for( i = 0; i < timeSpan + 1; ++i ) {
        (*cells)[i]->startUpdateCell();
    }
 
    QPtrList<Event> events = calendar()->events();
    Event *event;
    QDateTime dt;
    bool ok;
    QDate endDate =  mStartDate.addDays( timeSpan );
    for( event = events.first(); event; event = events.next() ) { // for event
        if ( event->doesRecur() ) {
            bool last;
            QDateTime incidenceStart = event->recurrence()->getPreviousDateTime( QDateTime( mStartDate ) , &last );
            QDateTime incidenceEnd;
            int eventlen = event->dtStart().date().daysTo ( event->dtEnd().date()  );
            bool invalid = false;
            while( true ) {
                    if ( incidenceStart.isValid() ) {
                        incidenceEnd = incidenceStart.addDays( eventlen );
                        int st =   incidenceStart.date().daysTo( endDate );
                        if ( st >= 0 ) { // start before timeend
                            int end = mStartDate.daysTo( incidenceEnd.date() );
                            if ( end >= 0 ) { // end after timestart --- got one!
                                //normalize
                                st =  timeSpan - st;
                                if ( st < 0 ) st = 0;
                                if ( end > timeSpan ) end = timeSpan;
                                int iii;
                                //qDebug("found %s %d %d ",event->summary().latin1(), st, end );
                                for ( iii = st;iii<= end;++iii) 
                                    (*cells)[iii]->insertEvent( event );
                            }
                        }
                    } else {
                        if ( invalid )
                            break;
                        invalid = true;
                        //qDebug("invalid %s", event->summary().latin1());
                        incidenceStart = QDateTime( mStartDate ).addSecs( -2 );;
                    }
                    if ( last )
                        break;
                    bool ok;
                    incidenceStart = event->getNextOccurence( incidenceStart.addSecs( 1 ) ,&ok );
                    if ( ! ok )
                        break;
                    if ( incidenceStart.date() > endDate )
                        break;
            }
        } else { // no recur 
            if ( !KOPrefs::instance()->mShowSyncEvents && event->uid().left(2) == QString("la") )
                if ( event->uid().left(15) == QString("last-syncEvent-")  )
                    continue;
            int st =  event->dtStart().date().daysTo( endDate );
            if ( st >= 0 ) { // start before timeend
                int end = mStartDate.daysTo( event->dtEnd().date() );
                if ( end >= 0 ) { // end after timestart --- got one!
                    //normalize
                    st =  timeSpan - st;
                    if ( st < 0 ) st = 0;
                    if ( end > timeSpan ) end = timeSpan;
                    int iii;
                    for ( iii = st;iii<= end;++iii)
                        (*cells)[iii]->insertEvent( event );
                }
            }
        }
    }
    // insert due todos
    QPtrList<Todo> todos = calendar()->todos( );
    Todo *todo;
    for(todo = todos.first(); todo; todo = todos.next()) {
        //insertTodo( todo );
        if ( todo->hasDueDate() ) {
            int day = mStartDate.daysTo( todo->dtDue().date() );
            if ( day >= 0 && day < timeSpan + 1)  {
                (*cells)[day]->insertTodo( todo );
            }
        }
    }
    for( i = 0; i < timeSpan+1; ++i ) {
        (*cells)[i]->finishUpdateCell();
    }
    processSelectionChange();
    //qApp->processEvents();
     for( i = 0; i < timeSpan+1; ++i ) {
         (*cells)[i]->repaintfinishUpdateCell();
    }
     setKeyBFocus();
 #else
    // old code
    //qDebug("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ");
    int i;
    for( i = 0; i < (*cells).count(); ++i ) {
        (*cells)[i]->updateCell();
    }
 
    //qDebug("KOMonthView::updateView() ");
    processSelectionChange();
    // qDebug("---------------------------------------------------------------------+ ");
    (*cells)[0]->setFocus();
 #endif
    //qDebug("update time %d ", ti.elapsed());
 }
 void KOMonthView::setKeyBoardFocus()
 {
    //qDebug("KOMonthView::setKeyBoardFocus() ");
    bool shootAgain = false;
    if ( mShowWeekView ) {
        shootAgain = !mWeekLabelsW[1]->hasFocus();
         mWeekLabelsW[1]->setFocus();
    }
    else {
        shootAgain = !mWeekLabels[mNumWeeks]->hasFocus();
         mWeekLabels[mNumWeeks]->setFocus();
    }
    if ( shootAgain ) {
      QTimer::singleShot( 0, this, SLOT ( setKeyBFocus() ) );
    }
 }
 void KOMonthView::setKeyBFocus()
 {
    //qDebug("KOMonthView::setKeyBFocus() ");
    QTimer::singleShot( 0, this, SLOT ( setKeyBoardFocus() ) );
 }
 void KOMonthView::resizeEvent(QResizeEvent * e)
 {
    //qDebug("KOMonthView::resizeEvent %d %d -- %d %d ", e->size().width(), e->size().height(), e->oldSize().width(), e->oldSize().height());
    if ( isVisible() ) {
        //qDebug("KOMonthView::isVisible ");
        slotComputeLayout();
    } else
        mComputeLayoutTimer->start( 100 );
 }
 void KOMonthView::slotComputeLayout()
 {
    mComputeLayoutTimer->stop();
    //qDebug("KOMonthView::Post - resizeEvent %d %d ", width(), height() );
    computeLayout();
    clPending = true;  
    setKeyBFocus();
 }
 void KOMonthView::computeLayoutWeek()
 {
    static int lastWid = 0;
    static int lastHei = 0;
    int daysToShow;
    bool combinedSatSun  = false;
    if (mShowSatSunComp = KOPrefs::instance()->mMonthViewSatSunTog ) {
        daysToShow = 6;
        combinedSatSun  = true;
    }
    int tWid = topLevelWidget()->size().width();
    int tHei = topLevelWidget()->size().height();
    int wid = width();//e
    int hei = height()-1-mNavigatorBar->height();
    if ( ((wid *3)/2) < tWid && (( hei *3) /2) < tHei  ) 
        return;
     
    if ( lastWid == width() && lastHei == height() ) {
        //qDebug("KOListWeekView::No compute layout needed ");
        return;
    }
    lastWid = width();
    lastHei = height();
    if ( wid < hei )
        daysToShow = 2;
    else
        daysToShow = 3;
    mShowSatSunComp = true;
    combinedSatSun  = true;
        
    //qDebug("KOMonthView::computeLayout() WWW ------------------------------------ ");
    QFontMetrics fm ( mWeekLabels[0]->font() );
    int weeklabelwid = fm.width( "888" );
    wid -= weeklabelwid;
    int colWid = wid / daysToShow;
    int lastCol = wid - ( colWid*6  ); 
    int dayLabelHei = mDayLabelsW[0]->sizeHint().height();
    int cellHei = (hei - (5- daysToShow )*dayLabelHei) /(5- daysToShow ); 
    int colModulo = wid % daysToShow;
    int rowModulo = (hei- (5- daysToShow )*dayLabelHei) % daysToShow-1;
    //qDebug("rowmod %d ", rowModulo);
    int i;
    int x,y,w,h;
    x= 0;
    y= 0;
    w = colWid;
    h = dayLabelHei ;
    for ( i = 0; i < 7; i++) {
        if ( i && !( i % daysToShow) && i < 6) {
            y += hei/(5-daysToShow);
            x = 0;
            w =  colWid;
        }
        if ( ((i) % daysToShow) >= daysToShow-colModulo ) {
            ++w;
        }
        if ( i >=  5 ) { 
            int wi = width() -  x - weeklabelwid;
            if ( i == 5 ) { 
                mDayLabelsW[i]->setGeometry( x+weeklabelwid,y,wi/2+wi%2,h);
            } else {
                mDayLabelsW[i]->setGeometry( x+weeklabelwid,y,wi,h);
            }
            x = x - w +  wi - (wi/2 );
        }
        else {
            int wi = w;  
            if ( !(( i+1) % daysToShow)) {
                wi = width() -  x - weeklabelwid;
            }
            mDayLabelsW[i]->setGeometry( x+weeklabelwid,y,wi,h);
        }
        x += w;                                   
    }
    x= 0;
    y= dayLabelHei;
    w = colWid;
    h = cellHei;
    int max = 0;
    for ( i = 0; i < mCellsW.count(); ++i) {
        if ( i > 6 ) {
            mCellsW[i]->hide();
            continue;
        }
        
        w = colWid;
        if ( ((i) % daysToShow) >= daysToShow-colModulo ) {
            ++w;
        }
        if ( i  == (daysToShow-1-rowModulo)*7)
            ++h; 
      
        if ( i >= 5 ) {
            if ( i ==5 ) {
                max = h/2;
                mCellsW[i]->setGeometry ( x+weeklabelwid,y,w,max ); 
                x -= w ;y += h/2;
            } else {
                if ( ((i-1) % daysToShow) >= daysToShow-colModulo ) {
                    ++w;
                }
                max = h-h/2;
                mCellsW[i]->setGeometry ( x+weeklabelwid,y,w,max ); 
                y -= h/2;
            }
        } else {
            max = h;
            mCellsW[i]->setGeometry ( x+weeklabelwid,y,w,h ); 
        }
                
       
        x += w;
        if ( x + w/2 > wid ) {
            x = 0;
            y += h+dayLabelHei ;
        }
        //mCellsW[i]->dateLabel()->setMaximumHeight( max - mCellsW[i]->lineWidth()*2 );
    }
    y= dayLabelHei;
    h = cellHei ;
    mWeekLabelsW[0]->setGeometry( 0,y,weeklabelwid,hei-dayLabelHei);
    mWeekLabelsW[1]->setGeometry( 0,0,weeklabelwid,dayLabelHei);
    // qDebug("RRRRRRRRRRRRR %d %d  old %d %d", e->size().width(),e->size().height() , e->oldSize().width(),e->oldSize().height());
    //qDebug("parent %d %d ", topLevelWidget()->size().width(), topLevelWidget()->size().height());
    mShortDayLabelsW = mDayLabelsW[0]->width()-2 < mWidthLongDayLabel ;
    updateDayLabels();
    //bool forceUpdate = !updatePossible;
    updatePossible = true;
    //mWeekLabels[mNumWeeks]->setText( i18n("M"));
    //if ( forceUpdate )
    //  updateView();
 }
 void KOMonthView::computeLayout()
 {
  
    static int lastWid = 0;
    static int lastHei = 0;
    if ( mShowWeekView ){
            computeLayoutWeek();
            return;
    }
    int daysToShow = 7;
    bool combinedSatSun  = false;
    if (mShowSatSunComp = KOPrefs::instance()->mMonthViewSatSunTog ) {
        daysToShow = 6;
        combinedSatSun  = true;
    }
    int tWid = topLevelWidget()->size().width();
    int tHei = topLevelWidget()->size().height();
    int wid = width();//e
    int hei = height()-1-mNavigatorBar->height();
    if ( ((wid *3)/2) < tWid && (( hei *3) /2) < tHei  ) {
        return;  
    }
    if ( lastWid == width() && lastHei == height() ){
        //qDebug("KOMonthview::No compute layout needed ");
        return;
    }
    lastWid = width();
    lastHei =  height();
    //qDebug("KOMonthView::computeLayout() MMM ------------------- ");
    QFontMetrics fm ( mWeekLabels[0]->font() );
    int weeklabelwid = fm.width( "888" );
    wid -= weeklabelwid;
    int colWid = wid / daysToShow;
    int lastCol = wid - ( colWid*6  ); 
    int dayLabelHei = mDayLabels[0]->sizeHint().height();
    int cellHei = (hei - dayLabelHei) /6; 
    int colModulo = wid % daysToShow;
    int rowModulo = (hei- dayLabelHei) % 6;
    //qDebug("rowmod %d ", rowModulo);
    int i;
    int x,y,w,h;
    x= 0;
    y= 0;
    w = colWid;
    h = dayLabelHei ;
    for ( i = 0; i < 7; i++) {
        if ( i == daysToShow-colModulo )
            ++w;
        if ( combinedSatSun ) {
            if ( i >=  daysToShow-1 ) {
                if ( i == 6 )
                    mDayLabels[i]->setGeometry( x+weeklabelwid,y,width()-x-weeklabelwid,h);
                else
                    mDayLabels[i]->setGeometry( x+weeklabelwid,y,w/2,h);
                x -= w/2 ;
            }
            else
                mDayLabels[i]->setGeometry( x+weeklabelwid,y,w,h);
        } else
            mDayLabels[i]->setGeometry( x+weeklabelwid,y,w,h);
        x += w;                                   
    }
    x= 0;
    y= dayLabelHei;
    w = colWid;
    h = cellHei ;
    int max = 0;
    for ( i = 0; i < mCells.count(); ++i) {
        //qDebug("iii %d ", i);
        w = colWid;
        if ( ((i) % 7) >= 7-colModulo ) {
            ++w;
        }
        if ( i  == (6-rowModulo)*7)
            ++h; 
        if ( combinedSatSun ) {
            if ( (i)%7 >=  daysToShow-1 ) {
                if ( (i)%7 ==  daysToShow-1 ) {
                    w = width()-x-weeklabelwid;
                    max = h/2;
                    mCells[i]->setGeometry ( x+weeklabelwid,y,w,max ); 
                    x -= w ;y += h/2;
                } else {
                    w = width()-x-weeklabelwid;
                    max = h-h/2;
                    mCells[i]->setGeometry ( x+weeklabelwid,y,w,max ); 
                    y -= h/2;
                }
            } else {
                max = h;
                mCells[i]->setGeometry ( x+weeklabelwid,y,w,h ); 
            }
                
        }
        else {
            max = h;
            mCells[i]->setGeometry ( x+weeklabelwid,y,w,h );
        }
        x += w;
        if ( x + w/2 > wid ) {
            x = 0;
            y += h;
        } 
        //mCells[i]->dateLabel()->setMaximumHeight( max- mCells[i]->lineWidth()*2 );
    }
    y= dayLabelHei;
    h = cellHei ;
    for ( i = 0; i < 6; i++) {
        if ( i  == (6-rowModulo))
            ++h;
        mWeekLabels[i]->setGeometry( 0,y,weeklabelwid,h);
        y += h;                            
    }
    mWeekLabels[6]->setGeometry( 0,0,weeklabelwid,dayLabelHei);
    // qDebug("RRRRRRRRRRRRR %d %d  old %d %d", e->size().width(),e->size().height() , e->oldSize().width(),e->oldSize().height());
    //qDebug("parent %d %d ", topLevelWidget()->size().width(), topLevelWidget()->size().height());
    mShortDayLabelsM = mDayLabels[0]->width()-2 < mWidthLongDayLabel ;
    updateDayLabels();
    //bool forceUpdate = !updatePossible;
    updatePossible = true;
    //mWeekLabels[mNumWeeks]->setText( i18n("W"));
 }
 void KOMonthView::showContextMenu( Incidence *incidence )
 {
    if( incidence )
        mContextMenu->showIncidencePopup(incidence);
    else {
        //qDebug("KOMonthView::showContextMenu ");
        mNewItemMenu->popup(QCursor::pos());
    }
    /*
      if( incidence && incidence->type() == "Event" ) {
      Event *event = static_cast<Event *>(incidence);
      mContextMenu->showEventPopup(event);
      } else {
      kdDebug() << "MonthView::showContextMenu(): cast failed." << endl;
      }
    */
 }
 MonthViewCell * KOMonthView::selectedCell( )
 {
    return mSelectedCell;
 }
 void KOMonthView::setSelectedCell( MonthViewCell *cell )
 {
    //qDebug("KOMonthView::setSelectedCell %d", cell);
    if ( mSelectedCell && mSelectedCell != cell ) {
        MonthViewCell * mvc = mSelectedCell;
        mSelectedCell = cell;
        mvc->deselect();
    } else 
        mSelectedCell = cell;
    //  if ( mSelectedCell )
    //         mSelectedCell->select();
    if ( !mSelectedCell )
        emit incidenceSelected( 0 );
    else 
        emit incidenceSelected( mSelectedCell->selectedIncidence() );
 }
 void KOMonthView::processSelectionChange()
 {
    QPtrList<Incidence> incidences = selectedIncidences();
    if (incidences.count() > 0) {
        emit incidenceSelected( incidences.first() );
    } else {
        emit incidenceSelected( 0 );
        clearSelection();
    }
 }
 void KOMonthView::clearSelection()
 {
    if ( mSelectedCell ) {
        mSelectedCell->deselect();
        mSelectedCell = 0;
    }
 }
 void KOMonthView::keyReleaseEvent ( QKeyEvent * e)
 {
    if ( !e->isAutoRepeat() ) {
        mFlagKeyPressed = false;
    }
 }
 void KOMonthView::keyPressEvent ( QKeyEvent * e )
 {
   
    qApp->processEvents();
    if ( e->isAutoRepeat() && !mFlagKeyPressed ) {
        //e->ignore();
        e->accept();
        return;
    }
    if (! e->isAutoRepeat() )
        mFlagKeyPressed = true;
    switch(e->key()) {
    case Key_Up: 
        {
            if ( mShowWeekView ) {
                emit selectWeekNum ( currentWeek() - 1 );
            }
            else {
                emit prevMonth();
            }
        }
        e->accept();
        break;
    case Key_Down:
        {
            if ( mShowWeekView ) {
                emit selectWeekNum ( currentWeek() +1);
            }
            else {
                emit nextMonth();
            }
           
        }
        e->accept();
        break;
    case Key_Return:
    case Key_Enter:
        {
            selectInternalWeekNum ( currentWeek() );
        }
        e->accept();
        break;
    case Key_D:
        if ( mSelectedCell ) {
            mSelectedCell->showDay();
            e->accept();
        } else {
            e->ignore();     
        }
        break;
    default:
        e->ignore();     
        break;
    }
 }
 void KOMonthView::nextCell()
 {
   bool res =  focusNextPrevChild ( true ); 
 }
 void KOMonthView::prevCell()
 {
    focusNextPrevChild ( false ); 
 }
 void KOMonthView::slotNewTodo()
 {
    //qDebug("KOMonthView::slotNewTodo() ");
    if ( mPopupCell ){
        QDateTime dt( mPopupCell->date(), QTime( KOPrefs::instance()->mStartTime, 0 ) );
        emit newTodoSignal(dt,true);
    }
    mPopupCell = 0;
 }
 void KOMonthView::slotNewEvent()
 {
    if ( mPopupCell ) {
        QDateTime dt( mPopupCell->date(), QTime( KOPrefs::instance()->mStartTime, 0 ) );
        emit newEventSignal( dt );
    }
    //qDebug("KOMonthView::slotNewEvent() ");
    mPopupCell = 0;
 }
 void KOMonthView::slotEditJournal()
 { 
    if (  mPopupCell )
        emit showJournalSignal( 7, mPopupCell->date() );
    //qDebug("KOMonthView::slotEditJournal() ");
    mPopupCell = 0;
 }
 void KOMonthView::setPopupCell( MonthViewCell * c)
 {
    mPopupCell = c;
 }
diff --git a/microkde/KDGanttMinimizeSplitter.cpp b/microkde/KDGanttMinimizeSplitter.cpp
index fb5d4e3..72c4e60 100644
--- a/microkde/KDGanttMinimizeSplitter.cpp
+++ b/microkde/KDGanttMinimizeSplitter.cpp
@@ -1,1701 +1,1716 @@
 /* -*- Mode: C++ -*-
   $Id$
 */
 /****************************************************************************
 ** Copyright (C)  2002-2004 Klar�lvdalens Datakonsult AB.  All rights reserved.
 **
 ** This file is part of the KDGantt library.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid commercial KDGantt licenses may use this file in
 ** accordance with the KDGantt Commercial License Agreement provided with
 ** the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.klaralvdalens-datakonsult.se/Public/products/ for
 **   information about KDGantt Commercial License Agreements.
 **
 ** Contact info@klaralvdalens-datakonsult.se if any conditions of this
 ** licensing are not clear to you.
 **
 ** As a special exception, permission is given to link this program
 ** with any edition of Qt, and distribute the resulting executable,
 ** without including the source code for Qt in the source distribution.
 **
 **********************************************************************/
 #include "KDGanttMinimizeSplitter.h"
 #ifndef QT_NO_SPLITTER___
 #include "qpainter.h"
 #include "qdrawutil.h"
 #include "qbitmap.h" 
 #if QT_VERSION >= 0x030000
 #include "qptrlist.h"
 #include "qmemarray.h"
 #else
 #include <qlist.h>
 #include <qarray.h>
 #define QPtrList QList
 #define QMemArray QArray
 #endif
 #include "qlayoutengine_p.h"
 #include "qobjectlist.h"
 #include "qstyle.h"
 #include "qapplication.h" //sendPostedEvents
 #include <qvaluelist.h>
 #include <qcursor.h>
+#include <qframe.h>
 #ifndef KDGANTT_MASTER_CVS
 //#include "KDGanttMinimizeSplitter.moc"
 #endif
 #ifndef DOXYGEN_SKIP_INTERNAL
 #if QT_VERSION >= 232
 static int mouseOffset;
 static int opaqueOldPos = -1; //### there's only one mouse, but this is a bit risky
+class KDRubberBand: public QFrame
+{
+public:
+    KDRubberBand(  QWidget *parent, const char * name, WFlags f ) :QFrame ( parent, name, f ) {;}
+protected:
+    virtual void mousePressEvent ( QMouseEvent * )
+    {
+        close();
+    };
+};
 KDGanttSplitterHandle::KDGanttSplitterHandle( Qt::Orientation o,
                                  KDGanttMinimizeSplitter *parent, const char * name )
    : QWidget( parent, name ), _activeButton( 0 ), _collapsed( false )
 {
    if ( QApplication::desktop()->width() > 320 &&  QApplication::desktop()->width() < 650 ) {
        mSizeHint = QSize(7,7);
        mUseOffset = true;
    } else {
        mSizeHint = QSize(6,6);
        mUseOffset = false;
    }
    s = parent;
    setOrientation(o);
    setMouseTracking( true );
    mMouseDown = false;
    //setMaximumHeight( 5 ); // test only
 }
 QSize KDGanttSplitterHandle::sizeHint() const
 {
    return  mSizeHint;
 }
 void KDGanttSplitterHandle::setOrientation( Qt::Orientation o )
 {
    orient = o;
 #ifndef QT_NO_CURSOR
    if ( o == KDGanttMinimizeSplitter::Horizontal )
        setCursor( splitHCursor );
    else
        setCursor( splitVCursor );
 #endif
 }
 void KDGanttSplitterHandle::mouseMoveEvent( QMouseEvent *e )
 {
    updateCursor( e->pos() );
    if ( !(e->state()&LeftButton) )
        return;
    if ( _activeButton != 0)
        return;
    QCOORD pos = s->pick(parentWidget()->mapFromGlobal(e->globalPos()))
                 - mouseOffset;
    if ( opaque() ) {
        s->moveSplitter( pos, id() );
    } else {
        int min = pos; int max = pos;
        s->getRange( id(), &min, &max );
        s->setRubberband( QMAX( min, QMIN(max, pos )));
    }
    _collapsed = false;
 }
 void KDGanttSplitterHandle::mousePressEvent( QMouseEvent *e )
 {
    if ( e->button() == LeftButton ) {
        _activeButton = onButton( e->pos() );
        mouseOffset = s->pick(e->pos());
        mMouseDown = true;
        repaint();
        updateCursor( e->pos() );
    }
 }
 void KDGanttSplitterHandle::updateCursor( const QPoint& p)
 {
    if ( onButton( p ) != 0 ) {
        setCursor( arrowCursor );
    }
    else {
        if ( orient == KDGanttMinimizeSplitter::Horizontal )
            setCursor( splitHCursor );
        else
            setCursor( splitVCursor );
    }
 }
 void KDGanttSplitterHandle::toggle()
 {
    int pos;
    int min, max;
    if ( !_collapsed ) {
        s->expandPos( id(), &min, &max );
        if ( s->minimizeDirection() == KDGanttMinimizeSplitter::Left
             || s->minimizeDirection() == KDGanttMinimizeSplitter::Up ) {
            pos = min;
        }
        else {
            pos = max;
        }
        _origPos = s->pick(mapToParent( QPoint( 0,0 ) ));
        s->moveSplitter( pos, id() );
        _collapsed = true;
    }
    else {
        s->moveSplitter( _origPos, id() );
        _collapsed = false;
    }
    repaint();
 }
 void KDGanttSplitterHandle::mouseReleaseEvent( QMouseEvent *e )
 {
    mMouseDown = false;
    if ( _activeButton != 0 ) {
        if ( onButton( e->pos() ) == _activeButton )
        {
            toggle();
        }
        _activeButton = 0;
        updateCursor( e->pos() );
    }
    else {
        if ( !opaque() && e->button() == LeftButton ) {
            QCOORD pos = s->pick(parentWidget()->mapFromGlobal(e->globalPos()))
                - mouseOffset;
            s->setRubberband( -1 );
            s->moveSplitter( pos, id() );
        }
    }
-    if ( s->rubberBand() )
+    if ( s->rubberBand() ) {
-        s->rubberBand()->hide();
+        //qDebug("hide rubberband ");
+        s->rubberBand()->close();
+    }
    repaint();
 }
 int KDGanttSplitterHandle::onButton( const QPoint& p )
 {
    QValueList<QPointArray> list = buttonRegions();
    int index = 1;
    int add = 12;
    for( QValueList<QPointArray>::Iterator it = list.begin(); it != list.end(); ++it ) {
        QRect rect = (*it).boundingRect();
        rect.setLeft( rect.left()- add );
        rect.setRight( rect.right() + add);
        rect.setTop( rect.top()- add );
        rect.setBottom( rect.bottom() + add);
        if ( rect.contains( p ) ) {
            return index;
        }
        index++;
    }
    return 0;
 }
 QValueList<QPointArray> KDGanttSplitterHandle::buttonRegions()
 {
    QValueList<QPointArray> list;
    int sw = 8;
    int yyy = 1;
    int xxx = 1;
    int voffset[] = { (int) -sw*3, (int) sw*3 };
    for ( int i = 0; i < 2; i++ ) {
        QPointArray arr;
        if ( !_collapsed && s->minimizeDirection() == KDGanttMinimizeSplitter::Right ||
             _collapsed  && s->minimizeDirection() == KDGanttMinimizeSplitter::Left) {
            int mid = height()/2 + voffset[i];
            arr.setPoints( 3,
                           1-xxx, mid - sw + 4,
                           sw-3-xxx, mid,
                           1-xxx, mid + sw -4);
        }
        else if ( !_collapsed &&  s->minimizeDirection() == KDGanttMinimizeSplitter::Left ||
                  _collapsed  && s->minimizeDirection() == KDGanttMinimizeSplitter::Right ) {
            int mid = height()/2 + voffset[i];
            arr.setPoints( 3,
                           sw-4, mid - sw + 4,
                           0, mid,
                           sw-4, mid + sw - 4);
        }
        else if ( !_collapsed &&  s->minimizeDirection() == KDGanttMinimizeSplitter::Up ||
                  _collapsed  && s->minimizeDirection() == KDGanttMinimizeSplitter::Down) {
            int mid = width()/2 + voffset[i];
            arr.setPoints( 3,
                           mid - sw + 4, sw-4,
                           mid, 0,
                           mid + sw - 4, sw-4 );
        }
        else if ( !_collapsed && s->minimizeDirection() == KDGanttMinimizeSplitter::Down ||
                  _collapsed  && s->minimizeDirection() == KDGanttMinimizeSplitter::Up ) {
            int mid = width()/2 + voffset[i];
            arr.setPoints( 3,
                           mid - sw + 4, 1-yyy,
                           mid, sw-3-yyy,
                           mid + sw -4, 1-yyy);
        }
        list.append( arr );
    }
    return list;
 }
 void KDGanttSplitterHandle::paintEvent( QPaintEvent * )
 {
    QPixmap buffer( size() );
    QPainter p( &buffer );
    //LR
    // Draw the splitter rectangle
    p.setBrush( colorGroup().background() );
    p.setPen( colorGroup().foreground() );
    //p.drawRect( rect() );
 #ifndef DESKTOP_VERSION
    if (  mMouseDown && ! _activeButton)
        buffer.fill( colorGroup().background().dark() );
    else    
 #endif
        buffer.fill( colorGroup().background() );
    //buffer.fill( backgroundColor() );
    // parentWidget()->style().drawPrimitive( QStyle::PE_Panel, &p, rect(), parentWidget()->colorGroup());
    int sw = 8; // Hardcoded, given I didn't use styles anymore, I didn't like to use their size
    // arrow color
    QColor col;
    if ( _activeButton )
        col = colorGroup().background().dark( 250 );
    else {
        if ( mMouseDown )
            col = Qt::white;
        else
            col = colorGroup().background().dark( 150 );
    }
    //QColor col = backgroundColor().dark( 130 );
    p.setBrush( col );
    p.setPen( col  );
    QValueList<QPointArray> list = buttonRegions();
    int index = 1;
    if ( mUseOffset )
        p.translate( 0, 1 );
    for ( QValueList<QPointArray>::Iterator it = list.begin(); it != list.end(); ++it ) {
        if ( index == _activeButton ) { 
           
            /*
            if ( ! _collapsed ) {
            p.save();
            // p.translate( parentWidget()->style().pixelMetric( QStyle::PM_ButtonShiftHorizontal ),
            //           parentWidget()->style().pixelMetric( QStyle::PM_ButtonShiftVertical ) );
            p.translate( -1, 0 );
            p.drawPolygon( *it, true );
            p.restore(); } else
            */
            p.drawPolygon( *it, true );
                
        }
        else {
            /*
            if ( ! _collapsed ) {
            p.save();
            p.translate( -1, 0 );
            p.drawPolygon( *it, true );
            p.restore();
            } else
            */
            p.drawPolygon( *it, true );
                
        }
        index++;
    }
    // Draw the lines between the arrows
    if ( s->minimizeDirection() == KDGanttMinimizeSplitter::Left ||
         s->minimizeDirection() == KDGanttMinimizeSplitter::Right ) {
        int mid = height()/2;
        p.drawLine ( 1, mid - sw, 1, mid + sw );
        p.drawLine ( 3, mid - sw, 3, mid + sw );
    }
    else if ( s->minimizeDirection() == KDGanttMinimizeSplitter::Up ||
              s->minimizeDirection() == KDGanttMinimizeSplitter::Down ) {
        int mid = width()/2;
        p.drawLine( mid -sw, 1, mid +sw, 1 );
        p.drawLine( mid -sw, 3, mid +sw, 3 );
    }
    bitBlt( this, 0, 0, &buffer );
 }
 #endif
 class QSplitterLayoutStruct
 {
 public:
    KDGanttMinimizeSplitter::ResizeMode mode;
    QCOORD sizer;
    bool isSplitter;
    QWidget *wid;
 };
 class QSplitterData
 {
 public:
    QSplitterData() : opaque( FALSE ), firstShow( TRUE ) {}
    QPtrList<QSplitterLayoutStruct> list;
    bool opaque;
    bool firstShow;
 };
 void kdganttGeomCalc( QMemArray<QLayoutStruct> &chain, int start, int count, int pos,
                 int space, int spacer );
 #endif // DOXYGEN_SKIP_INTERNAL
 /*!
  \class KDGanttMinimizeSplitter KDGanttMinimizeSplitter.h
  \brief The KDGanttMinimizeSplitter class implements a splitter
  widget with minimize buttons.
  This class (and its documentation) is largely a copy of Qt's
  QSplitter; the copying was necessary because QSplitter is not
  extensible at all. QSplitter and its documentation are licensed
  according to the GPL and the Qt Professional License (if you hold
  such a license) and are (C) Trolltech AS.
  A splitter lets the user control the size of child widgets by
  dragging the boundary between the children. Any number of widgets
  may be controlled.
  To show a QListBox, a QListView and a QTextEdit side by side:
  \code
    KDGanttMinimizeSplitter *split = new KDGanttMinimizeSplitter( parent );
    QListBox *lb = new QListBox( split );
    QListView *lv = new QListView( split );
    QTextEdit *ed = new QTextEdit( split );
  \endcode
  In KDGanttMinimizeSplitter, the boundary can be either horizontal or
  vertical.  The default is horizontal (the children are side by side)
  but you can use setOrientation( QSplitter::Vertical ) to set it to
  vertical.
  Use setResizeMode() to specify
  that a widget should keep its size when the splitter is resized.
  Although KDGanttMinimizeSplitter normally resizes the children only
  at the end of a resize operation, if you call setOpaqueResize( TRUE
  ) the widgets are resized as often as possible.
  The initial distribution of size between the widgets is determined
  by the initial size of each widget. You can also use setSizes() to
  set the sizes of all the widgets. The function sizes() returns the
  sizes set by the user.
  If you hide() a child, its space will be distributed among the other
  children. It will be reinstated when you show() it again. It is also
  possible to reorder the widgets within the splitter using
  moveToFirst() and moveToLast().
 */
 static QSize minSize( const QWidget* /*w*/ )
 {
    return QSize(0,0);
 }
 // This is the original version of minSize
 static QSize minSizeHint( const QWidget* w )
 {
    QSize min = w->minimumSize();
    QSize s;
    if ( min.height() <= 0 || min.width() <= 0 )
        s = w->minimumSizeHint();
    if ( min.height() > 0 )
        s.setHeight( min.height() );
    if ( min.width() > 0 )
        s.setWidth( min.width() );
    return s.expandedTo(QSize(0,0));
 }
 /*!
  Constructs a horizontal splitter with the \a parent and \a
  name arguments being passed on to the QFrame constructor.
 */
 KDGanttMinimizeSplitter::KDGanttMinimizeSplitter( QWidget *parent, const char *name )
    :QFrame(parent,name,WPaintUnclipped)
 {
    mRubberBand = 0;
    mFirstHandle = 0;
 #if QT_VERSION >= 232
     orient = Horizontal;
     init();
 #endif
 }
 /*!
  Constructs a splitter with orientation \a o with the \a parent
  and \a name arguments being passed on to the QFrame constructor.
 */
 KDGanttMinimizeSplitter::KDGanttMinimizeSplitter( Orientation o, QWidget *parent, const char *name )
    :QFrame(parent,name,WPaintUnclipped)
 { 
    
    mRubberBand = 0;
    mFirstHandle = 0;
 #if QT_VERSION >= 232
     orient = o;
     init();
 #endif
 }
 /*!
  Destroys the splitter and any children.
 */
 KDGanttMinimizeSplitter::~KDGanttMinimizeSplitter()
 {
 #if QT_VERSION >= 232
    data->list.setAutoDelete( TRUE );
    delete data;
 #endif
    if ( mRubberBand )
        delete mRubberBand;
 }
 #if QT_VERSION >= 232
 void KDGanttMinimizeSplitter::init()
 {
    data = new QSplitterData;
    if ( orient == Horizontal )
        setSizePolicy( QSizePolicy(QSizePolicy::Expanding,QSizePolicy::Minimum) );
    else
        setSizePolicy( QSizePolicy(QSizePolicy::Minimum,QSizePolicy::Expanding) );
 #ifndef DESKTOP_VERSION
     setOpaqueResize( false );
 #else
     setOpaqueResize( true );
 #endif
 }
 #endif
 void KDGanttMinimizeSplitter::toggle()
 {
    if ( mFirstHandle  )
        mFirstHandle->toggle();
    else
        qDebug("KDGanttMinimizeSplitter::toggle::sorry, handle not available ");
        
 }
 /*!
  \brief the orientation of the splitter
  By default the orientation is horizontal (the widgets are side by side).
  The possible orientations are Qt:Vertical and Qt::Horizontal (the default).
 */
 void KDGanttMinimizeSplitter::setOrientation( Orientation o )
 {
 #if QT_VERSION >= 232
    if ( orient == o )
        return;
    orient = o;
    if ( orient == Horizontal )
        setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Minimum ) );
    else
        setSizePolicy( QSizePolicy( QSizePolicy::Minimum, QSizePolicy::Expanding ) );
    QSplitterLayoutStruct *s = data->list.first();
    while ( s ) {
        if ( s->isSplitter )
            ((KDGanttSplitterHandle*)s->wid)->setOrientation( o );
        s = data->list.next();  // ### next at end of loop, no iterator
    }
    recalc( isVisible() );
 #endif
 }
 #if QT_VERSION >= 232
 /*!
  \reimp
 */
 void KDGanttMinimizeSplitter::resizeEvent( QResizeEvent * )
 {
    doResize();
 }
 /*
  Inserts the widget \a w at the end (or at the beginning if \a first
  is TRUE) of the splitter's list of widgets.
  It is the responsibility of the caller of this function to make sure
  that \a w is not already in the splitter and to call recalcId if
  needed.  (If \a first is TRUE, then recalcId is very probably
  needed.)
 */
 QSplitterLayoutStruct *KDGanttMinimizeSplitter::addWidget( QWidget *w, bool first )
 {
    QSplitterLayoutStruct *s;
    KDGanttSplitterHandle *newHandle = 0;
    if ( data->list.count() > 0 ) {
        s = new QSplitterLayoutStruct;
        s->mode = KeepSize;
        QString tmp = "qt_splithandle_";
        tmp += w->name();
        newHandle = new KDGanttSplitterHandle( orientation(), this, tmp.latin1() );
    if ( ! mFirstHandle )
        mFirstHandle = newHandle;
        s->wid = newHandle;
        newHandle->setId(data->list.count());
        s->isSplitter = TRUE;
        s->sizer = pick( newHandle->sizeHint() );
        if ( first )
            data->list.insert( 0, s );
        else
            data->list.append( s );
    }
    s = new QSplitterLayoutStruct;
    s->mode = Stretch;
    s->wid = w;
    if ( !testWState( WState_Resized ) && w->sizeHint().isValid() )
        s->sizer = pick( w->sizeHint() );
    else
        s->sizer = pick( w->size() );
    s->isSplitter = FALSE;
    if ( first )
        data->list.insert( 0, s );
    else
        data->list.append( s );
    if ( newHandle && isVisible() )
        newHandle->show(); //will trigger sending of post events
    return s;
 }
 /*!
  Tells the splitter that a child widget has been inserted or removed.
  The event is passed in \a c.
 */
 void KDGanttMinimizeSplitter::childEvent( QChildEvent *c )
 {
    if ( c->type() == QEvent::ChildInserted ) {
        if ( !c->child()->isWidgetType() )
            return;
        if ( ((QWidget*)c->child())->testWFlags( WType_TopLevel ) )
            return;
        QSplitterLayoutStruct *s = data->list.first();
        while ( s ) {
            if ( s->wid == c->child() )
                return;
            s = data->list.next();
        }
        addWidget( (QWidget*)c->child() );
        recalc( isVisible() );
    } else if ( c->type() == QEvent::ChildRemoved ) {
        QSplitterLayoutStruct *p = 0;
        if ( data->list.count() > 1 )
            p = data->list.at(1); //remove handle _after_ first widget.
        QSplitterLayoutStruct *s = data->list.first();
        while ( s ) {
            if ( s->wid == c->child() ) {
                data->list.removeRef( s );
                delete s;
                if ( p && p->isSplitter ) {
                    data->list.removeRef( p );
                    delete p->wid; //will call childEvent
                    delete p;
                }
                recalcId();
                doResize();
                return;
            }
            p = s;
            s = data->list.next();
        }
    }
 }
 /*!
  Shows a rubber band at position \a p. If \a p is negative, the
  rubber band is removed.
 */
 void KDGanttMinimizeSplitter::setRubberband( int p )
 {
 #ifdef DESKTOP_VERSION
    QPainter paint( this );
    paint.setPen( gray );
    paint.setBrush( gray );
    paint.setRasterOp( XorROP );
    QRect r = contentsRect();
    const int rBord = 3; //Themable????
 #if QT_VERSION >= 0x030000
    int sw = style().pixelMetric(QStyle::PM_SplitterWidth, this);
 #else
    int sw = style().splitterWidth();
 #endif
    if ( orient == Horizontal ) {
        if ( opaqueOldPos >= 0 )
            paint.drawRect( opaqueOldPos + sw/2 - rBord , r.y(),
                            2*rBord, r.height() );
        if ( p >= 0 )
            paint.drawRect( p  + sw/2 - rBord, r.y(), 2*rBord, r.height() );
    } else {
        if ( opaqueOldPos >= 0 )
            paint.drawRect( r.x(), opaqueOldPos + sw/2 - rBord,
                            r.width(), 2*rBord );
        if ( p >= 0 )
            paint.drawRect( r.x(), p + sw/2 - rBord, r.width(), 2*rBord );
    }
    opaqueOldPos = p;
 #else 
    if ( !mRubberBand  ) {
-        mRubberBand = new QFrame( 0, "rubber", WStyle_NoBorder | WStyle_Customize | WStyle_StaysOnTop);
+        mRubberBand = new KDRubberBand( 0, "rubber", WStyle_NoBorder | WStyle_Customize | WStyle_StaysOnTop);
        mRubberBand->setFrameStyle( Box | Raised );
        //mRubberBand->setPalette( QPalette ( Qt::red.light(),Qt::red.dark() ) );
        mRubberBand->setPalette( QPalette ( colorGroup().background().light(), colorGroup().background().dark() ));
    }
    QRect r = contentsRect();
    static int rBord = 0; //Themable????
    if ( !rBord ) {
        if (QApplication::desktop()->width() <= 320 )
            rBord = 3;
        else
            rBord = 4;
    }
    int sw = style().splitterWidth();
    if ( orient == Horizontal ) {
        if ( p >= 0 ) {
            QPoint geo =  mapToGlobal (QPoint ( p  + sw/2 - rBord, r.y()));
            mRubberBand->setGeometry( geo.x(), geo.y(), 2*rBord, r.height() );
        }
    } else {
        if ( p >= 0 ) {
            QPoint geo =  mapToGlobal (QPoint ( r.x(), p + sw/2 - rBord));
           mRubberBand->setGeometry( geo.x(), geo.y(), r.width(), 2*rBord);
        }
    }
    opaqueOldPos = p;
    if ( ! mRubberBand->isVisible() ) {
        mRubberBand->show();
    }
 #endif
 }
 /*! \reimp */
 bool KDGanttMinimizeSplitter::event( QEvent *e )
 {
    if ( e->type() == QEvent::LayoutHint || ( e->type() == QEvent::Show && data->firstShow ) ) {
        recalc( isVisible() );
        if ( e->type() == QEvent::Show )
            data->firstShow = FALSE;
    }
    return QWidget::event( e );
 }
 /*!
  \obsolete
  Draws the splitter handle in the rectangle described by \a x, \a y,
  \a w, \a h using painter \a p.
  \sa QStyle::drawPrimitive()
 */
 void KDGanttMinimizeSplitter::drawSplitter( QPainter *p,
                              QCOORD x, QCOORD y, QCOORD w, QCOORD h )
 {
 #if 0
    // LR
    style().drawPrimitive(QStyle::PE_Splitter, p, QRect(x, y, w, h), colorGroup(),
                          (orientation() == Qt::Horizontal ?
                           QStyle::Style_Horizontal : 0));
 #endif
 }
 /*!
  Returns the id of the splitter to the right of or below the widget \a w,
  or 0 if there is no such splitter
  (i.e. it is either not in this KDGanttMinimizeSplitter or it is at the end).
 */
 int KDGanttMinimizeSplitter::idAfter( QWidget* w ) const
 {
    QSplitterLayoutStruct *s = data->list.first();
    bool seen_w = FALSE;
    while ( s ) {
        if ( s->isSplitter && seen_w )
            return data->list.at();
        if ( !s->isSplitter && s->wid == w )
            seen_w = TRUE;
        s = data->list.next();
    }
    return 0;
 }
 /*!
  Moves the left/top edge of the splitter handle with id \a id as
  close as possible to position \a p, which is the distance from the
  left (or top) edge of the widget.
  For Arabic and Hebrew the layout is reversed, and using this
  function to set the position of the splitter might lead to
  unexpected results, since in Arabic and Hebrew the position of
  splitter one is to the left of the position of splitter zero.
  \sa idAfter()
 */
 void KDGanttMinimizeSplitter::moveSplitter( QCOORD p, int id )
 {
    p = adjustPos( p, id );
    QSplitterLayoutStruct *s = data->list.at(id);
    int oldP = orient == Horizontal ? s->wid->x() : s->wid->y();
    bool upLeft;
    if ( false && orient == Horizontal ) {
        p += s->wid->width();
        upLeft = p > oldP;
    } else
        upLeft = p < oldP;
    moveAfter( p, id, upLeft );
    moveBefore( p-1, id-1, upLeft );
    storeSizes();
 }
 void KDGanttMinimizeSplitter::setG( QWidget *w, int p, int s, bool isSplitter )
 {
    if ( orient == Horizontal ) {
        if ( false && orient == Horizontal && !isSplitter )
            p = contentsRect().width() - p - s;
        w->setGeometry( p, contentsRect().y(), s, contentsRect().height() );
    } else
        w->setGeometry( contentsRect().x(), p, contentsRect().width(), s );
 }
 /*
  Places the right/bottom edge of the widget at \a id at position \a pos.
  \sa idAfter()
 */
 void KDGanttMinimizeSplitter::moveBefore( int pos, int id, bool upLeft )
 {
    if( id < 0 )
        return;
    QSplitterLayoutStruct *s = data->list.at(id);
    if ( !s )
        return;
    QWidget *w = s->wid;
    if ( w->isHidden() ) {
        moveBefore( pos, id-1, upLeft );
    } else if ( s->isSplitter ) {
        int pos1, pos2;
        int dd = s->sizer;
        if( false && orient == Horizontal ) {
            pos1 = pos;
            pos2 = pos + dd;
        } else {
            pos2 = pos - dd;
            pos1 = pos2 + 1;
        }
        if ( upLeft ) {
            setG( w, pos1, dd, TRUE );
            moveBefore( pos2, id-1, upLeft );
        } else {
            moveBefore( pos2, id-1, upLeft );
            setG( w, pos1, dd, TRUE );
        }
    } else {
        int dd, newLeft, nextPos;
        if( false && orient == Horizontal ) {
            dd = w->geometry().right() - pos;
            dd = QMAX( pick(minSize(w)), QMIN(dd, pick(w->maximumSize())));
            newLeft = pos+1;
            nextPos = newLeft + dd;
        } else {
            dd = pos - pick( w->pos() ) + 1;
            dd = QMAX( pick(minSize(w)), QMIN(dd, pick(w->maximumSize())));
            newLeft = pos-dd+1;
            nextPos = newLeft - 1;
        }
        setG( w, newLeft, dd, TRUE );
        moveBefore( nextPos, id-1, upLeft );
    }
 }
 /*
  Places the left/top edge of the widget at \a id at position \a pos.
  \sa idAfter()
 */
 void KDGanttMinimizeSplitter::moveAfter( int pos, int id, bool upLeft )
 {
    QSplitterLayoutStruct *s = id < int(data->list.count()) ?
                               data->list.at(id) : 0;
    if ( !s )
        return;
    QWidget *w = s->wid;
    if ( w->isHidden() ) {
        moveAfter( pos, id+1, upLeft );
    } else if ( pick( w->pos() ) == pos ) {
        //No need to do anything if it's already there.
        return;
    } else if ( s->isSplitter ) {
        int dd = s->sizer;
        int pos1, pos2;
        if( false && orient == Horizontal ) {
            pos2 = pos - dd;
            pos1 = pos2 + 1;
        } else {
            pos1 = pos;
            pos2 = pos + dd;
        }
        if ( upLeft ) {
            setG( w, pos1, dd, TRUE );
            moveAfter( pos2, id+1, upLeft );
        } else {
            moveAfter( pos2, id+1, upLeft );
            setG( w, pos1, dd, TRUE );
        }
    } else {
        int left = pick( w->pos() );
        int right, dd,/* newRight,*/ newLeft, nextPos;
        if ( false && orient == Horizontal ) {
            dd = pos - left + 1;
            dd = QMAX( pick(minSize(w)), QMIN(dd, pick(w->maximumSize())));
            newLeft = pos-dd+1;
            nextPos = newLeft - 1;
        } else {
            right = pick( w->geometry().bottomRight() );
            dd = right - pos + 1;
            dd = QMAX( pick(minSize(w)), QMIN(dd, pick(w->maximumSize())));
            /*newRight = pos+dd-1;*/
            newLeft = pos;
            nextPos = newLeft + dd;
        }
        setG( w, newLeft, dd, TRUE );
        /*if( right != newRight )*/
        moveAfter( nextPos, id+1, upLeft );
    }
 }
 void KDGanttMinimizeSplitter::expandPos( int id, int*  min, int* max )
 {
    QSplitterLayoutStruct *s = data->list.at(id-1);
    QWidget* w = s->wid;
    *min = pick( w->mapToParent( QPoint(0,0) ) );
    if ( (uint) id == data->list.count() ) {
        pick( size() );
    }
    else {
        QSplitterLayoutStruct *s = data->list.at(id+1);
        QWidget* w = s->wid;
        *max = pick( w->mapToParent( QPoint( w->width(), w->height() ) ) ) -8;
    }
 }
 /*!
  Returns the valid range of the splitter with id \a id in \a *min and \a *max.
  \sa idAfter()
 */
 void KDGanttMinimizeSplitter::getRange( int id, int *min, int *max )
 {
            int minB = 0;//before
    int maxB = 0;
    int minA = 0;
            int maxA = 0;//after
    int n = data->list.count();
    if ( id < 0 || id >= n )
        return;
    int i;
    for ( i = 0; i < id; i++ ) {
        QSplitterLayoutStruct *s = data->list.at(i);
        if ( s->wid->isHidden() ) {
            //ignore
        } else if ( s->isSplitter ) {
            minB += s->sizer;
            maxB += s->sizer;
        } else {
            minB += pick( minSize(s->wid) );
            maxB += pick( s->wid->maximumSize() );
        }
    }
    for ( i = id; i < n; i++ ) {
        QSplitterLayoutStruct *s = data->list.at(i);
        if ( s->wid->isHidden() ) {
            //ignore
        } else if ( s->isSplitter ) {
            minA += s->sizer;
            maxA += s->sizer;
        } else {
            minA += pick( minSize(s->wid) );
            maxA += pick( s->wid->maximumSize() );
        }
    }
    QRect r = contentsRect();
    if ( orient == Horizontal && false ) {
 #if QT_VERSION >= 0x030000
    int splitterWidth = style().pixelMetric(QStyle::PM_SplitterWidth, this);
 #else
    int splitterWidth = style().splitterWidth();
 #endif
      
        if ( min )
            *min = pick(r.topRight()) - QMIN( maxB, pick(r.size())-minA ) - splitterWidth;
        if ( max )
            *max = pick(r.topRight()) - QMAX( minB, pick(r.size())-maxA ) - splitterWidth;
    } else {
        if ( min )
            *min = pick(r.topLeft()) + QMAX( minB, pick(r.size())-maxA );
        if ( max )
            *max = pick(r.topLeft()) + QMIN( maxB, pick(r.size())-minA );
    }
 }
 /*!
  Returns the closest legal position to \a p of the splitter with id \a id.
  \sa idAfter()
 */
 int KDGanttMinimizeSplitter::adjustPos( int p, int id )
 {
    int min = 0;
    int max = 0;
    getRange( id, &min, &max );
    p = QMAX( min, QMIN( p, max ) );
    return p;
 }
 void KDGanttMinimizeSplitter::doResize()
 {
    QRect r = contentsRect();
    int i;
    int n = data->list.count();
    QMemArray<QLayoutStruct> a( n );
    for ( i = 0; i< n; i++ ) {
        a[i].init();
        QSplitterLayoutStruct *s = data->list.at(i);
        if ( s->wid->isHidden() ) {
            a[i].stretch = 0;
            a[i].sizeHint = a[i].minimumSize = 0;
            a[i].maximumSize = 0;
        } else if ( s->isSplitter ) {
            a[i].stretch = 0;
            a[i].sizeHint = a[i].minimumSize = a[i].maximumSize = s->sizer;
            a[i].empty = FALSE;
        } else if ( s->mode == KeepSize ) {
            a[i].stretch = 0;
            a[i].minimumSize = pick( minSize(s->wid) );
            a[i].sizeHint = s->sizer;
            a[i].maximumSize = pick( s->wid->maximumSize() );
            a[i].empty = FALSE;
        } else if ( s->mode == FollowSizeHint ) {
            a[i].stretch = 0;
            a[i].minimumSize = a[i].sizeHint = pick( s->wid->sizeHint() );
            a[i].maximumSize = pick( s->wid->maximumSize() );
            a[i].empty = FALSE;
        } else { //proportional
            a[i].stretch = s->sizer;
            a[i].maximumSize = pick( s->wid->maximumSize() );
            a[i].sizeHint = a[i].minimumSize = pick( minSize(s->wid) );
            a[i].empty = FALSE;
        }
    }
    kdganttGeomCalc( a, 0, n, pick( r.topLeft() ), pick( r.size() ), 0 );
    for ( i = 0; i< n; i++ ) {
        QSplitterLayoutStruct *s = data->list.at(i);
        setG( s->wid, a[i].pos, a[i].size );
    }
 }
 void KDGanttMinimizeSplitter::recalc( bool update )
 {
    int fi = 2*frameWidth();
    int maxl = fi;
    int minl = fi;
    int maxt = QWIDGETSIZE_MAX;
    int mint = fi;
    int n = data->list.count();
    bool first = TRUE;
    /*
      The splitter before a hidden widget is always hidden.
      The splitter before the first visible widget is hidden.
      The splitter before any other visible widget is visible.
    */
    for ( int i = 0; i< n; i++ ) {
        QSplitterLayoutStruct *s = data->list.at(i);
        if ( !s->isSplitter ) {
            QSplitterLayoutStruct *p = (i > 0) ? p = data->list.at( i-1 ) : 0;
            if ( p && p->isSplitter )
                if ( first || s->wid->isHidden() )
                    p->wid->hide(); //may trigger new recalc
                else
                    p->wid->show(); //may trigger new recalc
            if ( !s->wid->isHidden() )
                first = FALSE;
        }
    }
    bool empty=TRUE;
    for ( int j = 0; j< n; j++ ) {
        QSplitterLayoutStruct *s = data->list.at(j);
        if ( !s->wid->isHidden() ) {
            empty = FALSE;
            if ( s->isSplitter ) {
                minl += s->sizer;
                maxl += s->sizer;
            } else {
                QSize minS = minSize(s->wid);
                minl += pick( minS );
                maxl += pick( s->wid->maximumSize() );
                mint = QMAX( mint, trans( minS ));
                int tm = trans( s->wid->maximumSize() );
                if ( tm > 0 )
                    maxt = QMIN( maxt, tm );
            }
        }
    }
    if ( empty ) {
        if ( parentWidget() != 0 && parentWidget()->inherits("KDGanttMinimizeSplitter") ) {
            // nested splitters; be nice
            maxl = maxt = 0;
        } else {
            // KDGanttMinimizeSplitter with no children yet
            maxl = QWIDGETSIZE_MAX;
        }
    } else {
        maxl = QMIN( maxl, QWIDGETSIZE_MAX );
    }
    if ( maxt < mint )
        maxt = mint;
    if ( orient == Horizontal ) {
        setMaximumSize( maxl, maxt );
        setMinimumSize( minl, mint );
    } else {
        setMaximumSize( maxt, maxl );
        setMinimumSize( mint, minl );
    }
    if ( update )
        doResize();
 }
 /*!
  Sets resize mode of \a w to \a mode.
  \sa ResizeMode
 */
 void KDGanttMinimizeSplitter::setResizeMode( QWidget *w, ResizeMode mode )
 {
    processChildEvents();
    QSplitterLayoutStruct *s = data->list.first();
    while ( s ) {
        if ( s->wid == w  ) {
            s->mode = mode;
            return;
        }
        s = data->list.next();
    }
    s = addWidget( w, TRUE );
    s->mode = mode;
 }
 /*!
  Returns TRUE if opaque resize is on; otherwise returns FALSE.
  \sa setOpaqueResize()
 */
 bool KDGanttMinimizeSplitter::opaqueResize() const
 {
    return data->opaque;
 }
 /*!
    If \a on is TRUE then opaque resizing is turned on; otherwise
    opaque resizing is turned off.
  Opaque resizing is initially turned off.
  \sa opaqueResize()
 */
 void KDGanttMinimizeSplitter::setOpaqueResize( bool on )
 {
    data->opaque = on;
 }
 /*!
  Moves widget \a w to the leftmost/top position.
 */
 void KDGanttMinimizeSplitter::moveToFirst( QWidget *w )
 {
    processChildEvents();
    bool found = FALSE;
    QSplitterLayoutStruct *s = data->list.first();
    while ( s ) {
        if ( s->wid == w  ) {
            found = TRUE;
            QSplitterLayoutStruct *p = data->list.prev();
            if ( p ) { // not already at first place
                data->list.take(); //take p
                data->list.take(); // take s
                data->list.insert( 0, p );
                data->list.insert( 0, s );
            }
            break;
        }
        s = data->list.next();
    }
     if ( !found )
        addWidget( w, TRUE );
     recalcId();
 }
 /*!
  Moves widget \a w to the rightmost/bottom position.
 */
 void KDGanttMinimizeSplitter::moveToLast( QWidget *w )
 {
    processChildEvents();
    bool found = FALSE;
    QSplitterLayoutStruct *s = data->list.first();
    while ( s ) {
        if ( s->wid == w  ) {
            found = TRUE;
            data->list.take(); // take s
            QSplitterLayoutStruct *p = data->list.current();
            if ( p ) { // the splitter handle after s
                data->list.take(); //take p
                data->list.append( p );
            }
            data->list.append( s );
            break;
        }
        s = data->list.next();
    }
     if ( !found )
        addWidget( w);
     recalcId();
 }
 void KDGanttMinimizeSplitter::recalcId()
 {
    int n = data->list.count();
    for ( int i = 0; i < n; i++ ) {
        QSplitterLayoutStruct *s = data->list.at(i);
        if ( s->isSplitter )
            ((KDGanttSplitterHandle*)s->wid)->setId(i);
    }
 }
 /*!\reimp
 */
 QSize KDGanttMinimizeSplitter::sizeHint() const
 {
    constPolish();
    int l = 0;
    int t = 0;
    if ( children() ) {
        const QObjectList * c = children();
        QObjectListIt it( *c );
        QObject * o;
        while( (o=it.current()) != 0 ) {
            ++it;
            if ( o->isWidgetType() &&
                 !((QWidget*)o)->isHidden() ) {
                QSize s = ((QWidget*)o)->sizeHint();
                if ( s.isValid() ) {
                    l += pick( s );
                    t = QMAX( t, trans( s ) );
                }
            }
        }
    }
    return orientation() == Horizontal ? QSize( l, t ) : QSize( t, l );
 }
 /*!
 \reimp
 */
 QSize KDGanttMinimizeSplitter::minimumSizeHint() const
 {
    constPolish();
    int l = 0;
    int t = 0;
    if ( children() ) {
        const QObjectList * c = children();
        QObjectListIt it( *c );
        QObject * o;
        while( (o=it.current()) != 0 ) {
            ++it;
            if ( o->isWidgetType() &&
                 !((QWidget*)o)->isHidden() ) {
                QSize s = minSizeHint((QWidget*)o);
                if ( s.isValid() ) {
                    l += pick( s );
                    t = QMAX( t, trans( s ) );
                }
            }
        }
    }
    return orientation() == Horizontal ? QSize( l, t ) : QSize( t, l );
 }
 /*
  Calculates stretch parameters from current sizes
 */
 void KDGanttMinimizeSplitter::storeSizes()
 {
    QSplitterLayoutStruct *s = data->list.first();
    while ( s ) {
        if ( !s->isSplitter )
            s->sizer = pick( s->wid->size() );
        s = data->list.next();
    }
 }
 #if 0 // ### remove this code ASAP
 /*!
  Hides \a w if \a hide is TRUE and updates the splitter.
  \warning Due to a limitation in the current implementation,
  calling QWidget::hide() will not work.
 */
 void KDGanttMinimizeSplitter::setHidden( QWidget *w, bool hide )
 {
    if ( w == w1 ) {
        w1show = !hide;
    } else if ( w == w2 ) {
        w2show = !hide;
    } else {
 #ifdef QT_CHECK_RANGE
        qWarning( "KDGanttMinimizeSplitter::setHidden(), unknown widget" );
 #endif
        return;
    }
    if ( hide )
        w->hide();
    else
        w->show();
    recalc( TRUE );
 }
 /*!
  Returns the hidden status of \a w
 */
 bool KDGanttMinimizeSplitter::isHidden( QWidget *w ) const
 {
    if ( w == w1 )
        return !w1show;
     else if ( w == w2 )
        return !w2show;
 #ifdef QT_CHECK_RANGE
    else
        qWarning( "KDGanttMinimizeSplitter::isHidden(), unknown widget" );
 #endif
    return FALSE;
 }
 #endif
 /*!
  Returns a list of the size parameters of all the widgets in this
  splitter.
  Giving the values to another splitter's setSizes() function will
  produce a splitter with the same layout as this one.
  Note that if you want to iterate over the list, you should
  iterate over a copy, e.g.
    \code
    QValueList<int> list = mySplitter.sizes();
    QValueList<int>::Iterator it = list.begin();
    while( it != list.end() ) {
        myProcessing( *it );
        ++it;
    }
    \endcode
  \sa setSizes()
 */
 QValueList<int> KDGanttMinimizeSplitter::sizes() const
 {
    if ( !testWState(WState_Polished) ) {
        QWidget* that = (QWidget*) this;
        that->polish();
    }
    QValueList<int> list;
    QSplitterLayoutStruct *s = data->list.first();
    while ( s ) {
        if ( !s->isSplitter )
            list.append( s->sizer );
        s = data->list.next();
    }
    return list;
 }
 /*!
  Sets the size parameters to the values given in \a list.
  If the splitter is horizontal, the values set the sizes from
  left to right. If it is vertical, the sizes are applied from
  top to bottom.
  Extra values in \a list are ignored.
  If \a list contains too few values, the result is undefined
  but the program will still be well-behaved.
  \sa sizes()
 */
 void KDGanttMinimizeSplitter::setSizes( QValueList<int> list )
 {
    processChildEvents();
    QValueList<int>::Iterator it = list.begin();
    QSplitterLayoutStruct *s = data->list.first();
    while ( s && it != list.end() ) {
        if ( !s->isSplitter ) {
            s->sizer = *it;
            ++it;
        }
        s = data->list.next();
    }
    doResize();
 }
 /*!
  Gets all posted child events, ensuring that the internal state of
  the splitter is consistent.
 */
 void KDGanttMinimizeSplitter::processChildEvents()
 {
    QApplication::sendPostedEvents( this, QEvent::ChildInserted );
 }
 /*!
  \reimp
 */
 void KDGanttMinimizeSplitter::styleChange( QStyle& old )
 {
 #if QT_VERSION >= 0x030000
    int sw = style().pixelMetric(QStyle::PM_SplitterWidth, this);
 #else
    int sw = style().splitterWidth();
 #endif
    QSplitterLayoutStruct *s = data->list.first();
    while ( s ) {
        if ( s->isSplitter )
            s->sizer = sw;
        s = data->list.next();
    }
    doResize();
    QFrame::styleChange( old );
 }
 #endif
 /*!
  Specifies the direction of the minimize buttons.
  If the orientation of the splitter is horizontal then with
  KDGanttMinimizeSplitter::Left or KDGanttMinimizeSplitter::Right should be used,
  otherwise either KDGanttMinimizeSplitter::Up or KDGanttMinimizeSplitter::Down
  should be used.
 */
 void KDGanttMinimizeSplitter::setMinimizeDirection( Direction direction )
 {
    _direction = direction;
 }
 /*!
  Returns the direction of the minimize buttons.
 */
 KDGanttMinimizeSplitter::Direction KDGanttMinimizeSplitter::minimizeDirection() const
 {
    return _direction;
 }
 /*
  This is a copy of qGeomCalc() in qlayoutengine.cpp which
  unfortunately isn't exported.
 */
 static inline int toFixed( int i ) { return i * 256; }
 static inline int fRound( int i ) {
    return ( i % 256 < 128 ) ? i / 256 : 1 + i / 256;
 }
 void kdganttGeomCalc( QMemArray<QLayoutStruct> &chain, int start, int count, int pos,
                int space, int spacer )
 {
    typedef int fixed;
    int cHint = 0;
    int cMin = 0;
    int cMax = 0;
    int sumStretch = 0;
    int spacerCount = 0;
    bool wannaGrow = FALSE; // anyone who really wants to grow?
    //    bool canShrink = FALSE; // anyone who could be persuaded to shrink?
    int i;
    for ( i = start; i < start + count; i++ ) {
        chain[i].done = FALSE;
        cHint += chain[i].sizeHint;
        cMin += chain[i].minimumSize;
        cMax += chain[i].maximumSize;
        sumStretch += chain[i].stretch;
        if ( !chain[i].empty )
            spacerCount++;
        wannaGrow = wannaGrow || chain[i].expansive;
    }
    int extraspace = 0;
    if ( spacerCount )
        spacerCount--; // only spacers between things
    if ( space < cMin + spacerCount * spacer ) {
                //qDebug("not enough space");
        for ( i = start; i < start+count; i++ ) {
            chain[i].size = chain[i].minimumSize;
            chain[i].done = TRUE;
        }
    } else if ( space < cHint + spacerCount*spacer ) {
        // Less space than sizeHint, but more than minimum.
        // Currently take space equally from each, like in Qt 2.x.
        // Commented-out lines will give more space to stretchier items.
        int n = count;
        int space_left = space - spacerCount*spacer;
        int overdraft = cHint - space_left;
        //first give to the fixed ones:
        for ( i = start; i < start+count; i++ ) {
            if ( !chain[i].done && chain[i].minimumSize >= chain[i].sizeHint) {
                chain[i].size = chain[i].sizeHint;
                chain[i].done = TRUE;
                space_left -= chain[i].sizeHint;
                // sumStretch -= chain[i].stretch;
                n--;
            }
        }
        bool finished = n == 0;
        while ( !finished ) {
            finished = TRUE;
            fixed fp_over = toFixed( overdraft );
            fixed fp_w = 0;
            for ( i = start; i < start+count; i++ ) {
                if ( chain[i].done )
                    continue;
                // if ( sumStretch <= 0 )
                fp_w += fp_over / n;
                // else
                //    fp_w += (fp_over * chain[i].stretch) / sumStretch;
                int w = fRound( fp_w );
                chain[i].size = chain[i].sizeHint - w;
                fp_w -= toFixed( w ); //give the difference to the next
                if ( chain[i].size < chain[i].minimumSize ) {
                    chain[i].done = TRUE;
                    chain[i].size = chain[i].minimumSize;
                    finished = FALSE;
                    overdraft -= chain[i].sizeHint - chain[i].minimumSize;
                    // sumStretch -= chain[i].stretch;
                    n--;
                    break;
                }
            }
        }
    } else { //extra space
        int n = count;
        int space_left = space - spacerCount*spacer;
        // first give to the fixed ones, and handle non-expansiveness
        for ( i = start; i < start + count; i++ ) {
            if ( !chain[i].done && (chain[i].maximumSize <= chain[i].sizeHint
                                    || wannaGrow && !chain[i].expansive) ) {
                chain[i].size = chain[i].sizeHint;
                chain[i].done = TRUE;
                space_left -= chain[i].sizeHint;
                sumStretch -= chain[i].stretch;
                n--;
            }
        }
        extraspace = space_left;
        /*
          Do a trial distribution and calculate how much it is off.
          If there are more deficit pixels than surplus pixels, give
          the minimum size items what they need, and repeat.
          Otherwise give to the maximum size items, and repeat.
          I have a wonderful mathematical proof for the correctness
          of this principle, but unfortunately this comment is too
          small to contain it.
        */
        int surplus, deficit;
        do {
            surplus = deficit = 0;
            fixed fp_space = toFixed( space_left );
            fixed fp_w = 0;
            for ( i = start; i < start+count; i++ ) {
                if ( chain[i].done )
                    continue;
                extraspace = 0;
                if ( sumStretch <= 0 )
                    fp_w += fp_space / n;
                else
                    fp_w += (fp_space * chain[i].stretch) / sumStretch;
                int w = fRound( fp_w );
                chain[i].size = w;
                fp_w -= toFixed( w ); // give the difference to the next
                if ( w < chain[i].sizeHint ) {
                    deficit +=  chain[i].sizeHint - w;
                } else if ( w > chain[i].maximumSize ) {
                    surplus += w - chain[i].maximumSize;
                }
            }
            if ( deficit > 0 && surplus <= deficit ) {
                // give to the ones that have too little
                for ( i = start; i < start+count; i++ ) {
                    if ( !chain[i].done &&
                         chain[i].size < chain[i].sizeHint ) {
                        chain[i].size = chain[i].sizeHint;
                        chain[i].done = TRUE;
                        space_left -= chain[i].sizeHint;
                        sumStretch -= chain[i].stretch;
                        n--;
                    }
                }
            }
            if ( surplus > 0 && surplus >= deficit ) {
                // take from the ones that have too much
                for ( i = start; i < start+count; i++ ) {
                    if ( !chain[i].done &&
                         chain[i].size > chain[i].maximumSize ) {
                        chain[i].size = chain[i].maximumSize;
                        chain[i].done = TRUE;
                        space_left -= chain[i].maximumSize;
                        sumStretch -= chain[i].stretch;
                        n--;
                    }
                }
            }
        } while ( n > 0 && surplus != deficit );
        if ( n == 0 )
            extraspace = space_left;
    }
    // as a last resort, we distribute the unwanted space equally
    // among the spacers (counting the start and end of the chain).
    //### should do a sub-pixel allocation of extra space
    int extra = extraspace / ( spacerCount + 2 );
    int p = pos + extra;
    for ( i = start; i < start+count; i++ ) {
        chain[i].pos = p;
        p = p + chain[i].size;
        if ( !chain[i].empty )
            p += spacer+extra;
    }
 }
 #endif
 /*!
  \enum KDGanttMinimizeSplitter::Direction
  The values of this enumeration describe into which direction the
  splitter will collapse its child widgets. By extension, it also
  specifies the orientation of the splitter; collapsing to the left or
  to the right results in a horizontal splitter, collapsing to the top
  or bottom in a vertical splitter.
 */
 /*!
  \fn Orientation KDGanttMinimizeSplitter::orientation() const
  Returns the orientation of the splitter.
 */
 /*! \enum KDGanttMinimizeSplitter::ResizeMode
  This enum type describes how KDGanttMinimizeSplitter will resize each of its child widgets.  The currently defined values are:
  Stretch: the widget will be resized when the splitter
  itself is resized.
  KeepSize: KDGanttMinimizeSplitter will try to keep this widget's size
  unchanged.
  FollowSizeHint: KDGanttMinimizeSplitter will resize the widget when the
  widget's size hint changes.
 */
diff --git a/microkde/KDGanttMinimizeSplitter.h b/microkde/KDGanttMinimizeSplitter.h
index 585298d..3042e0a 100644
--- a/microkde/KDGanttMinimizeSplitter.h
+++ b/microkde/KDGanttMinimizeSplitter.h
@@ -1,191 +1,192 @@
 /* -*- Mode: C++ -*-
   $Id$
 */
 /****************************************************************************
 ** Copyright (C)  2001-2004 Klar�lvdalens Datakonsult AB.  All rights reserved.
 **
 ** This file is part of the KDGantt library.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid commercial KDGantt licenses may use this file in
 ** accordance with the KDGantt Commercial License Agreement provided with
 ** the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.klaralvdalens-datakonsult.se/Public/products/ for
 **   information about KDGantt Commercial License Agreements.
 **
 ** Contact info@klaralvdalens-datakonsult.se if any conditions of this
 ** licensing are not clear to you.
 **
 ** As a special exception, permission is given to link this program
 ** with any edition of Qt, and distribute the resulting executable,
 ** without including the source code for Qt in the source distribution.
 **
 **********************************************************************/
 #ifndef KDGANTTMINIMIZESPLITTER_H
 #define KDGANTTMINIMIZESPLITTER_H
 #ifndef QT_H
 #include "qframe.h"
 #include "qvaluelist.h"
 #endif // QT_H
 #ifndef QT_NO_SPLITTER___
 class QSplitterData;
 class QSplitterLayoutStruct;
 class KDGanttSplitterHandle;
+class KDRubberBand; 
 class KDGanttMinimizeSplitter : public QFrame
 {
    Q_OBJECT
    //  Q_ENUMS( Direction )
    // Q_PROPERTY( Orientation orientation READ orientation WRITE setOrientation )
    // Q_PROPERTY( Direction minimizeDirection READ minimizeDirection WRITE setMinimizeDirection )
 public:
    enum ResizeMode { Stretch, KeepSize, FollowSizeHint };
    enum Direction { Left, Right, Up, Down };
    KDGanttMinimizeSplitter( QWidget* parent=0, const char* name=0 );
    KDGanttMinimizeSplitter( Orientation, QWidget* parent=0, const char* name=0 );
    ~KDGanttMinimizeSplitter();
    virtual void setOrientation( Orientation );
    Orientation orientation() const { return orient; }
    void setMinimizeDirection( Direction );
    Direction minimizeDirection() const;
 #if QT_VERSION >= 232
    virtual void setResizeMode( QWidget *w, ResizeMode );
    virtual void setOpaqueResize( bool = TRUE );
    bool opaqueResize() const;
    void moveToFirst( QWidget * );
    void moveToLast( QWidget * );
    void refresh() { recalc( TRUE ); }
    QSize sizeHint() const;
    QSize minimumSizeHint() const;
    QValueList<int> sizes() const;
    void setSizes( QValueList<int> );
    KDGanttSplitterHandle* firstHandle(){ return mFirstHandle;}
    void expandPos( int id, int* min, int* max );
-    QFrame* rubberBand() { return mRubberBand ;}
+    KDRubberBand* rubberBand() { return mRubberBand ;}
 public slots:
     void toggle();
 protected:
    void childEvent( QChildEvent * );
    bool event( QEvent * );
    void resizeEvent( QResizeEvent * );
    int idAfter( QWidget* ) const;
    void moveSplitter( QCOORD pos, int id );
    virtual void drawSplitter( QPainter*, QCOORD x, QCOORD y,
                               QCOORD w, QCOORD h );
    void styleChange( QStyle& );
    int adjustPos( int , int );
    virtual void setRubberband( int );
    void getRange( int id, int*, int* );
 private:
-    QFrame* mRubberBand;
+    KDRubberBand* mRubberBand;
    void init();
    void recalc( bool update = FALSE );
    void doResize();
    void storeSizes();
    void processChildEvents();
    QSplitterLayoutStruct *addWidget( QWidget*, bool first = FALSE );
    void recalcId();
    void moveBefore( int pos, int id, bool upLeft );
    void moveAfter( int pos, int id, bool upLeft );
    void setG( QWidget *w, int p, int s, bool isSplitter = FALSE );
    QCOORD pick( const QPoint &p ) const
    { return orient == Horizontal ? p.x() : p.y(); }
    QCOORD pick( const QSize &s ) const
    { return orient == Horizontal ? s.width() : s.height(); }
    QCOORD trans( const QPoint &p ) const
    { return orient == Vertical ? p.x() : p.y(); }
    QCOORD trans( const QSize &s ) const
    { return orient == Vertical ? s.width() : s.height(); }
    KDGanttSplitterHandle* mFirstHandle;
    QSplitterData *data;
 #endif
 private:
    Orientation orient;
    Direction _direction;
 #ifndef DOXYGEN_SKIP_INTERNAL
    friend class KDGanttSplitterHandle;
 #endif
        private:// Disabled copy constructor and operator=
 #if defined(Q_DISABLE_COPY)
    KDGanttMinimizeSplitter( const KDGanttMinimizeSplitter & );
    KDGanttMinimizeSplitter& operator=( const KDGanttMinimizeSplitter & );
 #endif
 };
 #ifndef DOXYGEN_SKIP_INTERNAL
 // This class was continued from a verbatim copy of the
 // QSplitterHandle pertaining to the Qt Enterprise License and the
 // GPL. It has only been renamed to KDGanttSplitterHandler in order to
 // avoid a symbol clash on some platforms.
 class KDGanttSplitterHandle : public QWidget
 {
    Q_OBJECT
 #if QT_VERSION >= 232
 public:
    KDGanttSplitterHandle( Qt::Orientation o,
                       KDGanttMinimizeSplitter *parent, const char* name=0 );
    void setOrientation( Qt::Orientation o );
    Qt::Orientation orientation() const { return orient; }
    bool opaque() const { return s->opaqueResize(); }
    QSize sizeHint() const;
    void toggle();
    int id() const { return myId; } // data->list.at(id())->wid == this
    void setId( int i ) { myId = i; }
 protected:
    QValueList<QPointArray> buttonRegions();
    void paintEvent( QPaintEvent * );
    void mouseMoveEvent( QMouseEvent * );
    void mousePressEvent( QMouseEvent * );
    void mouseReleaseEvent( QMouseEvent * );
    int onButton( const QPoint& p );
    void updateCursor( const QPoint& p );
 private:
    bool mMouseDown;
    QSize mSizeHint;
    bool mUseOffset;
    Qt::Orientation orient;
    bool opaq;
    int myId;
    KDGanttMinimizeSplitter *s;
    int _activeButton;
    bool _collapsed;
    int _origPos;
 #endif
 };
 #endif
 #endif // QT_NO_SPLITTER
 #endif // KDGANTTMINIMIZESPLITTER_H
author	zautrix <zautrix>	2005-04-21 12:32:52 (UTC)
committer	zautrix <zautrix>	2005-04-21 12:32:52 (UTC)
commit	0a13a3490ec3bf4735e3435f80f58fa7d50b4448 (patch) (unidiff)
tree	c7f28c49b52e479f47da0dce9f0bfe9189ecdca4
parent	4d96d7b681ce99d76746a843c289b75f5e7dba64 (diff)
download	kdepimpi-0a13a3490ec3bf4735e3435f80f58fa7d50b4448.zip kdepimpi-0a13a3490ec3bf4735e3435f80f58fa7d50b4448.tar.gz kdepimpi-0a13a3490ec3bf4735e3435f80f58fa7d50b4448.tar.bz2