← Back to branch summary

~ubuntu-branches/ubuntu/wily/tupi/wily-proposed

« back to all changes in this revision

Viewing changes to src/components/exposure/ktexposuretable.cpp

  • Committer: Package Import Robot
  • Author(s): Dmitry Smirnov
  • Date: 2013-05-13 09:53:35 UTC
  • mfrom: (8.1.1 experimental)
  • Revision ID: package-import@ubuntu.com-20130513095335-3iqdvt9ne07ia25v
Tags: 0.2+git01-1
* Upload to unstable.
* Removed unnecessary versioned Build-Depends.
* Removed obsolete "DM-Upload-Allowed".
* Added Vcs links to collab-maint.
* Standards updated to version 3.9.4.
* Corrected "libavutil51"-->"libavutil-dev" in Build-Depends.
* Updated debian/watch (corrected URL, removed comments).
* Updated get-orig-source (can work from any directory).
* Updated my email address; bumped copyright years.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/components/exposure/ktexposuretable.cpp
1
 
/***************************************************************************
2
 
 *   Project TUPI: Magia 2D                                                *
3
 
 *   Project Contact: info@maefloresta.com                                 *
4
 
 *   Project Website: http://www.maefloresta.com                           *
5
 
 *   Project Leader: Gustav Gonzalez <info@maefloresta.com>                *
6
 
 *                                                                         *
7
 
 *   Developers:                                                           *
8
 
 *   2010:                                                                 *
9
 
 *    Gustavo Gonzalez / xtingray                                          *
10
 
 *                                                                         *
11
 
 *   KTooN's versions:                                                     * 
12
 
 *                                                                         *
13
 
 *   2006:                                                                 *
14
 
 *    David Cuadrado                                                       *
15
 
 *    Jorge Cuadrado                                                       *
16
 
 *   2003:                                                                 *
17
 
 *    Fernado Roldan                                                       *
18
 
 *    Simena Dinas                                                         *
19
 
 *                                                                         *
20
 
 *   Copyright (C) 2010 Gustav Gonzalez - http://www.maefloresta.com       *
21
 
 *   License:                                                              *
22
 
 *   This program is free software; you can redistribute it and/or modify  *
23
 
 *   it under the terms of the GNU General Public License as published by  *
24
 
 *   the Free Software Foundation; either version 3 of the License, or     *
25
 
 *   (at your option) any later version.                                   *
26
 
 *                                                                         *
27
 
 *   This program is distributed in the hope that it will be useful,       *
28
 
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
29
 
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
30
 
 *   GNU General Public License for more details.                          *
31
 
 *                                                                         *
32
 
 *   You should have received a copy of the GNU General Public License     *
33
 
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
34
 
 ***************************************************************************/
35
 
 
36
 
#include "ktexposuretable.h"
37
 
#include "ktexposureheader.h"
38
 
#include "tdebug.h"
39
 
#include "ktglobal.h"
40
 
 
41
 
#include <QPainter>
42
 
#include <QItemDelegate>
43
 
#include <QLineEdit>
44
 
#include <QMouseEvent>
45
 
#include <QMenu>
46
 
#include <QHeaderView>
47
 
 
48
 
/**
49
 
 * @author Jorge Cuadrado
50
 
 */
51
 
 
52
 
/////////////////
53
 
class KTExposureVerticalHeader : public QHeaderView
54
 
{
55
 
    //Q_OBJECT
56
 
 
57
 
    public:
58
 
        KTExposureVerticalHeader(QWidget * parent = 0);
59
 
        ~KTExposureVerticalHeader();
60
 
        void paintSection(QPainter *painter, const QRect & rect, int logicalIndex) const;
61
 
};
62
 
 
63
 
KTExposureVerticalHeader::KTExposureVerticalHeader(QWidget * parent) : QHeaderView(Qt::Vertical, parent)
64
 
{
65
 
    //setClickable(true);
66
 
    setFixedWidth(25);
67
 
}
68
 
 
69
 
