Source Code (Use browser search to find items of interest.)

khexedit'CHexPrinter (./kdeutils/khexedit/hexprinter.h:67)

class CHexPrinter : public QPrinter
{
  public:
    CHexPrinter( void );
  
    void setAsText( bool state );
    void setAll( bool state );
    void setSelection( bool state );
    void setRange( bool state, uint start=0, uint stop=0 );
    void setOutputToStdout( bool state );
    void setScaleToFit( bool state );
    void setPrintBackWhite( bool state );
    void setPageMarginMM( uint top, uint bottom, int right, int left );
    void setTopMarginMM( uint value );
    void setLeftMarginMM( uint value );
    void setBottomMarginMM( uint value );
    void setRightMarginMM( uint value );
    void setPageHeader( bool enable, uint left, uint center, uint right, 
			uint line );
    void setPageFooter( bool enable, uint left, uint center, uint right, 
			uint line );

    inline bool asText( void );
    inline bool all( void );
    inline bool selection( void );
    inline bool range( void );
    inline uint startRange( void );
    inline uint stopRange( void );
    inline bool outputToStdout( void );
    inline bool scaleToFit( void );
    inline bool printBlackWhite( void );
    inline SPageHeader pageHeader( void );
    inline SPageHeader pageFooter( void );
    SPageMargin pageMargin( void );
    SPageMargin pageMarginMM( void );
    SPageSize   pageFullSize( void );
    SPageSize   pageUsableSize( void );

  private:
    bool mAsText;
    bool mAll;
    bool mInSelection;
    bool mInRange;
    bool mOutputToStdout;
    bool mScaleToFit;
    bool mPrintBlackWhite;
    uint mStartOffset;
    uint mStopOffset;
    SPageMargin mPageMargin;
    SPageHeader mHeader;
    SPageHeader mFooter;


};


inline bool CHexPrinter::asText( void )
{
  return( mAsText );
}

inline bool CHexPrinter::all( void )
{
  return( mAll );
}

inline bool CHexPrinter::selection( void )
{
  return( mInSelection );
}

inline bool CHexPrinter::range( void )
{
  return( mInRange );
}

inline uint CHexPrinter::startRange( void )
{
  return( mStartOffset );
}

inline uint CHexPrinter::stopRange( void )
{
  return( mStopOffset );
}

bool CHexPrinter::outputToStdout( void )
{
  return( mOutputToStdout );
}

inline bool CHexPrinter::scaleToFit( void )
{
  return( mScaleToFit );
}

inline bool CHexPrinter::printBlackWhite( void )
{
  return( mPrintBlackWhite );
}

inline SPageHeader CHexPrinter::pageHeader( void )
{
  return( mHeader );
}

inline SPageHeader CHexPrinter::pageFooter( void )
{
  return( mFooter );
}

khexedit'CHexPrinter::CHexPrinter() (./kdeutils/khexedit/hexprinter.cc:25)

CHexPrinter::CHexPrinter( void )
  : QPrinter()
{
}

khexedit'CHexPrinter::setAsText() (./kdeutils/khexedit/hexprinter.cc:31)

void CHexPrinter::setAsText( bool state )
{
  mAsText = state;
}

khexedit'CHexPrinter::setAll() (./kdeutils/khexedit/hexprinter.cc:37)

void CHexPrinter::setAll( bool state )
{
  mAll = state;
}

khexedit'CHexPrinter::setSelection() (./kdeutils/khexedit/hexprinter.cc:43)

void CHexPrinter::setSelection( bool state )
{
  mInSelection = state;
}

khexedit'CHexPrinter::setRange() (./kdeutils/khexedit/hexprinter.cc:49)

void CHexPrinter::setRange( bool state, uint start, uint stop )
{
  mInRange = state;
  if( mInRange == false ) 
  { 
    start = stop = 0; 
  }
  else
  {
    if( stop < start ) { stop = start; }
    
    mStartOffset = start;
    mStopOffset  = stop;
  }
}

khexedit'CHexPrinter::setOutputToStdout() (./kdeutils/khexedit/hexprinter.cc:66)

void CHexPrinter::setOutputToStdout( bool state )
{
  mOutputToStdout = state;
}

khexedit'CHexPrinter::setScaleToFit() (./kdeutils/khexedit/hexprinter.cc:72)

void CHexPrinter::setScaleToFit( bool state )
{
  mScaleToFit = state;
}

khexedit'CHexPrinter::setPrintBackWhite() (./kdeutils/khexedit/hexprinter.cc:78)

void CHexPrinter::setPrintBackWhite( bool state )
{
  mPrintBlackWhite = state;
}

khexedit'CHexPrinter::setPageMarginMM() (./kdeutils/khexedit/hexprinter.cc:84)

void CHexPrinter::setPageMarginMM( uint top, uint bottom, int right, int left )
{
  mPageMargin.top = top;
  mPageMargin.left = left;
  mPageMargin.bottom = bottom;
  mPageMargin.right = right;
}

khexedit'CHexPrinter::setTopMarginMM() (./kdeutils/khexedit/hexprinter.cc:92)

