[Lmuse-cvs-traffic] muse/awl Makefile.am,NONE,1.1 aslider.cpp,NONE,1.1 awlaslider.h,NONE,1.1 awlfloatentry.h,NONE,1.1 awlknob.h,NONE,1.1 awlmidivolentry.h,NONE,1.1 awlpanentry.h,NONE,1.1 awlpanknob.h,NONE,1.1 awlplugin.cpp,NONE,1.1 awlslider.h,NONE,1.1 awlvolentry.h,NONE,1.1 awlvolknob.h,NONE,1.1 awlvolslider.h,NONE,1.1 fastlog.h,NONE,1.1 floatentry.cpp,NONE,1.1 knob.cpp,NONE,1.1 midivolentry.cpp,NONE,1.1 panentry.cpp,NONE,1.1 panknob.cpp,NONE,1.1 slider.cpp,NONE,1.1 volentry.cpp,NONE,1.1 volknob.cpp,NONE,1.1 volslider.cpp,NONE,1.1

[werner s. <wsc...@us...>]

Update of /cvsroot/lmuse/muse/awl
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv16022/awl

Added Files:
	Makefile.am aslider.cpp awlaslider.h awlfloatentry.h awlknob.h 
	awlmidivolentry.h awlpanentry.h awlpanknob.h awlplugin.cpp 
	awlslider.h awlvolentry.h awlvolknob.h awlvolslider.h 
	fastlog.h floatentry.cpp knob.cpp midivolentry.cpp 
	panentry.cpp panknob.cpp slider.cpp volentry.cpp volknob.cpp 
	volslider.cpp 
Log Message:
add awl


--- NEW FILE: aslider.cpp ---
//=========================================================
//  AWL
//  Audio Widget Library
//  $Id: aslider.cpp,v 1.1 2004/07/28 10:22:12 wschweer Exp $
//
//  (C) Copyright 2004 Werner Schweer (ws...@se...)
//=========================================================

#include <cmath>
#include <qpainter.h>

#include "awlaslider.h"

//---------------------------------------------------------
//   AbstractSlider
//---------------------------------------------------------

AwlAbstractSlider::AwlAbstractSlider(QWidget* parent, const char* name)
   : QWidget(parent, name), _scaleColor(black), _scaleValueColor(blue)
      {
      _minValue   = 0.0;
      _maxValue   = 1.0;
      _lineStep   = 0.1;
      _pageStep   = 0.2;
      _value      = 0.0;
      pmValid     = false;
      _center     = false;
      _scaleWidth = 4;
      setBackgroundMode(NoBackground);
      brush.setStyle(SolidPattern);
      brush.setColor(lightGray);
      }

//---------------------------------------------------------
//   setCenter
//!   If the center flag is set, a notch is drawn to
//!   show the center position.
//---------------------------------------------------------

void AwlAbstractSlider::setCenter(bool val)
      {
      if (val != _center) {
            _center = val;
            redraw();
            }
      }

//!--------------------------------------------------------
//   setScaleWidth
//---------------------------------------------------------

void AwlAbstractSlider::setScaleWidth(int val)
      {
      if (val != _scaleWidth) {
            _scaleWidth = val;
            redraw();
            }
      }

//---------------------------------------------------------
//   setScaleColor
//---------------------------------------------------------

void AwlAbstractSlider::setScaleColor(const QColor& c)
      {
      if (c != _scaleColor) {
            _scaleColor = c;
            redraw();
            }
      }

//---------------------------------------------------------
//   setScaleValueColor
//---------------------------------------------------------

void AwlAbstractSlider::setScaleValueColor(const QColor& c)
      {
      if (c != _scaleValueColor) {
            _scaleValueColor = c;
            redraw();
            }
      }

//---------------------------------------------------------
//   resizeEvent
//---------------------------------------------------------

void AwlAbstractSlider::resizeEvent(QResizeEvent* ev)
      {
      pm.resize(ev->size());
      pmValid = false;
      }

//---------------------------------------------------------
//   paintEvent
//---------------------------------------------------------

void AwlAbstractSlider::paintEvent(QPaintEvent* ev)
      {
      if (!pmValid)
            paint(ev->rect());
      bitBlt(this, ev->rect().topLeft(), &pm, ev->rect(), CopyROP, true);
      }

//---------------------------------------------------------
//   wheelEvent
//---------------------------------------------------------

void AwlAbstractSlider::wheelEvent(QWheelEvent* ev)
      {
      int div = 50;
      if (ev->state() & ShiftButton)
            div = 15;
      _value += (ev->delta() * lineStep()) / div;
      if (_value < _minValue)
            _value = _minValue;
      else if (_value > _maxValue)
            _value = _maxValue;
      valueChange();
      }

//---------------------------------------------------------
//   keyPressEvent
//---------------------------------------------------------

void AwlAbstractSlider::keyPressEvent(QKeyEvent* ev)
      {
      float oval = _value;

      switch (ev->key()) {
            case Key_Home:    setValue(minValue()); break;
            case Key_End:     setValue(maxValue()); break;
            case Key_Up:
            case Key_Left:    setValue(_value+lineStep()); break;
            case Key_Down:
            case Key_Right:   setValue(_value-lineStep()); break;
            case Key_Next:    setValue(_value-pageStep()); break;
            case Key_Prior:   setValue(_value+pageStep()); break;
            default:
                  break;
            }
      if (_value < _minValue)
            _value = _minValue;
      else if (_value > _maxValue)
            _value = _maxValue;
      if (oval != _value)
            valueChange();
      }

//---------------------------------------------------------
//   redraw
//---------------------------------------------------------

void AwlAbstractSlider::redraw()
      {
      QRect r(0, 0, pm.width(), pm.height());
      paint(r);
      update();
      }

//---------------------------------------------------------
//   redraw
//---------------------------------------------------------

void AwlAbstractSlider::redraw(const QRect& r)
      {
      paint(r);
      update(r);
      }

//---------------------------------------------------------
//   setValue
//---------------------------------------------------------

void AwlAbstractSlider::setValue(float val)
      {
      _value = val;
      redraw();
      }


--- NEW FILE: knob.cpp ---
//=========================================================
//  AWL
//  Audio Widget Library
//  $Id: knob.cpp,v 1.1 2004/07/28 10:22:12 wschweer Exp $
//
//  (C) Copyright 2004 Werner Schweer (ws...@se...)
//=========================================================

#include <cmath>
#include <qpainter.h>

#include "awlknob.h"

//---------------------------------------------------------
//   Knob
///   this is the AwlKnob contructor
//---------------------------------------------------------

