← Back to branch summary

~ubuntu-branches/ubuntu/precise/koffice/precise

« back to all changes in this revision

Viewing changes to krita/ui/widgets/kis_autogradient.cc

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Riddell
  • Date: 2006-04-20 21:38:53 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20060420213853-j5lxluqvymxt2zny
Tags: 1:1.5.0-0ubuntu2
Ubuntu upload 

Show diffs side-by-side

added added

removed removed

Lines of Context:
krita/ui/widgets/kis_autogradient.cc
1
 
/*
2
 
 *  Copyright (c) 2004 Cyrille Berger <cberger@cberger.net>
3
 
 *                2004 Sven Langkamp <longamp@reallygood.de>
4
 
 *
5
 
 *  This program is free software; you can redistribute it and/or modify
6
 
 *  it under the terms of the GNU General Public License as published by
7
 
 *  the Free Software Foundation; either version 2 of the License, or
8
 
 *  (at your option) any later version.
9
 
 *
10
 
 *  This program is distributed in the hope that it will be useful,
11
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 *  GNU General Public License for more details.
14
 
 *
15
 
 *  You should have received a copy of the GNU General Public License
16
 
 *  along with this program; if not, write to the Free Software
17
 
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18
 
 */
19
 
 
20
 
#include "kis_autogradient.h"
21
 
 
22
 
#include <qpainter.h>
23
 
#include <qcombobox.h>
24
 
 
25
 
#include <kcolorbutton.h>
26
 
#include <knuminput.h>
27
 
 
28
 
#include "kis_gradient_slider_widget.h"
29
 
 
30
 
// FIXME: use the same #define as in kis_gradient.cc, probably best customizable?
31
 
#define PREVIEW_WIDTH 64
32
 
#define PREVIEW_HEIGHT 64
33
 
 
34
 
/************************** KisAutogradientResource **************************/
35
 
 
36
 
void KisAutogradientResource::createSegment( int interpolation, int colorInterpolation, double startOffset, double endOffset, double middleOffset, QColor left, QColor right )
37
 
{
38
 
        pushSegment(new KisGradientSegment(interpolation, colorInterpolation, startOffset, middleOffset, endOffset, Color( left, 1 ), Color( right, 1 )));
39
 
 
40
 
}
41
 
 
42
 
const QValueVector<double> KisAutogradientResource::getHandlePositions() const
43
 
{
44
 
        QValueVector<double> handlePositions;
45
 
 
46
 
        handlePositions.push_back(m_segments[0] -> startOffset());
47
 
        for (uint i = 0; i < m_segments.count(); i++)
48
 
        {
49
 
                handlePositions.push_back(m_segments[i] -> endOffset());
50
 
        }
51
 
        return handlePositions;
52
 
}
53
 
 
54
 
const QValueVector<double> KisAutogradientResource::getMiddleHandlePositions() const
55
 
{
56
 
        QValueVector<double> middleHandlePositions;
57
 
 
58
 
        for (uint i = 0; i < m_segments.count(); i++)
59
 
        {
60
 
                middleHandlePositions.push_back(m_segments[i] -> middleOffset());
61
 
        }
62
 
        return middleHandlePositions;
63
 
}
64
 
 
65
 
void KisAutogradientResource::moveSegmentStartOffset( KisGradientSegment* segment, double t)
66
 
{
67
 
        QValueVector<KisGradientSegment*>::iterator it = qFind( m_segments.begin(), m_segments.end(), segment );
68
 
        if ( it != m_segments.end() )
69
 
        {
70
 
                if ( it == m_segments.begin() )
71
 
                {
72
 
                        segment -> setStartOffset( 0.0 );
73
 
                        return;
74
 
                }
75
 
                KisGradientSegment* previousSegment = (*(it-1));
76
 
                if ( t > segment -> startOffset()  )
77
 
                {
78
 
                        if( t > segment -> middleOffset() )
79
 
                                t = segment -> middleOffset();
80
 
                }
81
 
                else {
82
 
                        if( t < previousSegment -> middleOffset() )
83
 
                                t = previousSegment -> middleOffset();
84
 
                }
85
 
                previousSegment -> setEndOffset( t );
86
 
                segment -> setStartOffset( t );
87
 
        }
88
 
}
89
 
 
90
 
void KisAutogradientResource::moveSegmentEndOffset( KisGradientSegment* segment, double t)
91
 