KTExposureVerticalHeader::~KTExposureVerticalHeader()
70
 
{
71
 
}
72
 
 
73
 
void KTExposureVerticalHeader::paintSection(QPainter * painter, const QRect & rect, int logicalIndex) const
74
 
{
75
 
    Q_UNUSED(logicalIndex);
76
 
 
77
 
    if (!rect.isValid())
78
 
        return;
79
 
 
80
 
    QStyleOptionHeader headerOption;
81
 
    headerOption.rect = rect;
82
 
    headerOption.orientation = Qt::Vertical;
83
 
    headerOption.position = QStyleOptionHeader::Middle;
84
 
    headerOption.text = "";
85
 
 
86
 
    QStyle::State state = QStyle::State_None;
87
 
 
88
 
    if (isEnabled())
89
 
        state |= QStyle::State_Enabled;
90
 
 
91
 
    if (window()->isActiveWindow())
92
 
        state |= QStyle::State_Active;
93
 
 
94
 
    style()->drawControl(QStyle::CE_HeaderSection, &headerOption, painter);
95
 
 
96
 
    QString text;
97
 
    text = text.setNum(logicalIndex + 1);
98
 
    QFont font("Arial", 7, QFont::Normal, false);
99
 
    QFontMetrics fm(font);
100
 
 
101
 
    int x = rect.normalized().x() + ((rect.normalized().width() - fm.width(text))/2);
102
 
    int y = rect.normalized().bottomLeft().y() - (1 + (rect.normalized().height() - fm.height())/2);
103
 
 
104
 
    painter->setFont(font);
105
 
    painter->setPen(QPen(Qt::black, 1, Qt::SolidLine));
106
 
    painter->drawText(x, y, text);
107
 
}
108
 
 
109
 
/////////////////
110
 
 
111
 
class KTExposureItemDelegate : public QItemDelegate
112
 
{
113
 
    public:
114
 
        KTExposureItemDelegate(QObject * parent = 0);
115
 
        ~KTExposureItemDelegate();
116
 
        virtual void paint(QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index) const;
117
 
};
118
 
 
119
 
KTExposureItemDelegate::KTExposureItemDelegate(QObject * parent) :  QItemDelegate(parent)
120
 
{
121
 
}
122
 
 
123
 
KTExposureItemDelegate::~KTExposureItemDelegate()
124
 
{
125
 
}
126
 
 
127
 
void KTExposureItemDelegate::paint(QPainter *painter, const QStyleOptionViewItem & option, const QModelIndex & index) const
128
 
{
129
 
    QItemDelegate::paint(painter, option, index);
130
 
 
131
 
    KTExposureTable *table = qobject_cast<KTExposureTable *>(index.model()->parent());
132
 
 
133
 
    QTableWidgetItem *item = table->itemFromIndex(index);
134
 
 
135
 
    if (item) {
136
 
 
137
 
        /* Useful code
138
 
        if (item->data(KTExposureTable::IsLocked).toBool()) {
139
 
             QPixmap pixmap(THEME_DIR + "icons/padlock.png");
140
 
             painter->drawPixmap(1, 5, pixmap);
141
 
        } else 
142
 
        */
143
 
 
144
 
        int x = option.rect.topLeft().x() + 2;
145
 
        int y = option.rect.topLeft().y() + 2;
146
 
        int w = option.rect.bottomRight().x() - x - 2;
147
 
        int h = option.rect.bottomRight().y() - y - 2;
148
 
 
149
 
        if (item->data(KTExposureTable::IsLocked).toBool()) {
150
 
            painter->setPen(QColor(255, 255, 255, 200));
151
 
            painter->drawRect(x, y, w, h);
152
 
        }
153
 
 
154
 
        if ((item->data(KTExposureTable::IsEmpty).toInt() == KTExposureTable::Empty) && !item->data(KTExposureTable::IsLocked).toBool()) {
155
 
            QPen pen(QColor(100, 100, 100, 30));
156
 
            pen.setStyle(Qt::DashLine);
157
 
            painter->setPen(pen);
158
 
            painter->drawRect(x, y, w, h);
159
 
        }
160
 
 
161
 
        if ((item->data(KTExposureTable::IsEmpty).toInt() == KTExposureTable::Used) && !item->data(KTExposureTable::IsLocked).toBool()) {
162
 
            painter->setPen(QColor(0, 0, 0, 60));
163
 
            painter->drawRect(x, y, w, h);
164
 
        }
165
 
    }
166
 
}
167
 
 
168
 
