1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
|
/*
* Copyright (c) 2004 Cyrille Berger <cberger@cberger.net>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef _KIS_FILTER_H_
#define _KIS_FILTER_H_
#include <list>
#include <tqstring.h>
#include <ksharedptr.h>
#include <tdelocale.h>
#include "kis_types.h"
#include "kis_filter_registry.h"
#include "kis_id.h"
#include "kis_paint_device.h"
#include "kis_progress_subject.h"
#include "kis_filter_configuration.h"
#include "kis_colorspace.h"
#include "koffice_export.h"
class KisColorSpace;
class KisPreviewDialog;
class KisProgressDisplayInterface;
class KisFilterConfigWidget;
class TQWidget;
/**
* Basic interface of a Chalk filter.
*/
class KRITACORE_EXPORT KisFilter : public KisProgressSubject, public TDEShared {
TQ_OBJECT
public:
/**
* Construct a Chalk filter
*/
KisFilter(const KisID& id, const TQString & category, const TQString & entry);
virtual ~KisFilter() {}
public:
virtual void setProgressDisplay(KisProgressDisplayInterface * progressDisplay);
virtual void process(KisPaintDeviceSP src, KisPaintDeviceSP dst, KisFilterConfiguration*, const TQRect&) = 0;
public:
/**
* @return a new configuration derived from the widget. If the widget is NULL or not the correct type,
* a default configuration object will be returned
*/
virtual KisFilterConfiguration * configuration(TQWidget*);
/**
* @return a default configuration object
* Normally this doesn't need to be overriden
*/
virtual KisFilterConfiguration * configuration();
/**
* If true, this filter can be used in painting tools as a paint operation
*/
virtual bool supportsPainting() { return false; };
/// This filter can be displayed in a preview dialog
virtual bool supportsPreview() { return false; };
/// This filter can be used in adjustment layers
// XXX: This uses supportsPreview() for backwards compatibility
virtual bool supportsAdjustmentLayers() { return supportsPreview(); };
/**
* Return a list of default configuration to demonstrates the use of the filter
* @return a list with a null element if the filter do not use a configuration
*/
virtual std::list<KisFilterConfiguration*> listOfExamplesConfiguration(KisPaintDeviceSP )
{ std::list<KisFilterConfiguration*> list; list.insert(list.begin(), 0); return list; }
/**
* Can this filter work incrementally when painting, or do we need to work
* on the state as it was before painting started. The former is faster.
*/
virtual bool supportsIncrementalPainting() { return true; };
/**
* This filter supports cutting up the work area and filtering
* each chunk in a separate thread. Filters that need access to the
* whole area for correct computations should return false.
*/
virtual bool supportsThreading() { return true; };
/**
* Used when threading is used -- the overlap margin is passed to the
* filter to use to compute pixels, but the margin is not pasted into the
* resulting image.
*/
virtual int overlapMarginNeeded(KisFilterConfiguration* = 0) const { return 0; };
/**
* Similar to overlapMarginNeeded: some filters will alter a lot of pixels that are
* near to each other at the same time. So when you changed a single rectangle
* in a device, the actual rectangle that will feel the influence of this change
* might be bigger. Use this function to detirmine that rect.
* The default implementation makes a guess using overlapMarginNeeded.
*/
virtual TQRect enlargeRect(TQRect rect, KisFilterConfiguration* = 0) const;
/**
* Determine the colorspace independence of this filter.
* @see ColorSpaceIndependence
*
* @return the degree of independence
*/
virtual ColorSpaceIndependence colorSpaceIndependence() { return TO_RGBA8; };
/**
* Determine if this filter can work with this colorSpace. For instance, some
* colorspaces don't depend on lcms, and cannot do certain tasks. The colorsfilters
* are problems here.
* BSAR: I'm still not convinced that this is the right approach. I think that every
* colorspace should implement the api fully; and that the filter should simply call
* that api. After all, you don't need lcms to desaturate.
*
* @param colorsSpace
*/
virtual bool workWith(KisColorSpace*) { return true; }
virtual void enableProgress();
virtual void disableProgress();
bool autoUpdate();
// Unique identification for this filter
inline const KisID id() const { return m_id; };
// Which submenu in the filters menu does filter want to go?
inline TQString menuCategory() const { return m_category; };
// The i18n'ed string this filter wants to show itself in the menu
inline TQString menuEntry() const { return m_entry; };
/**
* Create the configuration widget for this filter.
*
* @param parent the TQt owner widget of this widget
* @param dev the paintdevice this filter will act on
* @return NULL if the filter does not use user-settable configuration settings.
* else return a pointer to the new configuration widget
*/
virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget * parent, KisPaintDeviceSP dev);
virtual void cancel() { m_cancelRequested = true; }
virtual void setAutoUpdate(bool set);
bool progressEnabled() const { return m_progressEnabled; }
inline bool cancelRequested() const { return m_progressEnabled && m_cancelRequested; }
protected slots:
// Convenience functions for progress display.
void setProgressTotalSteps(TQ_INT32 totalSteps);
void setProgress(TQ_INT32 progress);
void incProgress();
void setProgressStage(const TQString& stage, TQ_INT32 progress);
void setProgressDone();
inline TQ_INT32 progress() { return m_progressSteps; }
private:
bool m_cancelRequested;
bool m_progressEnabled;
bool m_autoUpdate;
protected:
TQ_INT32 m_progressTotalSteps;
TQ_INT32 m_lastProgressPerCent;
TQ_INT32 m_progressSteps;
KisID m_id;
KisProgressDisplayInterface * m_progressDisplay;
TQString m_category; // The category in the filter menu this filter fits
TQString m_entry; // the i18n'ed accelerated menu text
};
#endif
|