{
92
 
        QValueVector<KisGradientSegment*>::iterator it = qFind( m_segments.begin(), m_segments.end(), segment );
93
 
        if ( it != m_segments.end() )
94
 
        {
95
 
                if ( it+1 == m_segments.end() )
96
 
                {
97
 
                        segment -> setEndOffset( 1.0 );
98
 
                        return;
99
 
                }
100
 
                KisGradientSegment* followingSegment = (*(it+1));
101
 
                if ( t < segment -> endOffset() )
102
 
                {
103
 
                        if( t < segment -> middleOffset() )
104
 
                                t = segment -> middleOffset();
105
 
                }
106
 
                else {
107
 
                        if( t > followingSegment -> middleOffset() )
108
 
                                t = followingSegment -> middleOffset();
109
 
                }
110
 
                followingSegment -> setStartOffset( t );
111
 
                segment -> setEndOffset( t );
112
 
        }
113
 
}
114
 
 
115
 
void KisAutogradientResource::moveSegmentMiddleOffset( KisGradientSegment* segment, double t)
116
 
{
117
 
        if( segment )
118
 
        {
119
 
                if( t > segment -> endOffset() )
120
 
                        segment -> setMiddleOffset( segment -> endOffset() );
121
 
                else if( t < segment -> startOffset() )
122
 
                        segment -> setMiddleOffset( segment -> startOffset() );
123
 
                else
124
 
                        segment -> setMiddleOffset( t );
125
 
        }
126
 
}
127
 
 
128
 
void KisAutogradientResource::splitSegment( KisGradientSegment* segment )
129
 
{
130
 
        Q_ASSERT(segment != 0);
131
 
        QValueVector<KisGradientSegment*>::iterator it = qFind( m_segments.begin(), m_segments.end(), segment );
132
 
        if ( it != m_segments.end() )
133
 
        {
134
 
                KisGradientSegment* newSegment = new KisGradientSegment(
135
 
                                segment -> interpolation(), segment -> colorInterpolation(),
136
 
                                segment  -> startOffset(),
137
 
                                ( segment -> middleOffset() - segment -> startOffset() ) / 2 + segment -> startOffset(),
138
 
                                segment -> middleOffset(),
139
 
                                segment -> startColor(),
140
 
                                segment -> colorAt( segment -> middleOffset() ) );
141
 
                m_segments.insert( it, newSegment );
142
 
                segment -> setStartColor( segment -> colorAt( segment -> middleOffset() ) );
143
 
                segment -> setStartOffset( segment -> middleOffset() );
144
 
                segment -> setMiddleOffset( ( segment -> endOffset() - segment -> startOffset() ) / 2 + segment -> startOffset() );
145
 
        }
146
 
}
147
 
 
148
 
void KisAutogradientResource::duplicateSegment( KisGradientSegment* segment )
149
 
{
150
 
        Q_ASSERT(segment != 0);
151
 
        QValueVector<KisGradientSegment*>::iterator it = qFind( m_segments.begin(), m_segments.end(), segment );
152
 
        if ( it != m_segments.end() )
153
 
        {
154
 
                double middlePostionPercentage = ( segment -> middleOffset() - segment -> startOffset() ) / segment -> length();
155
 
                double center = segment -> startOffset() + segment -> length() / 2;
156
 
                KisGradientSegment* newSegment = new KisGradientSegment(
157
 
                                segment -> interpolation(), segment -> colorInterpolation(),
158
 
                                segment  -> startOffset(),
159
 
                                segment -> length() / 2 * middlePostionPercentage + segment -> startOffset(),
160
 
                                center, segment -> startColor(),
161
 
                                segment -> endColor() );
162
 
                m_segments.insert( it, newSegment );
163
 
                segment -> setStartOffset( center );
164
 
                segment -> setMiddleOffset( segment -> length() * middlePostionPercentage  + segment -> startOffset() );
165
 
        }
166
 
}
167
 
 
168
 
void KisAutogradientResource::mirrorSegment( KisGradientSegment* segment )
169
 
