Kwave::FileProgress Class Reference

#include <FileProgress.h>

Inheritance diagram for Kwave::FileProgress:

Collaboration diagram for Kwave::FileProgress:

Public Slots
void	setValue (qreal percent)
void	setBytePosition (quint64 pos)
void	setLength (quint64 samples)

Signals
void	canceled ()

Public Member Functions
	FileProgress (QWidget *parent, const QUrl &url, quint64 size, sample_index_t samples, double rate, unsigned int bits, unsigned int tracks)
virtual	~FileProgress () Q_DECL_OVERRIDE
bool	isCanceled ()

Protected Slots
void	cancel ()

Protected Member Functions
virtual void	resizeEvent (QResizeEvent *) Q_DECL_OVERRIDE
virtual void	closeEvent (QCloseEvent *e) Q_DECL_OVERRIDE
void	fitUrlLabel ()
QLabel *	addInfoLabel (QGridLayout *layout, const QString text, int row, int column)
void	updateStatistics (double rate, double rest, quint64 pos)

Protected Attributes
QUrl	m_url
quint64	m_size
QLabel *	m_lbl_url
QLabel *	m_lbl_length
QProgressBar *	m_progress
QLabel *	m_stat_transfer
QLabel *	m_stat_bytes
QTime	m_time
bool	m_canceled
int	m_last_percent
unsigned int	m_bits_per_sample
double	m_sample_rate
unsigned int	m_tracks

Detailed Description

Definition at line 41 of file FileProgress.h.

Constructor & Destructor Documentation

FileProgress()

Kwave::FileProgress::FileProgress	(	QWidget *	parent,
		const QUrl &	url,
		quint64	size,
		sample_index_t	samples,
		double	rate,
		unsigned int	bits,
		unsigned int	tracks
	)

Constructor

Parameters

parent	the parent widget
url	the URL of the file
size	the size of the file in bytes
samples	the number of samples
rate	sample rate in samples per second
bits	number of bits per sample
tracks	number of tracks

Definition at line 44 of file FileProgress.cpp.

