#include <MainWidget.h>

Inheritance diagram for Kwave::MainWidget:

Collaboration diagram for Kwave::MainWidget:

Public Slots
virtual int	executeCommand (const QString &command) Q_DECL_OVERRIDE

void	setOffset (sample_index_t new_offset)

virtual void	scrollTo (sample_index_t pos) Q_DECL_OVERRIDE

virtual void	setZoom (double new_zoom) Q_DECL_OVERRIDE

void	zoomSelection ()

void	zoomAll ()

void	zoomNormal ()

void	zoomIn (int pos=-1)

void	zoomOut (int pos=-1)

Signals
void	sigZoomChanged (double zoom)

void	sigCommand (const QString &command)

void	sigVisibleRangeChanged (sample_index_t offset, sample_index_t visible, sample_index_t total)

Public Member Functions
	MainWidget (QWidget *parent, Kwave::FileContext &context, const QSize &preferred_size)

virtual bool	isOK ()

virtual	~MainWidget () Q_DECL_OVERRIDE

virtual double	zoom () const Q_DECL_OVERRIDE

virtual int	visibleWidth () const Q_DECL_OVERRIDE

virtual sample_index_t	visibleSamples () const Q_DECL_OVERRIDE

virtual sample_index_t	visibleOffset ()

virtual QSize	sizeHint () const Q_DECL_OVERRIDE

Public Member Functions inherited from Kwave::CommandHandler
	CommandHandler ()

virtual	~CommandHandler ()

virtual int	executeCommand (const QString &command)=0

Public Member Functions inherited from Kwave::Zoomable
	Zoomable ()

virtual	~Zoomable ()

virtual void	setZoom (double factor)=0

virtual void	scrollTo (sample_index_t pos)=0

Protected Slots
void	updateViewRange ()

Protected Member Functions
virtual void	dragEnterEvent (QDragEnterEvent *event) Q_DECL_OVERRIDE

virtual void	dropEvent (QDropEvent *event) Q_DECL_OVERRIDE

virtual void	resizeEvent (QResizeEvent *event) Q_DECL_OVERRIDE

virtual void	wheelEvent (QWheelEvent *event) Q_DECL_OVERRIDE

virtual void	closeEvent (QCloseEvent *e) Q_DECL_OVERRIDE

Private Slots
void	slotTrackInserted (unsigned int index, Kwave::Track *track)

void	slotTrackDeleted (unsigned int index, Kwave::Track *track)

void	refreshHorizontalScrollBar ()

void	horizontalScrollBarMoved (int newval)

Private Member Functions
sample_index_t	ms2samples (double ms)

sample_index_t	pixels2samples (unsigned int pixels) const

int	samples2pixels (sample_index_t samples) const

double	fullZoom () const

void	fixZoomAndOffset (double zoom, sample_index_t offset)

void	addLabel (sample_index_t pos, const QString &description)

bool	labelProperties (Kwave::Label &label)

int	loadLabels (const QString &filename)

int	saveLabels (const QString &filename)

Private Attributes
Kwave::FileContext &	m_context

QVBoxLayout	m_upper_dock

QVBoxLayout	m_lower_dock

QScrollArea	m_scroll_area

QScrollBar *	m_horizontal_scrollbar

Kwave::SignalWidget	m_signal_widget

Kwave::OverViewWidget *	m_overview

sample_index_t	m_offset

double	m_zoom

QSize	m_preferred_size

QTimer	m_delayed_update_timer

Detailed Description

The main widget is responsible for controlling the zoom on the time axis and the scrolling. For this purpose it has an optionally enabled vertical scroll bar at the right side and a horizontal scroll bar plus an overview widget at the lower side. The main view contains a viewport that contains a signal widget, which is fit in horizontally and has variable vertical size (scrolled via the vertical scroll bar if necessary). The layout looks like this:

/-----------------------------------------------------------------------\
| m_upper_dock                                                          |
|-----------------------------------------------------------------------|
| /- hbox ------------------------------------------------------------\ |
| +--- m_scroll_area------------------------------------------------+-| |
| |/---- m_signal_widget-------------------------------------------\|^| |
| ||          |                                                    ||#| |
| || controls |  SignalView                                        ||#| |
| ||          |                                                    ||#| |
| ||----------+----------------------------------------------------|||| |
| ||    .     |      .                                             |||| |
| ||    .     |      .                                             |||| |
| ||    .     |      .                                             ||v| |
| \-----------------------------------------------------------------+-/ |
|-----------------------------------------------------------------------|
| m_lower_dock                                                          |
|-----------------------------------------------------------------------|
| ############    m_overview                                            |
|-----------------------------------------------------------------------|
| <##### --------- m_horizontal_scrollbar ----------------------------> |
\-----------------------------------------------------------------------/

Definition at line 83 of file MainWidget.h.

Constructor & Destructor Documentation

◆ MainWidget()

Kwave::MainWidget::MainWidget	(	QWidget *	parent,
		Kwave::FileContext &	context,
		const QSize &	preferred_size
	)

Constructor.

Parameters

parent	parent widget
context	reference to the context of this instance
preferred_size	preferred size of the widget, needed in MDI mode, otherwise ignored

Definition at line 96 of file MainWidget.cpp.

