abstractbytearraycolumnrenderer.h

Go to the documentation of this file.

/*
    This file is part of the Okteta Gui library, made within the KDE community.

    Copyright 2003,2007-2009 Friedrich W. H. Kossebau <kossebau@kde.org>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) version 3, or any
    later version accepted by the membership of KDE e.V. (or its
    successor approved by the membership of KDE e.V.), which shall
    act as a proxy defined in Section 6 of version 3 of the license.

    This library 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef OKTETA_ABSTRACTBYTEARRAYCOLUMNRENDERER_H
#define OKTETA_ABSTRACTBYTEARRAYCOLUMNRENDERER_H

// ColumnsView
#include "abstractcolumnrenderer.h"
#include "linepositionrange.h"
#include "linerange.h"
// Okteta core
#include "oktetacore.h"
#include "abstractbytearraymodel.h"
#include "character.h"
// Qt
#include <QtGui/QFontMetrics>

class QPainter;
class QColor;
class QBrush;
class QRect;


namespace Okteta
{
class Coord;
class Bookmarkable;
class CharCodec;

// class KByteArrayView;
class ByteArrayTableRanges;
class ByteArrayTableLayout;

class OKTETAGUI_EXPORT AbstractByteArrayColumnRenderer : public AbstractColumnRenderer
{
  public:
    enum FrameStyle { Frame, Left, Right };
  public:
    AbstractByteArrayColumnRenderer( AbstractColumnStylist* stylist,
        AbstractByteArrayModel* byteArrayModel, ByteArrayTableLayout* layout, ByteArrayTableRanges* ranges );
    virtual ~AbstractByteArrayColumnRenderer();


  public: // AbstractColumnRenderer API
    virtual void renderFirstLine( QPainter* painter, const PixelXRange& Xs, Line firstLineIndex );
    virtual void renderNextLine( QPainter* painter );

  public:
    void prepareRendering( const PixelXRange& Xs );

  public:
    //void renderLine( QPainter* painter, int lineIndex );
    void renderLinePositions( QPainter* painter, Line lineIndex, const LineRange& linePositions );
    void renderCursor( QPainter* painter, Address byteIndex );
    void renderByte( QPainter* painter, Address byteIndex );
    void renderFramedByte( QPainter* painter, Address byteIndex, FrameStyle style );


  public: // modification access
    bool setSpacing( PixelX byteSpacingWidth, int noOfGroupedBytes = 0, PixelX groupSpacingWidth = 0 );
    bool setByteSpacingWidth( PixelX byteSpacingWidth );
    bool setNoOfGroupedBytes( int noOfGroupedBytes );
    bool setGroupSpacingWidth( PixelX groupSpacingWidth );
    void setFontMetrics( const QFontMetrics& fontMetrics );
    void set( AbstractByteArrayModel* byteArrayModel );
    void resetXBuffer();
    void setCharCodec( const CharCodec* charCodec );

    void setByteTypeColored( bool byteTypeColored );


  public: // functional logic
    LinePositionRange linePositionsOfX( PixelX x, PixelX width ) const;
    LinePosition linePositionOfX( PixelX x ) const;
    LinePosition magneticLinePositionOfX( PixelX x ) const;
    PixelX xOfLinePosition( LinePosition posInLine ) const;
    PixelX rightXOfLinePosition( LinePosition posInLine ) const;
    LinePosition linePositionOfColumnX( PixelX x ) const;
    LinePositionRange linePositionsOfColumnXs( PixelX x, PixelX width ) const;
    PixelX columnXOfLinePosition( LinePosition posInLine ) const;
    PixelX columnRightXOfLinePosition( LinePosition posInLine ) const;
    LinePositionRange visibleLinePositions( PixelX x, PixelX width ) const;
    PixelXRange xsOfLinePositionsInclSpaces( const LinePositionRange& linePositions ) const;
    PixelXRange columnXsOfLinePositionsInclSpaces( const LinePositionRange& linePositions ) const;

    QRect byteRect( const Coord& coord ) const;

  public: // value access
    PixelX byteWidth() const;
    PixelX digitWidth() const;
    PixelX groupSpacingWidth() const;
    PixelX byteSpacingWidth() const;
    int noOfGroupedBytes() const;

    LinePosition firstLinePos() const;
    LinePosition lastLinePos()  const;
    LinePositionRange visibleLinePositions() const;
    const ByteArrayTableLayout* layout() const;
    bool isByteTypeColored() const;


  protected: // API to be redefined
    virtual void renderByteText( QPainter* painter, Byte byte, Character charByte, const QColor& color ) const = 0;
    virtual void recalcByteWidth();


  protected:
    void renderPlain( QPainter* painter, const LinePositionRange& linePositions, Address byteIndex );
    void renderSelection( QPainter* painter, const LinePositionRange& linePositions, Address byteIndex, int flag );
    void renderMarking( QPainter* painter, const LinePositionRange& linePositions, Address byteIndex, int flag );
    void renderRange( QPainter* painter, const QBrush& brush, const LinePositionRange& linePositions, int flag );
    void renderSelectionSpaceBehind( QPainter* painter, LinePosition linePosition );
    void renderSpaceBehind( QPainter* painter, const QBrush& brush, LinePosition linePosition );
    void renderBookmark( QPainter* painter, const QBrush& brush );

    void recalcX();

    bool getNextSelectedAddressRange( AddressRange* selectedRange, unsigned int* flag, const AddressRange& range ) const;
    bool getNextMarkedAddressRange( AddressRange* markedRange, unsigned int* flag, const AddressRange& range ) const;

    void setByteWidth( int byteWidth );


  protected:
    AbstractByteArrayModel* mByteArrayModel;
    const ByteArrayTableLayout* mLayout;
    ByteArrayTableRanges* mRanges;
    Bookmarkable* mBookmarks;
    const CharCodec* mCharCodec;

    PixelX mDigitWidth;
    PixelY mDigitBaseLine;

    QFontMetrics mFontMetrics;

  protected:  // individual data
    PixelX mByteWidth;
//     PixelX mCursorWidth;
    PixelX mByteSpacingWidth;
    PixelX mGroupSpacingWidth;

    int mNoOfGroupedBytes;

    PixelX* mLinePosLeftPixelX;
    PixelX* mLinePosRightPixelX;
    LinePosition mLastLinePos;

    bool mByteTypeColored;


  protected: // buffering rendering data
    LinePositionRange mRenderLinePositions;
    Line mRenderLine;
    PixelX mRenderX;
    PixelX mRenderWidth;
    int mSpacingTrigger;
};


inline PixelX AbstractByteArrayColumnRenderer::byteWidth()         const { return mByteWidth; }
inline PixelX AbstractByteArrayColumnRenderer::digitWidth()        const { return mDigitWidth; }
inline PixelX AbstractByteArrayColumnRenderer::byteSpacingWidth()  const { return mByteSpacingWidth; }
inline PixelX AbstractByteArrayColumnRenderer::groupSpacingWidth() const { return mGroupSpacingWidth; }

inline int AbstractByteArrayColumnRenderer::noOfGroupedBytes()      const { return mNoOfGroupedBytes; }

inline LinePosition AbstractByteArrayColumnRenderer::firstLinePos() const { return mRenderLinePositions.start(); }
inline LinePosition AbstractByteArrayColumnRenderer::lastLinePos()  const { return mRenderLinePositions.end(); }
inline LinePositionRange AbstractByteArrayColumnRenderer::visibleLinePositions() const { return mRenderLinePositions; }

inline const ByteArrayTableLayout* AbstractByteArrayColumnRenderer::layout() const { return mLayout; }

inline void AbstractByteArrayColumnRenderer::setCharCodec( const CharCodec* charCodec )
{
    mCharCodec = charCodec;
}

inline void AbstractByteArrayColumnRenderer::setByteTypeColored( bool byteTypeColored )
{
    mByteTypeColored = byteTypeColored;
}
inline bool AbstractByteArrayColumnRenderer::isByteTypeColored() const { return mByteTypeColored; }

inline void AbstractByteArrayColumnRenderer::setByteWidth( int byteWidth ) { mByteWidth = byteWidth; }

}

#endif