← Back to branch summary

~ubuntu-branches/ubuntu/vivid/krusader/vivid-proposed

« back to all changes in this revision

Viewing changes to krusader/Panel/krinterbriefview.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-05-05 22:26:37 UTC
  • mfrom: (3.1.4 squeeze)
  • Revision ID: james.westby@ubuntu.com-20100505222637-ydv3cwjwy365on2r
Tags: 1:2.1.0~beta1-1ubuntu1
* Merge from Debian Unstable.  Remaining changes:
  - Retain Kubuntu doc path

Show diffs side-by-side

added added

removed removed

Lines of Context:
krusader/Panel/krinterbriefview.cpp
1
 
/***************************************************************************
2
 
                      krinterbriefview.cpp  -  description
3
 
                             -------------------
4
 
    begin                : Sat Feb 14 2009
5
 
    copyright            : (C) 2009+ by Csaba Karai
6
 
    email                : 
7
 
 ***************************************************************************/
8
 
 
9
 
/***************************************************************************
10
 
 *                                                                         *
11
 
 *   This program is free software; you can redistribute it and/or modify  *
12
 
 *   it under the terms of the GNU General Public License as published by  *
13
 
 *   the Free Software Foundation; either version 2 of the License, or     *
14
 
 *   (at your option) any later version.                                   *
15
 
 *                                                                         *
16
 
 ***************************************************************************/
 
1
/*****************************************************************************
 
2
 * Copyright (C) 2009 Csaba Karai <cskarai@freemail.hu>                      *
 
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
 * This package is distributed in the hope that it will be useful,           *
 
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
 
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
 
12
 * GNU General Public License for more details.                              *
 
13
 *                                                                           *
 
14
 * You should have received a copy of the GNU General Public License         *
 
15
 * along with this package; if not, write to the Free Software               *
 
16
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA *
 
17
 *****************************************************************************/
17
18
 
18
19
#include "krinterbriefview.h"
19
 
#include "krviewfactory.h"
20
 
#include "krinterviewitemdelegate.h"
21
 
#include "krviewitem.h"
22
 
#include "krvfsmodel.h"
23
 
#include "../VFS/krpermhandler.h"
24
 
#include "../defaults.h"
25
 
#include "krmousehandler.h"
26
 
#include "krcolorcache.h"
27
 
#include <klocale.h>
28
 
#include <kdirlister.h>
 
20
 
29
21
#include <QDir>
30
22
#include <QDirModel>
31
23
#include <QHashIterator>
32
24
#include <QHeaderView>
33
 
#include "../GUI/krstyleproxy.h"
34
 
#include <KMenu>
35
25
#include <QPainter>
36
26
#include <QScrollBar>
37
 
#include <QHeaderView>
38
27
#include <QRegion>
39
28
#include <QItemSelection>
40
29
#include <QItemSelectionRange>
41
 
#include <KMenu>
 
30
 
 
31
#include <kmenu.h>
 
32
#include <klocale.h>
 
33
#include <kdirlister.h>
 
34
 
 
35
#include "krviewfactory.h"
 
36
#include "krinterviewitemdelegate.h"
 
37
#include "krviewitem.h"
 
38
#include "krvfsmodel.h"
 
39
#include "krmousehandler.h"
 
40
#include "krcolorcache.h"
 
41
#include "../VFS/krpermhandler.h"
 
42
#include "../defaults.h"
 
43
#include "../GUI/krstyleproxy.h"
42
44
 
43
45
// dummy. remove this class when no longer needed
44
46
class KrInterBriefViewItem: public KrViewItem
45
47
{
46
48
public:
47
 
        KrInterBriefViewItem(KrInterBriefView *parent, vfile *vf): KrViewItem(vf, parent->properties()) {
48
 
                _view = parent;
49
 
                _vfile = vf;
50
 
                if( parent->_model->dummyVfile() == vf )
51
 
                        dummyVfile = true;
52
 
        }
53
 
        
54
 
        bool isSelected() const {
55
 
                const QModelIndex & ndx = _view->_model->vfileIndex( _vfile );
56
 
                return _view->selectionModel()->isSelected( ndx );
57
 
        }
58
 
        void setSelected( bool s ) {
59
 
                const QModelIndex & ndx = _view->_model->vfileIndex( _vfile );
60
 
                _view->selectionModel()->select( ndx, ( s ? QItemSelectionModel::Select : QItemSelectionModel::Deselect )
61
 
                        | QItemSelectionModel::Rows );
62
 
        }
63
 
        QRect itemRect() const {
64
 
                const QModelIndex & ndx = _view->_model->vfileIndex( _vfile );
65
 
                return _view->visualRect( ndx );
66
 
        }
67
 
        static void itemHeightChanged()
68
 
        {
69
 
        } // force the items to resize when icon/font size change
70
 
        void redraw() {}
 
49
    KrInterBriefViewItem(KrInterBriefView *parent, vfile *vf): KrViewItem(vf, parent->properties()) {
 
50
        _view = parent;
 
51
        _vfile = vf;
 
52
        if (parent->_model->dummyVfile() == vf)
 
53
            dummyVfile = true;
 
54
    }
 
55
 
 
56
    bool isSelected() const {
 
57
        const QModelIndex & ndx = _view->_model->vfileIndex(_vfile);
 
58
        return _view->selectionModel()->isSelected(ndx);
 
59
    }
 
60
    void setSelected(bool s) {
 
61
        const QModelIndex & ndx = _view->_model->vfileIndex(_vfile);
 
62
        _view->selectionModel()->select(ndx, (s ? QItemSelectionModel::Select : QItemSelectionModel::Deselect)
 
63
                                        | QItemSelectionModel::Rows);
 
64
    }
 
65
    QRect itemRect() const {
 
66
        const QModelIndex & ndx = _view->_model->vfileIndex(_vfile);
 
67
        return _view->visualRect(ndx);
 
68
    }
 
69
    static void itemHeightChanged() {
 
70
    } // force the items to resize when icon/font size change
 
71
    void redraw() {}
71
72
 
72
73
private:
73
 
        vfile *_vfile;
74
 
        KrInterBriefView * _view;
 
74
    vfile *_vfile;
 
75
    KrInterBriefView * _view;
75
76
};
76
77
 
77
78
 
78
79
// code used to register the view
79
 
#define INTERBRIEFVIEW_ID 3
80
 
KrViewInstance interBriefView( INTERBRIEFVIEW_ID, i18n( "&Experimental View" ), 0 /*Qt::ALT + Qt::SHIFT + Qt::Key_D*/,
81
 
                                  KrInterBriefView::create, KrInterBriefViewItem::itemHeightChanged );
 
80
#define INTERBRIEFVIEW_ID 1
 
81
KrViewInstance interBriefView(INTERBRIEFVIEW_ID, i18n("&Brief View"), Qt::ALT + Qt::SHIFT + Qt::Key_B,
 
82
                              KrInterBriefView::create, KrInterBriefViewItem::itemHeightChanged);
82
83
// end of register code
83
84
 
84
 
KrInterBriefView::KrInterBriefView( QWidget *parent, bool &left, KConfig *cfg ):
85
 
                KrView(cfg),
86
 
                QAbstractItemView(parent)
 
85
KrInterBriefView::KrInterBriefView(QWidget *parent, bool &left, KConfig *cfg):
 
86
        KrView(cfg),
 
87
        QAbstractItemView(parent)
87
88
{
88
 
        _header = 0;
89
 
        
90
 
        // fix the context menu problem
91
 
        int j = QFontMetrics( font() ).height() * 2;
92
 
        _mouseHandler = new KrMouseHandler( this, j );
93
 
        connect( _mouseHandler, SIGNAL( renameCurrentItem() ), this, SLOT( renameCurrentItem() ) );
94
 
        setWidget( this );
95
 
        _nameInKConfig=QString( "KrInterBriefView" ) + QString( ( left ? "Left" : "Right" ) ) ;
96
 
        KConfigGroup group( krConfig, "Private" );
97
 
 
98
 
        KConfigGroup grpSvr( _config, "Look&Feel" );
99
 
        _viewFont = grpSvr.readEntry( "Filelist Font", *_FilelistFont );
100
 
        _fileIconSize = (grpSvr.readEntry("Filelist Icon Size",_FilelistIconSize)).toInt();
101
 
        
102
 
        _model = new KrVfsModel( this );
103
 
        this->setModel(_model);
104
 
        _model->sort( KrVfsModel::Name, Qt::AscendingOrder );
105
 
        _model->setExtensionEnabled( false );
106
 
        _model->setAlternatingTable( true );
107
 
        connect( _model, SIGNAL( layoutChanged() ), this, SLOT( slotMakeCurrentVisible() ) );
108
 
        //header()->installEventFilter( this );
109
 
        
110
 
        setSelectionMode( QAbstractItemView::NoSelection );
111
 
        
112
 
        setStyle( new KrStyleProxy() );
113
 
        setItemDelegate( new KrInterViewItemDelegate() );
114
 
        setMouseTracking( true );
115
 
        setAcceptDrops( true );
116
 
        setDropIndicatorShown( true );
117
 
        
118
 
        connect( &KrColorCache::getColorCache(), SIGNAL( colorsRefreshed() ), this, SLOT( refreshColors() ) );
 
89
    _header = 0;
 
90
 
 
91
    // fix the context menu problem
 
92
    int j = QFontMetrics(font()).height() * 2;
 
93
    _mouseHandler = new KrMouseHandler(this, j);
 
94
    connect(_mouseHandler, SIGNAL(renameCurrentItem()), this, SLOT(renameCurrentItem()));
 
95
    setWidget(this);
 
96
    _nameInKConfig = QString("KrInterBriefView") + QString((left ? "Left" : "Right")) ;
 
97
    KConfigGroup group(krConfig, "Private");
 
98
 
 
99
    KConfigGroup grpSvr(_config, "Look&Feel");
 
100
    _viewFont = grpSvr.readEntry("Filelist Font", *_FilelistFont);
 
101
    _fileIconSize = (grpSvr.readEntry("Filelist Icon Size", _FilelistIconSize)).toInt();
 
102
 
 
103
    _model = new KrVfsModel(this);
 
104
    this->setModel(_model);
 
105
    _model->sort(KrVfsModel::Name, Qt::AscendingOrder);
 
106
    _model->setExtensionEnabled(false);
 
107
    _model->setAlternatingTable(true);
 
108
    //header()->installEventFilter( this );
 
109
 
 
110
    setSelectionMode(QAbstractItemView::NoSelection);
 
111
 
 
112
    setStyle(new KrStyleProxy());
 
113
    setItemDelegate(new KrInterViewItemDelegate());
 
114
    setMouseTracking(true);
 
115
    setAcceptDrops(true);
 
116
    setDropIndicatorShown(true);
 
117
 
 
118
    connect(&KrColorCache::getColorCache(), SIGNAL(colorsRefreshed()), this, SLOT(refreshColors()));
119
119
}
120
120
 