AwlKnob::AwlKnob(QWidget* parent, const char* name)
   : AwlAbstractSlider(parent, name), points(3)
      {
      _scaleSize = 270;
      }

//---------------------------------------------------------
//   setText
//---------------------------------------------------------

void AwlKnob::setText(const QString& s)
      {
      if (s != _text) {
            _text = s;
            redraw();
            }
      }

//---------------------------------------------------------
//   setScaleSize
//!   set the scale size in degrees
//
//!   the scale size is the max moving angle measured
//!   in degrees
//---------------------------------------------------------

void AwlKnob::setScaleSize(int val)
      {
      if (val != _scaleSize) {
            _scaleSize = val;
            redraw();
            }
      }

//---------------------------------------------------------
//   mousePressEvent
//---------------------------------------------------------

void AwlKnob::mousePressEvent(QMouseEvent* ev)
      {
      startY = ev->y();
      emit sliderPressed(_id);
      if (_center) {
            QRegion r(points);
            if (r.contains(ev->pos())) {
                  setValue(.0f);
                  valueChange();
                  }
            }
      }

//---------------------------------------------------------
//   mouseReleaseEvent
//---------------------------------------------------------

void AwlKnob::mouseReleaseEvent(QMouseEvent*)
      {
      emit sliderReleased(_id);
      }

//---------------------------------------------------------
//   mouseMoveEvent
//---------------------------------------------------------

void AwlKnob::mouseMoveEvent(QMouseEvent* ev)
      {
      int y     = ev->y();
      float delta = (maxValue() - minValue()) / 100.0f;
      if (delta == 0)
            delta = 1;
      _value  += (startY - y) * delta;
      if (_value < minValue())
            _value = _minValue;
      else if (_value > maxValue())
            _value = _maxValue;
      startY    = y;
      valueChange();
      }

//---------------------------------------------------------
//   paint
//    r - phys coord system
//---------------------------------------------------------

void AwlKnob::paint(const QRect& r)
      {
      if (pm.isNull())
            return;
      QRect rr(r);
      if (!pmValid) {
            pmValid = true;
            rr = QRect(0, 0, pm.width(), pm.height());
            }
      QPainter p(&pm);
      p.fillRect(rr, brush);

      int restR      = 360 - _scaleSize;
      int w          = width()  - _scaleWidth;
      int h          = height() - _scaleWidth;
      int markHeight = 8;

      if (_center) {
            if (w >= (h - markHeight/2))
                  w = h - markHeight/2;
            h = w;
            }
      else {
            if (w > h)
                  w = h;
            else
                  h = w;
            }

      int x = _scaleWidth / 2;
      int y = x + (_center ? markHeight : 0);

      QColor sc(isEnabled() ? _scaleColor : gray);
      QColor svc(isEnabled() ? _scaleValueColor : gray);

      //-----------------------------------------
      // draw arc
      //-----------------------------------------

      float dvalue = maxValue() - minValue();
      if (_center) {
            int size = _scaleSize * 8;
            if (value() >= 0) {
                  int offset = (restR-180) * 8;
                  int r1     = int (size * _value / maxValue());
                  int r2     = size - r1;
                  p.setPen(QPen(sc, _scaleWidth));
                  p.drawArc(x, y, w, h, offset, r2);
                  p.drawArc(x, y, w, h, 90*16, size);
                  p.setPen(QPen(svc, _scaleWidth));
                  p.drawArc(x, y, w, h, offset+r2, r1);
                  }
            else {
                  int offset = (restR+180) * 8;
                  int r1     = size * value() / minValue();
                  int r2     = size - r1;

                  p.setPen(QPen(sc, _scaleWidth));
                  p.drawArc(x, y, w, h, (restR-180)*8, size);
                  p.drawArc(x, y, w, h, 90 * 16 + r1, r2);

                  p.setPen(QPen(svc, _scaleWidth));
                  p.drawArc(x, y, w, h, 90*16, r1);
                  }
            }
      else {
            int offset = (180-restR) * 8;
            int size   = _scaleSize * 16;
            int r1     = size * (value()-minValue()) / dvalue;
            int r2     = size - r1;
            p.setPen(QPen(sc, _scaleWidth));
            p.drawArc(x, y, w, h, -offset, r2);
            p.setPen(QPen(svc, _scaleWidth));
            p.drawArc(x, y, w, h, r2-offset, r1);
            }

      //-----------------------------------------
      // draw pointer
      //-----------------------------------------

      p.setPen(QPen(svc, _scaleWidth));
      double r1 = double(_scaleSize) * (value()-minValue()) / dvalue + 90.0
            + double(restR/2);
      r1     = r1 / 180.0 * M_PI;   // convert to radians
      int rd = w/2;
      int x1 = x + rd;
      int y1 = y + rd;
      int x2 = x1 + lrint(cos(r1) * double(rd));
      int y2 = y1 + lrint(sin(r1) * double(rd));
      p.drawLine(x1, y1, x2, y2);

      //-----------------------------------------
      // draw center mark
      //-----------------------------------------

      p.setPen(QPen(svc, 0));
      p.setBrush(svc);
      if (_center) {
            x += rd;
            points.setPoint(0, x - markHeight/2, 0);
            points.setPoint(1, x + markHeight/2, 0);
            points.setPoint(2, x, markHeight);
            p.drawConvexPolygon(points);
            }

      //-----------------------------------------
      // draw text
      //-----------------------------------------

      if (!_text.isEmpty()) {
            p.drawText(_scaleWidth/2, 0, w, height(), AlignBottom | AlignHCenter, _text);
            }
      }

--- NEW FILE: awlvolentry.h ---
//=========================================================
//  AWL
//  Audio Widget Library
//  $Id: awlvolentry.h,v 1.1 2004/07/28 10:22:12 wschweer Exp $
//
//  (C) Copyright 2004 Werner Schweer (ws...@se...)
//=========================================================

#ifndef __AWLVOLENTRY_H__
#define __AWLVOLENTRY_H__

#include "awlfloatentry.h"

//---------------------------------------------------------
//   AwlVolEntry
//---------------------------------------------------------

class AwlVolEntry : public AwlFloatEntry {
      Q_OBJECT

   public:
      virtual void setValue(float);
      AwlVolEntry(QWidget* parent);
      };


#endif


--- NEW FILE: awlmidivolentry.h ---
//=========================================================
//  AWL
//  Audio Widget Library
//  $Id: awlmidivolentry.h,v 1.1 2004/07/28 10:22:12 wschweer Exp $
//
//  (C) Copyright 2004 Werner Schweer (ws...@se...)
//=========================================================

#ifndef __AWLMIDIVOLENTRY_H__
#define __AWLMIDIVOLENTRY_H__

