2
Copyright 2007-2008 by Robert Knight <robertknight@gmail.com>
4
This program is free software; you can redistribute it and/or modify
5
it under the terms of the GNU General Public License as published by
6
the Free Software Foundation; either version 2 of the License, or
7
(at your option) any later version.
9
This program is distributed in the hope that it will be useful,
10
but WITHOUT ANY WARRANTY; without even the implied warranty of
11
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12
GNU General Public License for more details.
14
You should have received a copy of the GNU General Public License
15
along with this program; if not, write to the Free Software
16
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
27
#include <QStringList>
36
typedef unsigned char LineProperty;
40
* A filter processes blocks of text looking for certain patterns (such as URLs or keywords from a list)
41
* and marks the areas which match the filter's patterns as 'hotspots'.
43
* Each hotspot has a type identifier associated with it ( such as a link or a highlighted section ),
44
* and an action. When the user performs some activity such as a mouse-click in a hotspot area ( the exact
45
* action will depend on what is displaying the block of text which the filter is processing ), the hotspot's
46
* activate() method should be called. Depending on the type of hotspot this will trigger a suitable response.
48
* For example, if a hotspot represents a URL then a suitable action would be opening that URL in a web browser.
49
* Hotspots may have more than one action, in which case the list of actions can be obtained using the
52
* Different subclasses of filter will return different types of hotspot.
53
* Subclasses must reimplement the process() method to examine a block of text and identify sections of interest.
54
* When processing the text they should create instances of Filter::HotSpot subclasses for sections of interest
55
* and add them to the filter's list of hotspots using addHotSpot()
57
class Filter : public QObject
61
* Represents an area of text which matched the pattern a particular filter has been looking for.
63
* Each hotspot has a type identifier associated with it ( such as a link or a highlighted section ),
64
* and an action. When the user performs some activity such as a mouse-click in a hotspot area ( the exact
65
* action will depend on what is displaying the block of text which the filter is processing ), the hotspot's
66
* activate() method should be called. Depending on the type of hotspot this will trigger a suitable response.
68
* For example, if a hotspot represents a URL then a suitable action would be opening that URL in a web browser.
69
* Hotspots may have more than one action, in which case the list of actions can be obtained using the
70
* actions() method. These actions may then be displayed in a popup menu or toolbar for example.
76
* Constructs a new hotspot which covers the area from (@p startLine,@p startColumn) to (@p endLine,@p endColumn)
79
HotSpot(int startLine , int startColumn , int endLine , int endColumn);
84
// the type of the hotspot is not specified
86
// this hotspot represents a clickable link
88
// this hotspot represents a marker
92
/** Returns the line when the hotspot area starts */
93
int startLine() const;
94
/** Returns the line where the hotspot area ends */
96
/** Returns the column on startLine() where the hotspot area starts */
97
int startColumn() const;
98
/** Returns the column on endLine() where the hotspot area ends */
99
int endColumn() const;
101
* Returns the type of the hotspot. This is usually used as a hint for views on how to represent
102
* the hotspot graphically. eg. Link hotspots are typically underlined when the user mouses over them
106
* Causes the an action associated with a hotspot to be triggered.
108
* @param action The action to trigger. This is
109
* typically empty ( in which case the default action should be performed ) or
110
* one of the object names from the actions() list. In which case the associated
111
* action should be performed.
113
virtual void activate(const QString& action = QString()) = 0;
115
* Returns a list of actions associated with the hotspot which can be used in a
118
virtual QList<QAction*> actions();
121
* Returns the text of a tooltip to be shown when the mouse moves over the hotspot, or
122
* an empty string if there is no tooltip associated with this hotspot.
124
* The default implementation returns an empty string.
126
virtual QString tooltip() const;
129
/** Sets the type of a hotspot. This should only be set once */
130
void setType(Type type);
141
/** Constructs a new filter. */
145
/** Causes the filter to process the block of text currently in its internal buffer */
146
virtual void process() = 0;
149
* Empties the filters internal buffer and resets the line count back to 0.
150
* All hotspots are deleted.
154
/** Adds a new line of text to the filter and increments the line count */
155
//void addLine(const QString& string);
157
/** Returns the hotspot which covers the given @p line and @p column, or 0 if no hotspot covers that area */
158
HotSpot* hotSpotAt(int line , int column) const;
160
/** Returns the list of hotspots identified by the filter */
161
QList<HotSpot*> hotSpots() const;
163
/** Returns the list of hotspots identified by the filter which occur on a given line */
164
QList<HotSpot*> hotSpotsAtLine(int line) const;
169
void setBuffer(const QString* buffer , const QList<int>* linePositions);
172
/** Adds a new hotspot to the list */
173
void addHotSpot(HotSpot*);
174
/** Returns the internal buffer */
175
const QString* buffer();
176
/** Converts a character position within buffer() to a line and column */
177
void getLineColumn(int position , int& startLine , int& startColumn);
180
QMultiHash<int,HotSpot*> _hotspots;
181
QList<HotSpot*> _hotspotList;
183
const QList<int>* _linePositions;
184
const QString* _buffer;
188
* A filter which searches for sections of text matching a regular expression and creates a new RegExpFilter::HotSpot
191
* Subclasses can reimplement newHotSpot() to return custom hotspot types when matches for the regular expression
194
class RegExpFilter : public Filter
198
* Type of hotspot created by RegExpFilter. The capturedTexts() method can be used to find the text
199
* matched by the filter's regular expression.
201
class HotSpot : public Filter::HotSpot
204
HotSpot(int startLine, int startColumn, int endLine , int endColumn);
205
virtual void activate(const QString& action = QString());
207
/** Sets the captured texts associated with this hotspot */
208
void setCapturedTexts(const QStringList& texts);
209
/** Returns the texts found by the filter when matching the filter's regular expression */
210
QStringList capturedTexts() const;
212
QStringList _capturedTexts;
215
/** Constructs a new regular expression filter */
219
* Sets the regular expression which the filter searches for in blocks of text.
221
* Regular expressions which match the empty string are treated as not matching
224
void setRegExp(const QRegExp& text);
225
/** Returns the regular expression which the filter searches for in blocks of text */
226
QRegExp regExp() const;
229
* Reimplemented to search the filter's text buffer for text matching regExp()
231
* If regexp matches the empty string, then process() will return immediately
232
* without finding results.
234
virtual void process();
238
* Called when a match for the regular expression is encountered. Subclasses should reimplement this
239
* to return custom hotspot types
241
virtual RegExpFilter::HotSpot* newHotSpot(int startLine,int startColumn,
242
int endLine,int endColumn);
250
/** A filter which matches URLs in blocks of text */
251
class UrlFilter : public RegExpFilter
256
* Hotspot type created by UrlFilter instances. The activate() method opens a web browser
257
* at the given URL when called.
259
class HotSpot : public RegExpFilter::HotSpot
262
HotSpot(int startLine,int startColumn,int endLine,int endColumn);
265
FilterObject* getUrlObject() const;
267
virtual QList<QAction*> actions();
270
* Open a web browser at the current URL. The url itself can be determined using
271
* the capturedTexts() method.
273
virtual void activate(const QString& action = QString());
275
virtual QString tooltip() const;
283
UrlType urlType() const;
285
FilterObject* _urlObject;
291
virtual RegExpFilter::HotSpot* newHotSpot(int,int,int,int);
295
static const QRegExp FullUrlRegExp;
296
static const QRegExp EmailAddressRegExp;
298
// combined OR of FullUrlRegExp and EmailAddressRegExp
299
static const QRegExp CompleteUrlRegExp;
301
void activated(const QUrl& url);
304
class FilterObject : public QObject
308
FilterObject(Filter::HotSpot* filter) : _filter(filter) {}
310
void emitActivated(const QUrl& url);
314
Filter::HotSpot* _filter;
316
void activated(const QUrl& url);
320
* A chain which allows a group of filters to be processed as one.
321
* The chain owns the filters added to it and deletes them when the chain itself is destroyed.
323
* Use addFilter() to add a new filter to the chain.
324
* When new text to be filtered arrives, use addLine() to add each additional
325
* line of text which needs to be processed and then after adding the last line, use
326
* process() to cause each filter in the chain to process the text.
328
* After processing a block of text, the reset() method can be used to set the filter chain's
329
* internal cursor back to the first line.
331
* The hotSpotAt() method will return the first hotspot which covers a given position.
333
* The hotSpots() and hotSpotsAtLine() method return all of the hotspots in the text and on
334
* a given line respectively.
336
class FilterChain : protected QList<Filter*>
339
virtual ~FilterChain();
341
/** Adds a new filter to the chain. The chain will delete this filter when it is destroyed */
342
void addFilter(Filter* filter);
343
/** Removes a filter from the chain. The chain will no longer delete the filter when destroyed */
344
void removeFilter(Filter* filter);
345
/** Returns true if the chain contains @p filter */
346
bool containsFilter(Filter* filter);
347
/** Removes all filters from the chain */
350
/** Resets each filter in the chain */
353
* Processes each filter in the chain
357
/** Sets the buffer for each filter in the chain to process. */
358
void setBuffer(const QString* buffer , const QList<int>* linePositions);
360
/** Returns the first hotspot which occurs at @p line, @p column or 0 if no hotspot was found */
361
Filter::HotSpot* hotSpotAt(int line , int column) const;
362
/** Returns a list of all the hotspots in all the chain's filters */
363
QList<Filter::HotSpot*> hotSpots() const;
364
/** Returns a list of all hotspots at the given line in all the chain's filters */
365
QList<Filter::HotSpot> hotSpotsAtLine(int line) const;
369
/** A filter chain which processes character images from terminal displays */
370
class TerminalImageFilterChain : public FilterChain
373
TerminalImageFilterChain();
374
virtual ~TerminalImageFilterChain();
377
* Set the current terminal image to @p image.
379
* @param image The terminal image
380
* @param lines The number of lines in the terminal image
381
* @param columns The number of columns in the terminal image
382
* @param lineProperties The line properties to set for image
384
void setImage(const Character* const image , int lines , int columns,
385
const QVector<LineProperty>& lineProperties);
389
QList<int>* _linePositions;
394
typedef Konsole::Filter Filter;
added
removed
src/plugin/qmltermwidget/qtermwidget/lib/Filter.h
