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

kimage'KImageDocument (./koffice/kimage/kimage_doc.h:33)

class KImageDocument : public KoDocument
{
  Q_OBJECT

public:

  KImageDocument( QObject* parent = 0, const char* name = 0, bool singleViewMode = false );
  ~KImageDocument();

  virtual bool openFile();
  virtual bool loadXML( const QDomDocument& doc, KoStore* store );
  virtual bool load( istream& in, KoStore* _store );

public:

  virtual KoView* createView( QWidget* parent = 0, const char* name = 0 );
  virtual KoMainWindow* createShell();

  virtual void paintContent( QPainter& painter, const QRect& rect, bool transparent = FALSE );
  virtual bool initDoc();
  virtual QCString mimeType() const;

  float printableWidth();
  float printableHeight();

  float paperHeight();
  float paperWidth();
  float leftBorder();
  float rightBorder();
  float topBorder();
  float bottomBorder();

  KoOrientation orientation();
  KoFormat paperFormat();

  void paperLayoutDlg();
  void setPaperLayout( float _leftBorder, float _topBorder, float _rightBorder, float _bottomBoder, KoFormat _paper, KoOrientation orientation );
  void setPaperLayout( float _leftBorder, float _topBorder, float _rightBorder, float _bottomBorder, const char * _paper, const char* _orientation );
  void setHeadFootLine( const char* _headl, const char* _headm, const char* _headr,	const char* _footl, const char* _footm, const char* _footr );
  QString headLeft( int _p, const char* _t );
  QString headMid( int _p, const char* _t );
  QString headRight( int _p, const char* _t );
  QString footLeft( int _p, const char* _t );
  QString footMid( int _p, const char* _t );
  QString footRight( int _p, const char* _t );
  QString completeHeading( const char* _data, int _page, const char* _table );
  QString headLeft();
  QString headMid();
  QString headRight();
  QString footLeft();
  QString footMid();
  QString footRight();
  void calcPaperSize();
  QString orientationString();
  void setOrientationString( QString );
  QString paperFormatString();
  void setPaperFormatString( QString );
  const QImage& image();
  void transformImage( const QWMatrix& matrix );

  enum DrawMode { OriginalSize, FitToView, FitWithProps, ZoomFactor };
  enum PositionMode { LeftTop, Center };

  void setDrawMode( DrawMode _mode ) { m_drawMode = _mode; };
  DrawMode drawMode() { return m_drawMode; };
  void setPositionMode( PositionMode _mode ) { m_posMode = _mode; };
  PositionMode positionMode() { return m_posMode; };
  void setZoomFactor( QPoint _factor ) { m_zoomFactorValue = _factor; };
  QPoint zoomFactor() { return m_zoomFactorValue; };

  QString positionString();
  void setPositionString( QString );
  QString sizeString();
  void setSizeString( QString );

signals:

  void sigUpdateView();

protected:

  virtual bool save( ostream&, const char* );
  virtual bool completeLoading( KoStore* );
  virtual bool completeSaving( KoStore* );
  virtual bool hasToWriteMultipart() { return true; };

  bool m_bEmpty;
  KoOrientation m_orientation;
  KoFormat m_paperFormat;
  float m_paperWidth;
  float m_paperHeight;
  float m_leftBorder;
  float m_rightBorder;
  float m_topBorder;
  float m_bottomBorder;
  QString m_headLeft;
  QString m_headRight;
  QString m_headMid;
  QString m_footLeft;
  QString m_footRight;
  QString m_footMid;

  QImage       m_image;
  DrawMode     m_drawMode;
  PositionMode m_posMode;
  QPoint       m_zoomFactorValue;
};

kimage'KImageDocument::KImageDocument() (./koffice/kimage/kimage_doc.cc:47)

KImageDocument::KImageDocument( QObject* parent, const char* name, bool singleViewMode )
  : KoDocument( parent, name, singleViewMode )
{
  setInstance( KImageFactory::global() );
}

kimage'KImageDocument::~KImageDocument() (./koffice/kimage/kimage_doc.cc:53)

KImageDocument::~KImageDocument()
{
}

kimage'KImageDocument::initDoc() (./koffice/kimage/kimage_doc.cc:57)

bool KImageDocument::initDoc()
{
  cout << "KImageDocument::initDoc"<< endl;

  m_bEmpty = true;

  m_leftBorder = 20.0;
  m_rightBorder = 20.0;
  m_topBorder = 20.0;
  m_bottomBorder = 20.0;
  m_paperFormat = PG_DIN_A4;
  m_paperWidth = PG_A4_WIDTH;
  m_paperHeight = PG_A4_HEIGHT;
  calcPaperSize();
  m_orientation = PG_PORTRAIT;

  m_drawMode = OriginalSize;
  m_posMode = LeftTop;
  m_zoomFactorValue = QPoint( 100, 100 );

  return true;
}

