← Back to branch summary

~kubuntu-members/kompare/4.11

« back to all changes in this revision

Viewing changes to komparepart/kompareconnectwidget.cpp

  • Committer: Otto Bruggeman
  • Date: 2002-03-26 23:09:21 UTC
  • Revision ID: git-v1:6463f3f86954bdfc86a95a04602a7b24db3249f9

Make some architectural changes:
- Moved the diffmodel stuff into a library
- Moved the komparenavtree into its own part
- Passing around pointers to diffmodels and differences now instead of offsets in a qptrlist
- Removed the differences menu because it sucked when there were many differences in a file

Still not ready but it is almost functional, only scrolling does not work atm, i'll fix that tonight if i can.

svn path=/trunk/kdesdk/kompare/; revision=145358

Show diffs side-by-side

added added

removed removed

Lines of Context:
komparepart/kompareconnectwidget.cpp
27
27
 
28
28
#include "kompareconnectwidget.h"
29
29
 
30
 
KompareConnectWidget::KompareConnectWidget( KompareModelList* models, KompareListView* left, KompareListView* right,
 
30
KompareConnectWidget::KompareConnectWidget( KompareListView* left, KompareListView* right,
31
31
      GeneralSettings* settings, KompareView* parent, const char* name )
32
32
        : QWidget(parent, name),
33
 
        m_models( models ),
34
33
        m_settings( settings ),
35
34
        m_diffView( parent ),
36
35
        m_leftView( left ),
37
36
        m_rightView( right ),
38
 
        m_selectedModel( -1 ),
39
 
        m_selectedDiff( -1 )
 
37
        m_selectedModel( 0 ),
 
38
        m_selectedDifference( 0 )
40
39
{
41
40
        connect( m_settings, SIGNAL( settingsChanged() ), this, SLOT( repaint() ) );
42
41
        setBackgroundMode( NoBackground );
47
46
{
48
47
}
49
48
 
50
 
void KompareConnectWidget::slotSetSelection( int model, int diff ) {
51
 
        if( m_selectedModel == model && m_selectedDiff == diff )
52
 
                return;
53
 
        
54
 
        if( m_selectedModel >= 0 ) {
55
 
                disconnect( m_models->modelAt( m_selectedModel ), SIGNAL( appliedChanged( const Difference* ) ),
 
49
void KompareConnectWidget::slotSetSelection( const DiffModel* model, const Difference* diff )
 
50
{
 
51
        if( m_selectedModel == model && m_selectedDifference == diff )
 
52
                return;
 
53
 
 
54
        if ( m_selectedModel == model && m_selectedDifference != diff )
 
55
        {
 
56
                m_selectedDifference = diff;
 
57
                repaint();
 
58
                return;
 
59
        }
 
60
 
 
61
        if( m_selectedModel != model )
 
62
        {
 
63
                disconnect( m_selectedModel, SIGNAL( appliedChanged( const Difference* ) ),
56
64
                            this, SLOT( repaint() ) );
57
65
        }
58
 
        
 
66
 
59
67
        m_selectedModel = model;
60
 
        m_selectedDiff = diff;
61
 
        
62
 
        if( m_selectedModel >= 0 ) {
63
 
                connect( m_models->modelAt( m_selectedModel ), SIGNAL( appliedChanged( const Difference* ) ),
64
 
                            this, SLOT( repaint() ) );
65
 
        }
66
 
        
 
68
        m_selectedDifference = diff;
 
69
 
 
70
        connect( m_selectedModel, SIGNAL( appliedChanged(const Difference*) ),
 
71
                 this, SLOT( repaint() ) );
 
72
 
 
73
        repaint();
 
74
}
 
75
 
 
76
void KompareConnectWidget::slotSetSelection( const Difference* diff )
 
77
{
 
78
        if ( m_selectedDifference == diff )
 
79
                return;
 
80
 
 
81
        m_selectedDifference = diff;
 
82
 
67
83
        repaint();
68
84
}
69
85
 
75
91
void KompareConnectWidget::paintEvent( QPaintEvent* /* e */ )
76
92
{
77
93
        kdDebug() << "KompareConnectWidget::paintEvent()" << endl;
78
 
        
 
94
 
79
95
        QPixmap pixbuf(size());
80
96
        QPainter paint(&pixbuf, this);
81
97
        QPainter* p = &paint;
82
98
 
83
99
        p->fillRect( 0, 0, pixbuf.width(), pixbuf.height(), white );
84
100
 
85
 
        if( m_selectedModel >= 0 ) {
86
 
 
87
 
                DiffModel* selectedModel = m_models->modelAt( m_selectedModel );
88
 
                const Difference* selectedDiff = selectedModel->differenceAt( m_selectedDiff );
89
 
                
 
101
        if( m_selectedModel )
 
102
        {
90
103
                int firstL = m_leftView->firstVisibleDifference();
91
104
                int firstR = m_rightView->firstVisibleDifference();
92
105
                int lastL = m_leftView->lastVisibleDifference();
93
106
                int lastR = m_rightView->lastVisibleDifference();
94
 
                
 
107
 
95
108
                int first = firstL < 0 ? firstR : QMIN( firstL, firstR );
96
109
                int last = lastL < 0 ? lastR : QMAX( lastL, lastR );
97
 
                
 
110
 
98
111
                kdDebug() << "    left: " << firstL << " - " << lastL << endl;
99
112
                kdDebug() << "   right: " << firstR << " - " << lastR << endl;
100
113
                kdDebug() << " drawing: " << first << " - " << last << endl;
101
 
                if( first >= 0 && last >= 0 && first <= last ) {
102
 
                        
 
114
                if( first >= 0 && last >= 0 && first <= last )
 
115
                {
103
116
                        QPtrListIterator<Difference> diffIt =
104
 
                             QPtrListIterator<Difference>( selectedModel->differences() );
 
117
                             QPtrListIterator<Difference>( m_selectedModel->differences() );
105
118
                        diffIt += first;
106
 
                        for( int i = first; diffIt.current() && i <= last; ++diffIt, ++i ) {
107
 
 
108
 
                                const Difference* d = diffIt.current();
109
 
                                bool selected = (d == selectedDiff);
 
119
                        for( int i = first; diffIt.current() && i <= last; ++diffIt, ++i )
 
120
                        {
 
121
                                const Difference* diff = diffIt.current();
 
122
                                bool selected = (diff == m_selectedDifference);
110
123
 
111
124
                                QRect leftRect = m_leftView->itemRect( i );
112
125
                                QRect rightRect = m_rightView->itemRect( i );
119
132
                                QPointArray topBezier = makeTopBezier( tl, tr );
120
133
                                QPointArray bottomBezier = makeBottomBezier( bl, br );
121
134
 
122
 
                                p->setPen( m_settings->colorForDifferenceType( d->type(), selected, d->applied() ) );
123
 
                                p->setBrush( m_settings->colorForDifferenceType( d->type(), selected, d->applied() ) );
 
135
                                p->setPen( m_settings->colorForDifferenceType( diff->type(), selected, diff->applied() ) );
 
136
                                p->setBrush( m_settings->colorForDifferenceType( diff->type(), selected, diff->applied() ) );
124
137
                                p->drawPolygon ( makeConnectPoly( topBezier, bottomBezier ) );
125
138
 
126
 
                                if( selected ) {
 
139
                                if( selected )
 
140
                                {
127
141
                                        p->setPen( black );
128
142
                                        p->drawPolyline( topBezier );
129
143
                                        p->drawPolyline( bottomBezier );
130
144
                                }
131
 
                                
 
145
 
132
146
                        }
133
 
                        
 
147
 
134
148
                }
135
149
        }
136
150
 
147
161
        int l = 0;
148
162
        int r = width();
149
163
        QPointArray controlPoints;
150
 
        controlPoints.setPoints( 4, l,tl, 20,tl, r-20,tr, r,tr );
151
 
        return controlPoints.cubicBezier();
 
164
 
 
165
        if ( true )
 
166
        {
 
167
                controlPoints.setPoints( 4, l,tl, 20,tl, r-20,tr, r,tr );
 
168
                return controlPoints.cubicBezier();
 
169
        }
 
170
        else
 
171
        {
 
172
                controlPoints.setPoints( 2, l,tl, r,tr );
 
173
                return controlPoints;
 
174
        }
152
175
}
153
176
 
154
177
QPointArray KompareConnectWidget::makeBottomBezier( int bl, int br )
156
179
        int l = 0;
157
180
        int r = width();
158
181
        QPointArray controlPoints;
159
 
        controlPoints.setPoints( 4, r,br, r-20,br, 20,bl, l,bl );
160
 
        return controlPoints.cubicBezier();
 
182
 
 
183
        if ( true )
 
184
        {
 
185
                controlPoints.setPoints( 4, r,br, r-20,br, 20,bl, l,bl );
 
186
                return controlPoints.cubicBezier();
 
187
        }
 
188
        else
 
189
        {
 
190
                controlPoints.setPoints( 2, r,br, l,bl );
 
191
                return controlPoints;
 
192
        }
161
193
}
162
194
 
163
195
QPointArray KompareConnectWidget::makeConnectPoly( const QPointArray& topBezier, const QPointArray& bottomBezier )