#include "awlfloatentry.h"

//---------------------------------------------------------
//   AwlMidiVolEntry
//---------------------------------------------------------

class AwlMidiVolEntry : public AwlFloatEntry {
      Q_OBJECT

   public:
      virtual void setValue(float);
      AwlMidiVolEntry(QWidget* parent);
      };

#endif


--- NEW FILE: volslider.cpp ---
//=========================================================
//  AWL
//  Audio Widget Library
//  $Id: volslider.cpp,v 1.1 2004/07/28 10:22:13 wschweer Exp $
//
//  (C) Copyright 2004 Werner Schweer (ws...@se...)
//=========================================================

#include "fastlog.h"
#include "awlvolslider.h"

//---------------------------------------------------------
//   VolSlider
//---------------------------------------------------------

AwlVolSlider::AwlVolSlider(QWidget* parent, const char* name)
   : AwlSlider(parent, name)
      {
      setMinValue(-60.0f);
      setMaxValue(10.0f);
      setScaleWidth(7);
      setLineStep(.8f);
      setPageStep(3.0f);
      }

//---------------------------------------------------------
//   setValue
//!   set the current volume to val
//---------------------------------------------------------

void AwlVolSlider::setValue(float gain)
      {
      if (gain == 0.0f)
            _value = _minValue;
      else
            _value = fast_log10(gain) * 20.0f;
      redraw();
      }

//---------------------------------------------------------
//   valueChange
//---------------------------------------------------------

void AwlVolSlider::valueChange()
      {
      float gain = pow(10.0, _value*0.05f);
      emit valueChanged(gain, _id);
      }


--- NEW FILE: awlvolknob.h ---
//=========================================================
//  AWL
//  Audio Widget Library
//  $Id: awlvolknob.h,v 1.1 2004/07/28 10:22:12 wschweer Exp $
//
//  (C) Copyright 2004 Werner Schweer (ws...@se...)
//=========================================================

#ifndef __AWLVOLKNOB_H__
#define __AWLVOLKNOB_H__

#include "awlknob.h"

//---------------------------------------------------------
//   VolKnob
//!   Volume Knob entry widget
//
//!   This widget implements knob with a logarithmic
//!   floating point scale used to adjust the volume
//!   in an audio mixer.
//---------------------------------------------------------

class AwlVolKnob : public AwlKnob {
      Q_OBJECT

      virtual void valueChange();

   signals:
      //! emitted, if the current volume changes
//      void valueChanged(float, int);

   public slots:
      virtual void setValue(float f);

   public:
      AwlVolKnob(QWidget* parent = 0, const char* name = 0);
      };

#endif


--- NEW FILE: panknob.cpp ---
//=========================================================
//  AWL
//  Audio Widget Library
//  $Id: panknob.cpp,v 1.1 2004/07/28 10:22:13 wschweer Exp $
//
//  (C) Copyright 2004 Werner Schweer (ws...@se...)
//=========================================================

#include <cmath>
#include "awlpanknob.h"

//---------------------------------------------------------
//   PanKnob
//---------------------------------------------------------

AwlPanKnob::AwlPanKnob(QWidget* parent, const char* name)
   : AwlKnob(parent, name)
      {
      setCenter(true);
      setMinValue(-1.0);
      setMaxValue(1.0);
      }

//---------------------------------------------------------
//   valueChange
//---------------------------------------------------------

void AwlPanKnob::valueChange()
      {
      emit valueChanged(_value, _id);
      redraw();
      }

--- NEW FILE: floatentry.cpp ---
//=========================================================
//  AWL
//  Audio Widget Library
//  $Id: floatentry.cpp,v 1.1 2004/07/28 10:22:12 wschweer Exp $
//
//  (C) Copyright 2004 Werner Schweer (ws...@se...)
//=========================================================

#include <stdio.h>
#include <values.h>

#include <qvalidator.h>
#include <qpalette.h>

#include "awlfloatentry.h"

#include <stdio.h>
#include <values.h>

#define TIMER1    400
#define TIMER2    200
#define TIMEC     7
#define TIMER3    100
#define TIMEC2    20
#define TIMER4    50

//---------------------------------------------------------
//   AwlFloatEntry
//---------------------------------------------------------

AwlFloatEntry::AwlFloatEntry(QWidget* parent)
   : QLineEdit(parent)
      {
      _id = -1;
      drawFrame = false;
      QLineEdit::setFrame(drawFrame);
      timer = new QTimer(this);
      connect(timer, SIGNAL(timeout()), SLOT(repeat()));
      val = 0.01;
      connect(this, SIGNAL(returnPressed()), SLOT(endEdit()));
      setCursor(QCursor(arrowCursor));
      evx = 1.0;
      min = 0.0;
      max = 1.0;
      _precision = 3;
      setValue(0.0);
      }

//---------------------------------------------------------
//   setString
//---------------------------------------------------------

bool AwlFloatEntry::setString(float v)
      {
      QString s;
      if (v < min || v > max) {
            setText(_specialText);
            return true;
            }
      s.setNum(v, 'f', _precision);
      if (!_suffix.isEmpty()) {
            s += " ";
            s += _suffix;
            }
      setText(s);
      return false;
      }

//---------------------------------------------------------
//   setSValue
//---------------------------------------------------------

void AwlFloatEntry::setSValue(const QString& s)
      {
      bool ok;
      float v = s.toFloat(&ok);
      if (ok && (v != val)) {
            if (v < min)
                  v = min;
            if (v > max)
                  v = max;
            setValue(v);
            emit valueChanged(val, _id);
            }
      }

//---------------------------------------------------------
//   incValue
//---------------------------------------------------------

void AwlFloatEntry::incValue(float)
      {
      if (val + 1.0 < max) {
            setValue(val + 1.0);
            emit valueChanged(val, _id);
            }
      }

//---------------------------------------------------------
//   decValue
//---------------------------------------------------------

void AwlFloatEntry::decValue(float)
      {
      if (val - 1.0 > min) {
            setValue(val - 1.0);
            emit valueChanged(val, _id);
            }
      }

//---------------------------------------------------------
//   setPrecision
//---------------------------------------------------------

void AwlFloatEntry::setPrecision(int v)
      {
      _precision = v;
      setString(val);
      }

//---------------------------------------------------------
//   sizeHint
//---------------------------------------------------------

QSize AwlFloatEntry::sizeHint() const
      {
      QFontMetrics fm = fontMetrics();
      int h           = fm.height() + 4;
      int n = _precision + 3;
      int w = fm.width(QString("-0.")) + fm.width('0') * n + 6;
      return QSize(w, h);
      }

//---------------------------------------------------------
//   setFrame
//---------------------------------------------------------