121
121
KrInterBriefView::~KrInterBriefView()
122
122
{
123
 
        delete _properties;
124
 
        _properties = 0;
125
 
        delete _operator;
126
 
        _operator = 0;
127
 
        delete _model;
128
 
        delete _mouseHandler;
129
 
        QHashIterator< vfile *, KrInterBriefViewItem *> it( _itemHash );
130
 
        while( it.hasNext() )
131
 
                delete it.next().value();
132
 
        _itemHash.clear();
 
123
    delete _properties;
 
124
    _properties = 0;
 
125
    delete _operator;
 
126
    _operator = 0;
 
127
    delete _model;
 
128
    delete _mouseHandler;
 
129
    QHashIterator< vfile *, KrInterBriefViewItem *> it(_itemHash);
 
130
    while (it.hasNext())
 
131
        delete it.next().value();
 
132
    _itemHash.clear();
133
133
}
134
134
 
135
135
KrViewItem* KrInterBriefView::findItemByName(const QString &name)
136
136
{
137
 
        if (!_model->ready()) 
138
 
                return 0;
139
 
                
140
 
        QModelIndex ndx = _model->nameIndex( name );
141
 
        if( !ndx.isValid() )
142
 
                return 0;
143
 
        return getKrInterViewItem( ndx );
 
137
    if (!_model->ready())
 
138
        return 0;
 
139
 
 
140
    QModelIndex ndx = _model->nameIndex(name);
 
141
    if (!ndx.isValid())
 
142
        return 0;
 
143
    return getKrInterViewItem(ndx);
 
144
}
 
145
 
 
146
void KrInterBriefView::currentChanged(const QModelIndex & current, const QModelIndex & previous)
 
147
{
 
148
    if (_model->ready()) {
 
149
        KrViewItem * item = getKrInterViewItem(currentIndex());
 
150
        op()->emitCurrentChanged(item);
 
151
    }
 
152
    QAbstractItemView::currentChanged(current, previous);
144
153
}
145
154
 
146
155
QString KrInterBriefView::getCurrentItem() const
147
156
{
148
 
        if (!_model->ready()) 
149
 
                return QString();
150
 
        
151
 
        vfile * vf = _model->vfileAt( currentIndex() );
152
 
        if( vf == 0 )
153
 
                return QString();
154
 
        return vf->vfile_getName();
 
157
    if (!_model->ready())
 
158
        return QString();
 
159
 
 
160
    vfile * vf = _model->vfileAt(currentIndex());
 
161
    if (vf == 0)
 
162
        return QString();
 
163
    return vf->vfile_getName();
155
164
}
156
165
 
157
166
KrViewItem* KrInterBriefView::getCurrentKrViewItem()
158
167
{
159
 
        if (!_model->ready()) 
160
 
                return 0;
 
168
    if (!_model->ready())
 
169
        return 0;
161
170
 
162
 
        return getKrInterViewItem( currentIndex() );
 
171
    return getKrInterViewItem(currentIndex());
163
172
}
164
173
 
165
174
KrViewItem* KrInterBriefView::getFirst()
166
175
{
167
 
        if (!_model->ready()) 
168
 
                return 0;
169
 
        
170
 
        return getKrInterViewItem( _model->index(0, 0, QModelIndex()));
 
176
    if (!_model->ready())
 
177
        return 0;
 
178
 
 
179
    return getKrInterViewItem(_model->index(0, 0, QModelIndex()));
171
180
}
172
181
 
173
182
KrViewItem* KrInterBriefView::getKrViewItemAt(const QPoint &vp)
174
183
{
175
 
        if (!_model->ready()) 
176
 
                return 0;
177
 
        
178
 
        return getKrInterViewItem( indexAt( vp ) );
 
184
    if (!_model->ready())
 
185
        return 0;
 
186
 
 
187
    return getKrInterViewItem(indexAt(vp));
179
188
}
180
189
 
181
190
KrViewItem* KrInterBriefView::getLast()
182
191
{
183
 
        if (!_model->ready()) 
184
 
                return 0;
185
 
        
186
 
        return getKrInterViewItem(_model->index(_model->rowCount()-1, 0, QModelIndex()));
 
192
    if (!_model->ready())
 
193
        return 0;
 
194
 
 
195
    return getKrInterViewItem(_model->index(_model->rowCount() - 1, 0, QModelIndex()));
187
196
}
188
197
 
189
198
KrViewItem* KrInterBriefView::getNext(KrViewItem *current)
190
199
{
191
 
        vfile* vf = (vfile *)current->getVfile();
192
 
        QModelIndex ndx = _model->vfileIndex( vf );
193
 
        if( ndx.row() >= _model->rowCount()-1 )
194
 
                return 0;
195
 
        return getKrInterViewItem( _model->index(ndx.row() + 1, 0, QModelIndex()));
 
200
    vfile* vf = (vfile *)current->getVfile();
 
201
    QModelIndex ndx = _model->vfileIndex(vf);
 
202
    if (ndx.row() >= _model->rowCount() - 1)
 
203
        return 0;
 
204
    return getKrInterViewItem(_model->index(ndx.row() + 1, 0, QModelIndex()));
196
205
}
197
206
 
198
207
KrViewItem* KrInterBriefView::getPrev(KrViewItem *current)
199
208
{
200
 
        vfile* vf = (vfile *)current->getVfile();
201
 
        QModelIndex ndx = _model->vfileIndex( vf );
202
 
        if( ndx.row() <= 0 )
203
 
                return 0;
204
 
        return getKrInterViewItem( _model->index(ndx.row() - 1, 0, QModelIndex()));
 
209
    vfile* vf = (vfile *)current->getVfile();
 
210
    QModelIndex ndx = _model->vfileIndex(vf);
 
211
    if (ndx.row() <= 0)
 
212
        return 0;
 
213
    return getKrInterViewItem(_model->index(ndx.row() - 1, 0, QModelIndex()));
205
214
}
206
215
 
207
216
void KrInterBriefView::slotMakeCurrentVisible()
208
217
{
209
 
        scrollTo( currentIndex() );
 
218
    scrollTo(currentIndex());
210
219
}
211
220
 
212
221
void KrInterBriefView::makeItemVisible(const KrViewItem *item)
213
222
{
214
 
        vfile* vf = (vfile *)item->getVfile();
215
 
        QModelIndex ndx = _model->vfileIndex( vf );
216
 
        if( ndx.isValid() )
217
 
                scrollTo( ndx );
 
223
    if (item == 0)
 
224
        return;
 
225
    vfile* vf = (vfile *)item->getVfile();
 
226
    QModelIndex ndx = _model->vfileIndex(vf);
 
227
    if (ndx.isValid())
 
228
        scrollTo(ndx);
218
229
}
219
230
 
220
231
void KrInterBriefView::setCurrentKrViewItem(KrViewItem *item)
221
232
{
222
 
        if( item == 0 ) {
223
 
                setCurrentIndex( QModelIndex() );
224
 
                return;
225
 
        }
226
 
        vfile* vf = (vfile *)item->getVfile();
227
 
        QModelIndex ndx = _model->vfileIndex( vf );
228
 
        if( ndx.isValid() && ndx.row() != currentIndex().row() ) {
229
 
                _mouseHandler->cancelTwoClickRename();
230
 
                setCurrentIndex( ndx );
231
 
        }
 
233
    if (item == 0) {
 
234
        setCurrentIndex(QModelIndex());
 
235
        return;
 
236
    }
 
237
    vfile* vf = (vfile *)item->getVfile();
 
238
    QModelIndex ndx = _model->vfileIndex(vf);
 
239
    if (ndx.isValid() && ndx.row() != currentIndex().row()) {
 
240
        _mouseHandler->cancelTwoClickRename();
 
241
        setCurrentIndex(ndx);
 
242
    }
232
243
}
233
244
 
234
245
KrViewItem* KrInterBriefView::preAddItem(vfile *vf)
235
246
{
236
 
        return getKrInterViewItem( _model->addItem( vf ) );
 
247
    return getKrInterViewItem(_model->addItem(vf));
237
248
}
238
249
 
