bytearrayrowcolumnrenderer.h

Go to the documentation of this file.

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

    Copyright 2008-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_BYTEARRAYROWCOLUMNRENDERER_H
#define OKTETA_BYTEARRAYROWCOLUMNRENDERER_H

// lib
#include "abstractbytearrayview.h"
// ColumnsView
#include "abstractcolumnrenderer.h"
#include "linepositionrange.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 ValueCodec;

// class KByteArrayView;
class ByteArrayTableRanges;
class ByteArrayTableLayout;

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


  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 LinePositionRange& linePositions );
    void renderCursor( QPainter* painter, Address byteIndex, AbstractByteArrayView::CodingTypeId codingId );
    void renderByte( QPainter* painter, Address byteIndex, AbstractByteArrayView::CodingTypeId codingId );
    void renderFramedByte( QPainter* painter, Address byteIndex, AbstractByteArrayView::CodingTypeId codingId, FrameStyle style );

    void renderEditedByte( QPainter* painter, Byte byte, const QString& editBuffer );

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

    void setValueCodec( ValueCoding valueCoding, const ValueCodec* valueCodec );
    bool setBinaryGapWidth( PixelX binaryGapWidth );

    void setByteTypeColored( bool byteTypeColored );

    bool setShowingNonprinting( bool showingNonprinting = true );
    bool setSubstituteChar( QChar substituteChar );
    bool setUndefinedChar( QChar undefinedChar );

    void setVisibleCodings( int visibleCodings );


  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;
    QRect byteRect( const Coord& coord, AbstractByteArrayView::CodingTypeId codingId ) const;

    AbstractByteArrayView::CodingTypeId codingIdofY( PixelY y ) const;
    PixelY yOfCodingId( AbstractByteArrayView::CodingTypeId codingId ) const;

  public: // value access
    PixelX byteWidth() const;
    PixelX digitWidth() const;
    PixelX groupSpacingWidth() const;
    PixelX byteSpacingWidth() const;
    Size noOfGroupedBytes() const;
    PixelY digitHeight() const;
    PixelY rowHeight() const;

    PixelX binaryGapWidth() const;

    bool isShowingNonprinting() const;
    QChar substituteChar() const;
    QChar undefinedChar() const;

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

    AbstractByteArrayView::CodingTypes visibleCodings() const;


  protected: // API to be redefined
    void renderByteText( QPainter* painter,
                         Byte byte, Character charByte, int codings, const QColor& color ) const;
    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 renderCode( QPainter* painter, const QString& code, const QColor& color ) const;

    void recalcX();

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


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

    AbstractByteArrayView::CodingTypes mVisibleCodings;
    PixelX mDigitWidth;
    PixelY mDigitBaseLine;
    PixelY mDigitHeight;

    QFontMetrics mFontMetrics;


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

    Size mNoOfGroupedBytes;

    PixelX* mLinePosLeftPixelX;
    PixelX* mLinePosRightPixelX;
    LinePosition mLastLinePos;

    bool mByteTypeColored;

  protected: // value specifics
    ValueCoding mValueCoding;
    const ValueCodec* mValueCodec;
    PixelX mBinaryGapWidth;

  protected: // buffered data
    mutable QString mDecodedByteText;
    PixelX mBinaryHalfOffset;

  protected: // char specifics
    bool mShowingNonprinting;
    QChar mSubstituteChar;
    QChar mUndefinedChar;

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

inline AbstractByteArrayView::CodingTypes ByteArrayRowColumnRenderer::visibleCodings() const { return mVisibleCodings; }


inline PixelX ByteArrayRowColumnRenderer::byteWidth()         const { return mByteWidth; }
inline PixelX ByteArrayRowColumnRenderer::digitWidth()        const { return mDigitWidth; }
inline PixelX ByteArrayRowColumnRenderer::byteSpacingWidth()  const { return mByteSpacingWidth; }
inline PixelX ByteArrayRowColumnRenderer::groupSpacingWidth() const { return mGroupSpacingWidth; }
inline PixelY ByteArrayRowColumnRenderer::digitHeight()       const { return mDigitHeight; }
inline Size ByteArrayRowColumnRenderer::noOfGroupedBytes()      const { return mNoOfGroupedBytes; }

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

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

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

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

inline PixelX ByteArrayRowColumnRenderer::binaryGapWidth()                 const { return mBinaryGapWidth; }

inline bool ByteArrayRowColumnRenderer::isShowingNonprinting()  const { return mShowingNonprinting; }
inline QChar ByteArrayRowColumnRenderer::substituteChar()       const { return mSubstituteChar; }
inline QChar ByteArrayRowColumnRenderer::undefinedChar()        const { return mUndefinedChar; }

inline bool ByteArrayRowColumnRenderer::setSubstituteChar( QChar substituteChar )
{
    if( mSubstituteChar == substituteChar )
        return false;

    mSubstituteChar = substituteChar;
    return true;
}

inline bool ByteArrayRowColumnRenderer::setUndefinedChar( QChar undefinedChar )
{
    if( mUndefinedChar == undefinedChar )
        return false;

    mUndefinedChar = undefinedChar;
    return true;
}

inline bool ByteArrayRowColumnRenderer::setShowingNonprinting( bool showingNonprinting )
{
    if( mShowingNonprinting == showingNonprinting )
        return false;

    mShowingNonprinting = showingNonprinting;
    return true;
}

}

#endif