void AwlFloatEntry::setFrame(bool flag)
      {
      drawFrame = flag;
      QLineEdit::setFrame(drawFrame);
      update();
      }

//---------------------------------------------------------
//   endEdit
//---------------------------------------------------------

void AwlFloatEntry::endEdit()
      {
      if (edited())
            setSValue(text());
      clearFocus();
      if (!drawFrame)
            QLineEdit::setFrame(false);
      }

//---------------------------------------------------------
//   mousePressEvent
//---------------------------------------------------------

void AwlFloatEntry::mousePressEvent(QMouseEvent* event)
      {
      button = event->button();
      starty = event->y();
      evx    = float(event->x());
      timecount = 0;
      repeat();
      timer->start(TIMER1);
      }

//---------------------------------------------------------
//   wheelEvent
//---------------------------------------------------------

void AwlFloatEntry::wheelEvent(QWheelEvent* event)
      {
      int delta = event->delta();

      if (delta < 0)
            decValue(-1.0);
      else if (delta > 0)
            incValue(1.0);
      }

//---------------------------------------------------------
//   repeat
//---------------------------------------------------------

void AwlFloatEntry::repeat()
      {
      if (timecount == 1) {
           ++timecount;
            timer->stop();
            timer->start(TIMER2);
            return;
            }
      ++timecount;
      if (timecount == TIMEC) {
            timer->stop();
            timer->start(TIMER3);
            }
      if (timecount == TIMEC2) {
            timer->stop();
            timer->start(TIMER4);
            }

      switch (button) {
            case QMouseEvent::LeftButton:
                  return;
            case QMouseEvent::MidButton:
                  decValue(evx);
                  break;
            case QMouseEvent::RightButton:
                  incValue(evx);
                  break;
            default:
                  break;
            }
      }

//---------------------------------------------------------
//   mouseReleaseEvent
//---------------------------------------------------------

void AwlFloatEntry::mouseReleaseEvent(QMouseEvent*)
      {
      button = QMouseEvent::NoButton;
      timer->stop();
      }

//---------------------------------------------------------
//   mouseMoveEvent
//---------------------------------------------------------

void AwlFloatEntry::mouseMoveEvent(QMouseEvent*)
      {
      switch (button) {
            case QMouseEvent::LeftButton:
                  break;
            case QMouseEvent::MidButton:
                  break;
            case QMouseEvent::RightButton:
                  break;
            default:
                  break;
            }
      }

//---------------------------------------------------------
//   mouseDoubleClickEvent
//---------------------------------------------------------

void AwlFloatEntry::mouseDoubleClickEvent(QMouseEvent* event)
      {
      if (event->button() != QMouseEvent::LeftButton) {
            mousePressEvent(event);
            return;
            }
      setFocus();
      QLineEdit::setFrame(true);
      update();
      }

//---------------------------------------------------------
//   setValue
//---------------------------------------------------------

void AwlFloatEntry::setValue(float v)
      {
      if (setString(v)) {
            // value is out of range:
            if (v > max)
                  v = max;
            else if (v < min)
                  v = min;
            }
      val = v;
      }


--- NEW FILE: panentry.cpp ---
//=========================================================
//  AWL
//  Audio Widget Library
//  $Id: panentry.cpp,v 1.1 2004/07/28 10:22:13 wschweer Exp $
//
//  (C) Copyright 2004 Werner Schweer (ws...@se...)
//=========================================================

#include "awlpanentry.h"

//---------------------------------------------------------
//   AwlPanEntry
//---------------------------------------------------------

AwlPanEntry::AwlPanEntry(QWidget* parent)
   : AwlFloatEntry(parent)
      {
      setRange(-1.0, 1.0);
      }



--- NEW FILE: awlpanknob.h ---
//=========================================================
//  AWL
//  Audio Widget Library
//  $Id: awlpanknob.h,v 1.1 2004/07/28 10:22:12 wschweer Exp $
//
//  (C) Copyright 2004 Werner Schweer (ws...@se...)
//=========================================================

#ifndef __AWLPANKNOB_H__
#define __AWLPANKNOB_H__

#include "awlknob.h"

//---------------------------------------------------------
//   PanKnob
//!   Pan Knob entry widget
//
//!   This widget implements a centered floating point
//!   knob used to adjust the pan position in an audio
//!   mixer.
//---------------------------------------------------------

class AwlPanKnob : public AwlKnob {
      Q_OBJECT

      virtual void valueChange();

   public:
      AwlPanKnob(QWidget* parent = 0, const char* name = 0);
      };

#endif


--- NEW FILE: awlknob.h ---
//=========================================================
//  AWL
//  Audio Widget Library
//  $Id: awlknob.h,v 1.1 2004/07/28 10:22:12 wschweer Exp $
//
//  (C) Copyright 2004 Werner Schweer (ws...@se...)
//=========================================================

#ifndef __AWLKNOB_H__
#define __AWLKNOB_H__

#include <qpointarray.h>
#include "awlaslider.h"

//---------------------------------------------------------
//    Knob
//
//!   Base class of all dialer type input widgets.
//
//!   xxxxxxxxx
//!
//---------------------------------------------------------

class AwlKnob : public AwlAbstractSlider {
      Q_OBJECT
      Q_PROPERTY(int scaleSize READ scaleSize WRITE setScaleSize)
      Q_PROPERTY(QString text READ text WRITE setText)

      int _scaleSize;         //! scale size in degrees
      QPointArray points;

      virtual void paint(const QRect& r);
      virtual void mousePressEvent(QMouseEvent*);
      virtual void mouseReleaseEvent(QMouseEvent*);
      virtual void mouseMoveEvent(QMouseEvent*);

   protected:
      int startY;
      QString _text;
      virtual void valueChange() { emit valueChanged(_value, _id); }

   signals:
      void sliderPressed(int);
      void sliderReleased(int);
      void valueChanged(float, int);

   public:
      AwlKnob(QWidget* parent = 0, const char* name = 0);
      virtual QSize sizeHint() const { return QSize(100, 100); }

      //! return text decoration
      QString text() const           { return _text; }
      void setText(const QString& s);

      //! return scale size in degrees
      int scaleSize() const          { return _scaleSize; }
      void setScaleSize(int val);
      };

#endif


--- NEW FILE: midivolentry.cpp ---
//=========================================================
//  AWL
//  Audio Widget Library
//  $Id: midivolentry.cpp,v 1.1 2004/07/28 10:22:13 wschweer Exp $
//
//  (C) Copyright 2004 Werner Schweer (ws...@se...)
//=========================================================

#include "fastlog.h"
#include "awlmidivolentry.h"