239
250
bool KrInterBriefView::preDelItem(KrViewItem *item)
240
251
{
241
 
        if( item == 0 )
242
 
                return true;
243
 
        QModelIndex ndx = _model->removeItem( (vfile *)item->getVfile() );
244
 
        if( ndx.isValid() )
245
 
                setCurrentIndex( ndx );
246
 
        _itemHash.remove( (vfile *)item->getVfile() );
247
 
        return true;
 
252
    if (item == 0)
 
253
        return true;
 
254
    QModelIndex ndx = _model->removeItem((vfile *)item->getVfile());
 
255
    if (ndx.isValid())
 
256
        setCurrentIndex(ndx);
 
257
    _itemHash.remove((vfile *)item->getVfile());
 
258
    return true;
248
259
}
249
260
 
250
261
void KrInterBriefView::redraw()
253
264
 
254
265
void KrInterBriefView::refreshColors()
255
266
{
256
 
        if( _model->rowCount() != 0 )
257
 
                _model->emitChanged();
 
267
    if (_model->rowCount() != 0)
 
268
        _model->emitChanged();
258
269
}
259
270
 
260
271
void KrInterBriefView::restoreSettings()
261
272
{
262
 
        _numOfColumns = _properties->numberOfColumns;
263
 
        
264
 
        KConfigGroup group( krConfig, nameInKConfig() );
265
 
        
266
 
        int column = group.readEntry( "Sort Indicator Column", (int)KrVfsModel::Name );
267
 
        bool isAscending = group.readEntry( "Ascending Sort Order", true );
268
 
        Qt::SortOrder sortDir = isAscending ? Qt::AscendingOrder : Qt::DescendingOrder;
269
 
        
270
 
        _header->setSortIndicator(column, sortDir);
271
 
        _model->sort( column, sortDir );
 
273
    _numOfColumns = _properties->numberOfColumns;
 
274
 
 
275
    KConfigGroup group(krConfig, nameInKConfig());
 
276
 
 
277
    int column = group.readEntry("Sort Indicator Column", (int)KrVfsModel::Name);
 
278
    bool isAscending = group.readEntry("Ascending Sort Order", true);
 
279
    Qt::SortOrder sortDir = isAscending ? Qt::AscendingOrder : Qt::DescendingOrder;
 
280
 
 
281
    _header->setSortIndicator(column, sortDir);
 
282
    _model->sort(column, sortDir);
272
283
}
273
284
 
274
285
void KrInterBriefView::saveSettings()
275
286
{
276
 
        KConfigGroup group( krConfig, nameInKConfig() );
277
 
        
278
 
        group.writeEntry( "Sort Indicator Column", (int)_model->getLastSortOrder() );
279
 
        group.writeEntry( "Ascending Sort Order", (_model->getLastSortDir() == Qt::AscendingOrder ) );
 
287
    KConfigGroup group(krConfig, nameInKConfig());
 
288
 
 
289
    group.writeEntry("Sort Indicator Column", (int)_model->getLastSortOrder());
 
290
    group.writeEntry("Ascending Sort Order", (_model->getLastSortDir() == Qt::AscendingOrder));
280
291
}
281
292
 
282
293
void KrInterBriefView::setCurrentItem(const QString& name)
283
294
{
284
 
        QModelIndex ndx = _model->nameIndex( name );
285
 
        if( ndx.isValid() )
286
 
                setCurrentIndex( ndx );
287
 
}
288
 
 
289
 
void KrInterBriefView::prepareForActive() {
290
 
        KrView::prepareForActive();
291
 
        setFocus();
292
 
        KrViewItem * current = getCurrentKrViewItem();
293
 
        if( current != 0 ) {
294
 
                QString desc = current->description();
295
 
                op()->emitItemDescription( desc );
296
 
        }
297
 
}
298
 
 
299
 
void KrInterBriefView::prepareForPassive() {
300
 
        KrView::prepareForPassive();
301
 
        _mouseHandler->cancelTwoClickRename();
302
 
        //if ( renameLineEdit() ->isVisible() )
303
 
                //renameLineEdit() ->clearFocus();
304
 
}
305
 
 
306
 
int KrInterBriefView::itemsPerPage() {
307
 
        int height = getItemHeight();
308
 
        if( height == 0 )
309
 
                height ++;
310
 
        int numRows = viewport()->height() / height;
311
 
        return numRows;
 
295
    QModelIndex ndx = _model->nameIndex(name);
 
296
    if (ndx.isValid())
 
297
        setCurrentIndex(ndx);
 
298
}
 
299
 
 
300
void KrInterBriefView::prepareForActive()
 
301
{
 
302
    KrView::prepareForActive();
 
303
    setFocus();
 
304
    KrViewItem * current = getCurrentKrViewItem();
 
305
    if (current != 0) {
 
306
        QString desc = current->description();
 
307
        op()->emitItemDescription(desc);
 
308
    }
 
309
}
 
310
 
 
311
void KrInterBriefView::prepareForPassive()
 
312
{
 
313
    KrView::prepareForPassive();
 
314
    _mouseHandler->cancelTwoClickRename();
 
315
    //if ( renameLineEdit() ->isVisible() )
 
316
    //renameLineEdit() ->clearFocus();
 
317
}
 
318
 
 
319
int KrInterBriefView::itemsPerPage()
 
320
{
 
321
    int height = getItemHeight();
 
322
    if (height == 0)
 
323
        height ++;
 
324
    int numRows = viewport()->height() / height;
 
325
    return numRows;
312
326
}
313
327
 
314
328
void KrInterBriefView::sort()
315
329
{
316
 
        _model->sort();
 
330
    _model->sort();
317
331
}
318
332
 
319
333
void KrInterBriefView::updateView()
320
334
{
321
335
}
322
336
 
 
337
void KrInterBriefView::updateItem(vfile * item)
 
338
{
 
339
    if (item == 0)
 
340
        return;
 
341
    _model->updateItem(item);
 
342
    op()->emitSelectionChanged();
 
343
}
 
344
 
323
345
void KrInterBriefView::updateItem(KrViewItem* item)
324
346
{
325
 
        if( item == 0 )
326
 
                return;
327
 
        _model->updateItem( (vfile *)item->getVfile() );
 
347
    if (item == 0)
 
348
        return;
 
349
    updateItem((vfile *)item->getVfile());
328
350
}
329
351
 
330
352
void KrInterBriefView::clear()
331
353
{
332
 
        clearSelection();
333
 
        _model->clear();
334
 
        QHashIterator< vfile *, KrInterBriefViewItem *> it( _itemHash );
335
 
        while( it.hasNext() )
336
 
                delete it.next().value();
337
 
        _itemHash.clear();
338
 
        KrView::clear();
 
354
    clearSelection();
 
355
    _model->clear();
 
356
    QHashIterator< vfile *, KrInterBriefViewItem *> it(_itemHash);
 
357
    while (it.hasNext())
 
358
        delete it.next().value();
 
359
    _itemHash.clear();
 
360
    KrView::clear();
339
361
}
340
362
 
341
363
void KrInterBriefView::addItems(vfs* v, bool addUpDir)
342
364
{
343
 
        _model->setVfs(v, addUpDir);
344
 
        _count = _model->rowCount();
345
 
        if( addUpDir )
346
 
                _count--;
347
 
        
348
 
        this->setCurrentIndex(_model->index(0, 0));
349
 
        if( !nameToMakeCurrent().isEmpty() )
350
 
                setCurrentItem( nameToMakeCurrent() );
 
365
    _model->setVfs(v, addUpDir);
 
366
    _count = _model->rowCount();
 
367
    if (addUpDir)
 
368
        _count--;
 
369
 
 
370
    this->setCurrentIndex(_model->index(0, 0));
 
371
    if (!nameToMakeCurrent().isEmpty())
 
372
        setCurrentItem(nameToMakeCurrent());
351
373
}
352
374
 
353
375
void KrInterBriefView::setup()
354
376
{
355
 
        _header = new QHeaderView(Qt::Horizontal, this);
356
 
        _header->setDefaultAlignment(Qt::AlignLeft|Qt::AlignVCenter);
357
 
        _header->setParent( this );
358
 
        _header->setModel( _model );
359
 
        _header->hideSection( KrVfsModel::Mime );
360
 
        _header->hideSection( KrVfsModel::Permissions );
361
 
        _header->hideSection( KrVfsModel::KrPermissions );
362
 
        _header->hideSection( KrVfsModel::Owner );
363
 
        _header->hideSection( KrVfsModel::Group );
364
 
        _header->setStretchLastSection( true );
365
 
        _header->setResizeMode( QHeaderView::Fixed );
366
 
        _header->setClickable( true );
367
 
        _header->setSortIndicatorShown( true );
368
 
        _header->setSortIndicator(KrVfsModel::Name, Qt::AscendingOrder);
369
 
        connect(_header, SIGNAL(sortIndicatorChanged(int,Qt::SortOrder)),
370
 
                _model, SLOT(sort(int,Qt::SortOrder)));
371
 
        _header->installEventFilter( this );
372
 
        
373
 
        restoreSettings();
 
377
    _header = new QHeaderView(Qt::Horizontal, this);
 
378
    _header->setDefaultAlignment(Qt::AlignLeft | Qt::AlignVCenter);
 
379
    _header->setParent(this);
 
380
    _header->setModel(_model);
 
381
    _header->hideSection(KrVfsModel::Mime);
 
382
    _header->hideSection(KrVfsModel::Permissions);
 
383
    _header->hideSection(KrVfsModel::KrPermissions);
 
384
    _header->hideSection(KrVfsModel::Owner);
 
385
    _header->hideSection(KrVfsModel::Group);
 
386
    _header->setStretchLastSection(true);
 
387
    _header->setResizeMode(QHeaderView::Fixed);
 
388
    _header->setClickable(true);
 
389
    _header->setSortIndicatorShown(true);
 
390
    _header->setSortIndicator(KrVfsModel::Name, Qt::AscendingOrder);
 
391
    connect(_header, SIGNAL(sortIndicatorChanged(int, Qt::SortOrder)),
 
392
            _model, SLOT(sort(int, Qt::SortOrder)));
 
393
    _header->installEventFilter(this);
 
394
 
 
395
    restoreSettings();
374
396
}
375
397
 
