← Back to branch summary

~ubuntu-branches/ubuntu/maverick/kdeutils/maverick-proposed

« back to all changes in this revision

Viewing changes to okteta/gui/bytearrayrowview_p.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Riddell
  • Date: 2010-05-28 09:49:30 UTC
  • mfrom: (1.2.44 upstream)
  • Revision ID: james.westby@ubuntu.com-20100528094930-jzynf0obv1n2v13a
Tags: 4:4.4.80-0ubuntu1~ppa1
New upstream beta release

Show diffs side-by-side

added added

removed removed

Lines of Context:
okteta/gui/bytearrayrowview_p.cpp
1
1
/*
2
2
    This file is part of the Okteta Gui library, part of the KDE project.
3
3
 
4
 
    Copyright 2008 Friedrich W. H. Kossebau <kossebau@kde.org>
 
4
    Copyright 2008-2009 Friedrich W. H. Kossebau <kossebau@kde.org>
5
5
 
6
6
    This library is free software; you can redistribute it and/or
7
7
    modify it under the terms of the GNU Lesser General Public
25
25
// lib
26
26
#include "bordercolumnrenderer.h"
27
27
#include "widgetcolumnstylist.h"
28
 
#include "bytearraytableranges.h"
29
 
#include "bytearraytablelayout.h"
30
 
#include "controller/kvalueeditor.h"
31
28
#include "controller/dropper.h"
32
29
#include "kcursor.h"
33
30
// Okteta core
34
 
#include <abstractbytearraymodel.h>
35
31
#include <valuecodec.h>
36
 
#include <charcodec.h>
37
 
#include <wordbytearrayservice.h>
38
32
// KDE
39
33
#include <KGlobalSettings>
40
34
// Qt
41
 
#include <QtGui/QApplication>
42
35
#include <QtGui/QStyle>
43
36
#include <QtGui/QPainter>
44
 
#include <QtGui/QCursor>
45
 
#include <QtGui/QClipboard>
46
37
#include <QtGui/QScrollBar>
47
 
#include <QtGui/QMouseEvent>
48
 
#include <QtCore/QListIterator>
49
 
#include <QtCore/QTimer>
50
38
 
51
39
 
52
40
namespace Okteta
53
41
{
54
 
static const int DefaultScrollTimerPeriod = 100;
55
42
static const int InsertCursorWidth = 2;
56
43
 
57
44
 
58
45
ByteArrayRowViewPrivate::ByteArrayRowViewPrivate( ByteArrayRowView* parent )
59
 
: AbstractByteArrayViewPrivate( parent ),
60
 
   mCursorPixmaps( new KCursor() ),
61
 
   mMousePressed( false ),
62
 
   mInDoubleClick( false ),
63
 
   mInDnD( false ),
64
 
   mDragStartPossible( false ),
65
 
   mBlinkCursorVisible( false )
 
46
  : AbstractByteArrayViewPrivate( parent )
66
47
{
67
48
}
68
49
 
70
51
{
71
52
   Q_Q( ByteArrayRowView );
72
53
 
73
 
    mCursorBlinkTimer = new QTimer( q );
74
 
    mScrollTimer = new QTimer( q );
75
 
    mDragStartTimer = new QTimer( q );
76
 
    mTrippleClickTimer = new QTimer( q );
77
 
 
78
 
    mStylist = new WidgetColumnStylist( q );
79
 
 
80
54
    // creating the columns in the needed order
81
 
    mOffsetColumn =
82
 
        new OffsetColumnRenderer( mStylist, mTableLayout, OffsetFormat::Hexadecimal );
83
 
    mBorderColumn =
84
 
        new BorderColumnRenderer( mStylist, false );
85
55
    mByteArrayColumn =
86
56
        new ByteArrayRowColumnRenderer( mStylist, mByteArrayModel, mTableLayout, mTableRanges );
87
57
 
88
58
    q->addColumn( mOffsetColumn );
89
 
    q->addColumn( mBorderColumn );
 
59
    q->addColumn( mOffsetBorderColumn );
90
60
    q->addColumn( mByteArrayColumn );
91
61
 
92
62
    // select the active column
100
70
 
101
71
    adaptController();
102
72
 
 
73
    // do here not in base class, as handleFontChange needs this init run before
103
74
    q->setFont( KGlobalSettings::fixedFont() );
104
 
 
105
 
    q->connect( mCursorBlinkTimer, SIGNAL(timeout()), q, SLOT(blinkCursor()) );
106
 
    q->connect( mScrollTimer,      SIGNAL(timeout()), q, SLOT(autoScrollTimerDone()) );
107
 
    q->connect( mDragStartTimer,   SIGNAL(timeout()), q, SLOT(startDrag()) );
108
 
    mDragStartTimer->setSingleShot( true );
109
 
    mTrippleClickTimer->setSingleShot( true );
110
 
 
111
 
    q->setAcceptDrops( true );
112
75
}
113
76
 
114
77
AbstractByteArrayView::CodingTypes ByteArrayRowViewPrivate::visibleCodings() const { return mByteArrayColumn->visibleCodings(); }
317
280
}
318
281
 
319
282
 
320
 
void ByteArrayRowViewPrivate::toggleOffsetColumn( bool showOffsetColumn )
321
 
{
322
 
    const bool isVisible = mOffsetColumn->isVisible();
323
 
    // no change?
324
 
    if( isVisible == showOffsetColumn )
325
 
        return;
326
 
 
327
 
    mOffsetColumn->setVisible( showOffsetColumn );
328
 
 
329
 
    updateViewByWidth();
330
 
}
331
 
 
332
 
 
333
283
QSize ByteArrayRowViewPrivate::minimumSizeHint() const
334
284
{
335
285
    Q_Q( const ByteArrayRowView );
337
287
    // TODO: better minimal width (visibility!)
338
288
    const int minWidth =
339
289
        mOffsetColumn->visibleWidth()
340
 
        + mBorderColumn->visibleWidth()
 
290
        + mOffsetBorderColumn->visibleWidth()
341
291
        + mByteArrayColumn->byteWidth();
342
292
    const int minHeight =
343
293
        q->lineHeight()
354
304
    const QSize newSize = q->maximumViewportSize();
355
305
    const PixelX reservedWidth =
356
306
        mOffsetColumn->visibleWidth()
357
 
        + mBorderColumn->visibleWidth();
 
307
        + mOffsetBorderColumn->visibleWidth();
358
308
 
359
309
    // abstract offset and border columns width
360
310
    const PixelX fullWidth = newSize.width() - reservedWidth;
384
334
    // no grouping?
385
335
    if( noOfGroupedBytes == 0 )
386
336
    {
387
 
        // faking grouping by 1
 
337
        // fake no grouping by grouping with 1 and using byteSpacingWidth
388
338
        noOfGroupedBytes = 1;
389
 
        groupSpacingWidth = 0;
 
339
        groupSpacingWidth = byteSpacingWidth;
390
340
    }
391
341
    else
392
342
        groupSpacingWidth = mByteArrayColumn->groupSpacingWidth();
593
543
}
594
544
 
595
545
 
596
 
void ByteArrayRowViewPrivate::startCursor()
597
 
{
598
 
    mCursorPaused = false;
599
 
 
600
 
    updateCursors();
601
 
 
602
 
    mCursorBlinkTimer->start( QApplication::cursorFlashTime()/2 );
603
 
}
604
 
 
605
 
 
606
 
void ByteArrayRowViewPrivate::unpauseCursor()
607
 
{
608
 
    mCursorPaused = false;
609
 
 
610
 
    if( mCursorBlinkTimer->isActive() )
611
 
        updateCursors();
612
 
}
613
 
 
614
 
 
615
546
void ByteArrayRowViewPrivate::updateCursors()
616
547
{
617
548
    createCursorPixmaps();
622
553
}
623
554
 
624
555
 
625
 
void ByteArrayRowViewPrivate::stopCursor()
626
 
{
627
 
    mCursorBlinkTimer->stop();
628
 
 
629
 
    pauseCursor();
630
 
}
631
 
 
632
 
 
633
556
void ByteArrayRowViewPrivate::pauseCursor()
634
557
{
635
558
    mCursorPaused = true;
905
828
}
906
829
 
907
830
 
908
 
#if 0
909
 
void ByteArrayRowViewPrivate::clipboardChanged()
910
 
{
911
 
    Q_Q( ByteArrayRowView );
912
 
 
913
 
    // don't listen to selection changes
914
 
    q->disconnect( QApplication::clipboard(), SIGNAL(selectionChanged()) );
915
 
    selectAll( false );
916
 
}
917
 
#endif
918
 
 
919
 
void ByteArrayRowViewPrivate::mousePressEvent( QMouseEvent* mouseEvent )
920
 
{
921
 
    Q_Q( ByteArrayRowView );
922
 
 
923
 
    const bool oldHasSelection = mTableRanges->hasSelection();
924
 
 
925
 
    pauseCursor();
926
 
    mValueEditor->finishEdit();
927
 
 
928
 
    // care about a left button press?
929
 
    if( mouseEvent->button() == Qt::LeftButton )
930
 
    {
931
 
        mMousePressed = true;
932
 
 
933
 
        // select whole line?
934
 
        if( mTrippleClickTimer->isActive()
935
 
            && (mouseEvent->globalPos()-mDoubleClickPoint).manhattanLength() < QApplication::startDragDistance() )
936
 
        {
937
 
            mTrippleClickTimer->stop();
938
 
            const Address indexAtFirstDoubleClickLinePosition = mTableLayout->indexAtFirstLinePosition( mDoubleClickLine );
939
 
            mTableRanges->setSelectionStart( indexAtFirstDoubleClickLinePosition );
940
 
            mTableCursor->gotoIndex( indexAtFirstDoubleClickLinePosition );
941
 
            mTableCursor->gotoLineEnd();
942
 
            mTableRanges->setSelectionEnd( cursorPosition() );
943
 
            updateChanged();
944
 
 
945
 
            unpauseCursor();
946
 
 
947
 
            const bool newHasSelection = mTableRanges->hasSelection();
948
 
            emit q->cursorPositionChanged( cursorPosition() );
949
 
            emit q->selectionChanged( mTableRanges->selection() );
950
 
            if( oldHasSelection != newHasSelection )
951
 
            {
952
 
                if( !mOverWrite ) emit q->cutAvailable( newHasSelection );
953
 
                emit q->copyAvailable( newHasSelection );
954
 
                emit q->hasSelectedDataChanged( newHasSelection );
955
 
            }
956
 
            return;
957
 
        }
958
 
 
959
 
        const QPoint mousePoint = q->viewportToColumns( mouseEvent->pos() );
960
 
 
961
 
        // start of a drag perhaps?
962
 
        if( mTableRanges->hasSelection() && mTableRanges->selectionIncludes(indexByPoint( mousePoint )) )
963
 
        {
964
 
            mDragStartPossible = true;
965
 
            mDragStartTimer->start( QApplication::startDragTime() );
966
 
            mDragStartPoint = mousePoint;
967
 
        }
968
 
        else
969
 
        {
970
 
            placeCursor( mousePoint );
971
 
            ensureCursorVisible();
972
 
 
973
 
            const Address realIndex = mTableCursor->realIndex();
974
 
            if( mTableRanges->selectionStarted() )
975
 
            {
976
 
                if( mouseEvent->modifiers() & Qt::SHIFT )
977
 
                    mTableRanges->setSelectionEnd( realIndex );
978
 
                else
979
 
                {
980
 
                    mTableRanges->removeSelection();
981
 
                    mTableRanges->setSelectionStart( realIndex );
982
 
                }
983
 
            }
984
 
            else // start of a new selection possible
985
 
            {
986
 
                mTableRanges->setSelectionStart( realIndex );
987
 
 
988
 
                if( !isEffectiveReadOnly() && (mouseEvent->modifiers()&Qt::SHIFT) ) // TODO: why only for readwrite?
989
 
                    mTableRanges->setSelectionEnd( realIndex );
990
 
            }
991
 
 
992
 
            mTableRanges->removeFurtherSelections();
993
 
        }
994
 
    }
995
 
    else if( mouseEvent->button() == Qt::MidButton )
996
 
        mTableRanges->removeSelection();
997
 
 
998
 
    if( mTableRanges->isModified() )
999
 
    {
1000
 
        updateChanged();
1001
 
        q->viewport()->setCursor( isEffectiveReadOnly() ? Qt::ArrowCursor : Qt::IBeamCursor );
1002
 
    }
1003
 
 
1004
 
    unpauseCursor();
1005
 
 
1006
 
    const bool newHasSelection = mTableRanges->hasSelection();
1007
 
    emit q->selectionChanged( mTableRanges->selection() );
1008
 
    if( oldHasSelection != newHasSelection )
1009
 
    {
1010
 
        if( !mOverWrite ) emit q->cutAvailable( newHasSelection );
1011
 
        emit q->copyAvailable( newHasSelection );
1012
 
        emit q->hasSelectedDataChanged( newHasSelection );
1013
 
    }
1014
 
}
1015
 
 
1016
 
 
1017
 
void ByteArrayRowViewPrivate::mouseMoveEvent( QMouseEvent *mouseEvent )
1018
 
{
1019
 
    Q_Q( ByteArrayRowView );
1020
 
 
1021
 
    const QPoint movePoint = q->viewportToColumns( mouseEvent->pos() );
1022
 
 
1023
 
    if( mMousePressed )
1024
 
    {
1025
 
        if( mDragStartPossible )
1026
 
        {
1027
 
            mDragStartTimer->stop();
1028
 
            // moved enough for a drag?
1029
 
            if( (movePoint-mDragStartPoint).manhattanLength() > QApplication::startDragDistance() )
1030
 
                startDrag();
1031
 
            if( !isEffectiveReadOnly() )
1032
 
                q->viewport()->setCursor( Qt::IBeamCursor );
1033
 
            return;
1034
 
        }
1035
 
        // selecting
1036
 
        handleMouseMove( movePoint );
1037
 
    }
1038
 
    else if( !isEffectiveReadOnly() )
1039
 
    {
1040
 
        // visual feedback for possible dragging
1041
 
        const bool InSelection =
1042
 
            mTableRanges->hasSelection() && mTableRanges->selectionIncludes( indexByPoint(movePoint) );
1043
 
        q->viewport()->setCursor( InSelection?Qt::ArrowCursor:Qt::IBeamCursor );
1044
 
    }
1045
 
}
1046
 
 
1047
 
 
1048
 
void ByteArrayRowViewPrivate::mouseReleaseEvent( QMouseEvent* mouseEvent )
1049
 
{
1050
 
    Q_Q( ByteArrayRowView );
1051
 
 
1052
 
    const bool oldHasSelection = mTableRanges->hasSelection();
1053
 
    const QPoint releasePoint = q->viewportToColumns( mouseEvent->pos() );
1054
 
 
1055
 
    // this is not the release of a doubleclick so we need to process it?
1056
 
    if( !mInDoubleClick )
1057
 
    {
1058
 
        const int line = q->lineAt( releasePoint.y() );
1059
 
        const int pos = mByteArrayColumn->linePositionOfX( releasePoint.x() ); // TODO: can we be sure here about the active column?
1060
 
        const Address index = mTableLayout->indexAtCCoord( Coord(pos,line) ); // TODO: can this be another index than the one of the cursor???
1061
 
        emit q->clicked( index );
1062
 
    }
1063
 
 
1064
 
    if( mMousePressed )
1065
 
    {
1066
 
        mMousePressed = false;
1067
 
 
1068
 
        if( mScrollTimer->isActive() )
1069
 
            mScrollTimer->stop();
1070
 
 
1071
 
        // was only click inside selection, nothing dragged?
1072
 
        if( mDragStartPossible )
1073
 
        {
1074
 
            selectAll( false );
1075
 
            mDragStartTimer->stop();
1076
 
            mDragStartPossible = false;
1077
 
 
1078
 
            placeCursor( mDragStartPoint );
1079
 
            ensureCursorVisible();
1080
 
 
1081
 
            unpauseCursor();
1082
 
        }
1083
 
        // was end of selection operation?
1084
 
        else if( mTableRanges->hasSelection() )
1085
 
        {
1086
 
            if( QApplication::clipboard()->supportsSelection() )
1087
 
            {
1088
 
                mClipboardMode = QClipboard::Selection;
1089
 
                q->disconnect( QApplication::clipboard(), SIGNAL(selectionChanged()) );
1090
 
 
1091
 
                copy();
1092
 
 
1093
 
                //TODO: why did we do this? And why does the disconnect above not work?
1094
 
                // got connected multiple times after a few selections by mouse
1095
 
        //         connect( QApplication::clipboard(), SIGNAL(selectionChanged()), SLOT(clipboardChanged()) );
1096
 
                mClipboardMode = QClipboard::Clipboard;
1097
 
            }
1098
 
        }
1099
 
    }
1100
 
    // middle mouse button paste?
1101
 
    else if( mouseEvent->button() == Qt::MidButton && !isEffectiveReadOnly() )
1102
 
    {
1103
 
        pauseCursor();
1104
 
        mValueEditor->finishEdit();
1105
 
 
1106
 
        placeCursor( releasePoint );
1107
 
 
1108
 
        // replace no selection?
1109
 
        if( mTableRanges->hasSelection() && !mTableRanges->selectionIncludes(mTableCursor->index()) )
1110
 
            mTableRanges->removeSelection();
1111
 
 
1112
 
        mClipboardMode = QClipboard::Selection;
1113
 
        paste();
1114
 
        mClipboardMode = QClipboard::Clipboard;
1115
 
 
1116
 
        // ensure selection changes to be drawn TODO: create a insert/pasteAtCursor that leaves out drawing
1117
 
        updateChanged();
1118
 
 
1119
 
        ensureCursorVisible();
1120
 
        unpauseCursor();
1121
 
    }
1122
 
 
1123
 
    emit q->cursorPositionChanged( cursorPosition() );
1124
 
 
1125
 
    mInDoubleClick = false;
1126
 
 
1127
 
    if( mTableRanges->selectionJustStarted() )
1128
 
        mTableRanges->removeSelection();
1129
 
 
1130
 
    const bool newHasSelection = mTableRanges->hasSelection();
1131
 
    emit q->selectionChanged( mTableRanges->selection() );
1132
 
    if( oldHasSelection != newHasSelection )
1133
 
    {
1134
 
        if( !mOverWrite ) emit q->cutAvailable( newHasSelection );
1135
 
        emit q->copyAvailable( newHasSelection );
1136
 
        emit q->hasSelectedDataChanged( newHasSelection );
1137
 
    }
1138
 
}
1139
 
 
1140
 
 
1141
 
// gets called after press and release instead of a plain press event (?)
1142
 
void ByteArrayRowViewPrivate::mouseDoubleClickEvent( QMouseEvent* mouseEvent )
1143
 
{
1144
 
    Q_Q( ByteArrayRowView );
1145
 
 
1146
 
    // we are only interested in LMB doubleclicks
1147
 
    if( mouseEvent->button() != Qt::LeftButton )
1148
 
    {
1149
 
        mouseEvent->ignore();
1150
 
        return;
1151
 
    }
1152
 
 
1153
 
    mDoubleClickLine = mTableCursor->line();
1154
 
 
1155
 
    const Address index = mTableCursor->validIndex();
1156
 
 
1157
 
    if( mActiveCoding == AbstractByteArrayView::CharCodingId )
1158
 
    {
1159
 
        selectWord( index );
1160
 
 
1161
 
        // as we already have a doubleclick maybe it is a tripple click
1162
 
        mTrippleClickTimer->start( qApp->doubleClickInterval() );
1163
 
        mDoubleClickPoint = mouseEvent->globalPos();
1164
 
    }
1165
 
    //  else
1166
 
    //    mValueEditor->goInsideByte(); TODO: make this possible again
1167
 
 
1168
 
    mInDoubleClick = true; //
1169
 
    mMousePressed = true;
1170
 
 
1171
 
    emit q->doubleClicked( index );
1172
 
}
1173
 
 
1174
 
 
1175
 
void ByteArrayRowViewPrivate::autoScrollTimerDone()
1176
 
{
1177
 
    Q_Q( ByteArrayRowView );
1178
 
 
1179
 
    if( mMousePressed )
1180
 
        handleMouseMove( q->viewportToColumns(q->viewport()->mapFromGlobal( QCursor::pos() )) );
1181
 
}
1182
 
 
1183
 
 
1184
 
void ByteArrayRowViewPrivate::handleMouseMove( const QPoint& point ) // handles the move of the mouse with pressed buttons
1185
 
{
1186
 
    Q_Q( ByteArrayRowView );
1187
 
 
1188
 
    const bool oldHasSelection = mTableRanges->hasSelection();
1189
 
    const int yOffset = q->yOffset();
1190
 
    const int behindLastYOffset = yOffset + q->visibleHeight();
1191
 
    // scrolltimer but inside of viewport?
1192
 
    if( mScrollTimer->isActive() )
1193
 
    {
1194
 
        if( yOffset <= point.y() && point.y() < behindLastYOffset )
1195
 
            mScrollTimer->stop();
1196
 
    }
1197
 
    // no scrolltimer and outside of viewport?
1198
 
    else
1199
 
    {
1200
 
        if( point.y() < yOffset || behindLastYOffset <= point.y() )
1201
 
            mScrollTimer->start( DefaultScrollTimerPeriod );
1202
 
    }
1203
 
    pauseCursor();
1204
 
 
1205
 
    placeCursor( point );
1206
 
    ensureCursorVisible();
1207
 
 
1208
 
    // do wordwise selection?
1209
 
    if( mInDoubleClick && mTableRanges->hasFirstWordSelection() )
1210
 
    {
1211
 
        Address newIndex = mTableCursor->realIndex();
1212
 
        const AddressRange firstWordSelection = mTableRanges->firstWordSelection();
1213
 
        const WordByteArrayService WBS( mByteArrayModel, charCodec() );
1214
 
        // are we before the selection?
1215
 
        if( firstWordSelection.startsBehind(newIndex) )
1216
 
        {
1217
 
            mTableRanges->ensureWordSelectionForward( false );
1218
 
            newIndex = WBS.indexOfLeftWordSelect( newIndex );
1219
 
        }
1220
 
        // or behind?
1221
 
        else if( firstWordSelection.endsBefore(newIndex) )
1222
 
        {
1223
 
            mTableRanges->ensureWordSelectionForward( true );
1224
 
            newIndex = WBS.indexOfRightWordSelect( newIndex );
1225
 
        }
1226
 
        // or inside?
1227
 
        else
1228
 
        {
1229
 
            mTableRanges->ensureWordSelectionForward( true );
1230
 
            newIndex = firstWordSelection.nextBehindEnd();
1231
 
        }
1232
 
 
1233
 
        mTableCursor->gotoIndex( newIndex );
1234
 
    }
1235
 
 
1236
 
    if( mTableRanges->selectionStarted() )
1237
 
        mTableRanges->setSelectionEnd( cursorPosition() );
1238
 
 
1239
 
    updateChanged();
1240
 
 
1241
 
    unpauseCursor();
1242
 
 
1243
 
    const bool newHasSelection = mTableRanges->hasSelection();
1244
 
    emit q->cursorPositionChanged( cursorPosition() );
1245
 
    emit q->selectionChanged( mTableRanges->selection() );
1246
 
    if( oldHasSelection != newHasSelection )
1247
 
    {
1248
 
        if( !mOverWrite ) emit q->cutAvailable( newHasSelection );
1249
 
        emit q->copyAvailable( newHasSelection );
1250
 
        emit q->hasSelectedDataChanged( newHasSelection );
1251
 
    }
1252
 
}
1253
 
 
1254
 
 
1255
 
void ByteArrayRowViewPrivate::startDrag()
1256
 
{
1257
 
    Q_Q( ByteArrayRowView );
1258
 
 
1259
 
    // reset states
1260
 
    mMousePressed = false;
1261
 
    mInDoubleClick = false;
1262
 
    mDragStartPossible = false;
1263
 
 
1264
 
    // create data
1265
 
    QMimeData *dragData = selectionAsMimeData();
1266
 
    if( !dragData )
1267
 
        return;
1268
 
 
1269
 
    QDrag *drag = new QDrag( q );
1270
 
    drag->setMimeData( dragData );
1271
 
 
1272
 
    Qt::DropActions request = (isEffectiveReadOnly()||mOverWrite) ? Qt::CopyAction : Qt::CopyAction|Qt::MoveAction;
1273
 
    Qt::DropAction dropAction = drag->exec( request );
1274
 
 
1275
 
    if( dropAction == Qt::MoveAction )
1276
 
    {
1277
 
        AbstractByteArrayView* targetByteArrayView = qobject_cast<AbstractByteArrayView*>( drag->target() );
1278
 
        // Not inside this widget itself?
1279
 
        if( ! targetByteArrayView
1280
 
            || targetByteArrayView->byteArrayModel() != q->byteArrayModel() )
1281
 
            removeSelectedData();
1282
 
    }
1283
 
}
1284
 
 
1285
831
ByteArrayRowViewPrivate::~ByteArrayRowViewPrivate()
1286
832
{
1287
 
    delete mCursorPixmaps;
1288
 
    delete mStylist;
1289
833
}
1290
834
 
1291
835
}