//---------------------------------------------------------
//   AwlMidiVolEntry
//---------------------------------------------------------

AwlMidiVolEntry::AwlMidiVolEntry(QWidget* parent)
   : AwlFloatEntry(parent)
      {
      setRange(-98.0f, 0.0f);
      setSpecialText(tr("off"));
      setSuffix(tr("db"));
      setFrame(true);
      setBackgroundMode(PaletteMid);
      setPrecision(0);
      }

//---------------------------------------------------------
//   setValue
//---------------------------------------------------------

void AwlMidiVolEntry::setValue(float v)
      {
      AwlFloatEntry::setValue(-fast_log10((127.0f*127.0f)/(v*v))*20.0f);
      }


--- NEW FILE: awlplugin.cpp ---
//=========================================================
//  Awl
//  Audio Widget Library
//    $Id: awlplugin.cpp,v 1.1 2004/07/28 10:22:12 wschweer Exp $
//  (C) Copyright 2004 Werner Schweer (ws...@se...)
//=========================================================

// this file makes the AWL widgets available
// to QT-Designer

#include <qwidgetplugin.h>
#include "awlknob.h"
#include "awlslider.h"
#include "awlvolknob.h"
#include "awlpanknob.h"
#include "awlvolslider.h"

//---------------------------------------------------------
//   AwlPlugin
//---------------------------------------------------------

class AwlPlugin : public QWidgetPlugin {
   public:
      AwlPlugin() {}
      ~AwlPlugin() {}
      QStringList keys() const;
      QWidget* create(const QString& key, QWidget* parent=0,
         const char* name = 0);
      QString group(const QString& key) const;
      QIconSet iconSet(const QString& key) const;
      QString includeFile(const QString& key) const;
      QString toolTip(const QString& key) const;
      QString whatsThis(const QString& key) const;
      bool isContainer(const QString& key) const;
      };

//---------------------------------------------------------
//   keys
//---------------------------------------------------------

QStringList AwlPlugin::keys() const
      {
      QStringList list;
      list << QString("AwlKnob")
           << QString("AwlSlider")
           << QString("AwlVolSlider")
           << QString("AwlVolKnob")
           << QString("AwlPanKnob")
      ;
      return list;
      }

//---------------------------------------------------------
//   create
//---------------------------------------------------------

QWidget* AwlPlugin::create(const QString& key, QWidget* parent,
   const char* name)
      {
      if (key == QString("AwlKnob"))
            return new AwlKnob(parent, name);
      else if (key == QString("AwlSlider"))
            return new AwlSlider(parent, name);
      else if (key == QString("AwlVolSlider"))
            return new AwlVolSlider(parent, name);
      else if (key == QString("AwlVolKnob"))
            return new AwlVolKnob(parent, name);
      else if (key == QString("AwlPanKnob"))
            return new AwlPanKnob(parent, name);
      return 0;
      }

//---------------------------------------------------------
//   group
//---------------------------------------------------------

QString AwlPlugin::group(const QString& /*key*/) const
      {
      return QString("AWL");
      }

//---------------------------------------------------------
//   iconSet
//---------------------------------------------------------

QIconSet AwlPlugin::iconSet(const QString&) const
      {
      return QIconSet();
      }

//---------------------------------------------------------
//   includeFile
//---------------------------------------------------------

QString AwlPlugin::includeFile(const QString& key) const
      {
      if (key == QString("AwlKnob"))
            return QString("awlknob.h");
      else if (key == QString("AwlSlider"))
            return QString("awlslider.h");
      else if (key == QString("AwlVolSlider"))
            return QString("awlvolslider.h");
      else if (key == QString("AwlVolKnob"))
            return QString("awlvolknob.h");
      else if (key == QString("AwlPanKnob"))
            return QString("awlpanknob.h");
      return QString::null;
      }

//---------------------------------------------------------
//   toolTip
//---------------------------------------------------------

QString AwlPlugin::toolTip (const QString& key) const
      {
      if (key == QString("AwlKnob"))
            return QString("knob");
      else if (key == QString("AwlSlider"))
            return QString("slider");
      else if (key == QString("AwlVolSlider"))
            return QString("volume slider");
      else if (key == QString("AwlVolKnob"))
            return QString("volume knob");
      else if (key == QString("AwlPanKnob"))
            return QString("pan knob");
      return QString::null;
      }

//---------------------------------------------------------
//   whatsThis
//---------------------------------------------------------

QString AwlPlugin::whatsThis (const QString& key) const
      {
      if (key == QString("AwlKnob"))
            return QString("knob");
      else if (key == QString("AwlSlider"))
            return QString("slider");
      else if (key == QString("AwlVolSlider"))
            return QString("volume slider");
      else if (key == QString("AwlVolKnob"))
            return QString("volume knob");
      else if (key == QString("AwlPanKnob"))
            return QString("pan knob");
      return QString::null;
      }

//---------------------------------------------------------
//   isContainer
//---------------------------------------------------------

bool AwlPlugin::isContainer (const QString& /*key*/) const
      {
      return false;
      }

Q_EXPORT_PLUGIN(AwlPlugin)


--- NEW FILE: volentry.cpp ---
//=========================================================
//  AWL
//  Audio Widget Library
//  $Id: volentry.cpp,v 1.1 2004/07/28 10:22:13 wschweer Exp $
//
//  (C) Copyright 2004 Werner Schweer (ws...@se...)
//=========================================================

#include "fastlog.h"
#include "awlvolentry.h"

//---------------------------------------------------------
//   AwlVolEntry
//---------------------------------------------------------

AwlVolEntry::AwlVolEntry(QWidget* parent)
   : AwlFloatEntry(parent)
      {
      setRange(-60.0, 10.0);
      }

//---------------------------------------------------------
//   setValue
//---------------------------------------------------------

void AwlVolEntry::setValue(float v)
      {
      AwlFloatEntry::setValue(fast_log10(v)*20.0);
      }


--- NEW FILE: Makefile.am ---
include $(top_srcdir)/common.am

## awlwidgetsplugin_so_CPPFLAGS = $(MUSECXXFLAGS) -fPIC \
##    -DQT_THREAD_SUPPORT -DQT_SHARED -DQT_PLUGIN

## awlplugin_so_LDFLAGS = --whole-archive -fno-exceptions -shared \
##	-Wl,-soname,libawlplugin.so.1 $(QT_LIBS) -lasound

## lib_LTLIBRARIES = libawl.la

libawl_la_CXXFLAGS = $(MUSECXXFLAGS) -fPIC -I.. -I$(top_srcdir)/synti \
   -DQT_THREAD_SUPPORT -DQT_SHARED -DQT_PLUGIN