////////////////////////
169
 
 
170
 
struct KTExposureTable::Private
171
 
{
172
 
    KTExposureHeader *header;
173
 
    QMenu *menu;
174
 
    bool removingLayer;
175
 
    bool removingFrame;
176
 
};
177
 
 
178
 
KTExposureTable::KTExposureTable(QWidget * parent) : QTableWidget(parent), k(new Private)
179
 
{
180
 
    KTExposureVerticalHeader *verticalHeader = new KTExposureVerticalHeader(this);
181
 
    setVerticalHeader(verticalHeader);
182
 
 
183
 
    setItemDelegate(new KTExposureItemDelegate(this));
184
 
    k->removingLayer = false;
185
 
    k->removingFrame = false;
186
 
 
187
 
    QTableWidgetItem *prototype = new QTableWidgetItem();
188
 
    prototype->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEditable);
189
 
    prototype->setTextAlignment(Qt::AlignCenter);
190
 
    prototype->setData(IsEmpty, Unset);
191
 
 
192
 
    setItemPrototype(prototype);
193
 
 
194
 
    setRowCount(100);
195
 
 
196
 
    for (int i=0; i < 100; i++)
197
 
         setRowHeight(i, 20);
198
 
 
199
 
    k->header = new KTExposureHeader(this);
200
 
 
201
 
    connect(k->header, SIGNAL(visibilityChanged(int, bool)), this, SIGNAL(requestChangeVisibilityLayer(int, bool)));
202
 
    connect(k->header, SIGNAL(changedName(int, const QString &)), this, SIGNAL(requestRenameLayer(int, 
203
 
                              const QString & )));
204
 
    connect(k->header, SIGNAL(sectionMoved(int, int, int)), this, SLOT(emitRequestMoveLayer(int, int, int)));
205
 
    connect(k->header, SIGNAL(selectionChanged(int)), this, SLOT(updateLayerSelection(int)));
206
 
 
207
 
    setHorizontalHeader(k->header);
208
 
 
209
 
    connect(this, SIGNAL(cellClicked(int, int)), this, SLOT(emitRequestSetUsedFrame(int, int)));
210
 
    connect(this, SIGNAL(currentCellChanged(int, int, int, int)), this, SLOT(emitRequestSelectFrame(int, int, int, int)));
211
 
 
212
 
    setSelectionBehavior(QAbstractItemView::SelectItems);
213
 
    setSelectionMode(QAbstractItemView::SingleSelection);
214
 
 
215
 
    k->menu = 0;
216
 
}
217
 
 
218
 
void KTExposureTable::emitRequestRenameFrame(QTableWidgetItem * item)
219
 
{
220
 
    QModelIndex  index = indexFromItem(item);
221
 
    emit requestRenameFrame(index.column(), index.row(), item->text());
222
 
}
223
 
 
224
 
void KTExposureTable::emitRequestSelectFrame(int currentSelectedRow, int currentColumn, int previousRow, int previousColumn)
225
 
