---

qdbtutil.h

#ifndef _QDBTUTIL_H
#define _QDBTUTIL_H

#include <qobject.h>
#include <qguardedptr.h>
#include <qmap.h>
#include <qrect.h>
#include <qstring.h>
#include <qvaluelist.h>
#include <qwidget.h>

#include <qdbt/qdbtbasetabular.h>
#include <qdbt/qdbtglobal.h>

#ifdef TABULAR_TRACE_FUNCTIONS
#define QDBT_CHECK_TABULAR( ptr ) \
  qdbt::checker_c cm( ptr, __PRETTY_FUNCTION__, __FILE__, __LINE__ );
#endif

class QdbtBaseCell;
class QdbtSection;

class QFont;
class QEvent;
class QPainter;
class QPoint;
class QString;
class QPixmap;

namespace qdbt
{
  class QDBT_EXPORT traceObject_c
  {
    static QMap< int, int >      _indent;
    QGuardedPtr<QdbtBaseTabular> _tab;
    QString                      _str;
  public:
    traceObject_c( const QdbtBaseTabular * t, const QString & str ) :
      _tab( const_cast< QdbtBaseTabular * >( t ) ),
      _str( str )
      {
        traceEntry();
      }
    template < typename A >
    traceObject_c( const QdbtBaseTabular * t, const QString & str, A a ) :
      _tab( const_cast< QdbtBaseTabular * >( t ) ),
      _str( str.arg( interpret( a ) ) )
      {
        traceEntry();
      }
    template < typename A, typename B >
    traceObject_c( const QdbtBaseTabular * t, const QString & str, A a, B b ) :
      _tab( const_cast< QdbtBaseTabular * >( t ) ),
      _str( str.arg( interpret( a ) ).arg( interpret( b ) ) )
      {
        traceEntry();
      }
    template < typename A, typename B, typename C >
    traceObject_c( const QdbtBaseTabular * t, const QString & str, A a, B b,
                   C c ) :
      _tab( const_cast< QdbtBaseTabular * >( t ) ),
      _str( str.arg( interpret( a ) ).arg( interpret( b ) ).
            arg( interpret( c ) ) )
      {
        traceEntry();
      }
    template < typename A, typename B, typename C, typename D >
    traceObject_c( const QdbtBaseTabular * t, const QString & str, A a, B b,
                   C c, D d ) :
      _tab( const_cast< QdbtBaseTabular * >( t ) ),
      _str( str.arg( interpret( a ) ).arg( interpret( b ) ).
            arg( interpret( c ) ).arg( interpret( d ) ) )
      {
        traceEntry();
      }
    template < typename A, typename B, typename C, typename D, typename E >
    traceObject_c( const QdbtBaseTabular * t, const QString & str, A a, B b,
                    C c, D d, E e ) :
      _tab( const_cast< QdbtBaseTabular * >( t ) ),
      _str( str.arg( interpret( a ) ).arg( interpret( b ) ).
            arg( interpret( c ) ).arg( interpret( d ) ).arg( interpret( e ) ) )
      {
        traceEntry();
      }
    template < typename A, typename B, typename C, typename D, typename E,
               typename F >
    traceObject_c( const QdbtBaseTabular * t, const QString & str, A a, B b,
                    C c, D d, E e, F f ) :
      _tab( const_cast< QdbtBaseTabular * >( t ) ),
      _str( str.arg( interpret( a ) ).arg( interpret( b ) ).
            arg( interpret( c ) ).arg( interpret( d ) ).
            arg( interpret( e ) ).arg( interpret( f ) ) )
      {
        traceEntry();
      }
    template < typename A, typename B, typename C, typename D, typename E,
               typename F, typename G  >
    traceObject_c( const QdbtBaseTabular * t, const QString & str, A a, B b,
                    C c, D d, E e, F f, G g ) :
      _tab( const_cast< QdbtBaseTabular * >( t ) ),
      _str( str.arg( interpret( a ) ).arg( interpret( b ) ).
            arg( interpret( c ) ).arg( interpret( d ) ).
            arg( interpret( e ) ).arg( interpret( f ) ).arg( interpret( g ) ) )
      {
        traceEntry();
      }

    ~traceObject_c()
      {
        traceExit();
      }
  private:
    int indent( int modifyBy = 0 );
    void traceEntry();
    void traceExit();

    /* @{ \name Interpretation Layer */
    QString interpret( QEvent * const );
    QString interpret( QWidget * const wid )
      {
        return interpret( const_cast< const QWidget * const >( wid ) );
      }
    QString interpret( const QWidget * const );
    QString interpret( QPainter * const );
    QString interpret( QdbtPImpl * const );
    QString interpret( const QColor & );
    QString interpret( const QCursor & );
    QString interpret( const QFont & );
    QString interpret( const QPalette & );
    QString interpret( const QPixmap * );
    QString interpret( const QPoint & );
    QString interpret( const QdbtBaseCell * const );