if PCH
libawl_la_CXXFLAGS += -include $(top_srcdir)/all-pic.h
endif

noinst_LTLIBRARIES  = libawl.la

## libawl_la_LDFLAGS  = -export-dynamic -version-info 1

libawl_la_SOURCES = \
      fastlog.h \
      aslider.cpp awlaslider.h      \
      knob.cpp awlknob.h            \
      panknob.cpp awlpanknob.h      \
      slider.cpp awlslider.h        \
      volknob.cpp awlvolknob.h      \
      volslider.cpp awlvolslider.h \
      floatentry.cpp awlfloatentry.h \
      volentry.cpp awlvolentry.h \
      panentry.cpp awlpanentry.h \
      midivolentry.cpp awlmidivolentry.h \
      moc_awlmidivolentry.cpp \
      moc_awlfloatentry.cpp \
      moc_awlvolentry.cpp \
      moc_awlpanentry.cpp \
	moc_awlaslider.cpp \
	moc_awlknob.cpp \
	moc_awlpanknob.cpp \
	moc_awlslider.cpp \
	moc_awlvolknob.cpp \
	moc_awlvolslider.cpp

## inst_PROGRAMS = awlplugin.so
## instdir = $(pkglibdir)/qtplugins/designer

## awlplugin.o: awlplugin.cpp
##	$(CXXCOMPILE) -fPIC -DQT_THREAD_SUPPORT -DQT_SHARED -DQT_PLUGIN -c awlplugin.cpp


--- NEW FILE: fastlog.h ---
/* Copyright unknown. Code by Laurent de Soras <la...@oh...>.
 */

#ifndef __pbd_fastlog_h__
#define __pbd_fastlog_h__

#include <math.h> /* for HUGE_VAL */

static inline float fast_log2 (float val)
      {
	/* don't use reinterpret_cast<> because that prevents this
	   from being used by pure C code (for example, GnomeCanvasItems)
	*/
	int* const exp_ptr = (int *)(&val);
	int x              = *exp_ptr;
	const int log_2    = ((x >> 23) & 255) - 128;
	x &= ~(255 << 23);
	x += 127 << 23;
	*exp_ptr = x;
	val = ((-1.0f/3) * val + 2) * val - 2.0f/3;   // (1)
	return (val + log_2);
      }

static inline float fast_log (const float val)
      {
      return (fast_log2 (val) * 0.69314718f);
      }

static inline float fast_log10 (const float val)
      {
	return fast_log2(val) / 3.312500f;
      }

static inline float minus_infinity() { return -HUGE_VAL; }

#endif /* __pbd_fastlog_h__ */

--- NEW FILE: awlaslider.h ---
//=========================================================
//  AWL
//  Audio Widget Library
//  $Id: awlaslider.h,v 1.1 2004/07/28 10:22:12 wschweer Exp $
//
//  (C) Copyright 2004 Werner Schweer (ws...@se...)
//=========================================================

#ifndef __AWLASLIDER_H__
#define __AWLASLIDER_H__

#include <qwidget.h>
#include <qpixmap.h>

//---------------------------------------------------------
//    AwlAbstractSlider
//
//!   The AwlAbstractSlider class provides an float value within a range
//
//!   The class is designed as a common super class for
//!   widgets like AwlKnob and AwlSlider
//!
//---------------------------------------------------------

class AwlAbstractSlider : public QWidget {
      Q_OBJECT
      Q_PROPERTY(bool center READ center WRITE setCenter)
      Q_PROPERTY(bool invertedAppearance READ invertedAppearance WRITE setInvertedAppearance)

      Q_PROPERTY(int scaleWidth READ scaleWidth WRITE setScaleWidth)
      Q_PROPERTY(QColor scaleColor READ scaleColor WRITE setScaleColor)
      Q_PROPERTY(QColor scaleValueColor READ scaleValueColor WRITE setScaleValueColor)

      Q_PROPERTY(int id READ id WRITE setId)

      Q_PROPERTY(float minValue READ minValue WRITE setMidValue)
      Q_PROPERTY(float maxValue READ maxValue WRITE setMaxValue)
      Q_PROPERTY(float lineStep READ lineStep WRITE setLineStep)
      Q_PROPERTY(float pageStep READ pageStep WRITE setPageStep)

      virtual void paint(const QRect& r) = 0;
      virtual void resizeEvent(QResizeEvent*);
      virtual void paintEvent(QPaintEvent*);
      virtual void wheelEvent(QWheelEvent*);
      virtual void keyPressEvent(QKeyEvent*);

   protected:
      int _id;
      float _value;
      float _minValue, _maxValue, _lineStep, _pageStep;
      bool _center;
      bool _invert;
      int _scaleWidth;        //! scale line width
      QColor _scaleColor;
      QColor _scaleValueColor;

      QBrush brush;
      QPixmap pm;
      bool pmValid;

      void redraw(const QRect& r);
      void redraw();

      virtual void valueChange() {}

   public slots:
      virtual void setValue(float v);

   public:
      AwlAbstractSlider(QWidget* parent = 0, const char* name = 0);
//      virtual QSize sizeHint() const { return QSize(10, 10); }

      virtual void setCenter(bool val);
      virtual void setScaleWidth(int);
      virtual void setScaleColor(const QColor&);
      virtual void setScaleValueColor(const QColor&);

      //! return the center flag
      bool center() const            { return _center; }

      //! return the scale line width
      int scaleWidth() const         { return _scaleWidth; }

      //! return current scale color
      QColor scaleColor() const      { return _scaleColor; }

      //! return color of active scale part
      QColor scaleValueColor() const { return _scaleValueColor; }

      virtual void setInvertedAppearance(bool val) { _invert = val; }
      bool invertedAppearance() const              { return _invert; }

      int id() const { return _id; }
      void setId(int i) { _id = i; }

      virtual float value() const { return _value; }

      float minValue() const { return _minValue; }
      void setMinValue(float v) { _minValue = v; }
      float maxValue() const { return _maxValue; }
      void setMaxValue(float v) { _maxValue = v; }
      void setRange(float a, float b) {
            setMinValue(a);
            setMaxValue(b);
            }
      float lineStep() const { return _lineStep; }
      void setLineStep(float v) { _lineStep = v; }
      float pageStep() const { return _pageStep; }
      void setPageStep(float f) { _pageStep = f; }
      };

#endif


--- NEW FILE: volknob.cpp ---
//=========================================================
//  AWL
//  Audio Widget Library
//  $Id: volknob.cpp,v 1.1 2004/07/28 10:22:13 wschweer Exp $
//
//  (C) Copyright 2004 Werner Schweer (ws...@se...)
//=========================================================