{
226
 
    #ifdef K_DEBUG
227
 
           T_FUNCINFO;
228
 
    #endif
229
 
 
230
 
    if (!k->removingLayer) { 
231
 
 
232
 
        if (k->removingFrame) {
233
 
            k->removingFrame = false;
234
 
            if ((previousColumn != currentColumn) || (columnCount() == 1))
235
 
                 k->header->updateSelection(currentColumn);
236
 
            return;
237
 
        }
238
 
 
239
 
        if (previousRow != currentSelectedRow || previousColumn != currentColumn)
240
 
            emit requestSelectFrame(currentLayer(), currentRow());
241
 
 
242
 
        if ((previousColumn != currentColumn) || (columnCount() == 1))
243
 
             k->header->updateSelection(currentColumn);
244
 
 
245
 
    } else { // A layer is being removed
246
 
        k->removingLayer = false;
247
 
        selectFrame(currentColumn, currentSelectedRow);
248
 
 
249
 
        if (previousColumn == 0)
250
 
            k->header->updateSelection(0);
251
 
        else
252
 
            k->header->updateSelection(currentColumn);
253
 
    }
254
 
}
255
 
 
256
 
void KTExposureTable::emitRequestMoveLayer(int logicalIndex, int oldVisualIndex, int newVisualIndex)
257
 
{
258
 
    Q_UNUSED(logicalIndex);
259
 
 
260
 
    if (! k->header->signalMovedBlocked()) {
261
 
        k->header->moveLayer(newVisualIndex, oldVisualIndex);
262
 
        emit requestMoveLayer(oldVisualIndex, newVisualIndex);
263
 
    }
264
 
}
265
 
 
266
 
void KTExposureTable::updateLayerSelection(int layerIndex)
267
 
{
268
 
    selectFrame(layerIndex, currentRow());
269
 
}
270
 
 
271
 
KTExposureTable::~KTExposureTable()
272
 
{
273
 
    delete k;
274
 
}
275
 
 
276
 
QString KTExposureTable::frameName(int indexLayer, int indexFrame)
277
 
{
278
 
    QTableWidgetItem *frame = item(indexFrame , indexLayer);
279
 
    if (frame)
280
 
        return frame->text();
281
 
 
282
 
    return "";
283
 
}
284
 
 
285
 
void KTExposureTable::setFrameName(int indexLayer, int indexFrame, const QString & name)
286
 
{
287
 
    QTableWidgetItem *frame = item(indexFrame , indexLayer);
288
 
    frame->setFont(QFont("Arial", 7, QFont::Normal, false));
289
 
 
290
 
    if (frame) {
291
 
        if (frame->text() != name)
292
 
            frame->setText(name);
293
 
    }
294
 
}
295
 
 
296
 
void KTExposureTable::setLayerName(int indexLayer, const QString & name)
297
 
{
298
 
    k->header->setLayerName(k->header->logicalIndex(indexLayer), name);
299
 
}
300
 
 
301
 
bool KTExposureTable::frameIsLocked(int indexLayer, int indexFrame)
302
 
{
303
 
    QTableWidgetItem *frame = item(indexFrame, indexLayer);
304
 
    if (frame) {
305
 
        return frame->data(IsLocked).toBool();
306
 
    } else {
307
 
        #ifdef K_DEBUG
308
 
               tWarning() << "KTExposureTable::frameIsLocked() - Layer: " << indexLayer << ", Frame: " << indexFrame << " doesn't exist";
309
 
        #endif
310
 
    }
311
 
    return false;
312
 
}
313
 
 
314
 
KTExposureTable::FrameType KTExposureTable::frameState(int indexLayer, int indexFrame)
315
 
{ 
316
 
    KTExposureTable::FrameType type = KTExposureTable::Unset;
317
 
    QTableWidgetItem *frame = item(indexFrame, indexLayer);
318
 
    if (frame)
319
 
        type = KTExposureTable::FrameType(frame->data(KTExposureTable::IsEmpty).toInt()); 
320
 
 
321
 
    return type;
322
 
}
323
 
 
324
 
void KTExposureTable::updateFrameState(int indexLayer, int indexFrame, KTExposureTable::FrameType value)
325
 
{
326
 
    QTableWidgetItem *frame = item(indexFrame, indexLayer);
327
 
    frame->setData(IsEmpty, value);
328
 
 
329
 
    if (value == KTExposureTable::Used)
330
 
        frame->setBackgroundColor(QColor(0xf0f0f0));
331
 
}
332
 
 
333
 
void KTExposureTable::selectFrame(int indexLayer, int indexFrame)
334
 