kimage'KImageDocument::createView() (./koffice/kimage/kimage_doc.cc:80)

KoView* KImageDocument::createView( QWidget* parent, const char* name )
{
  KImageView* view = new KImageView( this, parent, name );
  addView( view );

  return view;
}

kimage'KImageDocument::createShell() (./koffice/kimage/kimage_doc.cc:88)

KoMainWindow* KImageDocument::createShell()
{
  KoMainWindow* shell = new KImageShell;
  shell->show();

  return shell;
}

kimage'KImageDocument::paintContent() (./koffice/kimage/kimage_doc.cc:96)

void KImageDocument::paintContent( QPainter& _painter, const QRect& _rect, bool /* _transparent */ )
{
  if( isEmpty() )
    return;

  QPixmap pix;
  double dh, dw, d;
	
  switch ( m_drawMode )
  {
    case KImageDocument::OriginalSize:
      pix.convertFromImage( m_image );
      break;
    case KImageDocument::FitToView:
      pix.convertFromImage( m_image.smoothScale( _rect.width(), _rect.height() ) );
      break;
    case KImageDocument::FitWithProps:
      dh = (double) _rect.height() / (double) m_image.height();
      dw = (double) _rect.width() / (double) m_image.width();
      d = ( dh < dw ? dh : dw );
      pix.convertFromImage( m_image.smoothScale( int( d * m_image.width() ), int ( d * m_image.height() ) ) );
      break;
    case KImageDocument::ZoomFactor:
      dw = (double) m_zoomFactorValue.x() / (double) 100.0;
      dh = (double) m_zoomFactorValue.y() / (double) 100.0;
      pix.convertFromImage( m_image.smoothScale( int( dw * m_image.width() ), int ( dh * m_image.height() ) ) );
      break;
  }

  if( positionMode() == Center )
    _painter.drawPixmap( ( _rect.width() - pix.width() ) / 2, ( _rect.height() - pix.height() ) / 2, pix );
  else
    _painter.drawPixmap( 0, 0, pix );
}

kimage'KImageDocument::mimeType() (./koffice/kimage/kimage_doc.cc:131)

QCString KImageDocument::mimeType() const
{
  // FIXME: save the same file type as loaded, not allways KImage file format ;-)

  return "application/x-kimage";
}

kimage'KImageDocument::openFile() (./koffice/kimage/kimage_doc.cc:138)

bool KImageDocument::openFile()
{
  kdDebug() << "KImageDocument::openFile" << endl;

  if( KImageIO::isSupported( KImageIO::mimeType( m_file ) ) )
  {
    initDoc();

    if( !m_image.load( m_file ) )
      return false;

    setModified( true );
    m_bEmpty = false;
    return true;
  }

  return KoDocument::openFile();
}

kimage'KImageDocument::save() (./koffice/kimage/kimage_doc.cc:157)

bool KImageDocument::save( ostream& out, const char* )
{
  QDomDocument doc( "image" );
  doc.appendChild( doc.createProcessingInstruction( "xml", "version=\"1.0\" encoding=\"UTF-8\"" ) );
  QDomElement image = doc.createElement( "image" );
  image.setAttribute( "author", "Michael Koch" );
  image.setAttribute( "email", "koch@kde.org" );
  image.setAttribute( "editor", "KImage" );
  image.setAttribute( "mime", "application/x-kimage" );
  doc.appendChild( image );
  QDomElement paper = doc.createElement( "paper" );
  paper.setAttribute( "format", paperFormatString() );
  paper.setAttribute( "orientation", orientationString() );
  image.appendChild( paper );

  QDomElement borders = doc.createElement( "borders" );
  borders.setAttribute( "left", leftBorder() );
  borders.setAttribute( "top", topBorder() );
  borders.setAttribute( "right", rightBorder() );
  borders.setAttribute( "bottom", bottomBorder() );
  image.appendChild( borders );

  QDomElement head = doc.createElement( "head" );
  image.appendChild( head );
  if ( !headLeft().isEmpty() )
  {
    QDomElement left = doc.createElement( "left" );
    head.appendChild( left );
    left.appendChild( doc.createTextNode( headLeft() ) );
  }
  if ( !headMid().isEmpty() )
  {
    QDomElement center = doc.createElement( "center" );
    head.appendChild( center );
    center.appendChild( doc.createTextNode( headMid() ) );
  }
  if ( !headRight().isEmpty() )
  {
    QDomElement right = doc.createElement( "right" );
    head.appendChild( right );
    right.appendChild( doc.createTextNode( headRight() ) );
  }

  QDomElement foot = doc.createElement( "foot" );
  image.appendChild( foot );
  if ( !footLeft().isEmpty() )
  {
    QDomElement left = doc.createElement( "left" );
    foot.appendChild( left );
    left.appendChild( doc.createTextNode( footLeft() ) );
  }
  if ( !footMid().isEmpty() )
  {
    QDomElement center = doc.createElement( "center" );
    foot.appendChild( center );
    center.appendChild( doc.createTextNode( footMid() ) );
  }
  if ( !footRight().isEmpty() )
  {
    QDomElement right = doc.createElement( "right" );
    foot.appendChild( right );
    right.appendChild( doc.createTextNode( footRight() ) );
  }

  QDomElement drawmode = doc.createElement( "drawmode" );
  image.appendChild( drawmode );
  drawmode.setAttribute( "position", positionString() );
  drawmode.setAttribute( "size", sizeString() );
  if( m_drawMode == ZoomFactor )
  {
    drawmode.setAttribute( "x-factor", m_zoomFactorValue.x() );
    drawmode.setAttribute( "y-factor", m_zoomFactorValue.y() );
  }

  QBuffer buffer;
  buffer.open( IO_WriteOnly );
  QTextStream str( &buffer );
  str << doc;
  buffer.close();
  out.write( buffer.buffer().data(), buffer.buffer().size() );
  setModified( false );

  return true;
}

