okular/ui/annotationmodel.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2006 by Pino Toscano <pino@kde.org>                     *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  ***************************************************************************/
   9
  10 #include "annotationmodel.h"
  11
  12 #include <qlinkedlist.h>
  13 #include <qlist.h>
  14 #include <qpointer.h>
  15
  16 #include <kicon.h>
  17 #include <klocale.h>
  18
  19 #include "core/annotations.h"
  20 #include "core/document.h"
  21 #include "core/observer.h"
  22 #include "core/page.h"
  23 #include "ui/guiutils.h"
  24
  25 struct AnnItem
  26 {
  27     AnnItem();
  28     AnnItem( AnnItem *parent, Okular::Annotation *ann );
  29     AnnItem( AnnItem *parent, int page );
  30     ~AnnItem();
  31
  32     AnnItem *parent;
  33     QList< AnnItem* > children;
  34
  35     Okular::Annotation *annotation;
  36     int page;
  37 };
  38
  39
  40 class AnnotationModelPrivate : public Okular::DocumentObserver
  41 {
  42 public:
  43     AnnotationModelPrivate( AnnotationModel *qq );
  44     virtual ~AnnotationModelPrivate();
  45
  46     virtual uint observerId() const;
  47     virtual void notifySetup( const QVector< Okular::Page * > &pages, int setupFlags );
  48     virtual void notifyPageChanged( int page, int flags );
  49
  50     QModelIndex indexForItem( AnnItem *item ) const;
  51     void rebuildTree( const QVector< Okular::Page * > &pages );
  52     AnnItem* findItem( int page, int *index ) const;
  53
  54     AnnotationModel *q;
  55     AnnItem *root;
  56     QPointer< Okular::Document > document;
  57 };
  58
  59
  60 AnnItem::AnnItem()
  61     : parent( 0 ), annotation( 0 ), page( -1 )
  62 {
  63 }
  64
  65 AnnItem::AnnItem( AnnItem *_parent, Okular::Annotation *ann )
  66     : parent( _parent ), annotation( ann ), page( _parent->page )
  67 {
  68     Q_ASSERT( !parent->annotation );
  69     parent->children.append( this );
  70 }
  71
  72 AnnItem::AnnItem( AnnItem *_parent, int _page )
  73     : parent( _parent ), annotation( 0 ), page( _page )
  74 {
  75     Q_ASSERT( !parent->parent );
  76     parent->children.append( this );
  77 }
  78
  79 AnnItem::~AnnItem()
  80 {
  81     qDeleteAll( children );
  82 }
  83
  84
  85 AnnotationModelPrivate::AnnotationModelPrivate( AnnotationModel *qq )
  86     : q( qq ), root( new AnnItem )
  87 {
  88 }
  89
  90 AnnotationModelPrivate::~AnnotationModelPrivate()
  91 {
  92     delete root;
  93 }
  94
  95 uint AnnotationModelPrivate::observerId() const
  96 {
  97     return ANNOTATIONMODEL_ID;
  98 }
  99
 100 void AnnotationModelPrivate::notifySetup( const QVector< Okular::Page * > &pages, int setupFlags )
 101 {
 102     if ( !( setupFlags & Okular::DocumentObserver::DocumentChanged ) )
 103         return;
 104
 105     qDeleteAll( root->children );
 106     root->children.clear();
 107     q->reset();
 108
 109     rebuildTree( pages );
 110 }
 111
 112 void AnnotationModelPrivate::notifyPageChanged( int page, int flags )
 113 {
 114     // we are strictly interested in annotations
 115     if ( !(flags & Okular::DocumentObserver::Annotations ) )
 116         return;
 117
 118     QLinkedList< Okular::Annotation* > annots = document->page( page )->annotations();
 119     int annItemIndex = -1;
 120     AnnItem *annItem = findItem( page, &annItemIndex );
 121     // case 1: the page has no more annotations
 122     //         => remove the branch, if any
 123     if ( annots.isEmpty() )
 124     {
 125         if ( annItem )
 126         {
 127             q->beginRemoveRows( indexForItem( root ), annItemIndex, annItemIndex );
 128             delete root->children.at( annItemIndex );
 129             root->children.removeAt( annItemIndex );
 130             q->endRemoveRows();
 131         }
 132         return;
 133     }
 134     // case 2: no existing branch
 135     //         => add a new branch, and add the annotations for the page
 136     if ( !annItem )
 137     {
 138         int i = 0;
 139         while ( i < root->children.count() && root->children.at( i )->page < page ) ++i;
 140
 141         AnnItem *annItem = new AnnItem();
 142         annItem->page = page;
 143         annItem->parent = root;
 144         q->beginInsertRows( indexForItem( root ), i, i );
 145         annItem->parent->children.insert( i, annItem );
 146         q->endInsertRows();
 147         QLinkedList< Okular::Annotation* >::ConstIterator it = annots.begin(), itEnd = annots.end();
 148         int newid = 0;
 149         for ( ; it != itEnd; ++it, ++newid )
 150         {
 151             q->beginInsertRows( indexForItem( annItem ), newid, newid );
 152             new AnnItem( annItem, *it );
 153             q->endInsertRows();
 154         }
 155         return;
 156     }
 157     // case 3: existing branch, less annotations than items
 158     //         => lookup and remove the annotations
 159     if ( annItem->children.count() > annots.count() )
 160     {
 161         for ( int i = annItem->children.count(); i > 0; --i )
 162         {
 163             Okular::Annotation *ref = annItem->children.at( i - 1 )->annotation;
 164             bool found = false;
 165             QLinkedList< Okular::Annotation* >::ConstIterator it = annots.begin(), itEnd = annots.end();
 166             for ( ; !found && it != itEnd; ++it )
 167             {
 168                 if ( ( *it ) == ref )
 169                     found = true;
 170             }
 171             if ( !found )
 172             {
 173                 q->beginRemoveRows( indexForItem( annItem ), i - 1, i - 1 );
 174                 delete annItem->children.at( i - 1 );
 175                 annItem->children.removeAt( i - 1 );
 176                 q->endRemoveRows();
 177             }
 178         }
 179         return;
 180     }
 181     // case 4: existing branch, less items than annotations
 182     //         => lookup and add annotations if not in the branch
 183     if ( annots.count() > annItem->children.count() )
 184     {
 185         QLinkedList< Okular::Annotation* >::ConstIterator it = annots.begin(), itEnd = annots.end();
 186         for ( ; it != itEnd; ++it )
 187         {
 188             Okular::Annotation *ref = *it;
 189             bool found = false;
 190             int count = annItem->children.count();
 191             for ( int i = 0; !found && i < count; ++i )
 192             {
 193                 if ( ref == annItem->children.at( i )->annotation )
 194                     found = true;
 195             }
 196             if ( !found )
 197             {
 198                 q->beginInsertRows( indexForItem( annItem ), count, count );
 199                 new AnnItem( annItem, ref );
 200                 q->endInsertRows();
 201             }
 202         }
 203         return;
 204     }
 205     // case 5: the data of some annotation changed
 206     // TODO: what do we do in this case?
 207     // FIXME: for now, update ALL the annotations for that page
 208     for ( int i = 0; i < annItem->children.count(); ++i )
 209     {
 210         QModelIndex index = indexForItem( annItem->children.at( i ) );
 211         emit q->dataChanged( index, index );
 212     }
 213 }
 214
 215 QModelIndex AnnotationModelPrivate::indexForItem( AnnItem *item ) const
 216 {
 217     if ( item->parent )
 218     {
 219         int id = item->parent->children.indexOf( item );
 220         if ( id >= 0 && id < item->parent->children.count() )
 221            return q->createIndex( id, 0, item );
 222     }
 223     return QModelIndex();
 224 }
 225
 226 void AnnotationModelPrivate::rebuildTree( const QVector< Okular::Page * > &pages )
 227 {
 228     if ( pages.isEmpty() )
 229         return;
 230
 231     emit q->layoutAboutToBeChanged();
 232     for ( int i = 0; i < pages.count(); ++i )
 233     {
 234         QLinkedList< Okular::Annotation* > annots = pages.at( i )->annotations();
 235         if ( annots.isEmpty() )
 236             continue;
 237
 238         AnnItem *annItem = new AnnItem( root, i );
 239         QLinkedList< Okular::Annotation* >::ConstIterator it = annots.begin(), itEnd = annots.end();
 240         for ( ; it != itEnd; ++it )
 241         {
 242             new AnnItem( annItem, *it );
 243         }
 244     }
 245     emit q->layoutChanged();
 246 }
 247
 248 AnnItem* AnnotationModelPrivate::findItem( int page, int *index ) const
 249 {
 250     for ( int i = 0; i < root->children.count(); ++i )
 251     {
 252         AnnItem *tmp = root->children.at( i );
 253         if ( tmp->page == page )
 254         {
 255             if ( index )
 256                 *index = i;
 257             return tmp;
 258         }
 259     }
 260     if ( index )
 261         *index = -1;
 262     return 0;
 263 }
 264
 265
 266 AnnotationModel::AnnotationModel( Okular::Document *document, QObject *parent )
 267     : QAbstractItemModel( parent ), d( new AnnotationModelPrivate( this ) )
 268 {
 269     d->document = document;
 270
 271     d->document->addObserver( d );
 272 }
 273
 274 AnnotationModel::~AnnotationModel()
 275 {
 276     if ( d->document )
 277         d->document->removeObserver( d );
 278
 279     delete d;
 280 }
 281
 282 int AnnotationModel::columnCount( const QModelIndex &parent ) const
 283 {
 284     Q_UNUSED( parent )
 285     return 1;
 286 }
 287
 288 QVariant AnnotationModel::data( const QModelIndex &index, int role ) const
 289 {
 290     if ( !index.isValid() )
 291         return QVariant();
 292
 293     AnnItem *item = static_cast< AnnItem* >( index.internalPointer() );
 294     if ( !item->annotation )
 295     {
 296         if ( role == Qt::DisplayRole )
 297           return i18n( "Page %1", item->page + 1 );
 298         else if ( role == Qt::DecorationRole )
 299           return KIcon( "text-plain" );
 300         else if ( role == PageRole )
 301           return item->page;
 302
 303         return QVariant();
 304     }
 305     switch ( role )
 306     {
 307         case Qt::DisplayRole:
 308             return GuiUtils::captionForAnnotation( item->annotation );
 309             break;
 310         case Qt::DecorationRole:
 311             return KIcon( "okular" );
 312             break;
 313         case Qt::ToolTipRole:
 314             return GuiUtils::prettyToolTip( item->annotation );
 315             break;
 316         case AuthorRole:
 317             return item->annotation->author();
 318             break;
 319         case PageRole:
 320             return item->page;
 321             break;
 322     }
 323     return QVariant();
 324 }
 325
 326 bool AnnotationModel::hasChildren( const QModelIndex &parent ) const
 327 {
 328     if ( !parent.isValid() )
 329         return true;
 330
 331     AnnItem *item = static_cast< AnnItem* >( parent.internalPointer() );
 332     return !item->children.isEmpty();
 333 }
 334
 335 QVariant AnnotationModel::headerData( int section, Qt::Orientation orientation, int role ) const
 336 {
 337     if ( orientation != Qt::Horizontal )
 338         return QVariant();
 339
 340     if ( section == 0 && role == Qt::DisplayRole )
 341         return "Annotations";
 342
 343     return QVariant();
 344 }
 345
 346 QModelIndex AnnotationModel::index( int row, int column, const QModelIndex &parent ) const
 347 {
 348     if ( row < 0 || column != 0 )
 349         return QModelIndex();
 350
 351     AnnItem *item = parent.isValid() ? static_cast< AnnItem* >( parent.internalPointer() ) : d->root;
 352     if ( row < item->children.count() )
 353         return createIndex( row, column, item->children.at( row ) );
 354
 355     return QModelIndex();
 356 }
 357
 358 QModelIndex AnnotationModel::parent( const QModelIndex &index ) const
 359 {
 360     if ( !index.isValid() )
 361         return QModelIndex();
 362
 363     AnnItem *item = static_cast< AnnItem* >( index.internalPointer() );
 364     return d->indexForItem( item->parent );
 365 }
 366
 367 int AnnotationModel::rowCount( const QModelIndex &parent ) const
 368 {
 369     AnnItem *item = parent.isValid() ? static_cast< AnnItem* >( parent.internalPointer() ) : d->root;
 370     return item->children.count();
 371 }
 372
 373 bool AnnotationModel::isAnnotation( const QModelIndex &index ) const
 374 {
 375     return annotationForIndex( index );
 376 }
 377
 378 Okular::Annotation* AnnotationModel::annotationForIndex( const QModelIndex &index ) const
 379 {
 380     if ( !index.isValid() )
 381         return 0;
 382
 383     AnnItem *item = static_cast< AnnItem* >( index.internalPointer() );
 384     return item->annotation;
 385 }
 386
 387 #include "annotationmodel.moc"