#include "fastlog.h"
#include "awlvolknob.h"

//---------------------------------------------------------
//   VolKnob
//---------------------------------------------------------

AwlVolKnob::AwlVolKnob(QWidget* parent, const char* name)
   : AwlKnob(parent, name)
      {
      setMinValue(-60.0f);
      setMaxValue(10.0f);
      _lineStep = .8f;
      _pageStep = 3.0f;
      }

//---------------------------------------------------------
//   setValue
//!   set the current volume to val
//---------------------------------------------------------

void AwlVolKnob::setValue(float val)
      {
      if (val == 0.0f)
            _value = _minValue;
      else
            _value = fast_log10(val) * 20.0f;
      redraw();
      }

//---------------------------------------------------------
//   valueChange
//---------------------------------------------------------

void AwlVolKnob::valueChange()
      {
      float gain = pow(10.0, _value*0.05f);
      emit valueChanged(gain, _id);
      }


--- NEW FILE: awlvolslider.h ---
//=========================================================
//  AWL
//  Audio Widget Library
//  $Id: awlvolslider.h,v 1.1 2004/07/28 10:22:12 wschweer Exp $
//
//  (C) Copyright 2004 Werner Schweer (ws...@se...)
//=========================================================

#ifndef __AWLVOLSLIDER_H__
#define __AWLVOLSLIDER_H__

#include "awlslider.h"

//---------------------------------------------------------
//   VolSlider
//!   Volume Slider entry widget
//
//!   This widget implements a slider with a logarithmic
//!   floating point scale used to adjust the volume
//!   in an audio mixer.
//!   Internal value represents gain as a logarythmic
//!   dB value.
//---------------------------------------------------------

class AwlVolSlider : public AwlSlider {
      Q_OBJECT

      virtual void valueChange();

   public slots:
      void setValue(float gain);

   public:
      AwlVolSlider(QWidget* parent = 0, const char* name = 0);
      };

#endif


--- NEW FILE: awlslider.h ---
//=========================================================
//  AWL
//  Audio Widget Library
//  $Id: awlslider.h,v 1.1 2004/07/28 10:22:12 wschweer Exp $
//
//  (C) Copyright 2004 Werner Schweer (ws...@se...)
//=========================================================

#ifndef __AWLSLIDER_H__
#define __AWLSLIDER_H__

#include <qpointarray.h>
#include "awlaslider.h"

//---------------------------------------------------------
//    AwlSlider
//
//!   Base class of all slider type input widgets.
//
//!   Inherits from AwlKnob
//!
//---------------------------------------------------------

class AwlSlider : public AwlAbstractSlider {
      Q_OBJECT

      Q_PROPERTY(Orientation orientation READ orientation WRITE setOrientation)
      Q_PROPERTY(QSize sliderSize READ sliderSize WRITE setSliderSize)

      Orientation orient;
      QSize _sliderSize;

      QPoint startDrag;
      bool dragMode;
      int dragppos;
      QPointArray points;

      virtual void mousePressEvent(QMouseEvent*);
      virtual void mouseReleaseEvent(QMouseEvent*);
      virtual void mouseMoveEvent(QMouseEvent*);
      virtual void paint(const QRect& r);

      virtual void valueChange() { emit valueChanged(_value, _id); }

   signals:
      void sliderPressed(int);
      void sliderReleased(int);
      void valueChanged(float, int);

   public:
      AwlSlider(QWidget* parent = 0, const char* name = 0);
//      virtual QSize sizeHint() const;

      virtual void setOrientation(Orientation);
      Orientation orientation() const    { return orient; }

      QSize sliderSize() const           { return _sliderSize; }
      void setSliderSize(const QSize& s);

      virtual void setInvertedAppearance(bool val);
      };

#endif


--- NEW FILE: awlfloatentry.h ---
//=========================================================
//  AWL
//  Audio Widget Library
//  $Id: awlfloatentry.h,v 1.1 2004/07/28 10:22:12 wschweer Exp $
//
//  (C) Copyright 2004 Werner Schweer (ws...@se...)
//=========================================================

#ifndef __FLOATLABEL_H__
#define __FLOATLABEL_H__

#include <qlineedit.h>

class QTimer;

//---------------------------------------------------------
//   AwlFloatEntry
//---------------------------------------------------------

class AwlFloatEntry : public QLineEdit {
      Q_OBJECT
      Q_PROPERTY(int id READ id WRITE setId)
      Q_PROPERTY(bool frame READ frame WRITE setFrame)

      Q_PROPERTY(float minValue READ minValue WRITE setMinValue)
      Q_PROPERTY(float maxValue READ maxValue WRITE setMaxValue)
      Q_PROPERTY(QString specialText READ specialText WRITE setSpecialText)
      Q_PROPERTY(QString suffix READ suffix WRITE setSuffix)
      Q_PROPERTY(int precision READ precision WRITE setPrecision)

      int button;
      int starty;
      bool drawFrame;
      QTimer* timer;
      double evx;
      int timecount;
      float min, max;
      QString _specialText;   // text to show if value outside min,max
      QString _suffix;
      int _precision;

      virtual void wheelEvent(QWheelEvent*);
      virtual void mousePressEvent(QMouseEvent*);
      virtual void mouseMoveEvent(QMouseEvent*);
      virtual void mouseDoubleClickEvent(QMouseEvent*);
      virtual void mouseReleaseEvent(QMouseEvent*);
      virtual void setSValue(const QString&);
      virtual bool setString(float);
      virtual void incValue(float);
      virtual void decValue(float);

   protected:
      int _id;
      float val;

   private slots:
      void repeat();

   protected slots:
      void endEdit();

   public slots:
      virtual void setValue(float);

   signals:
      void valueChanged(float, int);

   public:
      AwlFloatEntry(QWidget*);
      virtual QSize sizeHint() const;
      double value() const                  { return val; }
      bool frame() const                    { return drawFrame; }
      void setFrame(bool);
      int id() const                        { return _id; }
      void setId(int i)                     { _id = i; }
      float minValue() const                { return min; }
      float maxValue() const                { return max; }
      void setMinValue(float v)             { min = v; }
      void setMaxValue(float v)             { max = v; }
      void setRange(float a, float b)       { min = a; max = b; }
      int precision() const                 { return _precision; }
      void setPrecision(int val);
      QString specialText() const           { return _specialText; }
      void setSpecialText(const QString& s) {
            _specialText = s;
            update();
            }
      QString suffix() const                { return _suffix; }
      void setSuffix(const QString& s)      { _suffix = s; }
      };
#endif