kimage'KImageDocument::positionString() (./koffice/kimage/kimage_doc.cc:242)

QString KImageDocument::positionString()
{
  QString result;

  switch( m_posMode )
  {
  case LeftTop:
    result = "topleft";
    break;
  case Center:
    result = "centered";
    break;
  }

  return result;
}

kimage'KImageDocument::setPositionString() (./koffice/kimage/kimage_doc.cc:259)

void KImageDocument::setPositionString( QString name )
{
  if( name == "centered" )
  {
    kDebugInfo( 0, "Setting position 'centered'" );
    m_posMode = Center;
    return;
  }
  else if( name == "topleft" )
  {
    kDebugInfo( 0, "Setting position 'lefttop'" );
    m_posMode = LeftTop;
    return;
  }

  kDebugError( 0, "Error: Unsupported position, using 'topleft' : " + name );

  m_posMode = LeftTop;
}

kimage'KImageDocument::sizeString() (./koffice/kimage/kimage_doc.cc:279)

QString KImageDocument::sizeString()
{
  QString result;

  switch( m_drawMode )
  {
  case OriginalSize:
    result = "original";
    break;
  case FitToView:
    result = "fittoview";
    break;
  case FitWithProps:
    result = "fitwithprops";
    break;
  case ZoomFactor:
    result = "zoomfactor";
    break;
  }

  return result;
}

kimage'KImageDocument::setSizeString() (./koffice/kimage/kimage_doc.cc:302)

void KImageDocument::setSizeString( QString name )
{
  if( name == "original" )
  {
    kDebugInfo( 0, "Setting 'original size'" );
    m_drawMode = OriginalSize;
    return;
  }
  else if( name == "fittoview" )
  {
    kDebugInfo( 0, "Setting 'fit to view'" );
    m_drawMode = FitToView;
    return;
  }
  else if( name == "fitwithprops" )
  {
    kDebugInfo( 0, "Setting 'fit with props'" );
    m_drawMode = FitWithProps;
    return;
  }
  else if( name == "zoomfactor" )
  {
    kDebugInfo( 0, "Setting 'zoomfactor'" );
    m_drawMode = ZoomFactor;
    return;
  }

  kDebugError( 0, "Error: Unsupported drawmode, using 'original' : " + name  );

  m_drawMode = OriginalSize;
}

kimage'KImageDocument::completeSaving() (./koffice/kimage/kimage_doc.cc:334)

bool KImageDocument::completeSaving( KoStore* _store )
{
  QString file = "image.bmp";

  if( !isStoredExtern() )
    file = url().url() + "/" + file;

  if ( _store->open( file, "image/bmp" ) )
  {
    ostorestream out( _store );
    writeImageToStream( out, m_image, "BMP" );
    out.flush();
    _store->close();
  }

  return true;
}

kimage'KImageDocument::load() (./koffice/kimage/kimage_doc.cc:352)

bool KImageDocument::load( istream& in, KoStore* store )
{
  int anz;
  char buf[ 4096 ];
  QBuffer buffer;

  buffer.open( IO_WriteOnly );
  do
  {
    in.read( buf, 4096 );
    anz = in.gcount();
    buffer.writeBlock( buf, anz );
  } while( anz > 0 );
  buffer.close();

  buffer.open( IO_ReadOnly );
  QDomDocument doc( &buffer );
  bool b = loadXML( doc, store );
  buffer.close();

  m_bEmpty = false;
  setModified( false );

  return b;
}