References Kwave::connect(), horizontalScrollBarMoved(), m_context, m_delayed_update_timer, m_horizontal_scrollbar, m_lower_dock, m_overview, m_scroll_area, m_signal_widget, m_upper_dock, Kwave::SignalManager::metaData(), Kwave::OverViewWidget::metaDataChanged(), Kwave::SignalManager::playbackController(), Kwave::FileContext::pluginManager(), Kwave::PluginManager::registerViewManager(), setOffset(), sigCommand(), Kwave::FileContext::signalManager(), Kwave::OverViewWidget::sizeHint(), slotTrackDeleted(), slotTrackInserted(), and updateViewRange().

     :QWidget(parent),
      Kwave::CommandHandler(),
      Kwave::Zoomable(),
      m_context(context), m_upper_dock(), m_lower_dock(),
      m_scroll_area(this), m_horizontal_scrollbar(Q_NULLPTR),
      m_signal_widget(
          &m_scroll_area,
          context.signalManager(),
          &m_upper_dock,
          &m_lower_dock
      ),
      m_overview(Q_NULLPTR), m_offset(0), m_zoom(1.0),
      m_preferred_size(preferred_size),
      m_delayed_update_timer(this)
 {
 //    qDebug("MainWidget::MainWidget()");
 
     setAcceptDrops(true); // enable drag&drop
 
     Kwave::SignalManager *signal_manager = m_context.signalManager();
     Q_ASSERT(signal_manager);
     if (!signal_manager) return;
 
     Kwave::PluginManager *plugin_manager = context.pluginManager();
     Q_ASSERT(plugin_manager);
     if (!plugin_manager) return;
     plugin_manager->registerViewManager(&m_signal_widget);
 
     // topLayout:
     // - upper dock
     // - view port
     // - lower dock
     // - overview
     // - horizontal scroll bar
     QVBoxLayout *topLayout = new QVBoxLayout(this);
     Q_ASSERT(topLayout);
     if (!topLayout) return;
 
     topLayout->setSpacing(0);
 
     // -- upper dock --
     topLayout->addLayout(&m_upper_dock);
 
     // -- view port with signal widget --
     m_signal_widget.setSizePolicy(
         QSizePolicy::Expanding,
         QSizePolicy::Expanding
     );
     m_scroll_area.setFrameStyle(QFrame::NoFrame);
     m_scroll_area.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
     m_scroll_area.setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     m_scroll_area.setWidgetResizable(true);
     m_scroll_area.setWidget(&m_signal_widget);
 
     topLayout->addWidget(&m_scroll_area);
 
     // -- lower dock --
     topLayout->addLayout(&m_lower_dock);
 
     // -- overview widget --
 
     m_overview = new Kwave::OverViewWidget(*signal_manager, this);
     Q_ASSERT(m_overview);
     if (!m_overview) return;
     m_overview->setMinimumHeight(m_overview->sizeHint().height());
     m_overview->setSizePolicy(
         QSizePolicy::MinimumExpanding, QSizePolicy::Fixed
     );
     topLayout->addWidget(m_overview);
     connect(m_overview, SIGNAL(valueChanged(sample_index_t)),
             this,       SLOT(setOffset(sample_index_t)));
     connect(m_overview, SIGNAL(sigCommand(QString)),
             this,       SIGNAL(sigCommand(QString)));
     m_overview->metaDataChanged(signal_manager->metaData());
     m_overview->hide();
 
     // -- horizontal scrollbar --
 
     m_horizontal_scrollbar = new QScrollBar(this);
     Q_ASSERT(m_horizontal_scrollbar);
     if (!m_horizontal_scrollbar) return;
     m_horizontal_scrollbar->setOrientation(Qt::Horizontal);
     topLayout->addWidget(m_horizontal_scrollbar);
     connect(m_horizontal_scrollbar, SIGNAL(valueChanged(int)),
             this,                   SLOT(horizontalScrollBarMoved(int)));
     m_horizontal_scrollbar->hide();
 
     // -- playback position update --
 
     Kwave::PlaybackController &playback = signal_manager->playbackController();
     connect(&playback, SIGNAL(sigPlaybackPos(sample_index_t)),
         m_overview, SLOT(showCursor(sample_index_t)));
     connect(&playback, SIGNAL(sigPlaybackStopped()),
         m_overview, SLOT(showCursor()));
 
     // -- connect all signals from/to the signal widget --
 
     connect(&m_signal_widget, SIGNAL(sigCommand(QString)),
             this,             SIGNAL(sigCommand(QString)));
     connect(&m_signal_widget, SIGNAL(sigCursorChanged(sample_index_t)),
             m_overview,       SLOT(showCursor(sample_index_t)));
 
     // -- connect all signals from/to the signal manager --
 
     connect(signal_manager,
             SIGNAL(sigTrackInserted(uint,Kwave::Track*)),
             this,
             SLOT(slotTrackInserted(uint,Kwave::Track*)));
     connect(signal_manager,
             SIGNAL(sigTrackDeleted(uint,Kwave::Track*)),
             this,
             SLOT(slotTrackDeleted(uint,Kwave::Track*)));
     connect(signal_manager,
             SIGNAL(sigMetaDataChanged(Kwave::MetaDataList)),
             this,
             SLOT(updateViewRange()));
 
     // set up the timer for delayed view range update
     m_delayed_update_timer.setSingleShot(true);
     connect(&m_delayed_update_timer, SIGNAL(timeout()),
             this, SLOT(updateViewRange()));
 
     setLayout(topLayout);
 }

Here is the call graph for this function:

◆ ~MainWidget()

Kwave::MainWidget::~MainWidget ( )

virtual

Destructor.

Definition at line 230 of file MainWidget.cpp.

References m_context, Kwave::FileContext::pluginManager(), and Kwave::PluginManager::registerViewManager().

 {
     Kwave::PluginManager *plugin_manager = m_context.pluginManager();
     Q_ASSERT(plugin_manager);
     if (plugin_manager) plugin_manager->registerViewManager(Q_NULLPTR);
 }

Here is the call graph for this function:

Member Function Documentation

◆ addLabel()

void Kwave::MainWidget::addLabel	(	sample_index_t	pos,
		const QString &	description
	)

private

add a new label

Parameters

pos	position of the label [samples]
description	optional label description

Definition at line 887 of file MainWidget.cpp.

References Kwave::SignalManager::abortUndoTransaction(), Kwave::SignalManager::addLabel(), Kwave::SignalManager::deleteLabel(), Kwave::SignalManager::isModified(), Kwave::MetaData::isNull(), Kwave::SignalManager::labelIndex(), labelProperties(), m_context, Kwave::SignalManager::setModified(), and Kwave::FileContext::signalManager().