376
398
void KrInterBriefView::initOperator()
377
399
{
378
 
        _operator = new KrViewOperator(this, this);
379
 
        // klistview emits selection changed, so chain them to operator
380
 
        connect(selectionModel(), SIGNAL(selectionChanged( const QItemSelection &, const QItemSelection &)), _operator, SLOT(emitSelectionChanged()));
381
 
}
382
 
 
383
 
void KrInterBriefView::keyPressEvent( QKeyEvent *e )
384
 
{
385
 
        if ( !e || !_model->ready() )
386
 
                return ; // subclass bug
387
 
        if(( e->key() != Qt::Key_Left && e->key() != Qt::Key_Right ) &&
388
 
                ( handleKeyEvent( e ) ) ) // did the view class handled the event?
389
 
                        return;
390
 
        switch ( e->key() ) {
391
 
        case Qt::Key_Right :
392
 
        {
393
 
                if ( e->modifiers() == Qt::ControlModifier ) { // let the panel handle it
394
 
                        e->ignore();
395
 
                        break;
396
 
                }
397
 
                KrViewItem *i = getCurrentKrViewItem();
398
 
                KrViewItem *newCurrent = i;
399
 
                
400
 
                if ( !i )
401
 
                        break;
402
 
                
403
 
                int num = itemsPerPage() + 1;
404
 
                
405
 
                if ( e->modifiers() & Qt::ShiftModifier ) i->setSelected( !i->isSelected() );
406
 
                
407
 
                while( i && num > 0 )
408
 
                {
409
 
                        if ( e->modifiers() & Qt::ShiftModifier ) i->setSelected( !i->isSelected() );
410
 
                        newCurrent = i;
411
 
                        i = getNext( i );
412
 
                        num--;
413
 
                }
414
 
                
415
 
                if( newCurrent ) {
416
 
                        setCurrentKrViewItem( newCurrent );
417
 
                        slotMakeCurrentVisible();
418
 
                }
419
 
                if ( e->modifiers() & Qt::ShiftModifier )
420
 
                        op()->emitSelectionChanged();
421
 
                break;
422
 
        }
423
 
        case Qt::Key_Left :
424
 
        {
425
 
                if ( e->modifiers() == Qt::ControlModifier ) { // let the panel handle it
426
 
                        e->ignore();
427
 
                        break;
428
 
                }
429
 
                KrViewItem *i = getCurrentKrViewItem();
430
 
                KrViewItem *newCurrent = i;
431
 
                
432
 
                if ( !i )
433
 
                        break;
434
 
                
435
 
                int num = itemsPerPage() + 1;
436
 
                
437
 
                if ( e->modifiers() & Qt::ShiftModifier ) i->setSelected( !i->isSelected() );
438
 
                
439
 
                while( i && num > 0 )
440
 
                {
441
 
                        if ( e->modifiers() & Qt::ShiftModifier ) i->setSelected( !i->isSelected() );
442
 
                        newCurrent = i;
443
 
                        i = getPrev( i );
444
 
                        num--;
445
 
                }
446
 
                
447
 
                if( newCurrent ) {
448
 
                        setCurrentKrViewItem( newCurrent );
449
 
                        slotMakeCurrentVisible();
450
 
                }
451
 
                if ( e->modifiers() & Qt::ShiftModifier )
452
 
                        op()->emitSelectionChanged();
453
 
                break;
454
 
        }
455
 
        default:
456
 
                QAbstractItemView::keyPressEvent( e );
457
 
        }
458
 
}
459
 
 
460
 
void KrInterBriefView::mousePressEvent ( QMouseEvent * ev )
461
 
{
462
 
        if( !_mouseHandler->mousePressEvent( ev ) )
463
 
                QAbstractItemView::mousePressEvent( ev );
464
 
}
465
 
 
466
 
void KrInterBriefView::mouseReleaseEvent ( QMouseEvent * ev )
467
 
{
468
 
        if( !_mouseHandler->mouseReleaseEvent( ev ) )
469
 
                QAbstractItemView::mouseReleaseEvent( ev );
470
 
}
471
 
 
472
 
void KrInterBriefView::mouseDoubleClickEvent ( QMouseEvent *ev )
473
 
{
474
 
        if( !_mouseHandler->mouseDoubleClickEvent( ev ) )
475
 
                QAbstractItemView::mouseDoubleClickEvent( ev );
476
 
}
477
 
 
478
 
void KrInterBriefView::mouseMoveEvent ( QMouseEvent * ev )
479
 
{
480
 
        if( !_mouseHandler->mouseMoveEvent( ev ) )
481
 
                QAbstractItemView::mouseMoveEvent( ev );
482
 
}
483
 
 
484
 
void KrInterBriefView::wheelEvent ( QWheelEvent *ev )
485
 
{
486
 
        if( !_mouseHandler->wheelEvent( ev ) )
487
 
                QAbstractItemView::wheelEvent( ev );
488
 
}
489
 
 
490
 
void KrInterBriefView::dragEnterEvent ( QDragEnterEvent *ev )
491
 
{
492
 
        if( !_mouseHandler->dragEnterEvent( ev ) )
493
 
                QAbstractItemView::dragEnterEvent( ev );
494
 
}
495
 
 
496
 
void KrInterBriefView::dragMoveEvent ( QDragMoveEvent *ev )
497
 
{
498
 
        QAbstractItemView::dragMoveEvent( ev );
499
 
        _mouseHandler->dragMoveEvent( ev );
500
 
}
501
 
 
502
 
void KrInterBriefView::dragLeaveEvent ( QDragLeaveEvent *ev )
503
 
{
504
 
        if( !_mouseHandler->dragLeaveEvent( ev ) )
505
 
                QAbstractItemView::dragLeaveEvent( ev );
506
 
}
507
 
 
508
 
void KrInterBriefView::dropEvent ( QDropEvent *ev )
509
 
{
510
 
        if( !_mouseHandler->dropEvent( ev ) )
511
 
                QAbstractItemView::dropEvent( ev );
512
 
}
513
 
 
514
 
bool KrInterBriefView::event( QEvent * e )
515
 
{
516
 
        _mouseHandler->otherEvent( e );
517
 
        return QAbstractItemView::event( e );
518
 
}
519
 
 
520
 
KrInterBriefViewItem * KrInterBriefView::getKrInterViewItem( const QModelIndex & ndx )
521
 
{
522
 
        if( !ndx.isValid() )
523
 
                return 0;
524
 
        vfile * vf = _model->vfileAt( ndx );
525
 
        if( vf == 0 )
526
 
                return 0;
527
 
        QHash<vfile *,KrInterBriefViewItem*>::iterator it = _itemHash.find( vf );
528
 
        if( it == _itemHash.end() ) {
529
 
                KrInterBriefViewItem * newItem =  new KrInterBriefViewItem( this, vf );
530
 
                _itemHash[ vf ] = newItem;
531
 
                _dict.insert( vf->vfile_getName(), newItem );
532
 
                return newItem;
533
 
        }
534
 
        return *it;
535
 
}
536
 
 
537
 
void KrInterBriefView::selectRegion( KrViewItem *i1, KrViewItem *i2, bool select)
538
 
{
539
 
        vfile* vf1 = (vfile *)i1->getVfile();
540
 
        QModelIndex mi1 = _model->vfileIndex( vf1 );
541
 
        vfile* vf2 = (vfile *)i2->getVfile();
542
 
        QModelIndex mi2 = _model->vfileIndex( vf2 );
543
 
        
544
 
        if( mi1.isValid() && mi2.isValid() )
545
 
        {
546
 
                int r1 = mi1.row();
547
 
                int r2 = mi2.row();
548
 
                
549
 
                if( r1 > r2 ) {
550
 
                        int t = r1;
551
 
                        r1 = r2;
552
 
                        r2 = t;
553
 
                }
554
 
                
555
 
                for( int row = r1; row <= r2; row++ )
556
 
                {
557
 
                        const QModelIndex & ndx = _model->index( row, 0 );
558
 
                        selectionModel()->select( ndx, ( select ? QItemSelectionModel::Select : QItemSelectionModel::Deselect )
559
 
                        | QItemSelectionModel::Rows );
560
 
                }
561
 
        }
562
 
        else if( mi1.isValid() && !mi2.isValid() )
563
 
                i1->setSelected( select );
564
 
        else if( mi2.isValid() && !mi1.isValid() )
565
 
                i2->setSelected( select );
566
 
}
567
 
 
568
 
void KrInterBriefView::renameCurrentItem() {
569
 
        QModelIndex cIndex = currentIndex();
570
 
        QModelIndex nameIndex = _model->index( cIndex.row(), KrVfsModel::Name );
571
 
        edit( nameIndex );
572
 
        updateEditorData();
573
 
        update( nameIndex );
 
400
    _operator = new KrViewOperator(this, this);
 
401
    // klistview emits selection changed, so chain them to operator
 
402
    connect(selectionModel(), SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)), _operator, SLOT(emitSelectionChanged()));
 
403
}
 