kimage'KImageDocument::loadXML() (./koffice/kimage/kimage_doc.cc:378)

bool KImageDocument::loadXML( const QDomDocument& doc, KoStore* /* store */ )
{
  QString format = "A4", orientation = "Portrait";
  float left = 20.0, right = 20.0, bottom = 20.0, top = 20.0;
  QString hl="", hm="", hr="";
  QString fl="", fm="", fr="";

  kDebugInfo( 0, "KImageDocument::loadXML()" );

  if( doc.doctype().name() != "image" )
    return false;

  QDomElement image = doc.documentElement();
  if( image.attribute( "mime" ) != "application/x-kimage" )
    return false;

  QDomElement paper = image.namedItem("paper").toElement();
  setPaperFormatString( paper.attribute( "format" ) );
  setOrientationString( paper.attribute( "orientation" ) );

  QDomElement borders = image.namedItem("borders").toElement();
  m_leftBorder = borders.attribute( "left" ).toFloat();
  m_topBorder = borders.attribute( "top" ).toFloat();
  m_rightBorder = borders.attribute( "right" ).toFloat();
  m_bottomBorder = borders.attribute( "bottom" ).toFloat();

  QDomElement head = image.namedItem("head").toElement();
  head.attribute( "left" );
  // hier dann schauen of vorhanden : left center right

  QDomElement foot = image.namedItem("foot").toElement();
  foot.attribute( "left" );
  // hier dann schauen of vorhanden : left center right

  QDomElement drawmode = image.namedItem( "drawmode" ).toElement();

  setPositionString( drawmode.attribute( "position" ) );
  setSizeString( drawmode.attribute( "size" ) );
  if( m_drawMode == ZoomFactor )
  {
    m_zoomFactorValue = QPoint(
      drawmode.attribute( "x-factor" ).toInt(),
      drawmode.attribute( "y-factor" ).toInt() );
  }

  setPaperLayout( left, top, right, bottom, format, orientation );
  setHeadFootLine( hl, hm, hr, fl, fm, fr );

  return true;
}

kimage'KImageDocument::completeLoading() (./koffice/kimage/kimage_doc.cc:429)

bool KImageDocument::completeLoading( KoStore* _store )
{
  kDebugInfo( 0, "KImageDocument::completeLoading()" );

  QString file = "image.bmp";

  if( !isStoredExtern() )
    file = url().url() + "/" + file;

 if( _store->open( file, "" ) )
  {
    istorestream in( _store );
    in >> m_image;
    _store->close();
  }

  emit sigUpdateView();

  return true;
}

/*
void KImageDocument::print( QPaintDevice* _dev )
{
  QPainter painter;
  painter.begin( _dev );

  // HACK
  int pagenr = 1;
  QString m_strName = "";

  // print head line
  QFont font( "Times", 10 );
  painter.setFont( font );
  QFontMetrics fm = painter.fontMetrics();
  int w = fm.width( headLeft( pagenr, m_strName ) );
  if ( w > 0 )
    painter.drawText( (int)( MM_TO_POINT * leftBorder() ),
		      (int)( MM_TO_POINT * 10.0 ), headLeft( pagenr, m_strName ) );
  w = fm.width( headMid( pagenr, m_strName ) );
  if ( w > 0 )
    painter.drawText( (int)( MM_TO_POINT * leftBorder() +
			     ( MM_TO_POINT * printableWidth() - (float)w ) / 2.0 ),
		      (int)( MM_TO_POINT * 10.0 ), headMid( pagenr, m_strName ) );
  w = fm.width( headRight( pagenr, m_strName ) );
  if ( w > 0 )
    painter.drawText( (int)( MM_TO_POINT * leftBorder() +
			     MM_TO_POINT * printableWidth() - (float)w ),
		      (int)( MM_TO_POINT * 10.0 ), headRight( pagenr, m_strName ) );

  // print foot line
  w = fm.width( footLeft( pagenr, m_strName ) );
  if ( w > 0 )
    painter.drawText( (int)( MM_TO_POINT * leftBorder() ),
		      (int)( MM_TO_POINT * ( paperHeight() - 10.0 ) ),
		      footLeft( pagenr, m_strName ) );
  w = fm.width( footMid( pagenr, m_strName ) );
  if ( w > 0 )
    painter.drawText( (int)( MM_TO_POINT * leftBorder() +
			     ( MM_TO_POINT * printableWidth() - (float)w ) / 2.0 ),
		      (int)( MM_TO_POINT * ( paperHeight() - 10.0 ) ),
		      footMid( pagenr, m_strName ) );
  w = fm.width( footRight( pagenr, m_strName ) );
  if ( w > 0 )
    painter.drawText( (int)( MM_TO_POINT * leftBorder() +
			     MM_TO_POINT * printableWidth() - (float)w ),
		      (int)( MM_TO_POINT * ( paperHeight() - 10.0 ) ),
		      footRight( pagenr, m_strName ) );

  painter.translate( MM_TO_POINT * m_leftBorder, MM_TO_POINT * m_topBorder );

  // Print centered
  painter.drawImage( ( MM_TO_POINT * printableWidth() - m_image.width() ) / 2,
		     ( MM_TO_POINT * printableHeight() - m_image.height() ) / 2,
		     m_image );

  painter.end();
}
*/