Referenced by executeCommand(), and sizeHint().

 {
     Kwave::SignalManager *signal_manager = m_context.signalManager();
     Q_ASSERT(signal_manager);
     if (!signal_manager) return;
 
     // remember the last "modified" state, in case that we abort
     bool was_modified = signal_manager->isModified();
 
     // create an own undo transaction
     Kwave::UndoTransactionGuard undo(*signal_manager, i18n("Add Label"));
 
     // add a new label, with undo
     Kwave::Label label = signal_manager->addLabel(pos, description);
     if (label.isNull()) {
         signal_manager->abortUndoTransaction();
         if (!was_modified) signal_manager->setModified(false);
         return;
     }
 
     // edit the properties of the new label
     if (!labelProperties(label)) {
         // aborted or failed -> delete (without undo)
         int index = signal_manager->labelIndex(label);
         signal_manager->deleteLabel(index, false);
         signal_manager->abortUndoTransaction();
         if (!was_modified) signal_manager->setModified(false);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ closeEvent()

void Kwave::MainWidget::closeEvent ( QCloseEvent * e )

protectedvirtual

See also: QWidget::closeEvent()

Definition at line 347 of file MainWidget.cpp.

References Kwave::FileContext::closeFile(), and m_context.

Referenced by sizeHint().

 {
     m_context.closeFile() ? e->accept() : e->ignore();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dragEnterEvent()

void Kwave::MainWidget::dragEnterEvent ( QDragEnterEvent * event )

protectedvirtual

See also: Qt XDND documentation

Definition at line 257 of file MainWidget.cpp.

References Kwave::FileDrag::canDecode().

Referenced by sizeHint().

 {
     if (!event) return;
     if ((event->proposedAction() != Qt::MoveAction) &&
         (event->proposedAction() != Qt::CopyAction))
         return; /* unsupported action */
 
     if (Kwave::FileDrag::canDecode(event->mimeData()))
         event->acceptProposedAction();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dropEvent()

void Kwave::MainWidget::dropEvent ( QDropEvent * event )

protectedvirtual

For dropping data into an empty signal

See also: Qt XDND documentation

Definition at line 269 of file MainWidget.cpp.

References Kwave::Drag::canDecode(), DBG, Kwave::Drag::decode(), Kwave::SignalManager::isEmpty(), m_context, m_offset, pixels2samples(), Kwave::SignalManager::selectRange(), and Kwave::FileContext::signalManager().

Referenced by sizeHint().

 {
     if (!event) return;
     if (!event->mimeData()) return;
 
     Kwave::SignalManager *signal_manager = m_context.signalManager();
     Q_ASSERT(signal_manager);
     if (!signal_manager) return;
 
     if (signal_manager->isEmpty() &&
         Kwave::Drag::canDecode(event->mimeData()))
     {
         sample_index_t pos = m_offset + pixels2samples(event->pos().x());
         sample_index_t len = 0;
 
         if ((len = Kwave::Drag::decode(this, event->mimeData(),
             *signal_manager, pos)))
         {
             // set selection to the new area where the drop was done
             signal_manager->selectRange(pos, len);
             event->acceptProposedAction();
         } else {
             QStringList formats = event->mimeData()->formats();
             QString fmt = (!formats.isEmpty()) ? formats.first() : QString();
             qWarning("MainWidget::dropEvent(%s): failed !", DBG(fmt));
             event->ignore();
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ executeCommand

int Kwave::MainWidget::executeCommand ( const QString & command )

virtualslot

Execute a Kwave text command

Parameters

command a text command

Returns: zero if succeeded or negative error code if failed

Return values

-ENOSYS is returned if the command is unknown in this component

Definition at line 389 of file MainWidget.cpp.

References addLabel(), Kwave::SignalManager::addLabel(), CASE_COMMAND, Kwave::SignalManager::executeCommand(), Kwave::Selection::first(), Kwave::Parser::hasParams(), Kwave::Parser::isDone(), labelProperties(), Kwave::Selection::last(), Kwave::Selection::length(), Kwave::SignalManager::length(), loadLabels(), m_context, m_offset, Kwave::SignalManager::metaData(), Kwave::Parser::nextParam(), saveLabels(), Kwave::SignalManager::selection(), Kwave::SignalManager::selectRange(), setOffset(), Kwave::FileContext::signalManager(), Kwave::Parser::toInt(), Kwave::Parser::toSampleIndex(), visibleSamples(), zoomAll(), zoomIn(), zoomNormal(), zoomOut(), and zoomSelection().

Referenced by sizeHint(), and wheelEvent().

 {
     Kwave::SignalManager *signal_manager = m_context.signalManager();
     Q_ASSERT(signal_manager);
     if (!signal_manager) return -EINVAL;
     if (!command.length()) return -EINVAL;
 
     Kwave::Parser parser(command);
     const sample_index_t visible_samples = visibleSamples();
     const sample_index_t signal_length   = signal_manager->length();
 
     if (false) {
 
     // -- zoom --
     CASE_COMMAND("view:zoom_selection")
         zoomSelection();
     CASE_COMMAND("view:zoom_in")
         int x = parser.hasParams() ? parser.toInt() : -1;
         zoomIn(x);
     CASE_COMMAND("view:zoom_out")
         int x = parser.hasParams() ? parser.toInt() : -1;
         zoomOut(x);
     CASE_COMMAND("view:zoom_normal")
         zoomNormal();
     CASE_COMMAND("view:zoom_all")
         zoomAll();
 
     // -- navigation --
     CASE_COMMAND("goto")
         sample_index_t offset = parser.toSampleIndex();
         setOffset((offset > (visible_samples / 2)) ?
                   (offset - (visible_samples / 2)) : 0);
         signal_manager->selectRange(offset, 0);
     CASE_COMMAND("view:scroll_right")
         const sample_index_t step = visible_samples / 10;
         setOffset(m_offset + step);
     CASE_COMMAND("view:scroll_left")
         const sample_index_t step = visible_samples / 10;
         setOffset((step < m_offset) ? (m_offset - step) : 0);
     CASE_COMMAND("view:scroll_start")
         setOffset(0);
         signal_manager->selectRange(0, 0);
     CASE_COMMAND("view:scroll_end")
         if (signal_length >= visible_samples)
             setOffset(signal_length - visible_samples);
     CASE_COMMAND("view:scroll_next")
         setOffset(m_offset + visible_samples);
     CASE_COMMAND("view:scroll_prev")
         setOffset((visible_samples < m_offset) ?
                   (m_offset - visible_samples) : 0);
     CASE_COMMAND("view:scroll_next_label")
         sample_index_t ofs =
             Kwave::LabelList(signal_manager->metaData()).nextLabelRight(
                 m_offset + (visible_samples / 2));
         if (ofs > signal_length)
             ofs = signal_length - 1;
         setOffset((ofs > (visible_samples / 2)) ?
                   (ofs - (visible_samples / 2)) : 0);
     CASE_COMMAND("view:scroll_prev_label")
         sample_index_t ofs =
             Kwave::LabelList(signal_manager->metaData()).nextLabelLeft(
                 m_offset + (visible_samples / 2));
         setOffset((ofs > (visible_samples / 2)) ?
                   (ofs - (visible_samples / 2)) : 0);
     // -- selection --
     CASE_COMMAND("selectall")
         signal_manager->selectRange(0, signal_manager->length());
     CASE_COMMAND("selectnext")
         if (signal_manager->selection().length())
             signal_manager->selectRange(signal_manager->selection().last() + 1,
                         signal_manager->selection().length());
         else
             signal_manager->selectRange(signal_manager->length() - 1, 0);
     CASE_COMMAND("selectprev")
         sample_index_t ofs = signal_manager->selection().first();
         sample_index_t len = signal_manager->selection().length();
         if (!len) len = 1;
         if (len > ofs) len = ofs;
         signal_manager->selectRange(ofs - len, len);
     CASE_COMMAND("selecttoleft")
         signal_manager->selectRange(0, signal_manager->selection().last() + 1);
     CASE_COMMAND("selecttoright")
         signal_manager->selectRange(signal_manager->selection().first(),
             signal_manager->length() - signal_manager->selection().first()
         );
     CASE_COMMAND("selectvisible")
         signal_manager->selectRange(m_offset, visibleSamples());
     CASE_COMMAND("selectnone")
         signal_manager->selectRange(m_offset, 0);
 
     // label handling
     CASE_COMMAND("label:add")
         sample_index_t pos = parser.toSampleIndex();
         if (!parser.isDone()) {
             // 2 parameters: position + description
             QString description = parser.nextParam();
             signal_manager->addLabel(pos, description);
         } else {
             // 1 parameter only: open dialog for editing the description
             addLabel(pos, QString());
         }
     CASE_COMMAND("label:edit")
         int index = parser.toInt();
         Kwave::LabelList labels(signal_manager->metaData());
         if ((index >= labels.count()) || (index < 0))
             return -EINVAL;
         Kwave::Label label = labels.at(index);
         labelProperties(label);
     CASE_COMMAND("label:load")
         QString filename = parser.nextParam();
         return loadLabels(filename);
    CASE_COMMAND("label:save")
         QString filename = parser.nextParam();
         return saveLabels(filename);
 
 //    CASE_COMMAND("label:by_intensity")
 //      markSignal(command);
 //    CASE_COMMAND("label:to_pitch")
 //      convertMarkstoPitch(command);
 //    CASE_COMMAND("label:by_period")
 //      markPeriods(command);
 
     } else {
         return (signal_manager) ?
             signal_manager->executeCommand(command) : -ENOSYS;
     }
 
     return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fixZoomAndOffset()

void Kwave::MainWidget::fixZoomAndOffset	(	double	zoom,
		sample_index_t	offset
	)

private

Fixes the zoom and the offset of the display so that no non-existing samples (index < 0 or index >= length) have to be displayed and the current display window of the signal fits into the screen.

Parameters

zoom	new zoom value [samples/pixel]
offset	new offset value [samples]

Definition at line 707 of file MainWidget.cpp.

References fullZoom(), Kwave::SignalManager::length(), m_context, m_offset, m_zoom, MINIMUM_SAMPLES_PER_SCREEN, pixels2samples(), Kwave::FileContext::signalManager(), sigVisibleRangeChanged(), sigZoomChanged(), updateViewRange(), visibleSamples(), visibleWidth(), and zoom().

Referenced by setOffset(), setZoom(), sizeHint(), updateViewRange(), zoomIn(), and zoomOut().

 {
     double max_zoom;
     double min_zoom;
     sample_index_t length;
 
     const double         old_zoom   = m_zoom;
     const sample_index_t old_offset = m_offset;
     const int            width      = visibleWidth();
 
     m_zoom   = zoom;
     m_offset = offset;
     Q_ASSERT(m_zoom >= 0.0);
 
     Kwave::SignalManager *signal_manager = m_context.signalManager();
     Q_ASSERT(signal_manager);
     if (!signal_manager) return;
     if (!width) return;
 
     length = signal_manager->length();
     if (!length) {
         // in streaming mode we have to use a guessed length
         length = static_cast<sample_index_t>(ceil(width * fullZoom()));
     }
     if (!length) {
         m_offset = 0;
         return;
     };
 
     // ensure that m_offset is [0...length-1]
     if (m_offset >= length) m_offset = (length - 1);
 
     // ensure that the zoom is in a reasonable range
     max_zoom = fullZoom();
     min_zoom = static_cast<double>(MINIMUM_SAMPLES_PER_SCREEN) /
                static_cast<double>(width);
 
     // ensure that pixel coordinates are within signed int range
     min_zoom = qMax(min_zoom, static_cast<double>(length) / double(INT_MAX));
 
     if (m_zoom < min_zoom) m_zoom = min_zoom;
     if (m_zoom > max_zoom) m_zoom = max_zoom;
 
     // try to correct the offset if there is not enough data to fill
     // the current window
     // example: width=100 [pixels], length=3 [samples],
     //          offset=1 [sample], zoom=1/49.5 [samples/pixel] (full)
     //          -> current last displayed sample = length-offset
     //             = 3 - 1 = 2
     //          -> available space = pixels2samples(width-1) + 1
     //             = (99/49.5) + 1 = 3
     //          -> decrease offset by 3 - 2 = 1
     Q_ASSERT(length >= m_offset);
     if ((pixels2samples(width - 1) + 1) > (length - m_offset)) {
         // there is space after the signal -> move offset right
         sample_index_t shift = pixels2samples(width - 1) + 1 -
                                (length - m_offset);
         if (shift >= m_offset) {
             m_offset = 0;
         } else {
             m_offset -= shift;
         }
     }
 
     // emit change in the zoom factor
     if (!qFuzzyCompare(m_zoom, old_zoom)) emit sigZoomChanged(m_zoom);
 
     if ((m_offset != old_offset) || !qFuzzyCompare(m_zoom, old_zoom)) {
         emit sigVisibleRangeChanged(m_offset, visibleSamples(), length);
         updateViewRange();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fullZoom()

double Kwave::MainWidget::fullZoom ( ) const

private

Returns the zoom value that will be used to fit the whole signal into the current window.

Returns: zoom value [samples/pixel]

Definition at line 661 of file MainWidget.cpp.

References DEFAULT_DISPLAY_TIME, Kwave::FileInfo::get(), Kwave::INF_ESTIMATED_LENGTH, Kwave::SignalManager::isEmpty(), Kwave::SignalManager::length(), m_context, Kwave::SignalManager::metaData(), Kwave::SignalManager::rate(), Kwave::FileContext::signalManager(), and visibleWidth().

Referenced by fixZoomAndOffset(), sizeHint(), and zoomAll().

 {
     const int width = visibleWidth();
     if (width <= 0) return 0.0; // no zoom info, window is not yet ready
 
     Kwave::SignalManager *signal_manager = m_context.signalManager();
     Q_ASSERT(signal_manager);
     if (!signal_manager) return 0.0;
     if (signal_manager->isEmpty()) return 0.0;    // no zoom if no signal
 
     sample_index_t length = signal_manager->length();
     if (!length) {
         // no length: streaming mode -> try to use "estimated length"
         // and add some extra, 10% should be ok
         Kwave::FileInfo info(signal_manager->metaData());
         if (info.contains(Kwave::INF_ESTIMATED_LENGTH)) {
             // estimated length in samples
             length = info.get(Kwave::INF_ESTIMATED_LENGTH).toULongLong();
             length += length / 10;
         }
         if (length <= 0) {
             // fallback: start with some default zoom,
             // use five minutes (just guessed)
             length = static_cast<sample_index_t>(ceil(DEFAULT_DISPLAY_TIME *
                 signal_manager->rate()));
         }
     }
     if (!length) return 0; // still no length !? -> bail out
 
     // example: width = 100 [pixels] and length = 3 [samples]
     //          -> samples should be at positions 0, 49.5 and 99
     //          -> 49.5 [pixels / sample]
     //          -> zoom = 1 / 49.5 [samples / pixel]
     // => full zoom [samples/pixel] = (length - 1) / (width - 1)
     if (length < static_cast<sample_index_t>(width) * 2) {
         // zoom is small enough, no error compensation needed
         return (static_cast<double>(length) - 1.0) /
                 static_cast<double>(width - 1);
     } else {
         // zoom is big, pre-compensate rounding errors
         return (static_cast<double>(length) - 0.5) /
                 static_cast<double>(width - 1);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ horizontalScrollBarMoved

void Kwave::MainWidget::horizontalScrollBarMoved ( int newval )

privateslot

Connected to the horizontal scrollbar for scrolling left/right

Definition at line 580 of file MainWidget.cpp.

References Kwave::SignalManager::length(), m_context, setOffset(), and Kwave::FileContext::signalManager().

Referenced by MainWidget(), and sizeHint().

 {
     // new offset = pos * f
     sample_index_t length  = m_context.signalManager()->length();
     const sample_index_t f = qMax(
         sample_index_t(1),
         sample_index_t((length + INT_MAX - 1) / INT_MAX)
     );
     const sample_index_t pos = newval * f;
     setOffset(pos);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isOK()

bool Kwave::MainWidget::isOK ( )

virtual

Returns true if this instance was successfully initialized, or false if something went wrong during initialization.

Definition at line 224 of file MainWidget.cpp.

References m_horizontal_scrollbar, and m_overview.

 {
     return (m_horizontal_scrollbar && m_overview);
 }

◆ labelProperties()

bool Kwave::MainWidget::labelProperties ( Kwave::Label & label )

private

Opens a dialog for editing the properties of a label

Parameters

label a Label that should be edited

Returns: true if the dialog has been accepted, otherwise false (canceled)

Definition at line 1026 of file MainWidget.cpp.

References Kwave::SignalManager::abortUndoTransaction(), Kwave::SignalManager::deleteLabel(), Kwave::SignalManager::findLabel(), Kwave::MetaData::isNull(), Kwave::SignalManager::labelIndex(), Kwave::LabelPropertiesWidget::labelName(), Kwave::LabelPropertiesWidget::labelPosition(), Kwave::SignalManager::length(), m_context, Kwave::SignalManager::modifyLabel(), Kwave::Label::moveTo(), Kwave::Label::name(), Kwave::Label::pos(), Kwave::SignalManager::rate(), Kwave::Label::rename(), Kwave::LabelPropertiesWidget::saveSettings(), Kwave::LabelPropertiesWidget::setLabelIndex(), Kwave::LabelPropertiesWidget::setLabelName(), Kwave::LabelPropertiesWidget::setLabelPosition(), Kwave::FileContext::signalManager(), and Kwave::MessageBox::warningYesNoCancel().

Referenced by addLabel(), executeCommand(), and sizeHint().

 {
     Kwave::SignalManager *signal_manager = m_context.signalManager();
     Q_ASSERT(signal_manager);
     if (!signal_manager) return false;
 
     if (label.isNull()) return false;
     int index = signal_manager->labelIndex(label);
     Q_ASSERT(index >= 0);
     if (index < 0) return false;
 
     // try to modify the label. just in case that the user moves it
     // to a position where we already have one, catch this situation
     // and ask if he wants to abort, re-enter the label properties
     // dialog or just replace (remove) the label at the target position
     bool accepted;
     sample_index_t new_pos  = label.pos();
     QString        new_name = label.name();
     int old_index = -1;
     while (true) {
         // create and prepare the dialog
         Kwave::LabelPropertiesWidget *dlg =
             new Kwave::LabelPropertiesWidget(this);
         Q_ASSERT(dlg);
         if (!dlg) return false;
         dlg->setLabelIndex(index);
         dlg->setLabelPosition(new_pos, signal_manager->length(),
             signal_manager->rate());
         dlg->setLabelName(new_name);
 
         // execute the dialog
         accepted = (dlg->exec() == QDialog::Accepted);
         if (!accepted) {
             // user pressed "cancel"
             delete dlg;
             break;
         }
 
         // if we get here the user pressed "OK"
         new_pos  = dlg->labelPosition();
         new_name = dlg->labelName();
         dlg->saveSettings();
         delete dlg;
 
         // check: if there already is a label at the new position
         // -> ask the user if he wants to overwrite that one
         if ((new_pos != label.pos()) &&
             !signal_manager->findLabel(new_pos).isNull())
         {
             int res = Kwave::MessageBox::warningYesNoCancel(this, i18n(
                 "There already is a label at the position you have chosen.\n"\
                 "Do you want to replace it?"));
             if (res == KMessageBox::Yes) {
                 // delete the label at the target position (with undo)
                 Kwave::Label old = signal_manager->findLabel(new_pos);
                 old_index = signal_manager->labelIndex(old);
                 break;
             }
             if (res == KMessageBox::No) {
                 // make another try -> re-enter the dialog
                 continue;
             }
 
             // cancel -> abort the whole action
             accepted = false;
             break;
         } else {
             // ok, we can put it there
             break;
         }
     }
 
     if (accepted) {
         // shortcut: abort if nothing has changed
         if ((new_name == label.name()) && (new_pos == label.pos()))
             return true;
 
         Kwave::UndoTransactionGuard undo(*signal_manager, i18n("Modify Label"));
 
         // if there is a label at the target position, remove it first
         if (old_index >= 0) {
             signal_manager->deleteLabel(old_index, true);
             // this might have changed the current index!
             index = signal_manager->labelIndex(label);
         }
 
         // modify the label through the signal manager
         if (!signal_manager->modifyLabel(index, new_pos, new_name, true)) {
             // position is already occupied
             signal_manager->abortUndoTransaction();
             return false;
         }
 
         // reflect the change in the passed label
         label.moveTo(new_pos);
         label.rename(new_name);
 
         // NOTE: moving might also change the index, so the complete
         //       markers layer has to be refreshed
     }
     else
         signal_manager->abortUndoTransaction();
 
     return accepted;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ loadLabels()

int Kwave::MainWidget::loadLabels ( const QString & filename )

private

load labels from a file

Parameters

filename file name from which to load the labels, a file open dialog will be shown if zero length

Returns: zero if succeeded or negative error code if failed

Definition at line 918 of file MainWidget.cpp.

References _, LABEL_LIST_EXT, LABEL_LIST_FILTER, Kwave::FileContext::loadBatch(), m_context, name, Kwave::FileDialog::OpenFile, Kwave::FileDialog::selectedUrl(), and Kwave::FileContext::signalManager().

Referenced by executeCommand(), and sizeHint().

 {
     Kwave::SignalManager *signal_manager = m_context.signalManager();
     Q_ASSERT(signal_manager);
     if (!signal_manager) return -1;
 
     QUrl url;
     if (!filename.length()) {
         QString name(filename);
 
         QPointer<Kwave::FileDialog> dlg = new (std::nothrow)Kwave::FileDialog(
         _("kfiledialog:///kwave_label_dir"),
         Kwave::FileDialog::OpenFile, LABEL_LIST_FILTER, this,
         QUrl(), LABEL_LIST_EXT);
         if (!dlg) return -1;
         dlg->setWindowTitle(i18n("Load Labels"));
         if (dlg->exec() != QDialog::Accepted) {
             delete dlg;
             return 0;
         } else {
             url = dlg->selectedUrl();
             delete dlg;
         }
     } else {
         url = QUrl::fromUserInput(filename);
     }
 
     // create an own undo transaction
     Kwave::UndoTransactionGuard undo(*signal_manager, i18n("Load Labels"));
 
     return m_context.loadBatch(url);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ms2samples()

sample_index_t Kwave::MainWidget::ms2samples ( double ms )

private

Converts a time in milliseconds to a number of samples, based on the current signal rate.

Parameters

ms	time in milliseconds

Returns: number of samples (rounded)

Definition at line 623 of file MainWidget.cpp.

References m_context, Kwave::SignalManager::rate(), and Kwave::FileContext::signalManager().

Referenced by sizeHint().

 {
     Kwave::SignalManager *signal_manager = m_context.signalManager();
     Q_ASSERT(signal_manager);
     if (!signal_manager) return 0;
 
     return static_cast<sample_index_t>(
         rint(ms * signal_manager->rate() / 1E3));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pixels2samples()

sample_index_t Kwave::MainWidget::pixels2samples ( unsigned int pixels ) const

private

Converts a sample index into a pixel offset using the current zoom value. Always rounds up or downwards. If the number of pixels or the current zoom is less than zero, the return value will be zero.

Parameters

pixels pixel offset

Returns: index of the sample

Definition at line 634 of file MainWidget.cpp.

References m_zoom.

Referenced by dropEvent(), fixZoomAndOffset(), sizeHint(), and visibleSamples().

 {
     if ((pixels == 0) || (m_zoom <= 0.0)) return 0;
 
     return static_cast<sample_index_t>(static_cast<double>(pixels) * m_zoom);
 }

Here is the caller graph for this function:

◆ refreshHorizontalScrollBar

void Kwave::MainWidget::refreshHorizontalScrollBar ( )

privateslot

refresh the scale and position of the horizontal scrollbar

Definition at line 520 of file MainWidget.cpp.

References Kwave::SignalManager::isEmpty(), Kwave::SignalManager::length(), m_context, m_horizontal_scrollbar, m_offset, m_overview, Kwave::FileContext::signalManager(), Kwave::toInt(), and visibleSamples().

Referenced by sizeHint(), and updateViewRange().

 {
     if (!m_horizontal_scrollbar || !m_context.signalManager()) return;
 
     m_horizontal_scrollbar->blockSignals(true);
 
     // show/hide the overview widget
     if (!m_context.signalManager()->isEmpty() && !m_overview->isVisible())
         m_overview->show();
     if (m_context.signalManager()->isEmpty() && m_overview->isVisible())
         m_overview->hide();
 
     // adjust the limits of the horizontal scrollbar
     if (m_context.signalManager()->length() > 1) {
         // get the view information in samples
         sample_index_t length  = m_context.signalManager()->length();
         sample_index_t visible = visibleSamples();
         if (visible > length) visible = length;
 
         // calculate the scrollbar ranges in scrollbar's units
         //
         // NOTE: we must take care of possible numeric overflows
         //       as the scrollbar internally works with "int" and
         //       the offsets we use for the samples might be bigger!
         //
         // [-------------------------------------------##############]
         // ^                                          ^     ^
         // min                                      max    page
         //
         // max + page = x | x < INT_MAX (!)
         //                                  x := length / f
         // page = x * (visible / length)  = visible  / f
         // max                            = length   / f - page
         // pos  = (m_offset / length) * x = m_offset / f
 
         const sample_index_t f = qMax(
             sample_index_t(1),
             sample_index_t((length + INT_MAX - 1) / INT_MAX)
         );
         int page    = Kwave::toInt(visible  / f);
         int min     = 0;
         int max     = Kwave::toInt(length   / f) - page;
         int pos     = Kwave::toInt(m_offset / f);
         int single  = qMax(1, (page / (10 * qApp->wheelScrollLines())));
         if (page < single) page = single;
 //      qDebug("width=%d, max=%d, page=%d, single=%d, pos=%d, visible=%d",
 //             m_width, max, page, single, pos, visible);
 //      qDebug("       last=%d", pos + visible - 1);
         m_horizontal_scrollbar->setRange(min, max);
         m_horizontal_scrollbar->setValue(pos);
         m_horizontal_scrollbar->setSingleStep(single);
         m_horizontal_scrollbar->setPageStep(page);
     } else {
         m_horizontal_scrollbar->setRange(0, 0);
     }
 
     m_horizontal_scrollbar->blockSignals(false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resizeEvent()

void Kwave::MainWidget::resizeEvent ( QResizeEvent * event )

protectedvirtual

Called if the main widget has been resized and resizes/moves the signal widget and the channel controls

Definition at line 238 of file MainWidget.cpp.

References Kwave::FileContext::app(), Kwave::App::GUI_TAB, Kwave::App::guiType(), Kwave::FileContext::isActive(), m_context, m_delayed_update_timer, and updateViewRange().

Referenced by sizeHint().

 {
     QWidget::resizeEvent(event);
 
     if (!m_context.isActive() &&
         (m_context.app().guiType() == Kwave::App::GUI_TAB))
     {
         // HACK: this is a workaround for stupid bug in Qt, which sends us a
         //       resize event with bogus size, when we are in tab mode, just
         //       before getting deactivated !?
         if (!m_delayed_update_timer.isActive())
             m_delayed_update_timer.start(0);
     } else {
         // update immediately
         updateViewRange();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ samples2pixels()

int Kwave::MainWidget::samples2pixels ( sample_index_t samples ) const

private

Converts a pixel offset into a sample index using the current zoom value. Always rounds op or downwards.

Parameters

samples number of samples to be converted

Returns: pixel offset

Definition at line 642 of file MainWidget.cpp.

References m_zoom, and Kwave::toInt().

Referenced by scrollTo(), and sizeHint().

 {
     if (m_zoom <= 0.0) return 0;
     return Kwave::toInt(rint(static_cast<double>(samples) / m_zoom));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ saveLabels()

int Kwave::MainWidget::saveLabels ( const QString & filename )

private

save all labels to a file

Parameters

filename file name from which to load the labels, a file open dialog will be shown if zero length

Returns: zero if succeeded or negative error code if failed

Definition at line 952 of file MainWidget.cpp.

References _, Kwave::Parser::escape(), Kwave::Logger::Info, LABEL_LIST_EXT, LABEL_LIST_FILTER, Kwave::Logger::log(), m_context, Kwave::SignalManager::metaData(), Kwave::Label::name(), name, Kwave::Label::pos(), Kwave::FileDialog::SaveFile, Kwave::FileDialog::selectedUrl(), Kwave::FileContext::signalManager(), Kwave::FileContext::signalName(), and Kwave::MessageBox::warningYesNo().

Referenced by executeCommand(), and sizeHint().

 {
     Kwave::SignalManager *signal_manager = m_context.signalManager();
     Q_ASSERT(signal_manager);
     if (!signal_manager) return false;
 
     QUrl url;
     url = QUrl(m_context.signalName());
 
     if (!filename.length()) {
         QString name(filename);
 
         QPointer<Kwave::FileDialog> dlg = new(std::nothrow)Kwave::FileDialog(
             _("kfiledialog:///kwave_label_dir"),
             Kwave::FileDialog::SaveFile, LABEL_LIST_FILTER,
             this, url, LABEL_LIST_EXT);
         if (!dlg) return 0;
         dlg->setWindowTitle(i18n("Save Labels"));
         if (dlg->exec() != QDialog::Accepted) {
             delete dlg;
             return -1;
         }
         url = dlg->selectedUrl();
         if (url.isEmpty()) {
             delete dlg;
             return 0;
         }
         delete dlg;
 
         // add an extension if necessary
         name = url.path();
         if (!QFileInfo(name).suffix().length()) {
             url.setPath(name + _(".label"));
             name = url.path();
         }
 
         // check if the file exists and ask before overwriting it
         // if it is not the old filename
         if (QFileInfo(name).exists())
         {
             if (Kwave::MessageBox::warningYesNo(this,
                 i18n("The file '%1' already exists.\n"
                 "Do you really want to overwrite it?", name)) !=
                 KMessageBox::Yes)
             {
                 return -1;
             }
         }
     } else {
         url = QUrl::fromUserInput(filename);
     }
 
     // now we have a file name -> save all labels...
     Kwave::Logger::log(this, Kwave::Logger::Info,
         _("saving labels to '") + url.toDisplayString() + _("'"));
 
     QFile file(url.path());
     file.open(QIODevice::WriteOnly);
     QTextStream out(&file);
 
     Kwave::LabelList labels(signal_manager->metaData());
     foreach (const Kwave::Label &label, labels) {
         sample_index_t pos = label.pos();
         const QString name = Kwave::Parser::escape(label.name());
         out << _("label:add(") << pos;
         if (name.length()) out << _(", ") << name;
         out << _(")") << endl;
     }
 
     file.close();
     return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scrollTo

void Kwave::MainWidget::scrollTo ( sample_index_t pos )

virtualslot

Scrolls the display so that the given position gets visible, centered within the display if possible.

Definition at line 793 of file MainWidget.cpp.

References m_offset, samples2pixels(), setOffset(), and visibleSamples().

Referenced by sizeHint().

 {
     sample_index_t visible = visibleSamples();
 
     if ( (pos < (m_offset + (visible / 10))) ||
          (pos > (m_offset + (visible /  2))) )
     {
         // new position is out of range or too close to the border
         sample_index_t offset = (visible / 2);
         pos = (pos > offset) ? (pos - offset) : 0;
         if (pos != m_offset) {
             // check: is the difference >= 1 pixel ?
             sample_index_t diff = (pos > m_offset) ?
                 (pos - m_offset) : (m_offset - pos);
             if (samples2pixels(diff) >= 1)
                 setOffset(pos);
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setOffset

void Kwave::MainWidget::setOffset ( sample_index_t new_offset )

slot

Sets the display offset [samples] and refreshes the screen.

Parameters

new_offset new value for the offset in samples, will be internally limited to [0...length-1]

Definition at line 787 of file MainWidget.cpp.

References fixZoomAndOffset(), and m_zoom.

Referenced by executeCommand(), horizontalScrollBarMoved(), MainWidget(), scrollTo(), and sizeHint().

 {
     fixZoomAndOffset(m_zoom, new_offset);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setZoom

void Kwave::MainWidget::setZoom ( double new_zoom )

virtualslot

sets a new zoom factor [samples/pixel], does not refresh the screen

Parameters

new_zoom new zoom value, will be internally limited to [length/width...1/width] (from full display to one visible sample only)

Definition at line 781 of file MainWidget.cpp.

References fixZoomAndOffset(), and m_offset.

Referenced by sizeHint(), zoomAll(), zoomNormal(), and zoomSelection().

 {
     fixZoomAndOffset(new_zoom, m_offset);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sigCommand

void Kwave::MainWidget::sigCommand ( const QString & command )

signal

forward a sigCommand to the next layer

Referenced by MainWidget(), and sizeHint().

Here is the caller graph for this function:

◆ sigVisibleRangeChanged

void Kwave::MainWidget::sigVisibleRangeChanged	(	sample_index_t	offset,
		sample_index_t	visible,
		sample_index_t	total
	)

signal

emitted when the visible range has changed

Referenced by fixZoomAndOffset(), and sizeHint().

Here is the caller graph for this function:

◆ sigZoomChanged

void Kwave::MainWidget::sigZoomChanged ( double zoom )

signal

Will be emitted if the zoom factor of the view has changed.

Referenced by fixZoomAndOffset(), and sizeHint().

Here is the caller graph for this function:

◆ sizeHint()

virtual QSize Kwave::MainWidget::sizeHint ( ) const

inlinevirtual

Returns the preferred size of the widget

Definition at line 123 of file MainWidget.h.

References addLabel(), closeEvent(), dragEnterEvent(), dropEvent(), executeCommand(), fixZoomAndOffset(), fullZoom(), horizontalScrollBarMoved(), labelProperties(), loadLabels(), m_preferred_size, ms2samples(), pixels2samples(), refreshHorizontalScrollBar(), resizeEvent(), samples2pixels(), saveLabels(), scrollTo(), setOffset(), setZoom(), sigCommand(), sigVisibleRangeChanged(), sigZoomChanged(), slotTrackDeleted(), slotTrackInserted(), updateViewRange(), wheelEvent(), zoom(), zoomAll(), zoomIn(), zoomNormal(), zoomOut(), and zoomSelection().

123 { return m_preferred_size; }

Kwave::MainWidget::m_preferred_size

QSize m_preferred_size

Definition: MainWidget.h:368

Here is the call graph for this function:

◆ slotTrackDeleted

void Kwave::MainWidget::slotTrackDeleted	(	unsigned int	index,
		Kwave::Track *	track
	)

privateslot

Called if a track has been deleted. Updates the display by resizing/re-positioning the signal views.

Parameters

index	the index of the inserted track [0...tracks-1]
track	pointer to the track object (ignored here)

See also: SignalManager::sigTrackDeleted

Definition at line 372 of file MainWidget.cpp.

References updateViewRange().

Referenced by MainWidget(), and sizeHint().

 {
 //     qDebug("MainWidget::slotTrackDeleted(%u)", index);
     Q_UNUSED(index);
     Q_UNUSED(track);
 
     updateViewRange();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ slotTrackInserted

void Kwave::MainWidget::slotTrackInserted	(	unsigned int	index,
		Kwave::Track *	track
	)

privateslot

Called if a track has been added. Updates the display by resizing/re-positioning the signal views.

Parameters

index	the index of the inserted track [0...tracks-1]
track	pointer to the track object (ignored here)

See also: SignalManager::sigTrackInserted

Definition at line 353 of file MainWidget.cpp.

References m_context, Kwave::FileContext::signalManager(), Kwave::SignalManager::tracks(), updateViewRange(), and zoomAll().

Referenced by MainWidget(), and sizeHint().

 {
 //     qDebug("MainWidget::slotTrackInserted(%u, %p)",
 //         index, static_cast<void *>(track));
     Q_UNUSED(index);
     Q_UNUSED(track);
 
     // when the first track has been inserted, set some reasonable zoom
     Kwave::SignalManager *signal_manager = m_context.signalManager();
     bool first_track = (signal_manager && (signal_manager->tracks() == 1));
     if (first_track)
         zoomAll();
     else
         updateViewRange();
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ updateViewRange

void Kwave::MainWidget::updateViewRange ( )

protectedslot

updates all widgets that depend on the current view range

Definition at line 593 of file MainWidget.cpp.

References fixZoomAndOffset(), Kwave::SignalManager::isEmpty(), Kwave::SignalManager::length(), m_context, m_horizontal_scrollbar, m_offset, m_overview, m_signal_widget, m_zoom, refreshHorizontalScrollBar(), Kwave::OverViewWidget::setRange(), Kwave::SignalWidget::setZoomAndOffset(), Kwave::FileContext::signalManager(), and visibleSamples().

Referenced by fixZoomAndOffset(), MainWidget(), resizeEvent(), sizeHint(), slotTrackDeleted(), and slotTrackInserted().

 {
     Kwave::SignalManager *signal_manager = m_context.signalManager();
     sample_index_t total = (signal_manager) ? signal_manager->length() : 0;
 
     if (m_overview) {
         m_overview->setRange(m_offset, visibleSamples(), total);
 
         // show/hide the overview widget and the horizontal scroll bar
         if (!m_context.signalManager()->isEmpty()) {
             if (!m_overview->isVisible())
                 m_overview->show();
             if (!m_horizontal_scrollbar->isVisible())
                 m_horizontal_scrollbar->show();
         }
         if (m_context.signalManager()->isEmpty()) {
             if (m_overview->isVisible())
                 m_overview->hide();
             if (m_horizontal_scrollbar->isVisible())
                 m_horizontal_scrollbar->hide();
         }
     }
 
     // forward the zoom and offset to the signal widget and overview
     fixZoomAndOffset(m_zoom, m_offset);
     m_signal_widget.setZoomAndOffset(m_zoom, m_offset);
     refreshHorizontalScrollBar();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ visibleOffset()

virtual sample_index_t Kwave::MainWidget::visibleOffset ( )

inlinevirtual

Returns the current start position of the visible area [samples]

Definition at line 120 of file MainWidget.h.

References m_offset.

120 { return m_offset; }

Kwave::MainWidget::m_offset

sample_index_t m_offset

Definition: MainWidget.h:362

◆ visibleSamples()

sample_index_t Kwave::MainWidget::visibleSamples ( ) const

virtual

Returns the width of the current view in samples

Implements Kwave::Zoomable.

Definition at line 655 of file MainWidget.cpp.

References pixels2samples(), and visibleWidth().

Referenced by executeCommand(), fixZoomAndOffset(), refreshHorizontalScrollBar(), scrollTo(), updateViewRange(), zoomIn(), zoomNormal(), and zoomOut().

 {
     return pixels2samples(visibleWidth() - 1) + 1;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ visibleWidth()

int Kwave::MainWidget::visibleWidth ( ) const

virtual

Returns the width of the current view in pixels

Implements Kwave::Zoomable.

Definition at line 649 of file MainWidget.cpp.

References m_signal_widget, and Kwave::SignalWidget::visibleWidth().

Referenced by fixZoomAndOffset(), fullZoom(), visibleSamples(), zoomNormal(), and zoomSelection().

 {
     return m_signal_widget.visibleWidth();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ wheelEvent()

void Kwave::MainWidget::wheelEvent ( QWheelEvent * event )

protectedvirtual

slot for mouse wheel events, for scrolling/zooming

Definition at line 300 of file MainWidget.cpp.

References _, executeCommand(), m_overview, m_scroll_area, m_signal_widget, and Kwave::SignalWidget::mapToViewPort().

Referenced by sizeHint().

 {
     if (!event || !m_overview) return;
 
     // process only wheel events on the signal and overview frame,
     // not on the channel controls or scrollbars
     if (!m_scroll_area.geometry().contains(event->pos()) &&
         !m_overview->geometry().contains(event->pos()) )
     {
         event->ignore();
         return;
     }
 
     switch (event->modifiers()) {
         case Qt::NoModifier: {
             // no modifier + <WheelUp/Down> => scroll left/right
             if (event->delta() > 0)
                 executeCommand(_("view:scroll_left()"));
             else if (event->delta() < 0)
                 executeCommand(_("view:scroll_right()"));
             event->accept();
             break;
         }
         case Qt::ShiftModifier:
             // <Shift> + <WheelUp/Down> => page up/down
             if (event->delta() > 0)
                 executeCommand(_("view:scroll_prev()"));
             else if (event->delta() < 0)
                 executeCommand(_("view:scroll_next()"));
             event->accept();
             break;
         case Qt::ControlModifier: {
             // <Ctrl> + <WheelUp/Down> => zoom in/out
             int x = qMax(m_signal_widget.mapToViewPort(event->globalPos()), 0);
             if (event->delta() > 0)
                 executeCommand(_("view:zoom_in(%1)").arg(x));
             else if (event->delta() < 0)
                 executeCommand(_("view:zoom_out(%1)").arg(x));
             event->accept();
             break;
         }
         default:
             event->ignore();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ zoom()

double Kwave::MainWidget::zoom ( ) const

virtual

Returns the current zoom factor [samples/pixel]

Implements Kwave::Zoomable.

Definition at line 383 of file MainWidget.cpp.

References m_zoom.

Referenced by fixZoomAndOffset(), and sizeHint().

 {
     return m_zoom;
 }

Here is the caller graph for this function:

◆ zoomAll

void Kwave::MainWidget::zoomAll ( )

slot

Zooms the signal to be fully visible.

See also: setZoom()

Definition at line 831 of file MainWidget.cpp.

References fullZoom(), and setZoom().

Referenced by executeCommand(), sizeHint(), and slotTrackInserted().

 {
     setZoom(fullZoom());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ zoomIn

void Kwave::MainWidget::zoomIn ( int pos = -1 )

slot

Zooms into the signal, the new display will show the signal zoomed at the position given as parameter (if >= 0) or centered if a position < 0 is given.

Definition at line 847 of file MainWidget.cpp.

References fixZoomAndOffset(), m_offset, m_zoom, Kwave::toInt(), and visibleSamples().

Referenced by executeCommand(), and sizeHint().

 {
     if (pos >= 0) {
         // position given, calculate shift:
         // ofs_old + (pos * m_zoom) := ofs_new + (pos * (m_zoom / 3))
         // ofs_new = ofs_old + (pos * m_zoom) -  (pos * (m_zoom / 3))
         fixZoomAndOffset(
             m_zoom / 3,
             m_offset + Kwave::toInt(pos * (m_zoom * (2.0 / 3.0)))
         );
     } else {
         // no position given, show centered
         fixZoomAndOffset(
             m_zoom / 3,
             m_offset + (visibleSamples() / 3)
         );
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ zoomNormal

void Kwave::MainWidget::zoomNormal ( )

slot

Zooms the signal to one-pixel-per-sample. Equivalent to setZoom(1.0).

See also: setZoom()

Definition at line 837 of file MainWidget.cpp.

References m_offset, setZoom(), visibleSamples(), and visibleWidth().

Referenced by executeCommand(), and sizeHint().

 {
     const sample_index_t shift1 = visibleWidth() / 2;
     const sample_index_t shift2 = visibleSamples() / 2;
     m_offset = (m_offset + shift2 >= m_offset) ? (m_offset + shift2) : -shift2;
     m_offset = (m_offset > shift1) ? (m_offset - shift1) : 0;
     setZoom(1.0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ zoomOut

void Kwave::MainWidget::zoomOut ( int pos = -1 )

slot

Zooms out the signal, the new display will show the signal zoomed at the position given as parameter (if >= 0) or centered if a position < 0 is given.

Definition at line 867 of file MainWidget.cpp.

References fixZoomAndOffset(), m_offset, m_zoom, Kwave::toInt(), and visibleSamples().

Referenced by executeCommand(), and sizeHint().

 {
     sample_index_t shift;
 
     if (pos >= 0) {
         // position given, calculate shift
         // ofs_old + (pos * m_zoom) := ofs_new + (pos * (m_zoom * 3))
         // ofs_new = ofs_old + (pos * m_zoom) -  (pos * (m_zoom * 3))
         shift = Kwave::toInt(m_zoom * 2.0) * pos;
     } else {
         // no position given, show centered
         shift = visibleSamples();
     }
     fixZoomAndOffset(
         m_zoom * 3,
         (m_offset > shift) ? (m_offset - shift) : 0
     );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ zoomSelection

void Kwave::MainWidget::zoomSelection ( )

slot

Zooms into the selected range between the left and right marker.

Definition at line 814 of file MainWidget.cpp.

References Kwave::Selection::length(), m_context, m_offset, Kwave::Selection::offset(), Kwave::SignalManager::selection(), setZoom(), Kwave::FileContext::signalManager(), and visibleWidth().

Referenced by executeCommand(), and sizeHint().

 {
     Kwave::SignalManager *signal_manager = m_context.signalManager();
     Q_ASSERT(signal_manager);
     if (!signal_manager) return;
 
     sample_index_t ofs = signal_manager->selection().offset();
     sample_index_t len = signal_manager->selection().length();
 
     if (len) {
         int width = visibleWidth();
         m_offset = ofs;
         setZoom((static_cast<double>(len)) / static_cast<double>(width - 1));
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ m_context

Kwave::FileContext& Kwave::MainWidget::m_context

private

context of the Kwave application instance

Definition at line 338 of file MainWidget.h.

Referenced by addLabel(), closeEvent(), dropEvent(), executeCommand(), fixZoomAndOffset(), fullZoom(), horizontalScrollBarMoved(), labelProperties(), loadLabels(), MainWidget(), ms2samples(), refreshHorizontalScrollBar(), resizeEvent(), saveLabels(), slotTrackInserted(), updateViewRange(), zoomSelection(), and ~MainWidget().

◆ m_delayed_update_timer

QTimer Kwave::MainWidget::m_delayed_update_timer

private

timer for delayed update

Definition at line 371 of file MainWidget.h.

Referenced by MainWidget(), and resizeEvent().

◆ m_horizontal_scrollbar

QScrollBar* Kwave::MainWidget::m_horizontal_scrollbar

private

horizontal scrollbar

Definition at line 350 of file MainWidget.h.

Referenced by isOK(), MainWidget(), refreshHorizontalScrollBar(), and updateViewRange().

◆ m_lower_dock

QVBoxLayout Kwave::MainWidget::m_lower_dock

private

lower docking area, managed by the signal widget

Definition at line 344 of file MainWidget.h.

Referenced by MainWidget().

◆ m_offset

sample_index_t Kwave::MainWidget::m_offset

private

Offset from which signal is being displayed. This is equal to the index of the first visible sample.

Definition at line 362 of file MainWidget.h.

Referenced by dropEvent(), executeCommand(), fixZoomAndOffset(), refreshHorizontalScrollBar(), scrollTo(), setZoom(), updateViewRange(), visibleOffset(), zoomIn(), zoomNormal(), zoomOut(), and zoomSelection().

◆ m_overview

Kwave::OverViewWidget* Kwave::MainWidget::m_overview

private

overview widget

Definition at line 356 of file MainWidget.h.

Referenced by isOK(), MainWidget(), refreshHorizontalScrollBar(), updateViewRange(), and wheelEvent().

◆ m_preferred_size

QSize Kwave::MainWidget::m_preferred_size

private

preferred size of the widget

Definition at line 368 of file MainWidget.h.

Referenced by sizeHint().

◆ m_scroll_area

QScrollArea Kwave::MainWidget::m_scroll_area

private

container widget that contains the signal widget.

Definition at line 347 of file MainWidget.h.

Referenced by MainWidget(), and wheelEvent().

◆ m_signal_widget

Kwave::SignalWidget Kwave::MainWidget::m_signal_widget

private

the widget that shows the signal, scrolled within the view port

Definition at line 353 of file MainWidget.h.

Referenced by MainWidget(), updateViewRange(), visibleWidth(), and wheelEvent().

◆ m_upper_dock

QVBoxLayout Kwave::MainWidget::m_upper_dock

private

upper docking area, managed by the signal widget

Definition at line 341 of file MainWidget.h.

Referenced by MainWidget().

◆ m_zoom

double Kwave::MainWidget::m_zoom

private

number of samples per pixel

Definition at line 365 of file MainWidget.h.

Referenced by fixZoomAndOffset(), pixels2samples(), samples2pixels(), setOffset(), updateViewRange(), zoom(), zoomIn(), and zoomOut().

The documentation for this class was generated from the following files:

kwave/MainWidget.h
kwave/MainWidget.cpp

Public Slots

Signals

Public Member Functions

Protected Slots

Protected Member Functions

Private Slots

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ MainWidget()

◆ ~MainWidget()

Member Function Documentation

◆ addLabel()

◆ closeEvent()

◆ dragEnterEvent()

◆ dropEvent()

◆ executeCommand

◆ fixZoomAndOffset()

◆ fullZoom()

◆ horizontalScrollBarMoved

◆ isOK()

◆ labelProperties()

◆ loadLabels()

◆ ms2samples()

◆ pixels2samples()

◆ refreshHorizontalScrollBar

◆ resizeEvent()

◆ samples2pixels()

◆ saveLabels()

◆ scrollTo

◆ setOffset

◆ setZoom

◆ sigCommand

◆ sigVisibleRangeChanged

◆ sigZoomChanged

◆ sizeHint()

◆ slotTrackDeleted

◆ slotTrackInserted

◆ updateViewRange

◆ visibleOffset()

◆ visibleSamples()

◆ visibleWidth()

◆ wheelEvent()

◆ zoom()

◆ zoomAll

◆ zoomIn

◆ zoomNormal

◆ zoomOut

◆ zoomSelection

Member Data Documentation

◆ m_context

◆ m_delayed_update_timer

◆ m_horizontal_scrollbar

◆ m_lower_dock

◆ m_offset

◆ m_overview

◆ m_preferred_size

◆ m_scroll_area

◆ m_signal_widget

◆ m_upper_dock

◆ m_zoom