{
170
 
        Q_ASSERT(segment != 0);
171
 
        Color tmpColor = segment -> startColor();
172
 
        segment -> setStartColor( segment -> endColor() );
173
 
        segment -> setEndColor( tmpColor );
174
 
        segment -> setMiddleOffset( segment -> endOffset() - ( segment -> middleOffset() - segment -> startOffset() ) );
175
 
 
176
 
        if( segment -> interpolation() == INTERP_SPHERE_INCREASING )
177
 
                segment -> setInterpolation( INTERP_SPHERE_DECREASING );
178
 
        else if( segment -> interpolation() == INTERP_SPHERE_DECREASING )
179
 
                segment -> setInterpolation( INTERP_SPHERE_INCREASING );
180
 
 
181
 
        if( segment -> colorInterpolation() == COLOR_INTERP_HSV_CW )
182
 
                segment -> setColorInterpolation( COLOR_INTERP_HSV_CCW );
183
 
        else if( segment -> colorInterpolation() == COLOR_INTERP_HSV_CCW )
184
 
                segment -> setColorInterpolation( COLOR_INTERP_HSV_CW );
185
 
}
186
 
 
187
 
KisGradientSegment* KisAutogradientResource::removeSegment( KisGradientSegment* segment )
188
 
{
189
 
        Q_ASSERT(segment != 0);
190
 
        if( m_segments.count() < 2 )
191
 
                return 0;
192
 
        QValueVector<KisGradientSegment*>::iterator it = qFind( m_segments.begin(), m_segments.end(), segment );
193
 
        if ( it != m_segments.end() )
194
 
        {
195
 
                double middlePostionPercentage;
196
 
                KisGradientSegment* nextSegment;
197
 
                if( it == m_segments.begin() )
198
 
                {
199
 
                        nextSegment = (*(it+1));
200
 
                        middlePostionPercentage = ( nextSegment -> middleOffset() - nextSegment -> startOffset() ) / nextSegment -> length();
201
 
                        nextSegment -> setStartOffset( segment -> startOffset() );
202
 
                        nextSegment -> setMiddleOffset( middlePostionPercentage * nextSegment -> length() + nextSegment -> startOffset() );
203
 
                }
204
 
                else
205
 
                {
206
 
                        nextSegment = (*(it-1));
207
 
                        middlePostionPercentage = ( nextSegment -> middleOffset() - nextSegment -> startOffset() ) / nextSegment -> length();
208
 
                        nextSegment -> setEndOffset( segment -> endOffset() );
209
 
                        nextSegment -> setMiddleOffset( middlePostionPercentage * nextSegment -> length() + nextSegment -> startOffset() );
210
 
                }
211
 
 
212
 
                delete segment;
213
 
                m_segments.erase( it );
214
 
                return nextSegment;
215
 
        }
216
 
        return 0;
217
 
}
218
 
 
219
 
bool KisAutogradientResource::removeSegmentPossible() const
220
 
{
221
 
        if( m_segments.count() < 2 )
222
 
                return false;
223
 
        return true;
224
 
}
225
 
 
226
 
void KisAutogradientResource::updatePreview()
227
 
{
228
 
        setImage( generatePreview( PREVIEW_WIDTH, PREVIEW_HEIGHT ) );
229
 
}
230
 
 
231
 
/****************************** KisAutogradient ******************************/
232
 
 
233
 
KisAutogradient::KisAutogradient(QWidget *parent, const char* name, const QString& caption) : KisWdgAutogradient(parent, name)
234
 
{
235
 
        setCaption(caption);
236
 
        m_autogradientResource = new KisAutogradientResource();
237
 
        m_autogradientResource->createSegment( INTERP_LINEAR, COLOR_INTERP_RGB, 0.0, 1.0, 0.5, Qt::black, Qt::white );
238
 
        connect(gradientSlider, SIGNAL( sigSelectedSegment( KisGradientSegment* ) ), SLOT( slotSelectedSegment(KisGradientSegment*) ));
239
 
        connect(gradientSlider, SIGNAL( sigChangedSegment(KisGradientSegment*) ), SLOT( slotChangedSegment(KisGradientSegment*) ));
240
 
        gradientSlider->setGradientResource( m_autogradientResource );
241
 
        connect(comboBoxColorInterpolationType, SIGNAL( activated(int) ), SLOT( slotChangedColorInterpolation(int) ));
242
 
        connect(comboBoxInterpolationType, SIGNAL( activated(int) ), SLOT( slotChangedInterpolation(int) ));
243
 
        connect(leftColorButton, SIGNAL( changed(const QColor&) ), SLOT( slotChangedLeftColor(const QColor&) ));
244
 
        connect(rightColorButton, SIGNAL( changed(const QColor&) ), SLOT( slotChangedRightColor(const QColor&) ));
245
 
 
246
 
//      intNumInputLeftOpacity -> setRange( 0, 100, false);
247
 
        connect(intNumInputLeftOpacity, SIGNAL( valueChanged(int) ), SLOT( slotChangedLeftOpacity(int) ));
248
 
//      intNumInputRightOpacity -> setRange( 0, 100, false);
249
 
        connect(intNumInputRightOpacity, SIGNAL( valueChanged(int) ), SLOT( slotChangedRightOpacity(int) ));
250
 
}
251
 
 
252
 