/*
void KImageDocument::draw( QPaintDevice* _dev, long int _width, long int _height,
		      float _scale )
{
  kDebugInfo( 0, "DRAWING w=%li h=%li", _width, _height );

  QPainter painter;
  painter.begin( _dev );

  if ( _scale != 1.0 )
    painter.scale( _scale, _scale );

  // Print centered
  int x = ( _width - m_image.width() ) / 2;
  int y = ( _height - m_image.height() ) / 2;
  QPoint p( x, y );

  QRect rect;
  if ( x >= 0 )
  {
    rect.setLeft( 0 );
    rect.setWidth( m_image.width() );
  }
  else
  {
    rect.setLeft( -x );
    rect.setWidth( m_image.width() + 2*x );
  }
  if ( y >= 0 )
  {
    rect.setTop( 0 );
    rect.setHeight( m_image.height() );
  }
  else
  {
    rect.setTop( -x );
    rect.setHeight( m_image.height() + 2*x );
  }

  painter.drawImage( p, m_image, rect );

  painter.end();
}
*/

kimage'KImageDocument::paperLayoutDlg() (./koffice/kimage/kimage_doc.cc:554)

void KImageDocument::paperLayoutDlg()
{
  kDebugInfo( 0, "KImageDocument::paperLayoutDlg" );

  KoPageLayout pl;
  pl.format = paperFormat();
  pl.orientation = orientation();
  pl.unit = PG_MM;
  pl.width = paperWidth();
  pl.height = paperHeight();
  pl.left = leftBorder();
  pl.right = rightBorder();
  pl.top = topBorder();
  pl.bottom = bottomBorder();

  KoHeadFoot hf;
  hf.headLeft = headLeft();
  hf.headRight = headRight();
  hf.headMid = headMid();
  hf.footLeft = footLeft();
  hf.footRight = footRight();
  hf.footMid = footMid();

  if ( !KoPageLayoutDia::pageLayout( pl, hf, FORMAT_AND_BORDERS | HEADER_AND_FOOTER ) )
    return;

  if ( pl.format == PG_CUSTOM )
  {
    m_paperWidth = pl.width;
    m_paperHeight = pl.height;
  }

  setPaperLayout( pl.left, pl.top, pl.right, pl.bottom, pl.format, pl.orientation );

  setHeadFootLine( hf.headLeft, hf.headMid, hf.headRight, hf.footLeft, hf.footMid, hf.footRight );

  emit sigUpdateView();
}

kimage'KImageDocument::setHeadFootLine() (./koffice/kimage/kimage_doc.cc:593)

void KImageDocument::setHeadFootLine( const char *_headl, const char *_headm, const char *_headr,
				    const char *_footl, const char *_footm, const char *_footr )
{
  m_headLeft = _headl;
  m_headRight = _headr;
  m_headMid = _headm;
  m_footLeft = _footl;
  m_footRight = _footr;
  m_footMid = _footm;

  setModified( TRUE );
}

kimage'KImageDocument::setPaperLayout() (./koffice/kimage/kimage_doc.cc:606)

