← Back to branch summary

~ubuntu-branches/ubuntu/breezy/koffice/breezy-security

« back to all changes in this revision

Viewing changes to krita/plugins/convolutionfilters/convolutionfilters.h

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Riddell
  • Date: 2005-10-11 14:49:50 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051011144950-lwpngbifzp8nk0ds
Tags: 1:1.4.1-0ubuntu7
* SECURITY UPDATE: fix heap based buffer overflow in the RTF importer of KWord
* Opening specially crafted RTF files in KWord can cause
  execution of abitrary code.
* Add kubuntu_01_rtfimport_heap_overflow.diff
* References:
  CAN-2005-2971
  CESA-2005-005
  http://www.koffice.org/security/advisory-20051011-1.txt

Show diffs side-by-side

added added

removed removed

Lines of Context:
krita/plugins/convolutionfilters/convolutionfilters.h
 
1
/*
 
2
 * This file is part of Krita
 
3
 *
 
4
 * Copyright (c) 2004 Cyrille Berger <cberger@cberger.net>
 
5
 *
 
6
 *  This program is free software; you can redistribute it and/or modify
 
7
 *  it under the terms of the GNU General Public License as published by
 
8
 *  the Free Software Foundation; either version 2 of the License, or
 
9
 *  (at your option) any later version.
 
10
 *
 
11
 *  This program is distributed in the hope that it will be useful,
 
12
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
 *  GNU General Public License for more details.
 
15
 *
 
16
 *  You should have received a copy of the GNU General Public License
 
17
 *  along with this program; if not, write to the Free Software
 
18
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
19
 */
 
20
 
 
21
#ifndef EXAMPLE_H
 
22
#define EXAMPLE_H
 
23
 
 
24
#include <kparts/plugin.h>
 
25
#include "kis_convolution_filter.h"
 
26
#include "kis_matrix.h"
 
27
#include "kis_view.h"
 
28
 
 
29
class KisView;
 
30
 
 
31
// XXX: All these filters are loaded on document creation. A document
 
32
// can, theoretically, contain zero or more images of different
 
33
// depths. If there are zero images, then closing Krita will crash
 
34
// in the destructor.
 
35
class KisGaussianBlurFilter : public KisConvolutionConstFilter {
 
36
public:
 
37
        KisGaussianBlurFilter(KisView * view);
 
38
public:
 
39
        static inline KisID id() { return KisID("gaussian blur", i18n("Gaussian Blur")); };
 
40
        virtual bool supportsPainting() { return true; }
 
41
        virtual bool supportsIncrementalPainting() { return true; }
 
42
};
 
43
 
 
44
class KisSharpenFilter : public KisConvolutionConstFilter {
 
45
public:
 
46
        KisSharpenFilter(KisView * view);
 
47
public:
 
48
        static inline KisID id() { return KisID("sharpen", i18n("Sharpen")); };
 
49
        virtual bool supportsPainting() { return false; }
 
50
        virtual bool supportsIncrementalPainting() { return false; }
 
51
};
 
52
 
 
53
class KisMeanRemovalFilter : public KisConvolutionConstFilter {
 
54
public:
 
55
        KisMeanRemovalFilter(KisView * view);
 
56
public:
 
57
        static inline KisID id() { return KisID("mean removal", i18n("Mean Removal")); };
 
58
        virtual bool supportsPainting() { return false; }
 
59
 
 
60
};
 
61
 
 
62
class KisEmbossLaplascianFilter : public KisConvolutionConstFilter {
 
63
public:
 
64
        KisEmbossLaplascianFilter(KisView * view);
 
65
public:
 
66
        static inline KisID id() { return KisID("emboss laplascian", i18n("Emboss Laplascian")); };
 
67
        virtual bool supportsPainting() { return false; }
 
68
 
 
69
};
 
