theme.h

Go to the documentation of this file.

/******************************************************************************
 *
 *  Copyright 2008 Szymon Tomasz Stefanek <pragma@kvirc.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 __MESSAGELIST_CORE_THEME_H__
#define __MESSAGELIST_CORE_THEME_H__

#include <QList>
#include <QPair>
#include <QString>
#include <QFont>
#include <QFontMetrics>
#include <QSize>
#include <QColor>

#include <messagelist/core/optionset.h>
#include <messagelist/core/sortorder.h>

class QPaintDevice;

namespace MessageList
{

namespace Core
{

class Theme : public OptionSet
{
public:
    class ContentItem
    {
    private:
        enum TypePropertyBits
        {
            CanUseCustomColor            = (1 << 16),
            CanBeDisabled                = (1 << 17),
            DisplaysText                 = (1 << 18),
            ApplicableToMessageItems     = (1 << 19),
            ApplicableToGroupHeaderItems = (1 << 20),
            LongText                     = (1 << 21),
            IsIcon                       = (1 << 22),
            IsSpacer                     = (1 << 23),
            IsClickable                  = (1 << 24)
        };

    public:
        enum Type
        {
            Subject                      = 1 | DisplaysText | CanUseCustomColor | ApplicableToMessageItems | LongText,
            Date                         = 2 | DisplaysText | CanUseCustomColor | ApplicableToMessageItems | ApplicableToGroupHeaderItems,
            SenderOrReceiver             = 3 | DisplaysText | CanUseCustomColor | ApplicableToMessageItems,
            Sender                       = 4 | DisplaysText | CanUseCustomColor | ApplicableToMessageItems,
            Receiver                     = 5 | DisplaysText | CanUseCustomColor | ApplicableToMessageItems,
            Size                         = 6 | DisplaysText | CanUseCustomColor | ApplicableToMessageItems,
            ReadStateIcon                = 7 | ApplicableToMessageItems | IsIcon,
            AttachmentStateIcon          = 8 | CanBeDisabled | ApplicableToMessageItems | IsIcon,
            RepliedStateIcon             = 9 | CanBeDisabled | ApplicableToMessageItems | IsIcon,
            GroupHeaderLabel             = 10 | DisplaysText | CanUseCustomColor | ApplicableToGroupHeaderItems,
            ActionItemStateIcon          = 11 | CanBeDisabled | ApplicableToMessageItems | IsIcon | IsClickable,
            ImportantStateIcon           = 12 | CanBeDisabled | ApplicableToMessageItems | IsIcon | IsClickable,
            SpamHamStateIcon             = 13 | CanBeDisabled | ApplicableToMessageItems | IsIcon | IsClickable,
            WatchedIgnoredStateIcon      = 14 | CanBeDisabled | ApplicableToMessageItems | IsIcon | IsClickable,
            ExpandedStateIcon            = 15 | CanBeDisabled | ApplicableToGroupHeaderItems | IsIcon | IsClickable,
            EncryptionStateIcon          = 16 | CanBeDisabled | ApplicableToMessageItems | IsIcon,
            SignatureStateIcon           = 17 | CanBeDisabled | ApplicableToMessageItems | IsIcon,
            VerticalLine                 = 18 | CanUseCustomColor | ApplicableToMessageItems | ApplicableToGroupHeaderItems | IsSpacer,
            HorizontalSpacer             = 19 | ApplicableToMessageItems | ApplicableToGroupHeaderItems | IsSpacer,
            MostRecentDate               = 20 | DisplaysText | CanUseCustomColor | ApplicableToMessageItems | ApplicableToGroupHeaderItems,
            CombinedReadRepliedStateIcon = 21 | ApplicableToMessageItems | IsIcon,
            TagList                      = 22 | ApplicableToMessageItems | IsIcon,
            AnnotationIcon               = 23 | ApplicableToMessageItems | IsIcon | CanBeDisabled | IsClickable,

            InvitationIcon               = 24 | ApplicableToMessageItems | IsIcon
#if 0
            TotalMessageCount
            UnreadMessageCount
            NewMessageCount
#endif
        };

        enum Flags
        {
            HideWhenDisabled = 1,                    
            SoftenByBlendingWhenDisabled = (1 << 1), 
            UseCustomColor = (1 << 2),               
            UseCustomFont = (1 << 3),                
            SoftenByBlending = (1 << 4)              
        };

    private:
        Type mType;                      
        unsigned int mFlags;             

        QFont mFont;                     
        QString mFontKey;                
        QColor mCustomColor;             

    public:
        explicit ContentItem( Type type );
        explicit ContentItem( const ContentItem &src );

    public:
        Type type() const
        { return mType; }

        bool canBeDisabled() const
        { return ( static_cast< int >( mType ) & CanBeDisabled ) != 0; }

        bool canUseCustomColor() const
        { return ( static_cast< int >( mType ) & CanUseCustomColor ) != 0; }

        bool displaysText() const
        { return ( static_cast< int >( mType ) & DisplaysText ) != 0; }

        bool displaysLongText() const
        { return ( static_cast< int >( mType ) & LongText ) != 0; }

        bool isIcon() const
        { return ( static_cast< int >( mType ) & IsIcon ) != 0; }
        bool isClickable() const
        { return ( static_cast< int >( mType ) & IsClickable ) != 0; }

        bool isSpacer() const
        { return ( static_cast< int >( mType ) & IsSpacer ) != 0; }

        static bool applicableToMessageItems( Type type );

        static bool applicableToGroupHeaderItems( Type type );

        static QString description( Type type );

        bool useCustomColor() const
        { return mFlags & UseCustomColor; }

        void setUseCustomColor( bool useCustomColor )
        { if ( useCustomColor )mFlags |= UseCustomColor; else mFlags &= ~UseCustomColor; }

        bool useCustomFont() const
        { return mFlags & UseCustomFont; }

        void setUseCustomFont( bool useCustomFont )
        { if ( useCustomFont )mFlags |= UseCustomFont; else mFlags &= ~UseCustomFont; }

        bool hideWhenDisabled() const
        { return mFlags & HideWhenDisabled; }

        void setHideWhenDisabled( bool hideWhenDisabled )
        { if ( hideWhenDisabled )mFlags |= HideWhenDisabled; else mFlags &= ~HideWhenDisabled; }

        bool softenByBlendingWhenDisabled() const
        { return mFlags & SoftenByBlendingWhenDisabled; }

        void setSoftenByBlendingWhenDisabled( bool softenByBlendingWhenDisabled )
        { if ( softenByBlendingWhenDisabled )mFlags |= SoftenByBlendingWhenDisabled; else mFlags &= ~SoftenByBlendingWhenDisabled; }

        bool softenByBlending() const
        { return mFlags & SoftenByBlending; }

        void setSoftenByBlending( bool softenByBlending )
        { if ( softenByBlending )mFlags |= SoftenByBlending; else mFlags &= ~SoftenByBlending; }

        void setFont( const QFont &font );

        const QFont & font() const
        { return mFont; }

        const QString & fontKey() const
        { return mFontKey; }

        const QColor & customColor() const
        { return mCustomColor; }

        void setCustomColor( const QColor &clr )
        { mCustomColor = clr; }

        // Stuff used by ThemeDelegate. This section should be protected but some gcc
        // versions seem to get confused with nested class and friend declarations
        // so for portability we're using a public interface also here.

        void save( QDataStream &stream ) const;

        bool load( QDataStream &stream, int themeVersion );
    };

    class Row
    {
    public:
        explicit Row();
        explicit Row( const Row &src );
        ~Row();

    private:
        QList< ContentItem * > mLeftItems;   
        QList< ContentItem * > mRightItems;  

        bool LoadContentItem(int val, QDataStream &stream, int themeVersion, bool leftItem);
    public:
        const QList< ContentItem * > & leftItems() const
        { return mLeftItems; }

        void removeAllLeftItems();

        void addLeftItem( ContentItem * item )
        { mLeftItems.append( item ); }

        void insertLeftItem( int idx, ContentItem * item );

        void removeLeftItem( ContentItem * item )
        { mLeftItems.removeAll( item ); }

        const QList< ContentItem * > & rightItems() const
        { return mRightItems; }

        void removeAllRightItems();

        void addRightItem( ContentItem * item )
        { mRightItems.append( item ); }

        void insertRightItem( int idx, ContentItem * item );

        void removeRightItem( ContentItem * item )
        { mRightItems.removeAll( item ); }

        bool containsTextItems() const;

        void save( QDataStream &stream ) const;

        bool load( QDataStream &stream, int themeVersion );

    };

    class Column
    {
    public:
        class SharedRuntimeData
        {
        private:
            int mReferences;          

            int mCurrentlyVisible;    
            int mCurrentWidth;        
        public:
            explicit SharedRuntimeData( bool currentlyVisible, int currentWidth );

            ~SharedRuntimeData();
        public:
            void addReference();

            bool deleteReference();

            int referenceCount() const
            { return mReferences; }

            bool currentlyVisible() const
            { return mCurrentlyVisible; }

            void setCurrentlyVisible( bool visible )
            { mCurrentlyVisible = visible; }

            int currentWidth() const
            { return mCurrentWidth; }

            void setCurrentWidth( int currentWidth )
            { mCurrentWidth = currentWidth; }

            void save( QDataStream &stream ) const;

            bool load( QDataStream &stream, int themeVersion );
        };
    public:
        explicit Column();
        explicit Column( const Column &src );
        ~Column();

    private:
        QString mLabel;                                   
        QString mPixmapName;                              
        bool mVisibleByDefault;                           
        bool mIsSenderOrReceiver;                         
        SortOrder::MessageSorting mMessageSorting;        
        QList< Row * > mGroupHeaderRows;                  
        QList< Row * > mMessageRows;                      

        SharedRuntimeData * mSharedRuntimeData;           
    public:
        const QString & label() const
        { return mLabel; }

        void setLabel( const QString &label )
        { mLabel = label; }

        const QString & pixmapName() const
        { return mPixmapName; }

        void setPixmapName( const QString &pixmapName )
        { mPixmapName = pixmapName; }

        bool isSenderOrReceiver() const
        { return mIsSenderOrReceiver; }

        void setIsSenderOrReceiver( bool sor )
        { mIsSenderOrReceiver = sor; }

        bool visibleByDefault() const
        { return mVisibleByDefault; }

        void setVisibleByDefault( bool vbd )
        { mVisibleByDefault = vbd; }

        void detach();

        SortOrder::MessageSorting messageSorting() const
        { return mMessageSorting; }

        void setMessageSorting( SortOrder::MessageSorting ms )
        { mMessageSorting = ms; }

        bool currentlyVisible() const
        { return mSharedRuntimeData->currentlyVisible(); }

        void setCurrentlyVisible( bool currentlyVisible )
        { mSharedRuntimeData->setCurrentlyVisible( currentlyVisible ); }

        int currentWidth() const
        { return mSharedRuntimeData->currentWidth(); }

        void setCurrentWidth( int currentWidth )
        { mSharedRuntimeData->setCurrentWidth( currentWidth ); }

        const QList< Row * > & messageRows() const
        { return mMessageRows; }

        void removeAllMessageRows();

        void addMessageRow( Row * row )
        { mMessageRows.append( row ); }

        void insertMessageRow( int idx, Row * row );

        void removeMessageRow( Row * row )
        { mMessageRows.removeAll( row ); }

        const QList< Row * > & groupHeaderRows() const
        { return mGroupHeaderRows; }

        void removeAllGroupHeaderRows();

        void addGroupHeaderRow( Row * row )
        { mGroupHeaderRows.append( row ); }

        void insertGroupHeaderRow( int idx, Row * row );

        void removeGroupHeaderRow( Row * row )
        { mGroupHeaderRows.removeAll( row ); }

        bool containsTextItems() const;

        void save( QDataStream &stream ) const;

        bool load( QDataStream &stream, int themeVersion );

    };

public:
    explicit Theme();

    explicit Theme( const QString &name, const QString &description, bool readOnly = false );

    explicit Theme( const Theme &src );

    ~Theme();

    static bool compareName( Theme *theme1, Theme *theme2 )
    {
        return ( theme1->name() < theme2->name() );
    }

public:
    enum GroupHeaderBackgroundMode
    {
        Transparent,                  
        AutoColor,                    
        CustomColor                   
    };

    enum GroupHeaderBackgroundStyle
    {
        PlainRect,                    
        PlainJoinedRect,              
        RoundedRect,                  
        RoundedJoinedRect,            
        GradientRect,                 
        GradientJoinedRect,           
        StyledRect,                   
        StyledJoinedRect              
    };

    enum ViewHeaderPolicy
    {
        ShowHeaderAlways,
        NeverShowHeader
        //ShowWhenMoreThanOneColumn,  ///< This doesn't work at the moment (since without header we don't have means for showing columns back)
    };

private:
    QList< Column * > mColumns;                             

    GroupHeaderBackgroundMode mGroupHeaderBackgroundMode;   
    QColor mGroupHeaderBackgroundColor;                     
    GroupHeaderBackgroundStyle mGroupHeaderBackgroundStyle; 
    ViewHeaderPolicy mViewHeaderPolicy;                     
    int mIconSize;                                          
public:
    void detach();

    void resetColumnState();

    void resetColumnSizes();

    const QList< Column * > & columns() const
    { return mColumns; }

    Column * column( int idx ) const
    { return mColumns.count() > idx ? mColumns.at( idx ) : 0; }

    void moveColumn(int idx, int newPosition);

    void removeAllColumns();

    void addColumn( Column * column )
    { mColumns.append( column ); }

    void insertColumn( int idx, Column * column );

    void removeColumn( Column * col )
    { mColumns.removeAll( col ); }

    GroupHeaderBackgroundMode groupHeaderBackgroundMode() const
    { return mGroupHeaderBackgroundMode; }

    void setGroupHeaderBackgroundMode( GroupHeaderBackgroundMode bm );

    const QColor & groupHeaderBackgroundColor() const
    { return mGroupHeaderBackgroundColor; }

    void setGroupHeaderBackgroundColor( const QColor &clr )
    { mGroupHeaderBackgroundColor = clr; }

    GroupHeaderBackgroundStyle groupHeaderBackgroundStyle() const
    { return mGroupHeaderBackgroundStyle; }

    void setGroupHeaderBackgroundStyle( GroupHeaderBackgroundStyle groupHeaderBackgroundStyle )
    { mGroupHeaderBackgroundStyle = groupHeaderBackgroundStyle; }

    static QList< QPair< QString, int > > enumerateGroupHeaderBackgroundStyles();

    ViewHeaderPolicy viewHeaderPolicy() const
    { return mViewHeaderPolicy; }

    void setViewHeaderPolicy( ViewHeaderPolicy vhp )
    { mViewHeaderPolicy = vhp; }

    int iconSize() const
    { return mIconSize; }

    void setIconSize( int iconSize );

    static QList< QPair< QString, int > > enumerateViewHeaderPolicyOptions();

protected:
    virtual void save( QDataStream &stream ) const;

    virtual bool load( QDataStream &stream );

};

} // namespace Core

} // namespace MessageList


#endif