void KImageDocument::setPaperLayout( float _leftBorder, float _topBorder, float _rightBorder, float _bottomBorder,
				const char * _paper, const char* _orientation )
{
    KoFormat f = paperFormat();
    KoOrientation o = orientation();

    if ( strcmp( "A3", _paper ) == 0L )
	f = PG_DIN_A3;
    else if ( strcmp( "A4", _paper ) == 0L )
	f = PG_DIN_A4;
    else if ( strcmp( "A5", _paper ) == 0L )
	f = PG_DIN_A5;
    else if ( strcmp( "B5", _paper ) == 0L )
	f = PG_DIN_B5;
    else if ( strcmp( "Executive", _paper ) == 0L )
	f = PG_US_EXECUTIVE;
    else if ( strcmp( "Letter", _paper ) == 0L )
	f = PG_US_LETTER;
    else if ( strcmp( "Legal", _paper ) == 0L )
	f = PG_US_LEGAL;
    else if ( strcmp( "Screen", _paper ) == 0L )
	f = PG_SCREEN;
    else if ( strcmp( "Custom", _paper ) == 0L )
    {
      f = PG_CUSTOM;
      QString tmp( _paper );
      m_paperWidth = atof( _paper );
      int i = tmp.find( 'x' );
      if ( i != -1 )
	m_paperHeight = atof( tmp.data() + i + 1 );
      if ( m_paperWidth < 10.0 )
	m_paperWidth = PG_A4_WIDTH;
      if ( m_paperHeight < 10.0 )
	m_paperWidth = PG_A4_HEIGHT;
    }

    if ( strcmp( "Portrait", _orientation ) == 0L )
	o = PG_PORTRAIT;
    else if ( strcmp( "Landscape", _orientation ) == 0L )
	o = PG_LANDSCAPE;

    setPaperLayout( _leftBorder, _topBorder, _rightBorder, _bottomBorder, f, o );
}

kimage'KImageDocument::setPaperLayout() (./koffice/kimage/kimage_doc.cc:650)

void KImageDocument::setPaperLayout( float _leftBorder, float _topBorder, float _rightBorder, float _bottomBorder,
				   KoFormat _paper, KoOrientation _orientation )
{
  m_leftBorder = _leftBorder;
  m_rightBorder = _rightBorder;
  m_topBorder = _topBorder;
  m_bottomBorder = _bottomBorder;
  m_orientation = _orientation;
  m_paperFormat = _paper;

  calcPaperSize();

  setModified( TRUE );
}

kimage'KImageDocument::completeHeading() (./koffice/kimage/kimage_doc.cc:665)

QString KImageDocument::completeHeading( const char* _data,
				    int /* _page */, const char* /* _table */ )
{
/*
  QString page;

  page.sprintf( "%i", _page );

  QString f = m_strFileURL.data();

  if ( f.isNull() )
    f = "";

  QString n = "";

  if ( f != "" )
  {
    KURL u( f.data() );
    n = u.filename();
  }
*/

    QString t = QTime::currentTime().toString().copy();
    QString d = QDate::currentDate().toString().copy();

    QString tmp = _data;
    int pos = 0;
    // while ( ( pos = tmp.find( "<file>", pos ) ) != -1 )
    // tmp.replace( pos, 6, f.data() );/
    pos = 0;
    // while ( ( pos = tmp.find( "<name>", pos ) ) != -1 )
    //  tmp.replace( pos, 6, n.data() );
    pos = 0;
    while ( ( pos = tmp.find( "<time>", pos ) ) != -1 )
	tmp.replace( pos, 6, t.data() );
    pos = 0;
    while ( ( pos = tmp.find( "<date>", pos ) ) != -1 )
	tmp.replace( pos, 6, d.data() );
    pos = 0;
    while ( ( pos = tmp.find( "<author>", pos ) ) != -1 )
	tmp.replace( pos, 8, "??" );
    pos = 0;
    while ( ( pos = tmp.find( "<email>", pos ) ) != -1 )
	tmp.replace( pos, 7, "??" );

    return QString( tmp.data() );
}

kimage'KImageDocument::calcPaperSize() (./koffice/kimage/kimage_doc.cc:713)

void KImageDocument::calcPaperSize()
{
    switch( m_paperFormat )
    {
    case PG_DIN_A5:
        m_paperWidth = PG_A5_WIDTH;
	m_paperHeight = PG_A5_HEIGHT;
	break;
    case PG_DIN_A4:
	m_paperWidth = PG_A4_WIDTH;
	m_paperHeight = PG_A4_HEIGHT;
	break;
    case PG_DIN_A3:
	m_paperWidth = PG_A3_WIDTH;
	m_paperHeight = PG_A3_HEIGHT;
	break;
    case PG_DIN_B5:
	m_paperWidth = PG_B5_WIDTH;
	m_paperHeight = PG_B5_HEIGHT;
	break;
    case PG_US_EXECUTIVE:
	m_paperWidth = PG_US_EXECUTIVE_WIDTH;
	m_paperHeight = PG_US_EXECUTIVE_HEIGHT;
	break;
    case PG_US_LETTER:
	m_paperWidth = PG_US_LETTER_WIDTH;
	m_paperHeight = PG_US_LETTER_HEIGHT;
	break;
    case PG_US_LEGAL:
	m_paperWidth = PG_US_LEGAL_WIDTH;
	m_paperHeight = PG_US_LEGAL_HEIGHT;
	break;
    case PG_SCREEN:
        m_paperWidth = PG_SCREEN_WIDTH;
        m_paperHeight = PG_SCREEN_HEIGHT;
    case PG_CUSTOM:
        return;
    }
}