void KisAutogradient::slotSelectedSegment(KisGradientSegment* segment)
253
 
{
254
 
        leftColorButton -> setColor( segment -> startColor().color() );
255
 
        rightColorButton -> setColor( segment -> endColor().color() );
256
 
        comboBoxColorInterpolationType -> setCurrentItem( segment -> colorInterpolation() );
257
 
        comboBoxInterpolationType -> setCurrentItem( segment -> interpolation() );
258
 
 
259
 
        int leftOpacity = qRound(segment -> startColor().alpha() * 100);
260
 
        intNumInputLeftOpacity -> setValue( leftOpacity );
261
 
 
262
 
        int rightOpacity = qRound(segment -> endColor().alpha() * 100);
263
 
        intNumInputRightOpacity -> setValue( rightOpacity );
264
 
 
265
 
        paramChanged();
266
 
}
267
 
 
268
 
void KisAutogradient::slotChangedSegment(KisGradientSegment* segment)
269
 
{
270
 
        paramChanged();
271
 
}
272
 
 
273
 
void KisAutogradient::slotChangedInterpolation(int type)
274
 
{
275
 
        KisGradientSegment* segment = gradientSlider -> selectedSegment();
276
 
        if(segment)
277
 
                segment -> setInterpolation( type );
278
 
        gradientSlider -> repaint();
279
 
 
280
 
        paramChanged();
281
 
}
282
 
 
283
 
void KisAutogradient::slotChangedColorInterpolation(int type)
284
 
{
285
 
        KisGradientSegment* segment = gradientSlider -> selectedSegment();
286
 
        if(segment)
287
 
                segment -> setColorInterpolation( type );
288
 
        gradientSlider -> repaint();
289
 
 
290
 
        paramChanged();
291
 
}
292
 
 
293
 
void KisAutogradient::slotChangedLeftColor( const QColor& color)
294
 
{
295
 
        KisGradientSegment* segment = gradientSlider -> selectedSegment();
296
 
        if(segment)
297
 
                segment -> setStartColor( Color( color, segment -> startColor().alpha() ) );
298
 
        gradientSlider -> repaint();
299
 
 
300
 
        paramChanged();
301
 
}
302
 
 
303
 
void KisAutogradient::slotChangedRightColor( const QColor& color)
304
 
{
305
 
        KisGradientSegment* segment = gradientSlider -> selectedSegment();
306
 
        if(segment)
307
 
                segment -> setEndColor( Color( color, segment -> endColor().alpha() ) );
308
 
        gradientSlider -> repaint();
309
 
 
310
 
        paramChanged();
311
 
}
312
 
 
313
 
void KisAutogradient::slotChangedLeftOpacity( int value )
314
 
{
315
 
        KisGradientSegment* segment = gradientSlider -> selectedSegment();
316
 
        if(segment)
317
 
                segment -> setStartColor( Color( segment -> startColor().color(), (double)value / 100 ) );
318
 
        gradientSlider -> repaint(false);
319
 
 
320
 
        paramChanged();
321
 
}
322
 
 
323
 
void KisAutogradient::slotChangedRightOpacity( int value )
324
 
{
325
 
        KisGradientSegment* segment = gradientSlider -> selectedSegment();
326
 
        if(segment)
327
 
                segment -> setEndColor( Color( segment -> endColor().color(), (double)value / 100 ) );
328
 
        gradientSlider -> repaint(false);
329
 
 
330
 
        paramChanged();
331
 
}
332
 
 
333
 
void KisAutogradient::paramChanged()
334
 
{
335
 
        m_autogradientResource -> updatePreview ();
336
 
        emit activatedResource( m_autogradientResource );
337
 
}
338
 
 
339
 
#include "kis_autogradient.moc"