{
335
 
    setCurrentCell(indexFrame, k->header->logicalIndex(indexLayer));
336
 
}
337
 
 
338
 
void KTExposureTable::setMenu(QMenu *menu)
339
 
{
340
 
    k->menu = menu;
341
 
}
342
 
 
343
 
int KTExposureTable::currentLayer() const
344
 
{
345
 
    return k->header->visualIndex(currentColumn());
346
 
}
347
 
 
348
 
int KTExposureTable::currentFrame() const
349
 
{
350
 
    #ifdef K_DEBUG
351
 
           T_FUNCINFO;
352
 
    #endif
353
 
 
354
 
    QTableWidgetItem *frame = currentItem();
355
 
 
356
 
    /* SQA: Old code. Remove it!
357
 
    if (frame) {
358
 
        if (frame->data(IsEmpty).toBool()) {
359
 
            return currentRow();
360
 
        } else {
361
 
            return currentRow()-1; //???
362
 
        }
363
 
    }
364
 
    */
365
 
 
366
 
    if (frame) {
367
 
        if (frame->data(KTExposureTable::IsEmpty).toInt() != Unset)
368
 
            return currentRow();
369
 
    }
370
 
 
371
 
    return 0;
372
 
}
373
 
 
374
 
void KTExposureTable::insertLayer(int index, const QString & name)
375
 
{
376
 
    insertColumn(index);
377
 
    setColumnWidth(index, 70);
378
 
    k->header->insertLayer(index, name);
379
 
}
380
 
 
381
 
void KTExposureTable::insertFrame(int indexLayer, int indexFrame, const QString & name, bool external)
382
 
{
383
 
    QTableWidgetItem *frame = new QTableWidgetItem;
384
 
    frame->setBackgroundColor(QColor(0xe6e6e6));
385
 
    frame->setFont(QFont("Arial", 7, QFont::Normal, false));
386
 
    frame->setSizeHint(QSize(65, 10));
387
 
    frame->setText(name);
388
 
    frame->setData(IsEmpty, Empty);
389
 
    frame->setTextAlignment(Qt::AlignCenter);
390
 
 
391
 
    int logicalIndex = k->header->logicalIndex(indexLayer);
392
 
 
393
 
    k->header->setLastFrame(logicalIndex, k->header->lastFrame(logicalIndex) + 1);
394
 
 
395
 
    setItem(k->header->lastFrame(logicalIndex)-1, logicalIndex, frame);
396
 
 
397
 
    for (int i = k->header->lastFrame(logicalIndex)-1; i > indexFrame; i--)
398
 
         exchangeFrame(indexLayer, i , indexLayer, i-1, external);
399
 
 
400
 
    if (k->header->lastFrame(logicalIndex) == rowCount()) {
401
 
        setRowCount(k->header->lastFrame(logicalIndex) + 100);
402
 
        int last = k->header->lastFrame(logicalIndex);
403
 
        for (int i=last; i < last + 100; i++)
404
 
             setRowHeight(i, 20);
405
 
    }
406
 
}
407
 
 
408
 
void KTExposureTable::setLockFrame(int indexLayer, int indexFrame, bool locked)
409
 
{
410
 
    int logicalIndex = k->header->logicalIndex(indexLayer);
411
 
    QTableWidgetItem * frame = item(indexFrame, logicalIndex);
412
 
 
413
 
    if (frame) {
414
 
        if (frame->data(KTExposureTable::IsEmpty).toInt() != Unset) {
415
 
            if (locked)
416
 
                frame->setBackgroundColor(QColor(250, 71, 53));
417
 
            else
418
 
                frame->setBackgroundColor(QColor(0xe6e6e6));
419
 
 
420
 
            frame->setData(IsLocked, locked);
421
 
        }
422
 
    }
423
 
}
424
 
 
425
 
void KTExposureTable::setLockLayer(int indexLayer, bool locked)
426
 
{
427
 
    k->header->setLockLayer(indexLayer, locked);
428
 
}
429
 
 
430
 