kimage'KImageDocument::paperFormatString() (./koffice/kimage/kimage_doc.cc:753)

QString KImageDocument::paperFormatString()
{
  QString paperFormatStr;

  switch( m_paperFormat )
  {
    case PG_DIN_A5:
	  paperFormatStr = "A5";
	  break;
    case PG_DIN_A4:
	  paperFormatStr = "A4";
	  break;
    case PG_DIN_A3:
	  paperFormatStr = "A3";
	  break;
    case PG_DIN_B5:
	  paperFormatStr = "B5";
	  break;
    case PG_US_EXECUTIVE:
	  paperFormatStr = "Executive";
	  break;
    case PG_US_LETTER:
	  paperFormatStr = "Letter";
	  break;
    case PG_US_LEGAL:
	  paperFormatStr = "Legal";
	  break;
    case PG_SCREEN:
	  paperFormatStr = "Screen";
	  break;
    case PG_CUSTOM:
      {
        QString tmp;
        tmp.sprintf( "%fx%f", m_paperWidth, m_paperHeight );
        paperFormatStr = tmp;
        break;
      }
    default :
      cout << "KImageDocument::paperFormatString() - unknown paper format type" << endl;

      paperFormatStr = "error";
      break;
  }
  return paperFormatStr;
}

kimage'KImageDocument::setPaperFormatString() (./koffice/kimage/kimage_doc.cc:799)

void KImageDocument::setPaperFormatString( QString _format )
{
  if( _format == "A3" )
    m_paperFormat = PG_DIN_A3;
  else if( _format == "A4" )
    m_paperFormat = PG_DIN_A4;
  else if( _format == "A5" )
    m_paperFormat = PG_DIN_A5;
  else if( _format == "B5" )
    m_paperFormat = PG_DIN_B5;
  else if( _format == "EXECUTIVE" )
    m_paperFormat = PG_US_EXECUTIVE;
  else if( _format == "LETTER" )
    m_paperFormat = PG_US_LETTER;
  else if( _format == "LEGAL" )
    m_paperFormat = PG_US_LEGAL;
  else if( _format == "SCREEN" )
    m_paperFormat = PG_SCREEN;
  else // customized
  {
    m_paperFormat = PG_CUSTOM;

    // format : "%fx%f"

    // TODO : set the right values

    m_paperWidth = 10.0;
    m_paperHeight = 10.0;
  }
}

kimage'KImageDocument::orientationString() (./koffice/kimage/kimage_doc.cc:830)

QString KImageDocument::orientationString()
{
  QString orientationStr;

  cout << "Orientation " << (int) m_orientation << endl;

  switch( m_orientation )
  {
    case PG_PORTRAIT :
      orientationStr = "Portrait";
      break;
    case PG_LANDSCAPE :
      orientationStr = "Landscape";
      break;
  default :
      cout << "KImageDocument::orientationString() - unknown orientation type" << endl;

      orientationStr = "error";
      break;
  }
  return orientationStr;
}

kimage'KImageDocument::setOrientationString() (./koffice/kimage/kimage_doc.cc:853)

void KImageDocument::setOrientationString( QString _orient )
{
  if( _orient == "Portrait" )
    m_orientation = PG_PORTRAIT;
  else if( _orient == "Landscape" )
    m_orientation = PG_LANDSCAPE;
  else
  {
    cout << "KImageDocument::setOrientationString() - unknown orientation string" << endl;
    cout << "KImageDocument::setOrientationString() - using portrait" << endl;

    m_orientation = PG_PORTRAIT;
  }
}

kimage'KImageDocument::transformImage() (./koffice/kimage/kimage_doc.cc:868)

void KImageDocument::transformImage( const QWMatrix& matrix )
{
  QPixmap pix, newpix;

  pix.convertFromImage( m_image );
  newpix = pix.xForm( matrix );
  m_image = newpix.convertToImage();
  emit sigUpdateView();
  setModified( true );
  m_bEmpty = false;

  kDebugInfo( 0, "Image manipulated with matrix" );
}

kimage'KImageDocument::printableWidth() (./koffice/kimage/kimage_doc.cc:882)

float KImageDocument::printableWidth()
{
  return m_paperWidth - m_leftBorder - m_rightBorder;
}

kimage'KImageDocument::printableHeight() (./koffice/kimage/kimage_doc.cc:887)

float KImageDocument::printableHeight()
{
  return m_paperHeight - m_topBorder - m_bottomBorder;
}

kimage'KImageDocument::paperHeight() (./koffice/kimage/kimage_doc.cc:892)

