---

qwavmonowaveview.h

/***************************************************************************
                          soneframedview.h  -  description
                             -------------------
    begin                : Sat Nov 9 2002
    copyright            : (C) 2002 by Peter Eschler
    email                : eschler@users.sourceforge.net
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef QwavMONOWAVEVIEW_H_
#define QwavMONOWAVEVIEW_H_

//---------------------------------------------------------------------------
// Includes: Qt
//---------------------------------------------------------------------------

#include <qwidget.h>
#include <qlayout.h>
#include <qlabel.h>
#include <qlineedit.h>
#include <qpushbutton.h>
#include <qslider.h>
#include <qscrollbar.h>

//---------------------------------------------------------------------------
// Includes: project
//---------------------------------------------------------------------------

#include "qwavdefines.h"
#include "qwavexceptions.h"
#include "qwavwaveviewinterface.h"
#include "qwavwaveview.h"

//---------------------------------------------------------------------------
// Includes: Qwt
//---------------------------------------------------------------------------

#include "qwt_slider.h"
#include "qwt_scale.h"


//---------------------------------------------------------------------------
// Includes: system
//---------------------------------------------------------------------------

#include <string>

//---------------------------------------------------------------------------
// Forward declarations
//---------------------------------------------------------------------------

Qwav_USING_NAMESPACE

Qwav_BEGIN_NAMESPACE

// class QwavWaveView;
class QwavWaveDataInterface;

//---------------------------------------------------------------------------
// Class: QwavMonoWaveView
//---------------------------------------------------------------------------
   
class QWAV_EXPORTIMPORT QwavMonoWaveView 
  : public QWidget, 
    public QwavWaveViewInterface
{
    Q_OBJECT
    
public:

    /*---------------------------------------------------------------------*/
    QwavMonoWaveView(QwavWaveDataInterface* waveData,
                 QWidget*           parent,
                 const char*        name=0,
                 int                wflags=0  );
                   
    QwavMonoWaveView(const string&  filename,
                 QWidget*       parent,
                 const char*    name=0   ) 
           throw(InvalidNrOfChannels,
             FileOpenError,
             FileReadError);

    virtual ~QwavMonoWaveView();

    /*---------------------------------------------------------------------*/
    virtual void update(QwavMonoWaveView* pSender);

    /*---------------------------------------------------------------------*/
    inline int              addLayer       (QwavViewLayer* layer);
    inline QwavViewLayer*   getLayer       (const string& name)  ;    
    inline QwavViewLayer*   getLayer       (uint index)          ;
    inline uint             getNrOfLayers  (void)         const  ;
    inline QPixmap*         getBackbuf     (void)                ;

    /*---------------------------------------------------------------------*/
    inline int          sample2Pixel   (long  sample) const;
    inline long         pixel2Sample   (int   pixel)  const;
    
    inline bool         isSampleVisible(long sample)  const;
    inline const int    nrOfPixels     (void)         const;

    inline double       zoomFac        (void)         const;
    inline double       zoomYFac       (void)         const;
    inline double       maxZoomFac     (void)         const;  

    inline const ulong  firstSample    (void)         const;
    inline const long   lastSample     (void)         const;    
    inline const long   samplesVisible (void)         const;
  
    inline void setPeakInterpolator(QwavPeakInterpolator* s);
    inline QwavPeakInterpolator* peakInterpolator() const;
    
    /*---------------------------------------------------------------------*/
    inline  void                setPosition(const ulong sample);
    inline const ulong&        position() const               ;

    /*---------------------------------------------------------------------*/
    inline uint           addSelection     (const QwavSelection& s);
    inline uint           getNrOfSelections(void)         const;
    inline const QwavSelection& getSelection(uint index=0)const;
    inline QwavSelection& getSelection     (uint index=0)      ;
    inline int            isSelectionBegin (int pixel )        ;
    inline int            isSelectionEnd   (int pixel )        ;
    inline int            activeSelection  (void)         const;
    inline void           clearSelections  (void)              ;

    inline const State&   state            (void) const;

signals:
    void           selBeginChanged(long sample);     
    void           selEndChanged  (long sample);     
    void           zoomFacChanged (double fac );     
    void           positionChanged(ulong sample);  
    void           firstSampleChanged(ulong sample);
    