404
 
 
405
void KrInterBriefView::keyPressEvent(QKeyEvent *e)
 
406
{
 
407
    if (!e || !_model->ready())
 
408
        return ; // subclass bug
 
409
    if ((e->key() != Qt::Key_Left && e->key() != Qt::Key_Right) &&
 
410
            (handleKeyEvent(e)))      // did the view class handled the event?
 
411
        return;
 
412
    switch (e->key()) {
 
413
    case Qt::Key_Right : {
 
414
        if (e->modifiers() == Qt::ControlModifier) {   // let the panel handle it
 
415
            e->ignore();
 
416
            break;
 
417
        }
 
418
        KrViewItem *i = getCurrentKrViewItem();
 
419
        KrViewItem *newCurrent = i;
 
420
 
 
421
        if (!i)
 
422
            break;
 
423
 
 
424
        int num = itemsPerPage() + 1;
 
425
 
 
426
        if (e->modifiers() & Qt::ShiftModifier) i->setSelected(!i->isSelected());
 
427
 
 
428
        while (i && num > 0) {
 
429
            if (e->modifiers() & Qt::ShiftModifier) i->setSelected(!i->isSelected());
 
430
            newCurrent = i;
 
431
            i = getNext(i);
 
432
            num--;
 
433
        }
 
434
 
 
435
        if (newCurrent) {
 
436
            setCurrentKrViewItem(newCurrent);
 
437
            slotMakeCurrentVisible();
 
438
        }
 
439
        if (e->modifiers() & Qt::ShiftModifier)
 
440
            op()->emitSelectionChanged();
 
441
        break;
 
442
    }
 
443
    case Qt::Key_Left : {
 
444
        if (e->modifiers() == Qt::ControlModifier) {   // let the panel handle it
 
445
            e->ignore();
 
446
            break;
 
447
        }
 
448
        KrViewItem *i = getCurrentKrViewItem();
 
449
        KrViewItem *newCurrent = i;
 
450
 
 
451
        if (!i)
 
452
            break;
 
453
 
 
454
        int num = itemsPerPage() + 1;
 
455
 
 
456
        if (e->modifiers() & Qt::ShiftModifier) i->setSelected(!i->isSelected());
 
457
 
 
458
        while (i && num > 0) {
 
459
            if (e->modifiers() & Qt::ShiftModifier) i->setSelected(!i->isSelected());
 
460
            newCurrent = i;
 
461
            i = getPrev(i);
 
462
            num--;
 
463
        }
 
464
 
 
465
        if (newCurrent) {
 
466
            setCurrentKrViewItem(newCurrent);
 
467
            slotMakeCurrentVisible();
 
468
        }
 
469
        if (e->modifiers() & Qt::ShiftModifier)
 
470
            op()->emitSelectionChanged();
 
471
        break;
 
472
    }
 
473
    default:
 
474
        QAbstractItemView::keyPressEvent(e);
 
475
    }
 
476
}
 
477
 
 
478
void KrInterBriefView::mousePressEvent(QMouseEvent * ev)
 
479
{
 
480
    if (!_mouseHandler->mousePressEvent(ev))
 
481
        QAbstractItemView::mousePressEvent(ev);
 
482
}
 
483
 
 
484
void KrInterBriefView::mouseReleaseEvent(QMouseEvent * ev)
 
485
{
 
486
    if (!_mouseHandler->mouseReleaseEvent(ev))
 
487
        QAbstractItemView::mouseReleaseEvent(ev);
 
488
}
 
489
 
 
490
void KrInterBriefView::mouseDoubleClickEvent(QMouseEvent *ev)
 
491
{
 
492
    if (!_mouseHandler->mouseDoubleClickEvent(ev))
 
493
        QAbstractItemView::mouseDoubleClickEvent(ev);
 
494
}
 
495
 
 
496
void KrInterBriefView::mouseMoveEvent(QMouseEvent * ev)
 
497
{
 
498
    if (!_mouseHandler->mouseMoveEvent(ev))
 
499
        QAbstractItemView::mouseMoveEvent(ev);
 
500
}
 
501
 
 
502
void KrInterBriefView::wheelEvent(QWheelEvent *ev)
 
503
{
 
504
    if (!_mouseHandler->wheelEvent(ev))
 
505
        QAbstractItemView::wheelEvent(ev);
 
506
}
 
507
 
 
508
void KrInterBriefView::dragEnterEvent(QDragEnterEvent *ev)
 
509
{
 
510
    if (!_mouseHandler->dragEnterEvent(ev))
 
511
        QAbstractItemView::dragEnterEvent(ev);
 
512
}
 
513
 
 
514
void KrInterBriefView::dragMoveEvent(QDragMoveEvent *ev)
 
515
{
 
516
    QAbstractItemView::dragMoveEvent(ev);
 
517
    _mouseHandler->dragMoveEvent(ev);
 
518
}
 
519
 
 
520
void KrInterBriefView::dragLeaveEvent(QDragLeaveEvent *ev)
 
521
{
 
522
    if (!_mouseHandler->dragLeaveEvent(ev))
 
523
        QAbstractItemView::dragLeaveEvent(ev);
 
524
}
 
525
 
 
526
void KrInterBriefView::dropEvent(QDropEvent *ev)
 
527
{
 
528
    if (!_mouseHandler->dropEvent(ev))
 
529
        QAbstractItemView::dropEvent(ev);
 
530
}
 
531
 
 
532
bool KrInterBriefView::event(QEvent * e)
 
533
{
 
534
    _mouseHandler->otherEvent(e);
 
535
    return QAbstractItemView::event(e);
 
536
}
 
537
 
 
538
KrInterBriefViewItem * KrInterBriefView::getKrInterViewItem(const QModelIndex & ndx)
 
539
{
 
540
    if (!ndx.isValid())
 
541
        return 0;
 
542
    vfile * vf = _model->vfileAt(ndx);
 
543
    if (vf == 0)
 
544
        return 0;
 
545
    QHash<vfile *, KrInterBriefViewItem*>::iterator it = _itemHash.find(vf);
 
546
    if (it == _itemHash.end()) {
 
547
        KrInterBriefViewItem * newItem =  new KrInterBriefViewItem(this, vf);
 
548
        _itemHash[ vf ] = newItem;
 
549
        _dict.insert(vf->vfile_getName(), newItem);
 
550
        return newItem;
 
551
    }
 
552
    return *it;
 
553
}
 
554
 
 
555
void KrInterBriefView::selectRegion(KrViewItem *i1, KrViewItem *i2, bool select)
 
556
{
 
557
    vfile* vf1 = (vfile *)i1->getVfile();
 
558
    QModelIndex mi1 = _model->vfileIndex(vf1);
 
559
    vfile* vf2 = (vfile *)i2->getVfile();
 
560
    QModelIndex mi2 = _model->vfileIndex(vf2);
 
561
 
 
562
    if (mi1.isValid() && mi2.isValid()) {
 
563
        int r1 = mi1.row();
 
564
        int r2 = mi2.row();
 
565
 
 
566
        if (r1 > r2) {
 
567
            int t = r1;
 
568
            r1 = r2;
 
569
            r2 = t;
 
570
        }
 
571
 
 
572
        for (int row = r1; row <= r2; row++) {
 
573
            const QModelIndex & ndx = _model->index(row, 0);
 
574
            selectionModel()->select(ndx, (select ? QItemSelectionModel::Select : QItemSelectionModel::Deselect)
 
575
                                     | QItemSelectionModel::Rows);
 
576
        }
 
577
    } else if (mi1.isValid() && !mi2.isValid())
 
578
        i1->setSelected(select);
 
579
    else if (mi2.isValid() && !mi1.isValid())
 
580
        i2->setSelected(select);
 
581
}
 
582
 
 
583
void KrInterBriefView::renameCurrentItem()
 
584
{
 
585
    QModelIndex cIndex = currentIndex();
 
586
    QModelIndex nameIndex = _model->index(cIndex.row(), KrVfsModel::Name);
 
587
    edit(nameIndex);
 
588
    updateEditorData();
 
589
    update(nameIndex);
574
590
}
575
591
 
576
592
bool KrInterBriefView::eventFilter(QObject *object, QEvent *event)
577
593
{
578
 
        if( object == _header )
579
 
        {
580
 
                if( event->type() == QEvent::ContextMenu )
581
 
                {
582
 
                        QContextMenuEvent *me = (QContextMenuEvent *)event;
583
 
                        showContextMenu( me->globalPos() );
584
 
                        return true;
585
 
                }
586
 
        }
587
 
        return false;
588
 
}
589
 
 
590
 
void KrInterBriefView::showContextMenu( const QPoint & p )
591
 
{
592
 
        KMenu popup( this );
593
 
        popup.setTitle( i18n("Columns"));
594
 
        
595
 
        int COL_ID = 14700;
596
 
        
597
 
        for( int i=1; i <= MAX_BRIEF_COLS; i++ )
598
 
        {
599
 
                QAction *act = popup.addAction( QString( "%1" ).arg( i ) );
600
 
                act->setData( QVariant( COL_ID + i ) );
601
 
                act->setCheckable( true );
602
 
                act->setChecked( properties()->numberOfColumns == i );
603
 
        }
604
 
        
605
 
        QAction * res = popup.exec( p );
606
 
        int result= -1;
607
 
        if( res && res->data().canConvert<int>() )
608
 
                result = res->data().toInt();
609
 
        
610
 
        KConfigGroup group( krConfig, nameInKConfig() );
611
 
        
612
 
        if( result > COL_ID && result <= COL_ID + MAX_BRIEF_COLS )
613
 
        {
614
 
                group.writeEntry( "Number Of Brief Columns", result - COL_ID );
615
 
                _properties->numberOfColumns = result - COL_ID;
616
 
                _numOfColumns = result - COL_ID;
617
 
                updateGeometries();
618
 
        }
619
 
}
620
 
 
621
 