    template < typename T > const T & interpret( const T & t ) { return t; }
    /* @} */

  };

  // Stuff being exported even on Windows platforms w/ dlls
  class QDBT_EXPORT eventFilter_c : public QObject
  {
  public:
    eventFilter_c( QObject * );
    virtual bool eventFilter( QObject *, QEvent * );
  };
  
  bool QDBT_EXPORT checkColumnWidths( const QdbtBaseTabular *tab );

  // Stuff that will remain privatly owned on Windows platforms
  // when using dlls
  class checker_c
  {
    QGuardedPtr< QdbtBaseTabular > _tab;
    QString                        _functionName;
    QString                        _fileName;
    int                            _line;

    static QMap< int, int >        _indent;

  public:
    checker_c( const QdbtBaseTabular * tab, const char * functionName,
               const char * fileName, int line );

    virtual ~checker_c();
  protected:
    int tabPtr();
    int indent( int modifyBy = 0 );
    virtual void write( const QString & text );
  };

  /* @{ \name String-Processing Functions */
  QString truncateSimpleString( QPainter *p, const QString text,
                                int width, int align );
  QString truncateString( QPainter *p, const QString text, int width,
                          int align );
  /* @} */


  /* @{ \name Style-Releated Functions */
  QRect computeTextRect( const QRect &, int enlarge = 0 );
  inline QRect computeTextRect( int w, int h, int enlarge = 0 )
  {
    return computeTextRect( QRect( 0, 0, w, h ), enlarge );
  }
  QRect computeButtonRect( const QRect &, int enlarge = 0 );
  inline QRect computeButtonRect( int w, int h, int enlarge = 0 )
  {
    return computeButtonRect( QRect( 0, 0, w, h ), enlarge );
  }
  /* @} */
  
  QRect shrinkRect( QRect i, int shrink );
  void snapshot( QWidget *wid, QString filename = QString::null,
                 QString format = "PNG" );
};

class QdbtPermutationArray
{
  QValueList<int> _permutation;
  
public:
  QdbtPermutationArray();
  ~QdbtPermutationArray();

  void clear();
  bool insertElement( int id, int position = -1 );
  int position( int id ) const;
  const int &operator[]( int i ) const;

  void dump() const;
};

#ifndef QDBT_CHECK_TABULAR
#define QDBT_CHECK_TABULAR( ptr )
#endif

#ifdef QDBT_FUNCTION_TRACING

#define QDBT_TRACE_TABULAR_0( tab, str ) \
        qdbt::traceObject_c _trace( tab, str );
#define QDBT_TRACE_TABULAR_1( tab, str, a ) \
        qdbt::traceObject_c _trace( tab, str, a );
#define QDBT_TRACE_TABULAR_2( tab, str, a, b ) \
        qdbt::traceObject_c _trace( tab, str, a, b );
#define QDBT_TRACE_TABULAR_3( tab, str, a, b, c ) \
        qdbt::traceObject_c _trace( tab, str, a, b, c );
#define QDBT_TRACE_TABULAR_4( tab, str, a, b, c, d ) \
        qdbt::traceObject_c _trace( tab, str, a, b, c, d );
#define QDBT_TRACE_TABULAR_5( tab, str, a, b, c, d, e ) \
        qdbt::traceObject_c _trace( tab, str, a, b, c, d, e );
#define QDBT_TRACE_TABULAR_6( tab, str, a, b, c, d, e, f ) \
        qdbt::traceObject_c _trace( tab, str, a, b, c, d, e, f );
#define QDBT_TRACE_TABULAR_7( tab, str, a, b, c, d, e, f, g ) \
        qdbt::traceObject_c _trace( tab, str, a, b, c, d, e, f, g );

#else

#define QDBT_TRACE_TABULAR_0( tab, str ) {}
#define QDBT_TRACE_TABULAR_1( tab, str, a ) {}
#define QDBT_TRACE_TABULAR_2( tab, str, a, b ) {}
#define QDBT_TRACE_TABULAR_3( tab, str, a, b, c ) {}
#define QDBT_TRACE_TABULAR_4( tab, str, a, b, c, d ) {}
#define QDBT_TRACE_TABULAR_5( tab, str, a, b, c, d, e ) {}
#define QDBT_TRACE_TABULAR_6( tab, str, a, b, c, d, e, f ) {}
#define QDBT_TRACE_TABULAR_7( tab, str, a, b, c, d, e, f, g ) {}

#endif


#endif

---