public slots:
    void activatePeakLayer(bool);
    void activateAverageLayer(bool);
    void activateZeroLineLayer(bool);

    /*---------------------------------------------------------------------*/
    inline void           setBgColor       (const QColor& c);
    inline const QColor&  bgColor          (void) const     ;
    inline void           setPeakColor     (const QColor& c);
    inline const QColor&  peakColor        (void) const     ;
    inline void           setAvgColor      (const QColor& c);
    inline const QColor&  avgColor         (void) const     ;
    
    /*---------------------------------------------------------------------*/
    inline void           setSamplesVisible(const long& newVal);
    inline void           setZoomFac       (double zoomFac)    ;
    inline void           setZoomYFac      (double zoomYFac)   ; 
    inline void           setFirstSample   (ulong sample)       ;
    inline void           setChannel       (uint channel=1)    ;
    inline uint           channel          (void) const        ;
    inline void           scrollBy         (int pixel);
protected slots: // Protected slots

    void onZoomFacChanged(double);    
    void onZoomFacInQwavWaveViewChanged(double);
    void onZoomFacEntered();

    void onPeakColor();
    void onBgColor();
    void onHScrollBarChanged(int);
    void onSelChanged(long);
    void onFirstSampleChanged(ulong);
    
private:
    void initWidgets(QwavWaveDataInterface*);
    void updatePosScale();

    QwavWaveDataInterface* _waveData;
    QwavWaveView*      _waveView;       
    QVBoxLayout*   _vLayout;
    QHBoxLayout*   _hLayout;
    QLabel*        _lblSize;
    QLabel*        _lblSampleRate;
    QwtSlider*     _slZoomFac;     
    QwtSlider*     _slZoomYFac;    
    QwtScale*      _scPowerScale;  
    QwtScale*      _scPosScale;
    QLineEdit*     _leVisibleSamples;
    QLineEdit*     _leZoomFac;     
    QLineEdit*     _leScrollValue;
    QLabel*        _lblSelection;
    QLabel*        _lblWidth;
    QLabel*        _lblVisibleSamples;
    QLabel*        _lblZoomFac;    
    QPushButton*   _btnPeakColor;
    QPushButton*   _btnBgColor;
    QPushButton*   _btnPeakLayer;
    QPushButton*   _btnAverageLayer;
    QPushButton*   _btnZeroLineLayer;
    QScrollBar*    _hScrollBar;

protected: // Protected methods

    virtual void      resizeEvent          (QResizeEvent* e); 
    void              updateHorScrollBar   ();
//     
//     virtual void      paintEvent           (QPaintEvent*  e); 
//     inline void       mousePressEvent      (QMouseEvent*  e); 
//     inline void       mouseMoveEvent       (QMouseEvent*  e); 
//     inline void       mouseReleaseEvent    (QMouseEvent*  e); 
//  inline void       mouseDoubleClickEvent(QMouseEvent*  e); 
//     inline void       wheelEvent           (QWheelEvent*  e); 
//     inline void       keyPressEvent        (QKeyEvent*    e);
//     inline void       setState             (State s)        ;        
//     inline void       initLayers()                          ;    
    
};

//---------------------------------------------------------------------------
// Method: waveData
//---------------------------------------------------------------------------

// QwavWaveDataInterface* QwavMonoWaveView::waveData() const
// {
//     return _waveData;
// }

int QwavMonoWaveView::addLayer(QwavViewLayer* layer)
{
    return _waveView->addLayer(layer);
}

QwavViewLayer* QwavMonoWaveView::getLayer(const string& name)
{
    return _waveView->getLayer(name);
}

QwavViewLayer* QwavMonoWaveView::getLayer(uint index)
{
    return _waveView->getLayer(index);
}

uint QwavMonoWaveView::getNrOfLayers(void) const
{
    return _waveView->getNrOfLayers();
}

QPixmap* QwavMonoWaveView::getBackbuf(void)
{
    return _waveView->getBackbuf();
}

int  QwavMonoWaveView::sample2Pixel(long  sample) const
{
    return _waveView->sample2Pixel(sample);
}