References _, addInfoLabel(), cancel(), Kwave::connect(), fitUrlLabel(), m_canceled, m_lbl_length, m_lbl_url, m_progress, m_stat_bytes, m_stat_transfer, m_time, m_url, setLength(), and updateStatistics().

    :QDialog(parent),
     m_url(url),
     m_size(size),
     m_lbl_url(Q_NULLPTR),
     m_lbl_length(Q_NULLPTR),
     m_progress(Q_NULLPTR),
     m_stat_transfer(Q_NULLPTR),
     m_stat_bytes(Q_NULLPTR),
     m_time(),
     m_canceled(true),
     m_last_percent(0),
     m_bits_per_sample(bits),
     m_sample_rate(rate),
     m_tracks(tracks)
{
    setModal(true);

    QString text;

    // start the timer now
    m_time.start();

    // set the caption to the url
    setWindowTitle(m_url.toString());

    // toplevel uses a vbox layout
    QVBoxLayout *top_layout = new QVBoxLayout(this);
    Q_ASSERT(top_layout);
    if (!top_layout) return;
    top_layout->setMargin(10);
    top_layout->setSpacing(10);

    // sublayout for the lines with the file info
    QGridLayout *info_layout = new QGridLayout();
    Q_ASSERT(info_layout);
    if (!info_layout) return;
    info_layout->setSpacing(0);
    info_layout->setColumnStretch(0, 0);
    info_layout->setColumnStretch(1, 100);
    top_layout->addLayout(info_layout);

    // label with "file"
    if (!addInfoLabel(info_layout,
        i18nc("file progress dialog", "File: "), 0, 0)) return;
    text = _("?");
    m_lbl_url = addInfoLabel(info_layout, text, 0, 1);
    if (!m_lbl_url) return;

    // label with "length"
    if (!addInfoLabel(info_layout,
        i18nc("file progress dialog", "Length: "), 1, 0)) return;

    m_lbl_length = addInfoLabel(info_layout, _(""), 1, 1);
    if (!m_lbl_length) return;
    setLength(quint64(samples) * quint64(tracks));

    // label with "rate:"
    if (!addInfoLabel(info_layout,
        i18nc("file progress dialog", "Sample Rate: "), 2, 0)) return;
    text = i18nc("file progress dialog, %1=number of samples per second",
                 "%1 Samples per second", rate);
    if (!addInfoLabel(info_layout, text, 2, 1)) return;

    // label with "resolution:"
    if (!addInfoLabel(info_layout,
        i18nc("file progress dialog", "Resolution: "), 3, 0)) return;
    text = i18nc("file progress dialog, "
                 "%1=number of bits per sample (8, 16, 24...)",
                 "%1 Bits per sample", bits);
    if (!addInfoLabel(info_layout, text, 3, 1)) return;

    // label with "tracks:"
    if (!addInfoLabel(info_layout,
        i18nc("file progress dialog", "Tracks: "), 4, 0)) return;
    switch (tracks) {
        case 1:
            text = i18nc("number of tracks", "1 (mono)");
            break;
        case 2:
            text = i18nc("number of tracks", "2 (stereo)");
            break;
        case 4:
            text = i18nc("number of tracks", "4 (quadro)");
            break;
        default:
            text = text.setNum(tracks);
    }
    if (!addInfoLabel(info_layout, text, 4, 1)) return;

    // progress bar
    m_progress = new QProgressBar(this);
    Q_ASSERT(m_progress);
    if (!m_progress) return;
    top_layout->addWidget(m_progress, 0);
    m_progress->setMinimum(0);
    m_progress->setMaximum(100);

    // sublayout for the line with estimated time
    QGridLayout *status_layout = new QGridLayout();
    Q_ASSERT(status_layout);
    if (!status_layout) return;
    status_layout->setSpacing(1);
    status_layout->setColumnMinimumWidth(1, 20);
    top_layout->addLayout(status_layout);

    // create the statistic labels
    m_stat_transfer = addInfoLabel(status_layout, _("-"), 1, 0);
    if (!m_stat_transfer) return;
    m_stat_bytes = addInfoLabel(status_layout, _("-"), 1, 2);
    if (!m_stat_bytes) return;

    // some dummy update to get maximum size
    updateStatistics(9999999.9, static_cast<double>(99*24*60*60), size);

    // now correct the minimum sizes of the statistic entries
    m_stat_transfer->adjustSize();
    m_stat_transfer->setMinimumWidth(m_stat_transfer->sizeHint().width());
    m_stat_bytes->adjustSize();
    m_stat_bytes->setMinimumWidth(m_stat_bytes->sizeHint().width());

    // right lower edge: the "cancel" button
    QPushButton *bt_cancel = new QPushButton(this);
    Q_ASSERT(bt_cancel);
    if (!bt_cancel) return;
    KGuiItem::assign(bt_cancel, KStandardGuiItem::cancel());
    bt_cancel->setFixedSize(bt_cancel->sizeHint());
    bt_cancel->setFocus();
    bt_cancel->setShortcut(Qt::Key_Escape);
    connect(bt_cancel, SIGNAL(clicked()), this, SLOT(cancel()));
    top_layout->addWidget(bt_cancel, 0, Qt::AlignRight);

    // activate the layout and show the dialog
    top_layout->activate();
    setFixedHeight(sizeHint().height());
    setMinimumWidth((sizeHint().width() * 110) / 100);

    show();
    fitUrlLabel();

    // now set canceled to false, this dialog is ready for use
    m_canceled = false;
}

Here is the call graph for this function:

~FileProgress()

virtual Kwave::FileProgress::~FileProgress ( )

inlinevirtual

Destructor

Definition at line 61 of file FileProgress.h.

{}

Member Function Documentation

addInfoLabel()

QLabel * Kwave::FileProgress::addInfoLabel ( QGridLayout *  layout, const QString  text, int  row, int  column  )

protected

Adds a label to an info field. Used within the constructor.

Parameters

layout	the QGridLayout with the labels
text	the content of the label, localized
row	the row within the layout [0...rows-1]
column	the column within the layout [0...columns-1]

Returns

the label if successful, 0 if failed

Definition at line 246 of file FileProgress.cpp.

Referenced by FileProgress().

{
    QLabel *label = new QLabel(this);
    Q_ASSERT(label);
    if (!label) return Q_NULLPTR;

    label->setText(text);
    label->adjustSize();
    label->setFixedHeight(label->sizeHint().height());
    label->setMinimumWidth(label->sizeHint().width());

    layout->addWidget(label, row, col);

    return label;
}

Here is the caller graph for this function:

cancel

void Kwave::FileProgress::cancel ( )

protectedslot

Connected to the "cancel" button to set the "m_canceled" flag if the user wants to abort.

Definition at line 372 of file FileProgress.cpp.

References canceled(), and m_canceled.

Referenced by FileProgress().

{
    close();
    if (m_canceled) emit canceled();
}

Here is the caller graph for this function:

canceled

void Kwave::FileProgress::canceled ( )

signal

Emitted when the user has pressed the Cancel button and has confirmed with "Yes".

Referenced by cancel().

Here is the caller graph for this function:

closeEvent()

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

protectedvirtual

Called if the window is to be closed.

Definition at line 198 of file FileProgress.cpp.

References m_canceled, and Kwave::MessageBox::warningYesNo().