void CHexPrinter::setTopMarginMM( uint value )
{
  mPageMargin.top = value;
}

khexedit'CHexPrinter::setLeftMarginMM() (./kdeutils/khexedit/hexprinter.cc:97)

void CHexPrinter::setLeftMarginMM( uint value )
{
  mPageMargin.left = value;
}

khexedit'CHexPrinter::setBottomMarginMM() (./kdeutils/khexedit/hexprinter.cc:102)

void CHexPrinter::setBottomMarginMM( uint value )
{
  mPageMargin.bottom = value;
}

khexedit'CHexPrinter::setRightMarginMM() (./kdeutils/khexedit/hexprinter.cc:107)

void CHexPrinter::setRightMarginMM( uint value )
{
  mPageMargin.right = value;
}

khexedit'CHexPrinter::setPageHeader() (./kdeutils/khexedit/hexprinter.cc:114)

void CHexPrinter::setPageHeader( bool enable, uint left, uint center, 
				 uint right, uint line )
{
  if( left > SPageHeader::FileName ) { left = SPageHeader::NoString; }
  if( center > SPageHeader::FileName ) { center = SPageHeader::NoString; }
  if( right > SPageHeader::FileName ) { right = SPageHeader::NoString; }
  if( line > SPageHeader::Rectangle ) { line = SPageHeader::NoLine; }

  mHeader.enable = enable;
  mHeader.pos[0] = (SPageHeader::EHeaderString)left; 
  mHeader.pos[1] = (SPageHeader::EHeaderString)center;
  mHeader.pos[2] = (SPageHeader::EHeaderString)right;
  mHeader.line = (SPageHeader::EHeaderLine)line;

  if( mHeader.pos[0] == SPageHeader::NoString && 
      mHeader.pos[1] == SPageHeader::NoString &&
      mHeader.pos[2] == SPageHeader::NoString &&
      mHeader.line == SPageHeader::NoLine )
  {
    mHeader.enable = false;
  }
}

khexedit'CHexPrinter::setPageFooter() (./kdeutils/khexedit/hexprinter.cc:137)

void CHexPrinter::setPageFooter( bool enable, uint left, uint center, 
				 uint right, uint line )
{
  if( left > SPageHeader::FileName ) { left = SPageHeader::NoString; }
  if( center > SPageHeader::FileName ) { center = SPageHeader::NoString; }
  if( right > SPageHeader::FileName ) { right = SPageHeader::NoString; }
  if( line > SPageHeader::Rectangle ) { line = SPageHeader::NoLine; }

  mFooter.enable = enable;
  mFooter.pos[0] = (SPageHeader::EHeaderString)left; 
  mFooter.pos[1] = (SPageHeader::EHeaderString)center;
  mFooter.pos[2] = (SPageHeader::EHeaderString)right;
  mFooter.line = (SPageHeader::EHeaderLine)line;

  if( mFooter.pos[0] == SPageHeader::NoString && 
      mFooter.pos[1] == SPageHeader::NoString &&
      mFooter.pos[2] == SPageHeader::NoString &&
      mFooter.line == SPageHeader::NoLine )
  {
    mFooter.enable = false;
  }
}

khexedit'CHexPrinter::pageMargin() (./kdeutils/khexedit/hexprinter.cc:161)

SPageMargin CHexPrinter::pageMargin( void )
{
  QPaintDeviceMetrics metric( this );
  float f = (float)metric.width()/(float)metric.widthMM();
    
  SPageMargin margin;
  margin.top = (uint) (f*(float)mPageMargin.top);
  margin.right = (uint) (f*(float)mPageMargin.right);
  margin.bottom = (uint) (f*(float)mPageMargin.bottom);
  margin.left = (uint) (f*(float)mPageMargin.left);

  return( margin );
}

khexedit'CHexPrinter::pageMarginMM() (./kdeutils/khexedit/hexprinter.cc:176)

SPageMargin CHexPrinter::pageMarginMM( void )
{
  return( mPageMargin );
}

khexedit'CHexPrinter::pageFullSize() (./kdeutils/khexedit/hexprinter.cc:182)

SPageSize CHexPrinter::pageFullSize( void )
{
  QPaintDeviceMetrics metric( this );
  SPageSize size;
  size.width = metric.width();
  size.width = metric.height();
  
  return( size );
}

khexedit'CHexPrinter::pageUsableSize() (./kdeutils/khexedit/hexprinter.cc:193)

SPageSize CHexPrinter::pageUsableSize( void )
{
  QPaintDeviceMetrics metric( this );
  SPageMargin margin = pageMargin();
  SPageSize size;

  uint mw = margin.left + margin.right;
  if( metric.width() <= (int)mw )
  {
    size.width = 1;
  }
  else
  {
    size.width = metric.width() - mw;
  }

  uint mh = margin.top + margin.bottom;
  if( metric.height() <= (int)mh )
  {
    size.height = 1;
  }
  else
  {
    size.height = metric.height() - mh;
  }

  return( size );
}

khexedit'CHexPrinter::pageFooter() (./kdeutils/khexedit/hexprinter.h:173)

inline SPageHeader CHexPrinter::pageFooter( void )
{
  return( mFooter );
}