long QwavMonoWaveView::pixel2Sample(int   pixel) const
{
    return _waveView->pixel2Sample(pixel);
}

bool QwavMonoWaveView::isSampleVisible(long sample) const
{
    return _waveView->isSampleVisible(sample);
}

const int QwavMonoWaveView::nrOfPixels(void) const
{
    return _waveView->nrOfPixels();
}

double  QwavMonoWaveView::zoomFac(void) const
{
    return _waveView->zoomFac();
}

double  QwavMonoWaveView::zoomYFac(void) const
{
    return _waveView->zoomYFac();
}

double  QwavMonoWaveView::maxZoomFac(void) const
{
    return _waveView->maxZoomFac();
}

const ulong QwavMonoWaveView::firstSample(void) const
{
    return _waveView->firstSample();
}

const long  QwavMonoWaveView::lastSample(void) const
{
    return _waveView->lastSample();
}

const long QwavMonoWaveView::samplesVisible(void) const
{
    return _waveView->samplesVisible();
}

void QwavMonoWaveView::setPeakInterpolator(QwavPeakInterpolator* s)
{
    _waveView->setPeakInterpolator(s);
}

QwavPeakInterpolator* QwavMonoWaveView::peakInterpolator() const
{
    return _waveView->peakInterpolator();
}
    
uint QwavMonoWaveView::addSelection(const QwavSelection& s)
{
    return _waveView->addSelection(s);
}

uint QwavMonoWaveView::getNrOfSelections(void) const
{
    return _waveView->getNrOfSelections();
}

const QwavSelection& QwavMonoWaveView::getSelection(uint index)const
{
    return _waveView->getSelection(index);
}

QwavSelection& QwavMonoWaveView::getSelection(uint index)
{
    return _waveView->getSelection(index);
}

int QwavMonoWaveView::isSelectionBegin(int pixel)
{
    return _waveView->isSelectionBegin(pixel);
}

int QwavMonoWaveView::isSelectionEnd(int pixel)
{
    return _waveView->isSelectionEnd(pixel);
}

int QwavMonoWaveView::activeSelection(void) const
{
    return _waveView->activeSelection();
}

void QwavMonoWaveView::clearSelections(void)
{
    _waveView->clearSelections();
}

const QwavWaveViewInterface::State& QwavMonoWaveView::state(void) const
{
    return _waveView->state();
}

void QwavMonoWaveView::setBgColor(const QColor& c)
{
    _waveView->setBgColor(c);
}

const QColor&  QwavMonoWaveView::bgColor(void) const
{
    return _waveView->bgColor();
}

void QwavMonoWaveView::setPeakColor(const QColor& c)
{
    _waveView->setPeakColor(c);
}

const QColor&  QwavMonoWaveView::peakColor(void) const
{
    return _waveView->peakColor();
}

void QwavMonoWaveView::setAvgColor(const QColor& c)
{
    _waveView->setAvgColor(c);
}


const QColor&  QwavMonoWaveView::avgColor(void) const
{
    return _waveView->avgColor();
}

void QwavMonoWaveView::setSamplesVisible(const long& newVal)
{
    _waveView->setSamplesVisible(newVal);
}

void QwavMonoWaveView::setZoomFac(double zoomFac)    
{
    _waveView->setZoomFac(zoomFac);
}

void QwavMonoWaveView::setZoomYFac(double zoomYFac) 
{
    _waveView->setZoomYFac(zoomYFac);
}

void QwavMonoWaveView::setFirstSample(ulong sample)       
{
    _waveView->setFirstSample(sample);
}

void QwavMonoWaveView::setChannel(uint channel)    
{
    _waveView->setChannel(channel);
}

uint QwavMonoWaveView::channel(void) const        
{
    return _waveView->channel();
}

void QwavMonoWaveView::scrollBy         (int pixel)
{
    _waveView->scrollBy(pixel);
}


void QwavMonoWaveView::setPosition(const ulong sample)
{
    _waveView->setPosition(sample);
}

const ulong& QwavMonoWaveView::position() const
{
    return _waveView->position();
}


Qwav_END_NAMESPACE


#endif  // QwavMONOWAVEVIEW_H_

---