void KTExposureTable::setVisibilityChanged(int visualIndex, bool visibility)
431
 
{
432
 
    k->header->setVisibilityChanged(k->header->logicalIndex(visualIndex), visibility);
433
 
}
434
 
 
435
 
void KTExposureTable::removeLayer(int indexLayer)
436
 
{
437
 
    setUpdatesEnabled(false);
438
 
    k->removingLayer = true;
439
 
 
440
 
    k->header->removeLayer(indexLayer);
441
 
    removeColumn(indexLayer);
442
 
 
443
 
    setUpdatesEnabled(true);
444
 
}
445
 
 
446
 
void KTExposureTable::removeFrame(int indexLayer, int indexFrame, bool fromMenu)
447
 
{
448
 
    //setUpdatesEnabled(false);
449
 
    k->removingFrame = fromMenu;
450
 
 
451
 
    QTableWidgetItem *item  = takeItem(indexFrame, indexLayer);
452
 
    if (item) {
453
 
        for (int index = indexFrame + 1; index < k->header->lastFrame(indexLayer); index++) {
454
 
             QTableWidgetItem * idx  = takeItem(index, indexLayer);
455
 
             if (idx)
456
 
                 setItem(index - 1, indexLayer, idx);
457
 
        }
458
 
        k->header->setLastFrame(indexLayer, k->header->lastFrame(indexLayer)-1);
459
 
    }
460
 
 
461
 
    //setUpdatesEnabled(true);
462
 
}
463
 
 
464
 
void KTExposureTable::exchangeFrame(int oldPosLayer, int oldPosFrame, int newPosLayer, int newPosFrame, bool external)
465
 
{
466
 
    QTableWidgetItem * oldItem  = takeItem(oldPosFrame, oldPosLayer);
467
 
    QTableWidgetItem * newItem  = takeItem(newPosFrame, newPosLayer);
468
 
 
469
 
    setItem(newPosFrame, newPosLayer, oldItem);
470
 
    setItem(oldPosFrame, oldPosLayer, newItem);
471
 
 
472
 
    if (!external) 
473
 
        setCurrentItem(oldItem);
474
 
}
475
 
 
476
 
void KTExposureTable::moveLayer(int oldPosLayer, int newPosLayer)
477
 
{
478
 
    k->header->moveLayer(oldPosLayer, newPosLayer);
479
 
}
480
 
 
481
 
void KTExposureTable::emitRequestSetUsedFrame(int indexFrame, int indexLayer)
482
 
{
483
 
    #ifdef K_DEBUG
484
 
           T_FUNCINFO;
485
 
    #endif
486
 
 
487
 
    int layer = k->header->visualIndex(indexLayer);
488
 
    int lastFrame = k->header->lastFrame(indexLayer); 
489
 
 
490
 
    if (indexFrame >= lastFrame) {
491
 
        for (int column=0; column<columnCount(); column++) {
492
 
             int used = usedFrames(column); 
493
 
             if (lastFrame >= used) {
494
 
                 for (int frame=used; frame <= indexFrame; frame++)
495
 
                      emit requestSetUsedFrame(column, frame);
496
 
             }
497
 
        }
498
 
 
499
 
        emit requestSelectFrame(layer, indexFrame);
500
 
    } 
501
 
}
502
 
 
503
 
int KTExposureTable::usedFrames(int column) const
504
 
{
505
 
    return k->header->lastFrame(column);
506
 
}
507
 
 
508
 
bool KTExposureTable::edit(const QModelIndex & index, EditTrigger trigger, QEvent *event)
509
 
{
510
 
    QTableWidgetItem *item = itemFromIndex(index);
511
 
 
512
 
    if (item) {
513
 
        if (item->data(KTExposureTable::IsEmpty).toInt() != Unset)
514
 
            QTableWidget::edit(index, trigger, event);
515
 
        else
516
 
            return false;
517
 
    }
518
 
 
519
 
    return false;
520
 
}
521
 
 
522
 
void KTExposureTable::mousePressEvent(QMouseEvent * event)
523
 
