Diffstat (limited to 'kaddressbook/views/cardview.cpp') (more/less context) (ignore whitespace changes)
| -rw-r--r-- | kaddressbook/views/cardview.cpp | 1719 |
1 files changed, 1719 insertions, 0 deletions
diff --git a/kaddressbook/views/cardview.cpp b/kaddressbook/views/cardview.cpp new file mode 100644 index 0000000..65f793c --- a/dev/null +++ b/kaddressbook/views/cardview.cpp @@ -0,0 +1,1719 @@ +/* + This file is part of KAddressBook. + Copyright (c) 2002 Mike Pilone <mpilone@slac.com> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + 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. +*/ + +//BEGIN Includes +#include "cardview.h" + +#include <limits.h> + +#include <qpainter.h> +#include <qtimer.h> +#include <qdatetime.h> +#include <qlabel.h> +#include <qstyle.h> +#include <qcursor.h> +#include <qtooltip.h> + +#include <kdebug.h> +#include <kglobalsettings.h> +//END includes + +#define MIN_ITEM_WIDTH 80 + +//BEGIN Helpers +////////////////////////////////////// +// CardViewTip +class CardViewTip : public QLabel { + public: + CardViewTip(QWidget *parent=0, const char *name=0) : QLabel( parent, name ) + { + setPalette( QToolTip::palette() ); + setFrameStyle( Panel|Plain ); + setMidLineWidth(0); + setIndent(1); + } + + ~CardViewTip() {}; + protected: + void leaveEvent( QEvent * ) + { + hide(); + } +}; + +////////////////////////////////////// +// CardViewItemList + + +// +// Warning: make sure you use findRef() instead of find() to find an +// item! Only the pointer value is unique in the list. +// +class CardViewItemList : public QPtrList<CardViewItem> +{ + protected: + virtual int compareItems(QPtrCollection::Item item1, + QPtrCollection::Item item2) + { + CardViewItem *cItem1 = (CardViewItem*)item1; + CardViewItem *cItem2 = (CardViewItem*)item2; + + if ( cItem1 == cItem2 ) + return 0; + + if ((cItem1 == 0) || (cItem2 == 0)) + return cItem1 ? -1 : 1; + + if (cItem1->caption() < cItem2->caption()) + return -1; + + else if (cItem1->caption() > cItem2->caption()) + return 1; + + return 0; + } + + private: + /*int find( const CardViewItem * ) + { + qDebug("DON'T USE CardViewItemList::find( item )! Use findRef( item )!"); + }*/ +}; + +////////////////////////////////////// +// CardViewSeparator +class CardViewSeparator +{ + friend class CardView; + + public: + CardViewSeparator(CardView *view) + : mView(view) + { + mRect = QRect(0, 0, view->separatorWidth(), 0); + } + + ~CardViewSeparator() {} + + void paintSeparator(QPainter *p, QColorGroup &cg) + { + p->fillRect(0, 0, mRect.width(), mRect.height(), + cg.brush(QColorGroup::Button)); + } + + void repaintSeparator() + { + mView->repaintContents(mRect); + } + + private: + CardView *mView; + QRect mRect; +}; + +//END Helpers + +//BEGIN Private Data + +class CardViewPrivate +{ + public: + CardViewPrivate() + : mSelectionMode( CardView::Multi ), + mDrawCardBorder( true ), + mDrawFieldLabels( true ), + mDrawSeparators( true), + mSepWidth( 2 ), + mShowEmptyFields( false ), + mLayoutDirty( true ), + mLastClickOnItem( false ), + mItemMargin( 0 ), + mItemSpacing( 10 ), + mItemWidth( 200 ), + mMaxFieldLines( INT_MAX ), + mCurrentItem( 0L ), + mLastClickPos( QPoint(0, 0) ), + mRubberBandAnchor( 0 ), + mCompText( QString::null ), + mResizeAnchor(0) + {}; + + CardViewItemList mItemList; + QPtrList<CardViewSeparator> mSeparatorList; + QFontMetrics *mFm; + QFontMetrics *mBFm; // bold font + QFont mHeaderFont; // custom header font + CardView::SelectionMode mSelectionMode; + bool mDrawCardBorder; + bool mDrawFieldLabels; + bool mDrawSeparators; + int mSepWidth; + bool mShowEmptyFields; + bool mLayoutDirty; + bool mLastClickOnItem; + uint mItemMargin; // internal margin in items + uint mItemSpacing; // spacing between items, column seperators and border + int mItemWidth; // width of all items + uint mMaxFieldLines; // Max lines to dispaly pr field + CardViewItem *mCurrentItem; + QPoint mLastClickPos; + QTimer *mTimer; // times out if mouse rests for more than 500 msecs + CardViewTip *mTip; // passed to the item under a resting cursor to display full text + bool mOnSeparator; // set/reset on mouse movement + // for resizing by dragging the separators + int mResizeAnchor; // uint, ulong? the mouse down separator left + int mRubberBandAnchor; // for erasing rubber bands + // data used for resizing. + // as they are beeded by each mouse move while resizing, we store them here, + // saving 8 calculations in each mouse move. + int colspace; // amount of space between items pr column + uint first; // the first col to anchor at for painting rubber bands + int firstX; // X position of first in pixel + int pressed; // the colummn that was pressed on at resizing start + int span; // pressed - first + // key completion + QString mCompText; // current completion string + QDateTime mCompUpdated; // ...was updated at this time +}; + +class CardViewItemPrivate +{ + public: + CardViewItemPrivate() : + x( 0 ), + y( 0 ), + mSelected( false ){}; + + + QString mCaption; + QPtrList< CardViewItem::Field > mFieldList; + bool mSelected; + int x; // horizontal position, set by the view + int y; // vertical position, set by the view + int maxLabelWidth; // the width of the widest label, according to the view font. + int hcache; // height cache +}; +//END Private Data + +//BEGIN CardViewItem + +CardViewItem::CardViewItem(CardView *parent, QString caption) + : d(new CardViewItemPrivate()), mView(parent) +{ + d->mCaption = caption; + + initialize(); +} + +CardViewItem::~CardViewItem() +{ + // Remove ourself from the view + if (mView != 0) + mView->takeItem(this); + + delete d; + d = 0; +} + +void CardViewItem::initialize() +{ + d->mSelected = false; + d->mFieldList.setAutoDelete(true); + d->maxLabelWidth = 0; + d->hcache=0; + + //calcRect(); + + // Add ourself to the view + if (mView != 0) + mView->insertItem(this); +} + +void CardViewItem::paintCard(QPainter *p, QColorGroup &cg) +{ + + if (!mView) + return; + + QPen pen; + QBrush brush; + QFontMetrics fm = *(mView->d->mFm); + QFontMetrics bFm = *(mView->d->mBFm); + bool drawLabels = mView->d->mDrawFieldLabels; + bool drawBorder = mView->d->mDrawCardBorder; + int mg = mView->itemMargin(); + int w = mView->itemWidth() - (mg*2); + int h = height() - (mg*2); + const int colonWidth( fm.width(":") ); + int labelXPos = 2 + mg; + int labelWidth = QMIN( w/2 - 4 - mg, d->maxLabelWidth + colonWidth + 4 ); + int valueXPos = labelWidth + 4 + mg; + int valueWidth = w - labelWidth - 4 - mg; + + p->setFont( mView->font() ); + labelWidth -= colonWidth; // extra space for the colon + + if (!drawLabels) + { + valueXPos = labelXPos; + valueWidth = w - 4; + } + + // Draw a simple box + if (isSelected()) + pen = QPen(cg.highlight(), 1); + else + pen = QPen(cg.button(), 1); + p->setPen(pen); + + // Draw the border - this is only draw if the user asks for it. + if (drawBorder) + p->drawRect( mg, mg, w, h ); + + // set the proper pen color for the caption box + if (isSelected()) + brush = cg.brush(QColorGroup::Highlight); + else + brush = cg.brush(QColorGroup::Button); + + p->fillRect(mg, mg, w, 4 + bFm.height(), brush); + + // Now paint the caption + p->save(); + QFont bFont = mView->headerFont(); + //bFont.setBold(true); + p->setFont(bFont); + if (isSelected()) + p->setPen(cg.highlightedText()); + else + p->setPen(cg.buttonText()); + p->drawText(2+mg, 2+mg + bFm.ascent()/*bFm.height()*//*-bFm.descent()*//*-bFm.leading()*/, trimString(d->mCaption, w-4, bFm)); + p->restore(); + + // Go through the fields and draw them + QPtrListIterator< CardViewItem::Field > iter(d->mFieldList); + QString label, value; + int yPos = mg + 4 + bFm.height()/* + 1*/ + fm.height(); // why the + 1 ??? (anders) + p->setPen(cg.text()); + + int fh = fm.height(); + int cln( 0 ); + QString tmp; + int maxLines = mView->maxFieldLines(); + for (iter.toFirst(); iter.current(); ++iter) + { + value = (*iter)->second; + if ( value.isEmpty() && ! mView->d->mShowEmptyFields ) + continue; + + if (drawLabels) + { + label = trimString((*iter)->first, labelWidth, fm); + p->drawText(labelXPos, yPos, label + ":"); + } +/* US original + for (cln=0; cln <= maxLines; cln++) + { + tmp = value.section('\n',cln,cln); + if ( !tmp.isEmpty() ) p->drawText( valueXPos, yPos + cln*fh, trimString( tmp, valueWidth, fm ) ); + else break; + } +*/ + +//US new implementation + QStringList strlst = QStringList::split('\n', value, true); + + for (cln=0; cln <= maxLines && cln <= (int)strlst.count(); cln++) + { + tmp = strlst[cln]; + + if ( !tmp.isEmpty() ) + p->drawText( valueXPos, yPos + cln*fh, trimString( tmp, valueWidth, fm ) ); + else + break; + + } + + if ( cln == 0 ) cln = 1; + yPos += cln * fh + 2; + } + + // if we are the current item and the view has focus, draw focus rect + if ( mView->currentItem() == this && mView->hasFocus() ) + { +/*US + mView->style().drawPrimitive( QStyle::PE_FocusRect, p, + QRect(0, 0, mView->itemWidth(), h+(2*mg)), cg, + QStyle::Style_FocusAtBorder, + QStyleOption( isSelected() ? cg.highlight() : cg.base() ) ); +*/ + + const QColor pHighl = isSelected() ? cg.highlight() : cg.base(); + const QRect r(0, 0, mView->itemWidth(), h+(2*mg)); +#ifndef DESKTOP_VERSION + mView->style().drawFocusRect(p, r, cg, &pHighl, true); +#endif + } +} + +const QString &CardViewItem::caption() const +{ + return d->mCaption; +} + + +int CardViewItem::height( bool allowCache ) const +{ + // use cache + if ( allowCache && d->hcache ) + return d->hcache; + + // Base height: + // 2 for line width + // 2 for top caption pad + // 2 for bottom caption pad + // 2 pad for the end + // + 2 times the advised margin + int baseHeight = 8 + ( 2 * mView->itemMargin() ); + + // size of font for each field + // 2 pad for each field + + // anders: if the view does not show empty fields, check for value + bool sef = mView->showEmptyFields(); + int fh = mView->d->mFm->height();//lineSpacing(); // font height + //int sp = QMAX( 0, 2- mView->d->mFm->leading() ); // field spacing NOTE make a property + int fieldHeight = 0; + int lines; + int maxLines( mView->maxFieldLines() ); + QPtrListIterator< CardViewItem::Field > iter(d->mFieldList); + for (iter.toFirst(); iter.current(); ++iter) + { + if ( !sef && (*iter)->second.isEmpty() ) + continue; + lines = QMIN( (*iter)->second.contains('\n') + 1, maxLines ); + fieldHeight += ( lines * fh ) + 2;//sp; + } + + // height of caption font (bold) + fieldHeight += mView->d->mBFm->height(); + d->hcache = baseHeight + fieldHeight; + return d->hcache; +} + +bool CardViewItem::isSelected() const +{ + return d->mSelected; +} + +void CardViewItem::setSelected(bool selected) +{ + d->mSelected = selected; +} + +void CardViewItem::insertField(const QString &label, const QString &value) +{ + CardViewItem::Field *f = new CardViewItem::Field(label, value); + d->mFieldList.append(f); + d->hcache=0; + + if (mView) + { + mView->setLayoutDirty(true); + d->maxLabelWidth = QMAX( mView->d->mFm->width( label ), d->maxLabelWidth ); + } +} + +void CardViewItem::removeField(const QString &label) +{ + CardViewItem::Field *f; + + QPtrListIterator< CardViewItem::Field > iter(d->mFieldList); + for (iter.toFirst(); iter.current(); ++iter) + { + f = *iter; + if (f->first == label) + break; + } + + if (*iter) + d->mFieldList.remove(*iter); + d->hcache = 0; + + if (mView) + mView->setLayoutDirty(true); +} + +void CardViewItem::clearFields() +{ + d->mFieldList.clear(); + d->hcache = 0; + + if (mView) + mView->setLayoutDirty(true); +} + +QString CardViewItem::trimString(const QString &text, int width, + QFontMetrics &fm) +{ + if (fm.width(text) <= width) + return text; + + QString dots = "..."; + int dotWidth = fm.width(dots); + QString trimmed; + int charNum = 0; + + while (fm.width(trimmed) + dotWidth < width) + { + trimmed += text[charNum]; + charNum++; + } + + // Now trim the last char, since it put the width over the top + trimmed = trimmed.left(trimmed.length()-1); + trimmed += dots; + + return trimmed; +} + +CardViewItem *CardViewItem::nextItem() +{ + CardViewItem *item = 0; + + if (mView) + item = mView->itemAfter(this); + + return item; +} + +void CardViewItem::repaintCard() +{ + if (mView) + mView->repaintItem(this); +} + +void CardViewItem::setCaption(const QString &caption) +{ + d->mCaption = caption; + repaintCard(); +} + +QString CardViewItem::fieldValue(const QString &label) +{ + QPtrListIterator< CardViewItem::Field > iter(d->mFieldList); + for (iter.toFirst(); iter.current(); ++iter) + if ((*iter)->first == label) + return (*iter)->second; + + return QString(); +} + + +void CardViewItem::showFullString( const QPoint &itempos, CardViewTip *tip ) +{ + bool trimmed( false ); + QString s; + int mrg = mView->itemMargin(); + int y = mView->d->mBFm->height() + 6 + mrg; + int w = mView->itemWidth() - (2*mrg); + int lw; + bool drawLabels = mView->drawFieldLabels(); + bool isLabel = drawLabels && itempos.x() < w/2 ? true : false; + + if ( itempos.y() < y ) + { + if ( itempos.y() < 8 + mrg || itempos.y() > y - 4 ) + return; + // this is the caption + s = caption(); + trimmed = mView->d->mBFm->width( s ) > w - 4; + y = 2 + mrg; + lw = 0; + isLabel=true; + } else { + // find the field + Field *f = fieldAt( itempos ); + if ( !f || ( !mView->showEmptyFields() && f->second.isEmpty() ) ) + return; + + // y position: + // header font height + 4px hader margin + 2px leading + item margin + // + actual field index * (fontheight + 2px leading) + int maxLines = mView->maxFieldLines(); + bool se = mView->showEmptyFields(); + int fh = mView->d->mFm->height(); +// { + Field *_f; + for (_f = d->mFieldList.first(); _f != f; _f = d->mFieldList.next()) + if ( se || ! _f->second.isEmpty() ) + y += ( QMIN(_f->second.contains('\n')+1, maxLines) * fh ) + 2; +// } + if ( isLabel && itempos.y() > y + fh ) + return; + // label or data? + s = isLabel ? f->first : f->second; + // trimmed? + int colonWidth = mView->d->mFm->width(":"); + lw = drawLabels ? // label width + QMIN( w/2 - 4 - mrg, d->maxLabelWidth + colonWidth + 4 ) : + 0; + int mw = isLabel ? lw - colonWidth : w - lw - (mrg*2); // max width for string + if ( isLabel ) + { + trimmed = mView->d->mFm->width( s ) > mw - colonWidth; + } else { + QRect r( mView->d->mFm->boundingRect( 0, 0, INT_MAX, INT_MAX, Qt::AlignTop|Qt::AlignLeft, s ) ); + trimmed = r.width() > mw || r.height()/fh > QMIN(s.contains('\n') + 1, maxLines); + } + } + if ( trimmed ) + { + tip->setFont( (isLabel && !lw) ? mView->headerFont() : mView->font() ); // if condition is true, a header + tip->setText( s ); + tip->adjustSize(); + // find a proper position + int lx; + lx = isLabel || !drawLabels ? mrg : lw + mrg + 2 /*-1*/; + QPoint pnt(mView->contentsToViewport( QPoint(d->x, d->y) )); + pnt += QPoint(lx, y); + if ( pnt.x() < 0 ) + pnt.setX( 0 ); + if ( pnt.x() + tip->width() > mView->visibleWidth() ) + pnt.setX( mView->visibleWidth() - tip->width() ); + if ( pnt.y() + tip->height() > mView->visibleHeight() ) + pnt.setY( QMAX( 0, mView->visibleHeight() - tip->height() ) ); + // show + tip->move( pnt ); + tip->show(); + } +} + +CardViewItem::Field *CardViewItem::fieldAt( const QPoint & itempos ) const +{ + int ypos = mView->d->mBFm->height() + 7 + mView->d->mItemMargin; + int iy = itempos.y(); + // skip below caption + if ( iy <= ypos ) + return 0; + // try find a field + bool showEmpty = mView->showEmptyFields(); + int fh = mView->d->mFm->height(); + int maxLines = mView->maxFieldLines(); + Field *f; + for ( f = d->mFieldList.first(); f; f = d->mFieldList.next() ) + { + if ( showEmpty || !f->second.isEmpty() ) + ypos += ( QMIN( f->second.contains('\n')+1, maxLines ) *fh)+2; + if ( iy <= ypos ) + break; + } + return f ? f : 0; +} +//END CardViewItem + +//BEGIN CardView + +CardView::CardView(QWidget *parent, const char *name) + : QScrollView(parent, name), + d(new CardViewPrivate()) +{ + d->mItemList.setAutoDelete(true); + d->mSeparatorList.setAutoDelete(true); + + QFont f = font(); + d->mFm = new QFontMetrics(f); + f.setBold(true); + d->mHeaderFont = f; + d->mBFm = new QFontMetrics(f); + d->mTip = ( new CardViewTip( viewport() ) ), + d->mTip->hide(); + d->mTimer = ( new QTimer(this, "mouseTimer") ), + + viewport()->setMouseTracking( true ); + viewport()->setFocusProxy(this); + viewport()->setFocusPolicy(WheelFocus); + viewport()->setBackgroundMode(PaletteBase); + + connect( d->mTimer, SIGNAL(timeout()), this, SLOT(tryShowFullText()) ); + +//US setBackgroundMode(PaletteBackground, PaletteBase); + setBackgroundMode(PaletteBackground); + + // no reason for a vertical scrollbar + setVScrollBarMode(AlwaysOff); +} + +CardView::~CardView() +{ + delete d->mFm; + delete d->mBFm; + delete d; + d = 0; +} + +void CardView::insertItem(CardViewItem *item) +{ + d->mItemList.inSort(item); + setLayoutDirty(true); +} + +void CardView::takeItem(CardViewItem *item) +{ + if ( d->mCurrentItem == item ) + d->mCurrentItem = item->nextItem(); + d->mItemList.take(d->mItemList.findRef(item)); + + setLayoutDirty(true); +} + +void CardView::clear() +{ + d->mItemList.clear(); + + setLayoutDirty(true); +} + +CardViewItem *CardView::currentItem() +{ + if ( ! d->mCurrentItem && d->mItemList.count() ) + d->mCurrentItem = d->mItemList.first(); + return d->mCurrentItem; +} + +void CardView::setCurrentItem( CardViewItem *item ) +{ + if ( !item ) + return; + else if ( item->cardView() != this ) + { + kdDebug(5720)<<"CardView::setCurrentItem: Item ("<<item<<") not owned! Backing out.."<<endl; + return; + } + else if ( item == currentItem() ) + { + return; + } + + if ( d->mSelectionMode == Single ) + { + setSelected( item, true ); + } + else + { + CardViewItem *it = d->mCurrentItem; + d->mCurrentItem = item; + if ( it ) + it->repaintCard(); + item->repaintCard(); + } + if ( ! d->mOnSeparator ) + ensureItemVisible( item ); + emit currentChanged( item ); +} + +CardViewItem *CardView::itemAt(const QPoint &viewPos) +{ + CardViewItem *item = 0; + QPtrListIterator<CardViewItem> iter(d->mItemList); + bool found = false; + for (iter.toFirst(); iter.current() && !found; ++iter) + { + item = *iter; + //if (item->d->mRect.contains(viewPos)) + if (QRect(item->d->x, item->d->y, d->mItemWidth, item->height()).contains(viewPos)) + found = true; + } + + if (found) + return item; + + return 0; +} + +QRect CardView::itemRect(const CardViewItem *item) +{ + //return item->d->mRect; + return QRect(item->d->x, item->d->y, d->mItemWidth, item->height()); +} + +void CardView::ensureItemVisible(const CardViewItem *item) +{ + ensureVisible(item->d->x , item->d->y, d->mItemSpacing, 0); + ensureVisible(item->d->x + d->mItemWidth, item->d->y, d->mItemSpacing, 0); +} + +void CardView::repaintItem(const CardViewItem *item) +{ + //repaintContents(item->d->mRect); + repaintContents( QRect(item->d->x, item->d->y, d->mItemWidth, item->height()) ); +} + +void CardView::setSelectionMode(CardView::SelectionMode mode) +{ + selectAll(false); + + d->mSelectionMode = mode; +} + +CardView::SelectionMode CardView::selectionMode() const +{ + return d->mSelectionMode; +} + +void CardView::selectAll(bool state) +{ + QPtrListIterator<CardViewItem> iter(d->mItemList); + if (!state) + { + for (iter.toFirst(); iter.current(); ++iter) + { + if ((*iter)->isSelected()) + { + (*iter)->setSelected(false); + (*iter)->repaintCard(); + } + } + //emit selectionChanged(); // WARNING FIXME + emit selectionChanged(0); + } + else if (d->mSelectionMode != CardView::Single) + { + for (iter.toFirst(); iter.current(); ++iter) + { + (*iter)->setSelected(true); + } + + if (d->mItemList.count() > 0) + { + // emit, since there must have been at least one selected + emit selectionChanged(); + //repaint();//??? + viewport()->update(); + } + } +} + +void CardView::setSelected(CardViewItem *item, bool selected) +{ + if ((item == 0) || (item->isSelected() == selected)) + return; + + if ( selected && d->mCurrentItem != item ) + { + CardViewItem *it = d->mCurrentItem; + d->mCurrentItem = item; + if ( it ) + it->repaintCard(); + } + + if (d->mSelectionMode == CardView::Single) + { + bool b = signalsBlocked(); + blockSignals(true); + selectAll(false); + blockSignals(b); + + if (selected) + { + item->setSelected(selected); + item->repaintCard(); + emit selectionChanged(); + emit selectionChanged(item); + } + else + { + emit selectionChanged(); + emit selectionChanged(0); + } + } + else if (d->mSelectionMode == CardView::Multi) + { + item->setSelected(selected); + item->repaintCard(); + emit selectionChanged(); + } + else if (d->mSelectionMode == CardView::Extended) + { + bool b = signalsBlocked(); + blockSignals(true); + selectAll(false); + blockSignals(b); + + item->setSelected(selected); + item->repaintCard(); + emit selectionChanged(); + } +} + +bool CardView::isSelected(CardViewItem *item) const +{ + return (item && item->isSelected()); +} + +CardViewItem *CardView::selectedItem() const +{ + // find the first selected item + QPtrListIterator<CardViewItem> iter(d->mItemList); + for (iter.toFirst(); iter.current(); ++iter) + { + if ((*iter)->isSelected()) + return *iter; + } + + return 0; +} + +CardViewItem *CardView::firstItem() const +{ + return d->mItemList.first(); +} + +int CardView::childCount() const +{ + return d->mItemList.count(); +} +/*US +CardViewItem *CardView::findItem(const QString &text, const QString &label, + Qt::StringComparisonMode compare) +{ + // IF the text is empty, we will return null, since empty text will + // match anything! + if (text.isEmpty()) + return 0; + + QPtrListIterator<CardViewItem> iter(d->mItemList); + if (compare & Qt::BeginsWith) + { + QString value; + for (iter.toFirst(); iter.current(); ++iter) + { + value = (*iter)->fieldValue(label).upper(); + if (value.startsWith(text.upper())) + return *iter; + } + } + else + { + kdDebug(5720) << "CardView::findItem: search method not implemented" << endl; + } + + return 0; +} +*/ + +uint CardView::columnWidth() +{ + return d->mDrawSeparators ? + d->mItemWidth + ( 2 * d->mItemSpacing ) + d->mSepWidth : + d->mItemWidth + d->mItemSpacing; +} + +void CardView::drawContents(QPainter *p, int clipx, int clipy, + int clipw, int cliph) +{ + QScrollView::drawContents(p, clipx, clipy, clipw, cliph); + + if (d->mLayoutDirty) + calcLayout(); + + //kdDebug() << "CardView::drawContents: " << clipx << ", " << clipy + // << ", " << clipw << ", " << cliph << endl; + + QColorGroup cg = viewport()->palette().active(); // allow setting costum colors in the viewport pale + + QRect clipRect(clipx, clipy, clipw, cliph); + QRect cardRect; + QRect sepRect; + CardViewItem *item; + CardViewSeparator *sep; + + // make sure the viewport is a pure background + viewport()->erase(clipRect); + + // Now tell the cards to draw, if they are in the clip region + QPtrListIterator<CardViewItem> iter(d->mItemList); + for (iter.toFirst(); iter.current(); ++iter) + { + item = *iter; + cardRect.setRect( item->d->x, item->d->y, d->mItemWidth, item->height() ); + + if (clipRect.intersects(cardRect) || clipRect.contains(cardRect)) + { + //kdDebug() << "\trepainting card at: " << cardRect.x() << ", " + // << cardRect.y() << endl; + + // Tell the card to paint + p->save(); + p->translate(cardRect.x(), cardRect.y()); + item->paintCard(p, cg); + p->restore(); + } + } + + // Followed by the separators if they are in the clip region + QPtrListIterator<CardViewSeparator> sepIter(d->mSeparatorList); + for (sepIter.toFirst(); sepIter.current(); ++sepIter) + { + sep = *sepIter; + sepRect = sep->mRect; + + if (clipRect.intersects(sepRect) || clipRect.contains(sepRect)) + { + p->save(); + p->translate(sepRect.x(), sepRect.y()); + sep->paintSeparator(p, cg); + p->restore(); + } + } +} + +void CardView::resizeEvent(QResizeEvent *e) +{ + QScrollView::resizeEvent(e); + + setLayoutDirty(true); +} + +void CardView::calcLayout() +{ + //kdDebug() << "CardView::calcLayout:" << endl; + + // Start in the upper left corner and layout all the + // cars using their height and width + int maxWidth = 0; + int maxHeight = 0; + int xPos = 0; + int yPos = 0; + int cardSpacing = d->mItemSpacing; + + // delete the old separators + d->mSeparatorList.clear(); + + QPtrListIterator<CardViewItem> iter(d->mItemList); + CardViewItem *item = 0; + CardViewSeparator *sep = 0; + xPos += cardSpacing; + + for (iter.toFirst(); iter.current(); ++iter) + { + item = *iter; + + yPos += cardSpacing; + + if (yPos + item->height() + cardSpacing >= height() - horizontalScrollBar()->height()) + { + maxHeight = QMAX(maxHeight, yPos); + + // Drawing in this column would be greater than the height + // of the scroll view, so move to next column + yPos = cardSpacing; + xPos += cardSpacing + maxWidth; + if (d->mDrawSeparators) + { + // Create a separator since the user asked + sep = new CardViewSeparator(this); + sep->mRect.moveTopLeft(QPoint(xPos, yPos+d->mItemMargin)); + xPos += d->mSepWidth + cardSpacing; + d->mSeparatorList.append(sep); + } + + maxWidth = 0; + } + + item->d->x = xPos; + item->d->y = yPos; + + yPos += item->height(); + maxWidth = QMAX(maxWidth, d->mItemWidth); + } + + xPos += maxWidth; + resizeContents( xPos + cardSpacing, maxHeight ); + + // Update the height of all the separators now that we know the + // max height of a column + QPtrListIterator<CardViewSeparator> sepIter(d->mSeparatorList); + for (sepIter.toFirst(); sepIter.current(); ++sepIter) + { + (*sepIter)->mRect.setHeight(maxHeight - 2*cardSpacing - 2*d->mItemMargin); + } + + d->mLayoutDirty = false; +} + +CardViewItem *CardView::itemAfter(CardViewItem *item) +{ + /*int pos = */d->mItemList.findRef(item); + return d->mItemList.next();//at(pos+1); +} + +uint CardView::itemMargin() +{ + return d->mItemMargin; +} + +void CardView::setItemMargin( uint margin ) +{ + if ( margin == d->mItemMargin ) + return; + + d->mItemMargin = margin; + setLayoutDirty( true ); +} + +uint CardView::itemSpacing() +{ + return d->mItemSpacing; +} + +void CardView::setItemSpacing( uint spacing ) +{ + if ( spacing == d->mItemSpacing ) + return; + + d->mItemSpacing = spacing; + setLayoutDirty( true ); +} + +void CardView::contentsMousePressEvent(QMouseEvent *e) +{ + QScrollView::contentsMousePressEvent(e); + + QPoint pos = e->pos(); + d->mLastClickPos = pos; + + CardViewItem *item = itemAt(pos); + + if (item == 0) + { + d->mLastClickOnItem = false; + if ( d->mOnSeparator) + { + d->mResizeAnchor = e->x()+contentsX(); + d->colspace = (2*d->mItemSpacing) /*+ (2*d->mItemMargin)*/; + int ccw = d->mItemWidth + d->colspace + d->mSepWidth; + d->first = (contentsX()+d->mSepWidth)/ccw; + d->pressed = (d->mResizeAnchor+d->mSepWidth)/ccw; + d->span = d->pressed - d->first; + d->firstX = d->first * ccw; + if ( d->firstX ) d->firstX -= d->mSepWidth; // (no sep in col 0) + } + else + { + selectAll(false); + } + return; + } + + d->mLastClickOnItem = true; + + CardViewItem *other = d->mCurrentItem; + setCurrentItem( item ); + + // Always emit the selection + emit clicked(item); + + // Check the selection type and update accordingly + if (d->mSelectionMode == CardView::Single) + { + // make sure it isn't already selected + if (item->isSelected()) + return; + + bool b = signalsBlocked(); + blockSignals(true); + selectAll(false); + blockSignals(b); + + item->setSelected(true); + item->repaintCard(); + emit selectionChanged(item); + } + + else if (d->mSelectionMode == CardView::Multi) + { + // toggle the selection + item->setSelected(!item->isSelected()); + item->repaintCard(); + emit selectionChanged(); + } + + else if (d->mSelectionMode == CardView::Extended) + { + if ((e->button() & Qt::LeftButton) && + (e->state() & Qt::ShiftButton)) + { + if ( item == other ) return; + + bool s = ! item->isSelected(); + + if ( s && ! (e->state() & ControlButton) ) + { + bool b = signalsBlocked(); + blockSignals(true); + selectAll(false); + blockSignals(b); + } + + int from, to, a, b; + a = d->mItemList.findRef( item ); + b = d->mItemList.findRef( other ); + from = a < b ? a : b; + to = a > b ? a : b; + //kdDebug()<<"selecting items "<<from<<" - "<<to<<" ( "<<s<<" )"<<endl; + CardViewItem *aItem; + for ( ; from <= to; from++ ) + { + aItem = d->mItemList.at( from ); + aItem->setSelected( s ); + repaintItem( aItem ); + } + emit selectionChanged(); + } + else if ((e->button() & Qt::LeftButton) && + (e->state() & Qt::ControlButton)) + { + item->setSelected(!item->isSelected()); + item->repaintCard(); + emit selectionChanged(); + } + + else if (e->button() & Qt::LeftButton) + { + bool b = signalsBlocked(); + blockSignals(true); + selectAll(false); + blockSignals(b); + + item->setSelected(true); + item->repaintCard(); + emit selectionChanged(); + } + } + +} + +void CardView::contentsMouseReleaseEvent(QMouseEvent *e) +{ + QScrollView::contentsMouseReleaseEvent(e); + + if ( d->mResizeAnchor ) + { + // finish the resizing: + unsetCursor(); + // hide rubber bands + int newiw = d->mItemWidth - ((d->mResizeAnchor - d->mRubberBandAnchor)/d->span); + drawRubberBands( 0 ); + // we should move to reflect the new position if we are scrolled. + if ( contentsX() ) + { + int newX = QMAX( 0, ( d->pressed * ( newiw + d->colspace + d->mSepWidth ) ) - e->x() ); + setContentsPos( newX, contentsY() ); + } + // set new item width + setItemWidth( newiw ); + // reset anchors + d->mResizeAnchor = 0; + d->mRubberBandAnchor = 0; + return; + } + + // If there are accel keys, we will not emit signals + if ((e->state() & Qt::ShiftButton) || (e->state() & Qt::ControlButton)) + return; + + // Get the item at this position + CardViewItem *item = itemAt(e->pos()); + + if (item && KGlobalSettings::singleClick()) + { + emit executed(item); + } +} + +void CardView::contentsMouseDoubleClickEvent(QMouseEvent *e) +{ + QScrollView::contentsMouseDoubleClickEvent(e); + + CardViewItem *item = itemAt(e->pos()); + + if (item) + { + d->mCurrentItem = item; + } + + if (item && !KGlobalSettings::singleClick()) + { + emit executed(item); + } + emit doubleClicked(item); +} + +void CardView::contentsMouseMoveEvent( QMouseEvent *e ) +{ + // resizing + if ( d->mResizeAnchor ) + { + int x = e->x(); + if ( x != d->mRubberBandAnchor ) + drawRubberBands( x ); + return; + } + + if (d->mLastClickOnItem && (e->state() & Qt::LeftButton) && + ((e->pos() - d->mLastClickPos).manhattanLength() > 4)) { + + startDrag(); + return; + } + + d->mTimer->start( 500 ); + + // see if we are over a separator + // only if we actually have them painted? + if ( d->mDrawSeparators ) + { + int colcontentw = d->mItemWidth + (2*d->mItemSpacing); + int colw = colcontentw + d->mSepWidth; + int m = e->x()%colw; + if ( m >= colcontentw && m > 0 ) + { + setCursor( SplitVCursor ); // Why does this fail sometimes? + d->mOnSeparator = true; + } + else + { + setCursor( ArrowCursor ); + d->mOnSeparator = false; + } + } +} + +void CardView::enterEvent( QEvent * ) +{ + d->mTimer->start( 500 ); +} + +void CardView::leaveEvent( QEvent * ) +{ + d->mTimer->stop(); + if (d->mOnSeparator) + { + d->mOnSeparator = false; + setCursor( ArrowCursor ); + } +} + +void CardView::focusInEvent( QFocusEvent * ) +{ + if (!d->mCurrentItem && d->mItemList.count() ) + { + setCurrentItem( d->mItemList.first() ); + } + else if ( d->mCurrentItem ) + { + d->mCurrentItem->repaintCard(); + } +} + +void CardView::focusOutEvent( QFocusEvent * ) +{ + if (d->mCurrentItem) + d->mCurrentItem->repaintCard(); +} + +void CardView::keyPressEvent( QKeyEvent *e ) +{ + if ( ! ( childCount() && d->mCurrentItem ) ) + { + e->ignore(); + return; + } + + uint pos = d->mItemList.findRef( d->mCurrentItem ); + CardViewItem *aItem = 0L; // item that gets the focus + CardViewItem *old = d->mCurrentItem; + + switch ( e->key() ) + { + case Key_Up: + if ( pos > 0 ) + { + aItem = d->mItemList.at( pos - 1 ); + setCurrentItem( aItem ); + } + break; + case Key_Down: + if ( pos < d->mItemList.count() - 1 ) + { + aItem = d->mItemList.at( pos + 1 ); + setCurrentItem( aItem ); + } + break; + case Key_Left: + { + // look for an item in the previous/next column, starting from + // the vertical middle of the current item. + // FIXME use nice calculatd measures!!! + QPoint aPoint( d->mCurrentItem->d->x, d->mCurrentItem->d->y ); + aPoint -= QPoint( 30,-(d->mCurrentItem->height()/2) ); + aItem = itemAt( aPoint ); + // maybe we hit some space below an item + while ( !aItem && aPoint.y() > 27 ) + { + aPoint -= QPoint( 0, 16 ); + aItem = itemAt( aPoint ); + } + if ( aItem ) + setCurrentItem( aItem ); + } + break; + case Key_Right: + { + // FIXME use nice calculated measures!!! + QPoint aPoint( d->mCurrentItem->d->x + d->mItemWidth, d->mCurrentItem->d->y ); + aPoint += QPoint( 30,(d->mCurrentItem->height()/2) ); + aItem = itemAt( aPoint ); + while ( !aItem && aPoint.y() > 27 ) + { + aPoint -= QPoint( 0, 16 ); + aItem = itemAt( aPoint ); + } + if ( aItem ) + setCurrentItem( aItem ); + } + break; + case Key_Home: + aItem = d->mItemList.first(); + setCurrentItem( aItem ); + break; + case Key_End: + aItem = d->mItemList.last(); + setCurrentItem( aItem ); + break; + case Key_Prior: // PageUp + { + // QListView: "Make the item above the top visible and current" + // TODO if contentsY(), pick the top item of the leftmost visible column + if ( contentsX() <= 0 ) + return; + int cw = columnWidth(); + int theCol = ( QMAX( 0, ( contentsX()/cw) * cw ) ) + d->mItemSpacing; + aItem = itemAt( QPoint( theCol + 1, d->mItemSpacing + 1 ) ); + if ( aItem ) + setCurrentItem( aItem ); + } + break; + case Key_Next: // PageDown + { + // QListView: "Make the item below the bottom visible and current" + // find the first not fully visible column. + // TODO: consider if a partly visible (or even hidden) item at the + // bottom of the rightmost column exists + int cw = columnWidth(); + int theCol = ( (( contentsX() + visibleWidth() )/cw) * cw ) + d->mItemSpacing + 1; + // if separators are on, we may need to we may be one column further right if only the spacing/sep is hidden + if ( d->mDrawSeparators && cw - (( contentsX() + visibleWidth() )%cw) <= int( d->mItemSpacing + d->mSepWidth ) ) + theCol += cw; + + // make sure this is not too far right + while ( theCol > contentsWidth() ) + theCol -= columnWidth(); + + aItem = itemAt( QPoint( theCol, d->mItemSpacing + 1 ) ); + + if ( aItem ) + setCurrentItem( aItem ); + } + break; + case Key_Space: + setSelected( d->mCurrentItem, !d->mCurrentItem->isSelected() ); + emit selectionChanged(); + break; + case Key_Return: + case Key_Enter: + emit returnPressed( d->mCurrentItem ); + emit executed( d->mCurrentItem ); + break; + default: + if ( (e->state() & ControlButton) && e->key() == Key_A ) + { + // select all + selectAll( true ); + break; + } + // if we have a string, do autosearch + else if ( ! e->text().isEmpty() && e->text()[0].isPrint() ) + { + + } + break; + } + // handle selection + if ( aItem ) + { + if ( d->mSelectionMode == CardView::Extended ) + { + if ( (e->state() & ShiftButton) ) + { + // shift button: toggle range + // if control button is pressed, leave all items + // and toggle selection current->old current + // otherwise, ?????? + bool s = ! aItem->isSelected(); + int from, to, a, b; + a = d->mItemList.findRef( aItem ); + b = d->mItemList.findRef( old ); + from = a < b ? a : b; + to = a > b ? a : b; + + if ( to - from > 1 ) + { + bool b = signalsBlocked(); + blockSignals(true); + selectAll(false); + blockSignals(b); + } + + //kdDebug()<<"selecting items "<<from<<" - "<<to<<" ( "<<s<<" )"<<endl; + CardViewItem *item; + for ( ; from <= to; from++ ) + { + item = d->mItemList.at( from ); + item->setSelected( s ); + repaintItem( item ); + } + emit selectionChanged(); + } + else if ( (e->state() & ControlButton) ) + { + // control button: do nothing + } + else + { + // no button: move selection to this item + bool b = signalsBlocked(); + blockSignals(true); + selectAll(false); + blockSignals(b); + + setSelected( aItem, true ); + emit selectionChanged(); + } + } + } +} + +void CardView::contentsWheelEvent( QWheelEvent * e ) +{ + scrollBy(2*e->delta()/-3, 0); +} + +void CardView::setLayoutDirty(bool dirty) +{ + if (d->mLayoutDirty != dirty) + { + d->mLayoutDirty = dirty; + repaint(); + } +} + +void CardView::setDrawCardBorder(bool enabled) +{ + if (enabled != d->mDrawCardBorder) + { + d->mDrawCardBorder = enabled; + repaint(); + } +} + +bool CardView::drawCardBorder() const +{ + return d->mDrawCardBorder; +} + +void CardView::setDrawColSeparators(bool enabled) +{ + if (enabled != d->mDrawSeparators) + { + d->mDrawSeparators = enabled; + setLayoutDirty(true); + } +} + +bool CardView::drawColSeparators() const +{ + return d->mDrawSeparators; +} + +void CardView::setDrawFieldLabels(bool enabled) +{ + if (enabled != d->mDrawFieldLabels) + { + d->mDrawFieldLabels = enabled; + repaint(); + } +} + +bool CardView::drawFieldLabels() const +{ + return d->mDrawFieldLabels; +} + +void CardView::setShowEmptyFields(bool show) +{ + if (show != d->mShowEmptyFields) + { + d->mShowEmptyFields = show; + setLayoutDirty(true); + } +} + +bool CardView::showEmptyFields() const +{ + return d->mShowEmptyFields; +} + +void CardView::startDrag() +{ + // The default implementation is a no-op. It must be + // reimplemented in a subclass to be useful +} +void CardView::tryShowFullText() +{ + d->mTimer->stop(); + // if we have an item + QPoint cpos = viewportToContents( viewport()->mapFromGlobal( QCursor::pos() ) ); + CardViewItem *item = itemAt( cpos ); + if ( item ) + { + // query it for a value to display + //QString s = item ? item->caption() : "(no item)"; + //kdDebug()<<"MOUSE REST: "<<s<<endl; + QPoint ipos = cpos - itemRect( item ).topLeft(); + item->showFullString( ipos, d->mTip ); + } +} + +void CardView::drawRubberBands( int pos ) +{ + if ( pos && ((pos-d->firstX)/d->span) - d->colspace - d->mSepWidth < MIN_ITEM_WIDTH ) return; + + int tmpcw = (d->mRubberBandAnchor-d->firstX)/d->span; + int x = d->firstX + tmpcw - d->mSepWidth - contentsX(); + int h = visibleHeight(); + + QPainter p( viewport() ); + p.setRasterOp( XorROP ); + p.setPen( gray ); + p.setBrush( gray ); + uint n = d->first; + // erase + if ( d->mRubberBandAnchor ) + do { + p.drawRect( x, 0, 2, h ); + x += tmpcw; + n++; + } while ( x < visibleWidth() && n < d->mSeparatorList.count() ); + // paint new + if ( ! pos ) return; + tmpcw = (pos - d->firstX)/d->span; + n = d->first; + x = d->firstX + tmpcw - d->mSepWidth - contentsX(); + do { + p.drawRect( x, 0, 2, h ); + x += tmpcw; + n++; + } while ( x < visibleWidth() && n < d->mSeparatorList.count() ); + d->mRubberBandAnchor = pos; +} + + +int CardView::itemWidth() const +{ + return d->mItemWidth; +} + +void CardView::setItemWidth( int w ) +{ + if ( w == d->mItemWidth ) + return; + if ( w < MIN_ITEM_WIDTH ) + w = MIN_ITEM_WIDTH; + d->mItemWidth = w; + setLayoutDirty( true ); +#ifndef KAB_EMBEDDED + updateContents(); +#else //KAB_EMBEDDED +//US updateContents( d->contentsX(), d->contentsY(), visibleWidth(), visibleHeight() ); +qDebug("CardView::setItemWidth has to be verified"); + updateContents( contentsX(), contentsY(), visibleWidth(), visibleHeight() ); +#endif //KAB_EMBEDDED +} + +void CardView::setHeaderFont( const QFont &fnt ) +{ + d->mHeaderFont = fnt; + delete d->mBFm; + d->mBFm = new QFontMetrics( fnt ); +} + +QFont CardView::headerFont() const +{ + return d->mHeaderFont; +} + +void CardView::setFont( const QFont &fnt ) +{ + QScrollView::setFont( fnt ); + delete d->mFm; + d->mFm = new QFontMetrics( fnt ); +} + +int CardView::separatorWidth() +{ + return d->mSepWidth; +} + +void CardView::setSeparatorWidth( int width ) +{ + d->mSepWidth = width; + setLayoutDirty( true ); // hmm, actually I could just adjust the x'es... +} + +int CardView::maxFieldLines() const +{ + return d->mMaxFieldLines; +} + +void CardView::setMaxFieldLines( int howmany ) +{ + d->mMaxFieldLines = howmany ? howmany : INT_MAX; + // FIXME update, forcing the items to recalc height!! +} +//END Cardview + +#ifndef KAB_EMBEDDED +#include "cardview.moc" +#endif //KAB_EMBEDDED |