{
    Q_ASSERT(e);
    if (!e) return;

    // if not already cancelled -> ask user to confirm
    if (!m_canceled) {
        if (Kwave::MessageBox::warningYesNo(this,
            i18n("Do you really want to abort the operation?")) !=
            KMessageBox::Yes)
        {
            // the user was wise and said "No"
            e->ignore();
            return;
        } else {
            // user pressed "Yes", he should know what he has done
            m_canceled = true;
        }
    }

    // default action: accept
    e->accept();
}

Here is the call graph for this function:

fitUrlLabel()

void Kwave::FileProgress::fitUrlLabel ( )

protected

Fits the URL text into the available area, with shortening it if necessary.

Definition at line 223 of file FileProgress.cpp.

References _, m_lbl_url, and m_url.

Referenced by FileProgress(), and resizeEvent().

{
    if (!m_lbl_url) return;

    int width = m_lbl_url->frameRect().width();
    QString url = m_url.toString();
    m_lbl_url->setText(url);
    int todel = 4;
    while (m_lbl_url->sizeHint().width() > width) {
        // delete characters in the middle of the string
        url = m_url.toString();
        int len = url.length();
        if (len <= todel) break;
        url = url.left((len-todel)/2) + _("...") +
            url.right((len-todel)/2 + 4);
        m_lbl_url->setText(url);
        todel++;
    }

    m_lbl_url->adjustSize();
}

Here is the caller graph for this function:

isCanceled()

bool Kwave::FileProgress::isCanceled ( )

inline

Returns true if the dialog is unusable or the user has pressed the "cancel" button.

Definition at line 67 of file FileProgress.h.

Referenced by Kwave::SignalManager::save().

{ return m_canceled; }

Here is the caller graph for this function:

resizeEvent()

void Kwave::FileProgress::resizeEvent ( QResizeEvent *  )

protectedvirtual

Fits again the URL label on resize events.

See also

fitUrlLabel()

Definition at line 192 of file FileProgress.cpp.

References fitUrlLabel().

{
    fitUrlLabel();
}

Here is the call graph for this function:

setBytePosition

void Kwave::FileProgress::setBytePosition ( quint64  pos )

slot

Like setValue, but takes position in bytes as argument

Parameters

pos	position within the file, in bytes [0...m_size-1]

Definition at line 316 of file FileProgress.cpp.

References m_last_percent, m_progress, m_size, m_time, m_url, Kwave::toInt(), and updateStatistics().

Referenced by Kwave::SignalManager::loadFile(), and setValue().

{
    if (!m_progress) return;
    if (pos > m_size) pos = m_size;

    // the easiest part: the progress bar and the caption
    int percent = Kwave::toInt(
        (static_cast<double>(pos) / static_cast<double>(m_size)) * 100.0);

    // not enough progress not worth showing ?
    if (percent <= m_last_percent) return;
    m_last_percent = percent;

    if (m_progress->value() != percent) {
        QString newcap;
        newcap = i18nc(
            "%1=Progress in percentage, %2=path to file",
            "(%1%) %2",
            percent, m_url.toString()
        );
        setWindowTitle(newcap);

        m_progress->setValue(percent);
    }

    // update the transfer statistics
    double seconds = m_time.elapsed() / 1000.0; // [sec]
    double rate = pos / seconds;                // [bytes/sec]
    double rest = 0;
    if (rate > 10) {
        rest = static_cast<double>(m_size - pos) / rate;     // [seconds]
    }
    updateStatistics(rate, rest, pos);
}

Here is the call graph for this function:

Here is the caller graph for this function:

setLength

void Kwave::FileProgress::setLength ( quint64  samples )

slot

Updates the length information, needed in stream mode.

Parameters

samples

total number of samples, must be divided through the number of tracks for getting the real length

Definition at line 352 of file FileProgress.cpp.

References m_lbl_length, m_sample_rate, m_tracks, and Kwave::ms2string().

Referenced by FileProgress(), and Kwave::SignalManager::loadFile().

{
    QString text;

    // length in samples -> h:m:s
    if ((m_sample_rate > 0) && m_tracks) {
        // length in ms
        text = Kwave::ms2string(
            1000.0 *
            qreal(samples / m_tracks) /
            qreal(m_sample_rate));
    } else {
        // fallback if no rate: length in samples
        text = i18nc("file progress dialog, %1=a number of samples",
                     "%1 samples", samples);
    }
    m_lbl_length->setText(text);
}

Here is the call graph for this function:

Here is the caller graph for this function:

setValue

void Kwave::FileProgress::setValue ( qreal  percent )

slot

Advances the progress to a given position within the file.

Parameters

percent

position within the file, in percent

Definition at line 308 of file FileProgress.cpp.

References m_size, and setBytePosition().

{
    // position is in samples, we need bytes
    quint64 pos = static_cast<quint64>(percent * qreal(m_size) / 100.0);
    setBytePosition(pos);
}

