Profile.h

Go to the documentation of this file.

/*
    This source file is part of Konsole, a terminal emulator.

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

// Qt
#include <QtCore/QHash>
#include <QtCore/QStringList>
#include <QtCore/QVariant>
#include <QtGui/QFont>
#include <QtGui/QColor>

// KDE
#include <KSharedPtr>

// Konsole
#include "konsole_export.h"

namespace Konsole
{
class ProfileGroup;

class KONSOLEPRIVATE_EXPORT Profile : public QSharedData
{
    friend class KDE4ProfileReader;
    friend class KDE4ProfileWriter;
    friend class ProfileGroup;

public:
    typedef KSharedPtr<Profile> Ptr;
    typedef KSharedPtr<ProfileGroup> GroupPtr;

    enum Property {
        Path,
        Name,
        UntranslatedName,
        Icon,
        Command,
        Arguments,
        Environment,
        Directory,
        LocalTabTitleFormat,
        RemoteTabTitleFormat,
        ShowTerminalSizeHint,
        SaveGeometryOnExit,
        Font,
        ColorScheme,
        KeyBindings,
        HistoryMode,
        HistorySize,
        ScrollBarPosition,
        ScrollFullPage,
        BidiRenderingEnabled,
        BlinkingTextEnabled,
        FlowControlEnabled,
        LineSpacing,
        BlinkingCursorEnabled,
        UseCustomCursorColor,
        CursorShape,
        CustomCursorColor,
        WordCharacters,
        TripleClickMode,
        UnderlineLinksEnabled,
        OpenLinksByDirectClickEnabled,
        CtrlRequiredForDrag,
        AutoCopySelectedText,
        TrimTrailingSpacesInSelectedText,
        PasteFromSelectionEnabled,
        PasteFromClipboardEnabled,
        MiddleClickPasteMode,
        DefaultEncoding,
        AntiAliasFonts,
        BoldIntense,
        StartInCurrentSessionDir,
        SilenceSeconds,
        BellMode,
        TerminalColumns,
        TerminalRows,
        MenuIndex,
        MouseWheelZoomEnabled
    };

    explicit Profile(Ptr parent = Ptr());
    virtual ~Profile();

    void clone(Ptr profile, bool differentOnly = true);

    void setParent(Ptr parent);

    const Ptr parent() const;

    const GroupPtr asGroup() const;
    GroupPtr asGroup();

    template <class T>
    T property(Property property) const;

    virtual void setProperty(Property property, const QVariant& value);
    virtual bool isPropertySet(Property property) const;

    virtual QHash<Property, QVariant> setProperties() const;

    bool isEmpty() const;

    bool isHidden() const;

    void setHidden(bool hidden);

    //
    // Convenience methods for property() and setProperty() go here
    //

    QString path() const {
        return property<QString>(Profile::Path);
    }

    QString name() const {
        return property<QString>(Profile::Name);
    }

    QString untranslatedName() const {
        return property<QString>(Profile::UntranslatedName);
    }

    QString defaultWorkingDirectory() const {
        return property<QString>(Profile::Directory);
    }

    QString icon() const {
        return property<QString>(Profile::Icon);
    }

    QString command() const {
        return property<QString>(Profile::Command);
    }

    QStringList arguments() const {
        return property<QStringList>(Profile::Arguments);
    }

    QString localTabTitleFormat() const {
        return property<QString>(Profile::LocalTabTitleFormat);
    }

    QString remoteTabTitleFormat() const {
        return property<QString>(Profile::RemoteTabTitleFormat);
    }

    bool showTerminalSizeHint() const {
        return property<bool>(Profile::ShowTerminalSizeHint);
    }

    bool saveGeometryOnExit() const {
        return property<bool>(Profile::SaveGeometryOnExit);
    }

    QFont font() const {
        return property<QFont>(Profile::Font);
    }

    QString colorScheme() const {
        return property<QString>(Profile::ColorScheme);
    }

    QStringList environment() const {
        return property<QStringList>(Profile::Environment);
    }

    QString keyBindings() const {
        return property<QString>(Profile::KeyBindings);
    }

    int historySize() const {
        return property<int>(Profile::HistorySize);
    }

    bool bidiRenderingEnabled() const {
        return property<bool>(Profile::BidiRenderingEnabled);
    }

    int lineSpacing() const {
        return property<int>(Profile::LineSpacing);
    }


    bool blinkingTextEnabled() const {
        return property<bool>(Profile::BlinkingTextEnabled);
    }

    bool mouseWheelZoomEnabled() const {
        return property<bool>(Profile::MouseWheelZoomEnabled);
    }

    bool blinkingCursorEnabled() const {
        return property<bool>(Profile::BlinkingCursorEnabled);
    }

    bool flowControlEnabled() const {
        return property<bool>(Profile::FlowControlEnabled);
    }

    bool useCustomCursorColor() const {
        return property<bool>(Profile::UseCustomCursorColor);
    }

    QColor customCursorColor() const {
        return property<QColor>(Profile::CustomCursorColor);
    }

    QString wordCharacters() const {
        return property<QString>(Profile::WordCharacters);
    }

    bool underlineLinksEnabled() const {
        return property<bool>(Profile::UnderlineLinksEnabled);
    }

    bool autoCopySelectedText() const {
        return property<bool>(Profile::AutoCopySelectedText);
    }

    QString defaultEncoding() const {
        return property<QString>(Profile::DefaultEncoding);
    }

    bool antiAliasFonts() const {
        return property<bool>(Profile::AntiAliasFonts);
    }

    bool boldIntense() const {
        return property<bool>(Profile::BoldIntense);
    }

    bool startInCurrentSessionDir() const {
        return property<bool>(Profile::StartInCurrentSessionDir);
    }

    int silenceSeconds() const {
        return property<int>(Profile::SilenceSeconds);
    }

    QString menuIndex() const {
        return property<QString>(Profile::MenuIndex);
    }

    int menuIndexAsInt() const;

    const QStringList propertiesInfoList() const;

    static Property lookupByName(const QString& name);

private:
    struct PropertyInfo;
    // Defines a new property, this property is then available
    // to all Profile instances.
    static void registerProperty(const PropertyInfo& info);

    // fills the table with default names for profile properties
    // the first time it is called.
    // subsequent calls return immediately
    static void fillTableWithDefaultNames();

    // returns true if the property can be inherited
    static bool canInheritProperty(Property property);

    QHash<Property, QVariant> _propertyValues;
    Ptr _parent;

    bool _hidden;

    static QHash<QString, PropertyInfo> PropertyInfoByName;
    static QHash<Property, PropertyInfo> PropertyInfoByProperty;

    // Describes a property.  Each property has a name and group
    // which is used when saving/loading the profile.
    struct PropertyInfo {
        Property property;
        const char* name;
        const char* group;
        QVariant::Type type;
    };
    static const PropertyInfo DefaultPropertyNames[];
};

inline bool Profile::canInheritProperty(Property aProperty)
{
    return aProperty != Name && aProperty != Path;
}

template <class T>
inline T Profile::property(Property aProperty) const
{
    return property<QVariant>(aProperty).value<T>();
}
template <>
inline QVariant Profile::property(Property aProperty) const
{
    if (_propertyValues.contains(aProperty)) {
        return _propertyValues[aProperty];
    } else if (_parent && canInheritProperty(aProperty)) {
        return _parent->property<QVariant>(aProperty);
    } else {
        return QVariant();
    }
}

class FallbackProfile : public Profile
{
public:
    FallbackProfile();
};

class KONSOLEPRIVATE_EXPORT ProfileGroup : public Profile
{
public:
    typedef KSharedPtr<ProfileGroup> Ptr;

    explicit ProfileGroup(Profile::Ptr parent = Profile::Ptr());

    void addProfile(Profile::Ptr profile) {
        _profiles.append(profile);
    }

    void removeProfile(Profile::Ptr profile) {
        _profiles.removeAll(profile);
    }

    QList<Profile::Ptr> profiles() const {
        return _profiles;
    }

    void updateValues();

    void setProperty(Property property, const QVariant& value);

private:
    QList<Profile::Ptr> _profiles;
};
inline ProfileGroup::ProfileGroup(Profile::Ptr profileParent)
    : Profile(profileParent)
{
    setHidden(true);
}
inline const Profile::GroupPtr Profile::asGroup() const
{
    const Profile::GroupPtr ptr(dynamic_cast<ProfileGroup*>(
                                    const_cast<Profile*>(this)));
    return ptr;
}
inline Profile::GroupPtr Profile::asGroup()
{
    return Profile::GroupPtr(dynamic_cast<ProfileGroup*>(this));
}

class KONSOLEPRIVATE_EXPORT ProfileCommandParser
{
public:
    QHash<Profile::Property, QVariant> parse(const QString& input);
};
}
Q_DECLARE_METATYPE(Konsole::Profile::Ptr)

#endif // PROFILE_H