bool KrInterBriefView::viewportEvent ( QEvent * event )
622
 
{
623
 
        if( event->type() == QEvent::ToolTip )
624
 
        {
625
 
                QHelpEvent *he = static_cast<QHelpEvent*>(event);
626
 
                const QModelIndex index = indexAt(he->pos());
627
 
                
628
 
                if( index.isValid() )
629
 
                {
630
 
                        int width = visualRect( index ).width();
631
 
                        int textWidth = elementWidth( index );
632
 
                        
633
 
                        if( textWidth <= width )
634
 
                        {
635
 
                                event->accept();
636
 
                                return true;
637
 
                        }
638
 
                }
639
 
        }
640
 
        return QAbstractItemView::viewportEvent( event );
 
594
    if (object == _header) {
 
595
        if (event->type() == QEvent::ContextMenu) {
 
596
            QContextMenuEvent *me = (QContextMenuEvent *)event;
 
597
            showContextMenu(me->globalPos());
 
598
            return true;
 
599
        }
 
600
    }
 
601
    return false;
 
602
}
 
603
 
 
604
void KrInterBriefView::showContextMenu(const QPoint & p)
 
605
{
 
606
    KMenu popup(this);
 
607
    popup.setTitle(i18n("Columns"));
 
608
 
 
609
    int COL_ID = 14700;
 
610
 
 
611
    for (int i = 1; i <= MAX_BRIEF_COLS; i++) {
 
612
        QAction *act = popup.addAction(QString("%1").arg(i));
 
613
        act->setData(QVariant(COL_ID + i));
 
614
        act->setCheckable(true);
 
615
        act->setChecked(properties()->numberOfColumns == i);
 
616
    }
 
617
 
 
618
    QAction * res = popup.exec(p);
 
619
    int result = -1;
 
620
    if (res && res->data().canConvert<int>())
 
621
        result = res->data().toInt();
 
622
 
 
623
    KConfigGroup group(krConfig, nameInKConfig());
 
624
 
 
625
    if (result > COL_ID && result <= COL_ID + MAX_BRIEF_COLS) {
 
626
        group.writeEntry("Number Of Brief Columns", result - COL_ID);
 
627
        _properties->numberOfColumns = result - COL_ID;
 
628
        _numOfColumns = result - COL_ID;
 
629
        updateGeometries();
 
630
    }
 
631
}
 
632
 
 
633
bool KrInterBriefView::viewportEvent(QEvent * event)
 
634
{
 
635
    if (event->type() == QEvent::ToolTip) {
 
636
        QHelpEvent *he = static_cast<QHelpEvent*>(event);
 
637
        const QModelIndex index = indexAt(he->pos());
 
638
 
 
639
        if (index.isValid()) {
 
640
            int width = visualRect(index).width();
 
641
            int textWidth = elementWidth(index);
 
642
 
 
643
            if (textWidth <= width) {
 
644
                event->accept();
 
645
                return true;
 
646
            }
 
647
        }
 
648
    }
 
649
    return QAbstractItemView::viewportEvent(event);
641
650
}
642
651
 
643
652
 
644
653
QRect KrInterBriefView::visualRect(const QModelIndex&ndx) const
645
654
{
646
 
        int width = (viewport()->width())/_numOfColumns;
647
 
        if( (viewport()->width())%_numOfColumns )
648
 
                width++;
649
 
        int height = getItemHeight();
650
 
        int numRows = viewport()->height() / height;
651
 
        if( numRows == 0 )
652
 
                numRows++;
653
 
        int x = width * (ndx.row()/numRows);
654
 
        int y = height * (ndx.row() % numRows );
655
 
        return mapToViewport(QRect( x, y, width, height ));
 
655
    int width = (viewport()->width()) / _numOfColumns;
 
656
    if ((viewport()->width()) % _numOfColumns)
 
657
        width++;
 
658
    int height = getItemHeight();
 
659
    int numRows = viewport()->height() / height;
 
660
    if (numRows == 0)
 
661
        numRows++;
 
662
    int x = width * (ndx.row() / numRows);
 
663
    int y = height * (ndx.row() % numRows);
 
664
    return mapToViewport(QRect(x, y, width, height));
656
665
}
657
666
 
658
667
void KrInterBriefView::scrollTo(const QModelIndex &ndx, QAbstractItemView::ScrollHint hint)
659
668
{
660
 
        const QRect rect = visualRect( ndx );
661
 
        if (hint == EnsureVisible && viewport()->rect().contains(rect)) {
662
 
                setDirtyRegion(rect);
663
 
                return;
664
 
        }
665
 
        
666
 
        const QRect area = viewport()->rect();
667
 
        
668
 
        const bool leftOf = rect.left() < area.left();
669
 
        const bool rightOf = rect.right() > area.right();
670
 
        
671
 
        int horizontalValue = horizontalScrollBar()->value();
672
 
        
673
 
        if (leftOf)
674
 
                horizontalValue -= area.left() - rect.left();
675
 
        else if (rightOf)
676
 
                horizontalValue += rect.right() - area.right();
677
 
        
678
 
        horizontalScrollBar()->setValue( horizontalValue );
 
669
    const QRect rect = visualRect(ndx);
 
670
    if (hint == EnsureVisible && viewport()->rect().contains(rect)) {
 
671
        setDirtyRegion(rect);
 
672
        return;
 
673
    }
 
674
 
 
675
    const QRect area = viewport()->rect();
 
676
 
 
677
    const bool leftOf = rect.left() < area.left();
 
678
    const bool rightOf = rect.right() > area.right();
 
679
 
 
680
    int horizontalValue = horizontalScrollBar()->value();
 
681
 
 
682
    if (leftOf)
 
683
        horizontalValue -= area.left() - rect.left();
 
684
    else if (rightOf)
 
685
        horizontalValue += rect.right() - area.right();
 
686
 
 
687
    horizontalScrollBar()->setValue(horizontalValue);
679
688
}
680
689
 
681
690
QModelIndex KrInterBriefView::indexAt(const QPoint& p) const
682
691
{
683
 
        int x = p.x() + horizontalOffset();
684
 
        int y = p.y() + verticalOffset();
685
 
        
686
 
        int width = (viewport()->width())/_numOfColumns;
687
 
        if( (viewport()->width())%_numOfColumns )
688
 
                width++;
689
 
        int height = getItemHeight();
690
 
        int numRows = viewport()->height() / height;
691
 
        if( numRows == 0 )
692
 
                numRows++;
693
 
        int ys = y / height;
694
 
        int xs = (x / width) * numRows;
695
 
        
696
 
        return _model->index( xs + ys, 0 );
 
692
    int x = p.x() + horizontalOffset();
 
693
    int y = p.y() + verticalOffset();
 
694
 
 
695
    int width = (viewport()->width()) / _numOfColumns;
 
696
    if ((viewport()->width()) % _numOfColumns)
 
697
        width++;
 
698
    int height = getItemHeight();
 
699
    int numRows = viewport()->height() / height;
 
700
    if (numRows == 0)
 
701
        numRows++;
 
702
    int ys = y / height;
 
703
    int xs = (x / width) * numRows;
 
704
 
 
705
    return _model->index(xs + ys, 0);
697
706
}
698
707
 
699
708
QModelIndex KrInterBriefView::moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers)
700
709
{
701
 
        if( _model->rowCount() == 0 )
702
 
                return QModelIndex();
703
 
        
704
 
        QModelIndex current = currentIndex();
705
 
        if (!current.isValid())
706
 
                return _model->index( 0, 0 );
707
 
        
708
 
        switch (cursorAction) {
709
 
        case MoveLeft:
710
 
        case MovePageDown:
711
 
        {
712
 
                int newRow = current.row() - itemsPerPage();
713
 
                if( newRow < 0 )
714
 
                        newRow = 0;
715
 
                return _model->index( newRow, 0 );
716
 
        }
717
 
        case MoveRight:
718
 
        case MovePageUp:
719
 
        {
720
 
                int newRow = current.row() + itemsPerPage();
721
 
                if( newRow >= _model->rowCount() )
722
 
                        newRow = _model->rowCount() - 1;
723
 
                return _model->index( newRow, 0 );
724
 
        }
725
 
        case MovePrevious:
726
 
        case MoveUp:
727
 
        {
728
 
                int newRow = current.row() - 1;
729
 
                if( newRow < 0 )
730
 
                        newRow = 0;
731
 
                return _model->index( newRow, 0 );
732
 
        }
733
 
        case MoveNext:
734
 
        case MoveDown:
735
 
        {
736
 
                int newRow = current.row() + 1;
737
 
                if( newRow >= _model->rowCount() )
738
 
                        newRow = _model->rowCount() - 1;
739
 
                return _model->index( newRow, 0 );
740
 
        }
741
 
        case MoveHome:
742
 
                return _model->index(0, 0);
743
 
        case MoveEnd:
744
 
                return _model->index(_model->rowCount() - 1, 0);
745
 
        }
746
 
        
747
 
        return current;
 
710
    if (_model->rowCount() == 0)
 
711
        return QModelIndex();
 
712
 
 
713
    QModelIndex current = currentIndex();
 
714
    if (!current.isValid())
 
715
        return _model->index(0, 0);
 
716
 
 
717
    switch (cursorAction) {
 
718
    case MoveLeft:
 
719
    case MovePageDown: {
 
720
        int newRow = current.row() - itemsPerPage();
 
721
        if (newRow < 0)
 
722
            newRow = 0;
 
723
        return _model->index(newRow, 0);
 
724
    }
 
725
    case MoveRight:
 
726
    case MovePageUp: {
 
727
        int newRow = current.row() + itemsPerPage();
 
728
        if (newRow >= _model->rowCount())
 
729
            newRow = _model->rowCount() - 1;
 
730
        return _model->index(newRow, 0);
 
731
    }
 
732
    case MovePrevious:
 
733
    case MoveUp: {
 
734
        int newRow = current.row() - 1;
 
735
        if (newRow < 0)
 
736
            newRow = 0;
 
737
        return _model->index(newRow, 0);
 
738
    }
 
739
    case MoveNext:
 
740
    case MoveDown: {
 
741
        int newRow = current.row() + 1;
 
742
        if (newRow >= _model->rowCount())
 
743
            newRow = _model->rowCount() - 1;
 
744
        return _model->index(newRow, 0);
 
745
    }
 
746
    case MoveHome:
 
747
        return _model->index(0, 0);
 
748
    case MoveEnd:
 
749
        return _model->index(_model->rowCount() - 1, 0);
 
750
    }
 
751
 
 
752
    return current;
748
753
}
749
754
 