Here is the call graph for this function:

updateStatistics()

void Kwave::FileProgress::updateStatistics ( double  rate, double  rest, quint64  pos  )

protected

Updates the statistics of the transferred bytes and transfer rate.

Parameters

rate	transfer rate in kilobytes per seconds
rest	remaining time in seconds
pos	position in the file

Definition at line 264 of file FileProgress.cpp.

References m_size, m_stat_bytes, and m_stat_transfer.

Referenced by FileProgress(), and setBytePosition().

{
    QString text;
    QString num;

    if (!m_stat_transfer) return;
    if (!m_stat_bytes) return;

    // left: transfer rate and estimated time
    num = num.sprintf("%1.1f", rate / 1024.0);

    quint64 ms = qMin(quint64(rest * 1000.0), 24ULL * 60ULL * 60ULL * 1000ULL);
    text = i18nc("file progress dialog, "
                 "%1=transfer rate, %2=remaining duration",
                 "%1 kB/s (%2 remaining)", num,
                 KFormat().formatDecimalDuration(ms));
    m_stat_transfer->setText(text);

    // right: statistic over the transferred bytes
    QString num1, num2;
    text = i18nc("file progress dialog, "
                 "%1=number of loaded/saved megabytes, "
                 "%2=number of total megabytes to load or save",
                  "%1 MB of %2 MB done",
        num1.sprintf("%1.1f", pos / (1024.0 * 1024.0)),
        num2.sprintf("%1.1f", m_size / (1024.0 * 1024.0)));
    m_stat_bytes->setText(text);

    // process events for some short time, otherwise we would
    // not have GUI updates and the "cancel" button would not work
    // check: this must be called from the GUI thread only!
    Q_ASSERT(this->thread() == QThread::currentThread());
    Q_ASSERT(this->thread() == qApp->thread());
    QTimer t;
    t.setSingleShot(true);
    t.start(5);
    while (t.isActive()) {
        qApp->sendPostedEvents();
        qApp->processEvents();
    }
}

Here is the caller graph for this function:

Member Data Documentation

m_bits_per_sample

unsigned int Kwave::FileProgress::m_bits_per_sample

protected

number of bits per sample

Definition at line 180 of file FileProgress.h.

m_canceled

bool Kwave::FileProgress::m_canceled

protected

true if the dialog is unusable or canceled by the user

Definition at line 174 of file FileProgress.h.

Referenced by cancel(), closeEvent(), and FileProgress().

m_last_percent

int Kwave::FileProgress::m_last_percent

protected

last displayed percent value

Definition at line 177 of file FileProgress.h.

Referenced by setBytePosition().

m_lbl_length

QLabel* Kwave::FileProgress::m_lbl_length

protected

label with length info, changes in streaming mode

Definition at line 159 of file FileProgress.h.

Referenced by FileProgress(), and setLength().

m_lbl_url

QLabel* Kwave::FileProgress::m_lbl_url

protected

label with the url, shortened when too long

Definition at line 156 of file FileProgress.h.

Referenced by FileProgress(), and fitUrlLabel().

m_progress

QProgressBar* Kwave::FileProgress::m_progress

protected

progress bar

Definition at line 162 of file FileProgress.h.

Referenced by FileProgress(), and setBytePosition().

m_sample_rate

double Kwave::FileProgress::m_sample_rate

protected

number of samples per second, used for output

Definition at line 183 of file FileProgress.h.

Referenced by setLength().

m_size

quint64 Kwave::FileProgress::m_size

protected

size of the file [Bytes]

Definition at line 153 of file FileProgress.h.

Referenced by setBytePosition(), setValue(), and updateStatistics().

m_stat_bytes

QLabel* Kwave::FileProgress::m_stat_bytes

protected

label with progress statistics

Definition at line 168 of file FileProgress.h.

Referenced by FileProgress(), and updateStatistics().

m_stat_transfer

QLabel* Kwave::FileProgress::m_stat_transfer

protected

label with transfer statistics

Definition at line 165 of file FileProgress.h.

Referenced by FileProgress(), and updateStatistics().

m_time

QTime Kwave::FileProgress::m_time

protected

start time, set on initialization of this dialog

Definition at line 171 of file FileProgress.h.

Referenced by FileProgress(), and setBytePosition().

m_tracks

unsigned int Kwave::FileProgress::m_tracks

protected

number of tracks

Definition at line 186 of file FileProgress.h.

Referenced by setLength().

m_url

QUrl Kwave::FileProgress::m_url

protected

url of the file

Definition at line 150 of file FileProgress.h.

Referenced by FileProgress(), fitUrlLabel(), and setBytePosition().

---

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

• libkwave/FileProgress.h
• libkwave/FileProgress.cpp