float KImageDocument::paperHeight()
{
  return m_paperHeight;
}

kimage'KImageDocument::paperWidth() (./koffice/kimage/kimage_doc.cc:897)

float KImageDocument::paperWidth()
{
  return m_paperWidth;
}

kimage'KImageDocument::leftBorder() (./koffice/kimage/kimage_doc.cc:902)

float KImageDocument::leftBorder()
{
  return m_leftBorder;
}

kimage'KImageDocument::rightBorder() (./koffice/kimage/kimage_doc.cc:907)

float KImageDocument::rightBorder()
{
  return m_rightBorder;
}

kimage'KImageDocument::topBorder() (./koffice/kimage/kimage_doc.cc:912)

float KImageDocument::topBorder()
{
  return m_topBorder;
}

kimage'KImageDocument::bottomBorder() (./koffice/kimage/kimage_doc.cc:917)

float KImageDocument::bottomBorder()
{
  return m_bottomBorder;
}

kimage'KImageDocument::orientation() (./koffice/kimage/kimage_doc.cc:922)

KoOrientation KImageDocument::orientation()
{
  return m_orientation;
}

kimage'KImageDocument::paperFormat() (./koffice/kimage/kimage_doc.cc:927)

KoFormat KImageDocument::paperFormat()
{
  return m_paperFormat;
}

kimage'KImageDocument::headLeft() (./koffice/kimage/kimage_doc.cc:932)

QString KImageDocument::headLeft( int _p, const char* _t )
{
  if( m_headLeft.isNull() )
  {
    return "";
  }
  return completeHeading( m_headLeft.data(), _p, _t );
}

kimage'KImageDocument::headRight() (./koffice/kimage/kimage_doc.cc:941)

QString KImageDocument::headRight( int _p, const char* _t )
{
  if( m_headRight.isNull() )
  {
    return "";
  }
  return completeHeading( m_headRight.data(), _p, _t );
}

kimage'KImageDocument::headMid() (./koffice/kimage/kimage_doc.cc:950)

QString KImageDocument::headMid( int _p, const char* _t )
{
  if( m_headMid.isNull() )
  {
    return "";
  }
  return completeHeading( m_headMid.data(), _p, _t );
}

kimage'KImageDocument::footLeft() (./koffice/kimage/kimage_doc.cc:959)

QString KImageDocument::footLeft( int _p, const char* _t )
{
  if( m_footLeft.isNull() )
  {
    return "";
  }
  return completeHeading( m_footLeft.data(), _p, _t );
}

kimage'KImageDocument::footMid() (./koffice/kimage/kimage_doc.cc:968)

QString KImageDocument::footMid( int _p, const char* _t )
{
  if( m_footMid.isNull() )
  {
    return "";
  }
  return completeHeading( m_footMid.data(), _p, _t );
}

kimage'KImageDocument::footRight() (./koffice/kimage/kimage_doc.cc:977)

QString KImageDocument::footRight( int _p, const char* _t )
{
  if( m_footRight.isNull() )
  {
    return "";
  }
  return completeHeading( m_footRight.data(), _p, _t );
}

kimage'KImageDocument::headLeft() (./koffice/kimage/kimage_doc.cc:986)

QString KImageDocument::headLeft()
{
  if( m_headLeft.isNull() )
  {
    return "";
  }
  return m_headLeft.data();
}

kimage'KImageDocument::headMid() (./koffice/kimage/kimage_doc.cc:995)

QString KImageDocument::headMid()
{
  if( m_headMid.isNull() )
  {
    return "";
  }
  return m_headMid.data();
}

kimage'KImageDocument::headRight() (./koffice/kimage/kimage_doc.cc:1004)

QString KImageDocument::headRight()
{
  if( m_headRight.isNull() )
  {
    return "";
  }
  return m_headRight.data();
}

kimage'KImageDocument::footLeft() (./koffice/kimage/kimage_doc.cc:1013)

QString KImageDocument::footLeft()
{
  if( m_footLeft.isNull() )
  {
    return "";
  }
  return m_footLeft.data();
}

kimage'KImageDocument::footMid() (./koffice/kimage/kimage_doc.cc:1022)

QString KImageDocument::footMid()
{
  if( m_footMid.isNull() )
  {
    return "";
  }
  return m_footMid.data();
}

kimage'KImageDocument::footRight() (./koffice/kimage/kimage_doc.cc:1031)

QString KImageDocument::footRight()
{
  if( m_footRight.isNull() )
  {
    return "";
  }
  return m_footRight.data();
}

kimage'KImageDocument::image() (./koffice/kimage/kimage_doc.cc:1040)

const QImage& KImageDocument::image()
{
  return m_image;
}