70
 
 
71
class KisEmbossInAllDirectionsFilter : public KisConvolutionConstFilter {
 
72
public:
 
73
        KisEmbossInAllDirectionsFilter(KisView * view);
 
74
public:
 
75
        static inline KisID id() { return KisID("emboss all directions", i18n("Emboss in All Directions")); };
 
76
        virtual bool supportsPainting() { return false; }
 
77
 
 
78
};
 
79
 
 
80
class KisEmbossHorizontalVerticalFilter : public KisConvolutionConstFilter {
 
81
public:
 
82
        KisEmbossHorizontalVerticalFilter(KisView * view);
 
83
public:
 
84
        static inline KisID id() { return KisID("", i18n("Emboss Horizontal & Vertical")); };
 
85
        virtual bool supportsPainting() { return false; }
 
86
 
 
87
};
 
88
 
 
89
class KisEmbossVerticalFilter : public KisConvolutionConstFilter {
 
90
public:
 
91
        KisEmbossVerticalFilter(KisView * view);
 
92
public:
 
93
        static inline KisID id() { return KisID("emboss vertical only", i18n("Emboss Vertical Only")); };
 
94
        virtual bool supportsPainting() { return false; }
 
95
 
 
96
};
 
97
 
 
98
class KisEmbossHorizontalFilter : public KisConvolutionConstFilter {
 
99
public:
 
100
        KisEmbossHorizontalFilter(KisView * view);
 
101
public:
 
102
        static inline KisID id() { return KisID("emboss horizontal only", i18n("Emboss Horizontal Only")); };
 
103
        virtual bool supportsPainting() { return false; }
 
104
 
 
105
};
 
106
 
 
107
class KisEmbossDiagonalFilter : public KisConvolutionConstFilter {
 
108
public:
 
109
        KisEmbossDiagonalFilter(KisView * view);
 
110
public:
 
111
        static inline KisID id() { return KisID("emboss diagonal", i18n("Emboss Diagonal")); };
 
112
        virtual bool supportsPainting() { return false; }
 
113
 
 
114
};
 
115
 
 
116
class KisTopEdgeDetectionFilter : public KisConvolutionConstFilter {
 
117
public:
 
118
        KisTopEdgeDetectionFilter(KisView * view);
 
119
public:
 
120
        static inline KisID id() { return KisID("top edge detections", i18n("Top Edge Detection")); };
 
121
        virtual bool supportsPainting() { return false; }
 
122
 
 
123
};
 
124
 
 
125
class KisRightEdgeDetectionFilter : public KisConvolutionConstFilter {
 
126
public:
 
127
        KisRightEdgeDetectionFilter(KisView * view);
 
128
public:
 
129
        static inline KisID id() { return KisID("right edge detections", i18n("Right Edge Detection")); };
 
130
        virtual bool supportsPainting() { return false; }
 
131
 
 
132
};
 
133
 
 
134
class KisBottomEdgeDetectionFilter : public KisConvolutionConstFilter {
 
135
public:
 
136
        KisBottomEdgeDetectionFilter(KisView * view);
 
137
public:
 
138
        static inline KisID id() { return KisID("bottom edge detections", i18n("Bottom Edge Detection")); };
 
139
        virtual bool supportsPainting() { return false; }
 
140
 
 
141
};
 
142
 
 
143
class KisLeftEdgeDetectionFilter : public KisConvolutionConstFilter {
 
144
public:
 
145
        KisLeftEdgeDetectionFilter(KisView * view);
 
146
public:
 
147
        static inline KisID id() { return KisID("left edge detections", i18n("Left Edge Detection")); };
 
148
        virtual bool supportsPainting() { return false; }
 
149
 
 
150
};
 
151
 
 
152
 
 
153
class KritaConvolutionFilters : public KParts::Plugin
 
154
{
 
155
public:
 
156
        KritaConvolutionFilters(QObject *parent, const char *name, const QStringList &);
 
157
        virtual ~KritaConvolutionFilters();
 
158
};
 
159
 
 
160
#endif