{
524
 
    int frame = rowAt(event->y());
525
 
    if (event->button() == Qt::RightButton) {
526
 
        if (k->header->lastFrame(currentLayer()) >= frame) {
527
 
            if (k->menu) {
528
 
                clearFocus();
529
 
                k->menu->exec(event->globalPos());
530
 
            }
531
 
        } else {
532
 
            return;
533
 
        }
534
 
    }
535
 
 
536
 
    QTableWidget::mousePressEvent(event);
537
 
}
538
 
 
539
 
void KTExposureTable::commitData(QWidget *editor)
540
 
{
541
 
    QLineEdit *lineEdit = qobject_cast<QLineEdit *>(editor);
542
 
    QTableWidget::commitData(0); // Don't rename
543
 
 
544
 
    if (lineEdit)
545
 
        emit requestRenameFrame(currentLayer(), currentFrame(), lineEdit->text());
546
 
}
547
 
 
548
 
int KTExposureTable::layersTotal()
549
 
{
550
 
    return k->header->layersTotal();
551
 
}
552
 
 
553
 
int KTExposureTable::framesTotal()
554
 
{
555
 
    return k->header->lastFrame(0);
556
 
}
557
 
 
558
 
int KTExposureTable::framesTotalAtCurrentLayer()
559
 
{
560
 
    return k->header->lastFrame(currentLayer());
561
 
}
562
 
 
563
 
void KTExposureTable::keyPressEvent(QKeyEvent * event)
564
 
{
565
 
    if (event->key() == Qt::Key_Up) {
566
 
        int row = currentRow()-1;
567
 
        if (row > -1)
568
 
            setCurrentCell(row, currentColumn());
569
 
        return;
570
 
    }
571
 
 
572
 
    if (event->key() == Qt::Key_Down) {
573
 
        int limit = rowCount()-1;
574
 
        int next = currentRow()+1;
575
 
        if (next <= limit)
576
 
            setCurrentCell(next, currentColumn());
577
 
        return;
578
 
    }
579
 
 
580
 
    if (event->key() == Qt::Key_Right) {
581
 
        int limit = columnCount()-1;
582
 
        int next = currentColumn()+1;
583
 
        if (next <= limit)
584
 
            setCurrentCell(currentRow(), next);
585
 
        return;
586
 
    }
587
 
 
588
 
    if (event->key() == Qt::Key_Left) {
589
 
        int column = currentColumn()-1;
590
 
        if (column > -1)
591
 
            setCurrentCell(currentRow(), column);
592
 
        return;
593
 
    }   
594
 
 
595
 
    if (event->key() == Qt::Key_Return) {
596
 
        emitRequestSetUsedFrame(currentRow(), currentColumn());
597
 
        return;
598
 
    }
599
 
}
600
 
 
601
 
void KTExposureTable::emitCellClicked(int frame, int layer) 
602
 
{
603
 
    emit cellClicked(frame, layer);
604
 
}
605
 
 
606
 
void KTExposureTable::enterEvent(QEvent *event)
607
 
{
608
 
    if (!hasFocus())
609
 
        setFocus();
610
 
 
611
 
    QTableWidget::enterEvent(event);
612
 
}
613
 
 
614
 
void KTExposureTable::leaveEvent(QEvent *event)
615
 
{
616
 
    if (hasFocus())
617
 
        clearFocus();
618
 
 
619
 
    QTableWidget::leaveEvent(event);
620
 
}
621
 
 
622
 
void KTExposureTable::reset()
623
 
{
624
 
    int cols = columnCount();
625
 
    if (cols > 1) {
626
 
        for (int i=1; i < cols; i++)
627
 
             removeLayer(i);
628
 
    }
629
 
 
630
 
    int rows = rowCount();
631
 
    for (int i=1; i < rows;  i++) {
632
 
         QTableWidgetItem *item = takeItem(i, 0);
633
 
    }
634
 
 
635
 
    k->header->setLastFrame(0, 1);
636
 
}
637