--- NEW FILE: slider.cpp ---
//=========================================================
//  AWL
//  Audio Widget Library
//  $Id: slider.cpp,v 1.1 2004/07/28 10:22:13 wschweer Exp $
//
//  (C) Copyright 2004 Werner Schweer (ws...@se...)
//=========================================================

#include <qpainter.h>

#include "awlslider.h"

//---------------------------------------------------------
//   Slider
//---------------------------------------------------------

AwlSlider::AwlSlider(QWidget* parent, const char* name)
   : AwlAbstractSlider(parent, name), orient(Vertical), _sliderSize(14,14), points(3) {
      dragMode = false;
      }

//---------------------------------------------------------
//   sizeHint
//---------------------------------------------------------

#if 0
QSize AwlSlider::sizeHint() const
      {
      if (orient == Horizontal)
            return QSize(200, 20);
      else
            return QSize(20, 200);
      }
#endif

//---------------------------------------------------------
//   setOrientation
//---------------------------------------------------------

void AwlSlider::setOrientation(Orientation o)
      {
      orient = o;
      redraw();
      }

//---------------------------------------------------------
//   setInvertedAppearance
//---------------------------------------------------------

void AwlSlider::setInvertedAppearance(bool val)
      {
      AwlAbstractSlider::setInvertedAppearance(val);
      redraw();
      }

//---------------------------------------------------------
//   setSliderSize
//---------------------------------------------------------

void AwlSlider::setSliderSize(const QSize& s)
      {
      _sliderSize = s;
      redraw();
      }

//---------------------------------------------------------
//   mousePressEvent
//---------------------------------------------------------

void AwlSlider::mousePressEvent(QMouseEvent* ev)
      {
      startDrag = ev->pos();
      if (points.boundingRect().contains(startDrag)) {
            emit sliderPressed(_id);
            dragMode = true;
            int pixel = (orient == Vertical) ? height() - _sliderSize.height() : width() - _sliderSize.width();
            dragppos = int(pixel * (_value - minValue()) / (maxValue() - minValue()));
            if (_invert)
                  dragppos = pixel - dragppos;
            }
      }

//---------------------------------------------------------
//   mouseReleaseEvent
//---------------------------------------------------------

void AwlSlider::mouseReleaseEvent(QMouseEvent*)
      {
      if (dragMode) {
            emit sliderReleased(_id);
            dragMode = false;
            }
      }

//---------------------------------------------------------
//   mouseMoveEvent
//---------------------------------------------------------

void AwlSlider::mouseMoveEvent(QMouseEvent* ev)
      {
      if (!dragMode)
            return;
      int ppos;
      if (orient == Vertical)
            ppos = dragppos + (startDrag.y() - ev->y());
      else
            ppos = dragppos + (ev->x() - startDrag.x());
      if (ppos < 0)
            ppos = 0;
      int pixel = (orient == Vertical) ? height() - _sliderSize.height() : width() - _sliderSize.width();
      if (ppos > pixel)
            ppos = pixel;
      int pos = _invert ? (pixel - ppos) : ppos;
      _value  = (pos * (maxValue() - minValue()) / pixel) + minValue();

      redraw();
      valueChange();
      }

//---------------------------------------------------------
//   paint
//    r - phys coord system
//---------------------------------------------------------

void AwlSlider::paint(const QRect& r)
      {
      if (pm.isNull())
            return;
      int pixel = (orient == Vertical) ? height() - _sliderSize.height() : width() - _sliderSize.width();
      int ppos = int(pixel * (_value - minValue()) / (maxValue() - minValue()));
      if (_invert)
            ppos = pixel - ppos;

      QRect rr(r);
      if (!pmValid) {
            pmValid = true;
            rr = QRect(0, 0, pm.width(), pm.height());
            }
      QPainter p(&pm);
      p.fillRect(rr, brush);

      QColor sc(isEnabled() ? _scaleColor : gray);
      QColor svc(isEnabled() ? _scaleValueColor : gray);
      p.setBrush(svc);

      int h  = height();
      int w  = width();
      int kw = _sliderSize.width();
      int kh = _sliderSize.height();

      //---------------------------------------------------
      //    draw scale
      //---------------------------------------------------

      int x1, x2, y1, y2;
      int xx1, xx2, yy1, yy2;
      if (orient == Vertical) {
            if (_invert) {
                  y1  = kh / 2;
                  y2  = h - (ppos + y1);
                  yy1 = y2;
                  yy2 = h - y1;
                  }
            else {
                  yy1 = kh / 2;
                  yy2 = h - (ppos + yy1);
                  y1  = yy2;
                  y2  = h - yy1;
                  }
            xx1 = x1 = _scaleWidth/2;
            xx2 = x2 = x1;
            }
      else {
            if (_invert) {
                  xx1 = kw / 2;
                  xx2 = ppos + xx1;
                  x1  = xx2;
                  x2  = w - xx1;
                  }
            else {
                  x1  = kw / 2;
                  x2  = ppos + x1;
                  xx1 = x2;
                  xx2 = w - x1;
                  }
            yy1 = y1 = _scaleWidth/2;
            yy2 = y2 = y1;
            }
      p.setPen(QPen(sc, _scaleWidth));
      p.drawLine(xx1, yy1, xx2, yy2);
      p.setPen(QPen(svc, _scaleWidth));
      p.drawLine(x1, y1, x2, y2);

      p.setPen(QPen(svc, 0));

      //---------------------------------------------------
      //    draw slider
      //---------------------------------------------------

      if (orient == Vertical) {
            int y = _invert ? yy2 : y1;
            points.setPoint(0, _scaleWidth,    y);
            points.setPoint(1, _scaleWidth+kw, y-kh/2);
            points.setPoint(2, _scaleWidth+kw, y+kh/2);
            }
      else {
            int x = _invert ? xx2 : x2;
            points.setPoint(0, x,      _scaleWidth);
            points.setPoint(1, x-kw/2, _scaleWidth+kh);
            points.setPoint(2, x+kw/2, _scaleWidth+kh);
            }
      p.drawConvexPolygon(points);
      }


--- NEW FILE: awlpanentry.h ---
//=========================================================
//  AWL
//  Audio Widget Library
//  $Id: awlpanentry.h,v 1.1 2004/07/28 10:22:12 wschweer Exp $
//
//  (C) Copyright 2004 Werner Schweer (ws...@se...)
//=========================================================

#ifndef __AWLPANENTRY_H__
#define __AWLPANENTRY_H__

#include "awlfloatentry.h"

//---------------------------------------------------------
//   AwlPanEntry
//---------------------------------------------------------

class AwlPanEntry : public AwlFloatEntry {
      Q_OBJECT

   public:
      AwlPanEntry(QWidget*);
      };

#endif