750
755
int KrInterBriefView::horizontalOffset() const
751
756
{
752
 
        return horizontalScrollBar()->value();
 
757
    return horizontalScrollBar()->value();
753
758
}
754
759
 
755
760
int KrInterBriefView::verticalOffset() const
756
761
{
757
 
        return 0;
 
762
    return 0;
758
763
}
759
764
 
760
765
bool KrInterBriefView::isIndexHidden(const QModelIndex&ndx) const
761
766
{
762
 
        return ndx.column() != 0;
 
767
    return ndx.column() != 0;
763
768
}
764
769
 
765
770
void KrInterBriefView::setSelection(const QRect&, QFlags<QItemSelectionModel::SelectionFlag>)
766
771
{
767
 
        /* Don't do anything, selections are handled by the mouse handler and not by QAbstractItemView */
 
772
    /* Don't do anything, selections are handled by the mouse handler and not by QAbstractItemView */
768
773
}
769
774
 
770
775
QRegion KrInterBriefView::visualRegionForSelection(const QItemSelection &selection) const
771
776
{
772
 
        if (selection.isEmpty())
773
 
                return QRegion();
774
 
        
775
 
        QRegion selectionRegion;
776
 
        for (int i = 0; i < selection.count(); ++i) {
777
 
                QItemSelectionRange range = selection.at(i);
778
 
                if (!range.isValid())
779
 
                        continue;
780
 
                QModelIndex leftIndex = range.topLeft();
781
 
                if (!leftIndex.isValid())
782
 
                        continue;
783
 
                const QRect leftRect = visualRect(leftIndex);
784
 
                int top = leftRect.top();
785
 
                QModelIndex rightIndex = range.bottomRight();
786
 
                if (!rightIndex.isValid())
787
 
                        continue;
788
 
                const QRect rightRect = visualRect(rightIndex);
789
 
                int bottom = rightRect.bottom();
790
 
                if (top > bottom)
791
 
                        qSwap<int>(top, bottom);
792
 
                int height = bottom - top + 1;
793
 
                QRect combined = leftRect|rightRect;
794
 
                combined.setX(range.left());
795
 
                selectionRegion += combined;
796
 
        }
797
 
        return selectionRegion;
 
777
    if (selection.isEmpty())
 
778
        return QRegion();
 
779
 
 
780
    QRegion selectionRegion;
 
781
    for (int i = 0; i < selection.count(); ++i) {
 
782
        QItemSelectionRange range = selection.at(i);
 
783
        if (!range.isValid())
 
784
            continue;
 
785
        QModelIndex leftIndex = range.topLeft();
 
786
        if (!leftIndex.isValid())
 
787
            continue;
 
788
        const QRect leftRect = visualRect(leftIndex);
 
789
        int top = leftRect.top();
 
790
        QModelIndex rightIndex = range.bottomRight();
 
791
        if (!rightIndex.isValid())
 
792
            continue;
 
793
        const QRect rightRect = visualRect(rightIndex);
 
794
        int bottom = rightRect.bottom();
 
795
        if (top > bottom)
 
796
            qSwap<int>(top, bottom);
 
797
        int height = bottom - top + 1;
 
798
        QRect combined = leftRect | rightRect;
 
799
        combined.setX(range.left());
 
800
        selectionRegion += combined;
 
801
    }
 
802
    return selectionRegion;
798
803
}
799
804
 
800
805
void KrInterBriefView::paintEvent(QPaintEvent *e)
801
806
{
802
 
        QStyleOptionViewItemV4 option = viewOptions();
803
 
        option.widget = this;
804
 
        option.decorationSize = QSize( _fileIconSize, _fileIconSize );
805
 
        option.decorationPosition = QStyleOptionViewItem::Left;
806
 
        QPainter painter( viewport() );
807
 
        
808
 
        QModelIndex curr = currentIndex();
809
 
 
810
 
        QVector<QModelIndex> intersectVector;
811
 
        QRect area = e->rect();
812
 
        area.adjust( horizontalOffset(), verticalOffset(), horizontalOffset(), verticalOffset() );
813
 
        intersectionSet( area, intersectVector );
814
 
        
815
 
        foreach( QModelIndex mndx, intersectVector )
816
 
        {
817
 
                option.state = QStyle::State_None;
818
 
                option.rect = visualRect( mndx );
819
 
                painter.save();
820
 
                
821
 
                bool focus = curr.isValid() && curr.row() == mndx.row() && hasFocus();
822
 
                
823
 
                itemDelegate()->paint(&painter, option, mndx );
824
 
                
825
 
                if( focus ) {
826
 
                        QStyleOptionFocusRect o;
827
 
                        o.QStyleOption::operator=(option);
828
 
                        QPalette::ColorGroup cg = QPalette::Normal;
829
 
                        o.backgroundColor = option.palette.color(cg, QPalette::Background);
830
 
                        style()->drawPrimitive(QStyle::PE_FrameFocusRect, &o, &painter);
831
 
                }
832
 
                
833
 
                painter.restore();
834
 
        }
 
807
    QStyleOptionViewItemV4 option = viewOptions();
 
808
    option.widget = this;
 
809
    option.decorationSize = QSize(_fileIconSize, _fileIconSize);
 
810
    option.decorationPosition = QStyleOptionViewItem::Left;
 
811
    QPainter painter(viewport());
 
812
 
 
813
    QModelIndex curr = currentIndex();
 
814
 
 
815
    QVector<QModelIndex> intersectVector;
 
816
    QRect area = e->rect();
 
817
    area.adjust(horizontalOffset(), verticalOffset(), horizontalOffset(), verticalOffset());
 
818
    intersectionSet(area, intersectVector);
 
819
 
 
820
    foreach(const QModelIndex &mndx, intersectVector) {
 
821
        option.state = QStyle::State_None;
 
822
        option.rect = visualRect(mndx);
 
823
        painter.save();
 
824
 
 
825
        bool focus = curr.isValid() && curr.row() == mndx.row() && hasFocus();
 
826
 
 
827
        itemDelegate()->paint(&painter, option, mndx);
 
828
 
 
829
        if (focus) {
 
830
            QStyleOptionFocusRect o;
 
831
            o.QStyleOption::operator=(option);
 
832
            QPalette::ColorGroup cg = QPalette::Normal;
 
833
            o.backgroundColor = option.palette.color(cg, QPalette::Background);
 
834
            style()->drawPrimitive(QStyle::PE_FrameFocusRect, &o, &painter);
 
835
        }
 
836
 
 
837
        painter.restore();
 
838
    }
835
839
}
836
840
 
837
 
