Filter.h

Go to the documentation of this file.

/*
    Copyright 2007-2008 by Robert Knight <robertknight@gmail.com>

    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 FILTER_H
#define FILTER_H

// Qt
#include <QtCore/QList>
#include <QtCore/QObject>
#include <QtCore/QStringList>
#include <QtCore/QRegExp>
#include <QtCore/QMultiHash>

// Konsole
#include "Character.h"

class QAction;

namespace Konsole
{
class Filter
{
public:
    class HotSpot
    {
    public:
        HotSpot(int startLine , int startColumn , int endLine , int endColumn);
        virtual ~HotSpot();

        enum Type {
            // the type of the hotspot is not specified
            NotSpecified,
            // this hotspot represents a clickable link
            Link,
            // this hotspot represents a marker
            Marker
        };

        int startLine() const;
        int endLine() const;
        int startColumn() const;
        int endColumn() const;
        Type type() const;
        virtual void activate(QObject* object = 0) = 0;
        virtual QList<QAction*> actions();

    protected:
        void setType(Type type);

    private:
        int    _startLine;
        int    _startColumn;
        int    _endLine;
        int    _endColumn;
        Type _type;
    };

    Filter();
    virtual ~Filter();

    virtual void process() = 0;

    void reset();

    //void addLine(const QString& string);

    HotSpot* hotSpotAt(int line , int column) const;

    QList<HotSpot*> hotSpots() const;

    QList<HotSpot*> hotSpotsAtLine(int line) const;

    void setBuffer(const QString* buffer , const QList<int>* linePositions);

protected:
    void addHotSpot(HotSpot*);
    const QString* buffer();
    void getLineColumn(int position , int& startLine , int& startColumn);

private:
    QMultiHash<int, HotSpot*> _hotspots;
    QList<HotSpot*> _hotspotList;

    const QList<int>* _linePositions;
    const QString* _buffer;
};

class RegExpFilter : public Filter
{
public:
    class HotSpot : public Filter::HotSpot
    {
    public:
        HotSpot(int startLine, int startColumn, int endLine , int endColumn);
        virtual void activate(QObject* object = 0);

        void setCapturedTexts(const QStringList& texts);
        QStringList capturedTexts() const;
    private:
        QStringList _capturedTexts;
    };

    RegExpFilter();

    void setRegExp(const QRegExp& text);
    QRegExp regExp() const;

    virtual void process();

protected:
    virtual RegExpFilter::HotSpot* newHotSpot(int startLine, int startColumn,
            int endLine, int endColumn);

private:
    QRegExp _searchText;
};

class FilterObject;

class UrlFilter : public RegExpFilter
{
public:
    class HotSpot : public RegExpFilter::HotSpot
    {
    public:
        HotSpot(int startLine, int startColumn, int endLine, int endColumn);
        virtual ~HotSpot();

        virtual QList<QAction*> actions();

        virtual void activate(QObject* object = 0);

    private:
        enum UrlType {
            StandardUrl,
            Email,
            Unknown
        };
        UrlType urlType() const;

        FilterObject* _urlObject;
    };

    UrlFilter();

protected:
    virtual RegExpFilter::HotSpot* newHotSpot(int, int, int, int);

private:
    static const QRegExp FullUrlRegExp;
    static const QRegExp EmailAddressRegExp;

    // combined OR of FullUrlRegExp and EmailAddressRegExp
    static const QRegExp CompleteUrlRegExp;
};

class FilterObject : public QObject
{
    Q_OBJECT
public:
    explicit FilterObject(Filter::HotSpot* filter) : _filter(filter) {}
private slots:
    void activated();
private:
    Filter::HotSpot* _filter;
};

class FilterChain : protected QList<Filter*>
{
public:
    virtual ~FilterChain();

    void addFilter(Filter* filter);
    void removeFilter(Filter* filter);
    void clear();

    void reset();
    void process();

    void setBuffer(const QString* buffer , const QList<int>* linePositions);

    Filter::HotSpot* hotSpotAt(int line , int column) const;
    QList<Filter::HotSpot*> hotSpots() const;
    QList<Filter::HotSpot> hotSpotsAtLine(int line) const;
};

class TerminalImageFilterChain : public FilterChain
{
public:
    TerminalImageFilterChain();
    virtual ~TerminalImageFilterChain();

    void setImage(const Character* const image , int lines , int columns,
                  const QVector<LineProperty>& lineProperties);

private:
    QString* _buffer;
    QList<int>* _linePositions;
};
}
#endif //FILTER_H