int KrInterBriefView::getItemHeight() const {
838
 
        int textHeight = QFontMetrics( _viewFont ).height();
839
 
        int height = textHeight;
840
 
        int iconSize = 0;
841
 
        if( properties()->displayIcons )
842
 
                iconSize = _fileIconSize;
843
 
        if( iconSize > textHeight )
844
 
                height = iconSize;
845
 
        if( height == 0 )
846
 
                height++;
847
 
        return height;
 
841
int KrInterBriefView::getItemHeight() const
 
842
{
 
843
    int textHeight = QFontMetrics(_viewFont).height();
 
844
    int height = textHeight;
 
845
    int iconSize = 0;
 
846
    if (properties()->displayIcons)
 
847
        iconSize = _fileIconSize;
 
848
    if (iconSize > textHeight)
 
849
        height = iconSize;
 
850
    if (height == 0)
 
851
        height++;
 
852
    return height;
848
853
}
849
854
 
850
855
void KrInterBriefView::updateGeometries()
851
856
{
852
 
        if( _header )
853
 
        {
854
 
                QSize hint = _header->sizeHint();
855
 
                setViewportMargins(0, hint.height(), 0, 0);
856
 
                QRect vg = viewport()->geometry();
857
 
                QRect geometryRect(vg.left(), vg.top() - hint.height(), vg.width(), hint.height());
858
 
                _header->setGeometry(geometryRect);
859
 
                
860
 
                int items = 0;
861
 
                for( int i=0;  i!= _header->count(); i++ )
862
 
                        if( !_header->isSectionHidden( i ) )
863
 
                                items++;
864
 
                if( items == 0 )
865
 
                        items++;
866
 
                
867
 
                int sectWidth = viewport()->width() / items; 
868
 
                for( int i=0;  i!= _header->count(); i++ )
869
 
                        if( !_header->isSectionHidden( i ) )
870
 
                                _header->resizeSection( i, sectWidth );
871
 
                
872
 
                QMetaObject::invokeMethod(_header, "updateGeometries");
873
 
        }
874
 
        
875
 
        
876
 
        
877
 
        if (_model->rowCount() <= 0 )
878
 
                horizontalScrollBar()->setRange(0, 0);
879
 
        else
880
 
        {
881
 
                int itemsPerColumn = viewport()->height() / getItemHeight();
882
 
                if( itemsPerColumn <= 0 )
883
 
                        itemsPerColumn = 1;
884
 
                int columnWidth = (viewport()->width())/_numOfColumns;
885
 
                if( (viewport()->width())%_numOfColumns )
886
 
                        columnWidth++;
887
 
                int maxWidth = _model->rowCount() / itemsPerColumn;
888
 
                if( _model->rowCount() % itemsPerColumn )
889
 
                        maxWidth++;
890
 
                maxWidth *= columnWidth;
891
 
                if( maxWidth > viewport()->width() )
892
 
                {
893
 
                        horizontalScrollBar()->setSingleStep(columnWidth);
894
 
                        horizontalScrollBar()->setPageStep(columnWidth * _numOfColumns);
895
 
                        horizontalScrollBar()->setRange(0, maxWidth - viewport()->width());
896
 
                } else {
897
 
                        horizontalScrollBar()->setRange(0, 0);
898
 
                }
899
 
        }
900
 
 
901
 
        QAbstractItemView::updateGeometries();
 
857
    if (_header) {
 
858
        QSize hint = _header->sizeHint();
 
859
        setViewportMargins(0, hint.height(), 0, 0);
 
860
        QRect vg = viewport()->geometry();
 
861
        QRect geometryRect(vg.left(), vg.top() - hint.height(), vg.width(), hint.height());
 
862
        _header->setGeometry(geometryRect);
 
863
 
 
864
        int items = 0;
 
865
        for (int i = 0;  i != _header->count(); i++)
 
866
            if (!_header->isSectionHidden(i))
 
867
                items++;
 
868
        if (items == 0)
 
869
            items++;
 
870
 
 
871
        int sectWidth = viewport()->width() / items;
 
872
        for (int i = 0;  i != _header->count(); i++)
 
873
            if (!_header->isSectionHidden(i))
 
874
                _header->resizeSection(i, sectWidth);
 
875
 
 
876
        QMetaObject::invokeMethod(_header, "updateGeometries");
 
877
    }
 
878
 
 
879
 
 
880
 
 
881
    if (_model->rowCount() <= 0)
 
882
        horizontalScrollBar()->setRange(0, 0);
 
883
    else {
 
884
        int itemsPerColumn = viewport()->height() / getItemHeight();
 
885
        if (itemsPerColumn <= 0)
 
886
            itemsPerColumn = 1;
 
887
        int columnWidth = (viewport()->width()) / _numOfColumns;
 
888
        if ((viewport()->width()) % _numOfColumns)
 
889
            columnWidth++;
 
890
        int maxWidth = _model->rowCount() / itemsPerColumn;
 
891
        if (_model->rowCount() % itemsPerColumn)
 
892
            maxWidth++;
 
893
        maxWidth *= columnWidth;
 
894
        if (maxWidth > viewport()->width()) {
 
895
            horizontalScrollBar()->setSingleStep(columnWidth);
 
896
            horizontalScrollBar()->setPageStep(columnWidth * _numOfColumns);
 
897
            horizontalScrollBar()->setRange(0, maxWidth - viewport()->width());
 
898
        } else {
 
899
            horizontalScrollBar()->setRange(0, 0);
 
900
        }
 
901
    }
 
902
 
 
903
    QAbstractItemView::updateGeometries();
902
904
}
903
905
 
904
906
QRect KrInterBriefView::mapToViewport(const QRect &rect) const
917
919
 
918
920
void KrInterBriefView::setSortMode(KrViewProperties::SortSpec mode)
919
921
{
920
 
        Qt::SortOrder sortDir;
921
 
        int column = _model->convertSortOrderFromKrViewProperties( mode, sortDir );
922
 
        if( column == _model->getLastSortOrder() && sortDir == _model->getLastSortDir() )
923
 
                sortDir = (sortDir == Qt::AscendingOrder) ? Qt::DescendingOrder : Qt::AscendingOrder;
924
 
        
925
 
        _header->setSortIndicator(column, sortDir);
926
 
        _model->sort( column, sortDir );
927
 
}
928
 
 
929
 
int KrInterBriefView::elementWidth( const QModelIndex & index )
930
 
{
931
 
        QString text = index.data( Qt::DisplayRole ).toString();
932
 
        
933
 
        int textWidth = QFontMetrics( _viewFont ).width( text );
934
 
        
935
 
        const int textMargin = QApplication::style()->pixelMetric(QStyle::PM_FocusFrameHMargin) + 1;
936
 
        textWidth += 2 * textMargin;
937
 
        
938
 
        QVariant decor = index.data( Qt::DecorationRole );
939
 
        if( decor.isValid() && decor.type() == QVariant::Pixmap )
940
 
        {
941
 
                QPixmap p = decor.value<QPixmap>();
942
 
                textWidth += p.width() + 2 * textMargin;
943
 
        }
944
 
        
945
 
        return textWidth;
946
 
}
947
 
 
948
 
void KrInterBriefView::intersectionSet( const QRect &rect, QVector<QModelIndex> &ndxList )
949
 
{
950
 
        int maxNdx = _model->rowCount();
951
 
        int width = (viewport()->width())/_numOfColumns;
952
 
        if( (viewport()->width())%_numOfColumns )
953
 
                width++;
954
 
        
955
 
        int height = getItemHeight();
956
 
        int items = viewport()->height() / height;
957
 
        if( items == 0 )
958
 
                items++;
959
 
        
960
 
        int xmin = -1;
961
 
        int ymin = -1;
962
 
        int xmax = -1;
963
 
        int ymax = -1;
964
 
        
965
 
        xmin = rect.x() / width;
966
 
        ymin = rect.y() / height;
967
 
        xmax = ( rect.x() + rect.width() ) / width;
968
 
        if(( rect.x() + rect.width() ) % width )
969
 
                xmax++;
970
 
        ymax = ( rect.y() + rect.height() ) / height;
971
 
        if(( rect.y() + rect.height() ) % height )
972
 
                ymax++;
973
 
        
974
 
        for( int i=ymin; i < ymax; i++ )
975
 
                for( int j=xmin; j < xmax; j++ )
976
 
                {
977
 
                        int ndx = j * items + i;
978
 
                        if( ndx < maxNdx )
979
 
                                ndxList.append( _model->index( ndx, 0 ) );
980
 
                }
 
922
    Qt::SortOrder sortDir;
 
923
    int column = _model->convertSortOrderFromKrViewProperties(mode, sortDir);
 
924
    if (column == _model->getLastSortOrder() && sortDir == _model->getLastSortDir())
 
925
        sortDir = (sortDir == Qt::AscendingOrder) ? Qt::DescendingOrder : Qt::AscendingOrder;
 
926
 
 
927
    _header->setSortIndicator(column, sortDir);
 
928
    _model->sort(column, sortDir);
 
929
}
 
930
 
 
931
int KrInterBriefView::elementWidth(const QModelIndex & index)
 
932
{
 
933
    QString text = index.data(Qt::DisplayRole).toString();
 
934
 
 
935
    int textWidth = QFontMetrics(_viewFont).width(text);
 
936
 
 
937
    const int textMargin = QApplication::style()->pixelMetric(QStyle::PM_FocusFrameHMargin) + 1;
 
938
    textWidth += 2 * textMargin;
 
939
 
 
940
    QVariant decor = index.data(Qt::DecorationRole);
 
941
    if (decor.isValid() && decor.type() == QVariant::Pixmap) {
 
942
        QPixmap p = decor.value<QPixmap>();
 
943
        textWidth += p.width() + 2 * textMargin;
 
944
    }
 
945
 
 
946
    return textWidth;
 
947
}
 
948
 
 
949
void KrInterBriefView::intersectionSet(const QRect &rect, QVector<QModelIndex> &ndxList)
 
950
{
 
951
    int maxNdx = _model->rowCount();
 
952
    int width = (viewport()->width()) / _numOfColumns;
 
953
    if ((viewport()->width()) % _numOfColumns)
 
954
        width++;
 
955
 
 
956
    int height = getItemHeight();
 
957
    int items = viewport()->height() / height;
 
958
    if (items == 0)
 
959
        items++;
 
960
 
 
961
    int xmin = -1;
 
962
    int ymin = -1;
 
963
    int xmax = -1;
 
964
    int ymax = -1;
 
965
 
 
966
    xmin = rect.x() / width;
 
967
    ymin = rect.y() / height;
 
968
    xmax = (rect.x() + rect.width()) / width;
 
969
    if ((rect.x() + rect.width()) % width)
 
970
        xmax++;
 
971
    ymax = (rect.y() + rect.height()) / height;
 
972
    if ((rect.y() + rect.height()) % height)
 
973
        ymax++;
 
974
 
 
975
    for (int i = ymin; i < ymax; i++)
 
976
        for (int j = xmin; j < xmax; j++) {
 
977
            int ndx = j * items + i;
 
978
            if (ndx < maxNdx)
 
979
                ndxList.append(_model->index(ndx, 0));
 
980
        }
981
981
}