#include <RecordDialog.h>

Inheritance diagram for Kwave::RecordDialog:

Collaboration diagram for Kwave::RecordDialog:

Public Types
enum	Mode { SETTINGS_DEFAULT = 0, SETTINGS_FORMAT, SETTINGS_SOURCE, START_RECORDING }

Public Slots
void	setDevice (const QString &device)

void	setFileFilter (const QString &filter)

void	setRecordedSamples (sample_index_t samples_recorded)

void	message (const QString &message)

Signals
void	sigMethodChanged (Kwave::record_method_t method)

void	sigDeviceChanged (const QString &device)

void	sigTracksChanged (unsigned int tracks)

void	sampleRateChanged (double rate)

void	sigCompressionChanged (Kwave::Compression::Type compression)

void	sigBitsPerSampleChanged (unsigned int bits)

void	sigSampleFormatChanged (Kwave::SampleFormat::Format sample_format)

void	sigBuffersChanged ()

void	sigRecordTimeChanged (int limit)

void	sigTriggerChanged (bool enabled)

void	sigPreRecordingChanged (bool enabled)

Public Member Functions
	RecordDialog (QWidget parent, QStringList &params, Kwave::RecordController controller, Mode mode)

virtual	~RecordDialog ()

Kwave::RecordParams &	params ()

void	setMethod (Kwave::record_method_t method)

void	setSupportedDevices (QStringList devices)

void	setSupportedTracks (unsigned int min, unsigned int max)

void	setTracks (unsigned int tracks)

void	setSupportedSampleRates (const QList< double > &rates)

void	setSampleRate (double new_rate)

void	setSupportedCompressions (const QList< Kwave::Compression::Type > &comps)

void	setCompression (int compression)

void	setSupportedBits (const QList< unsigned int > &bits)

void	setBitsPerSample (unsigned int bits)

QString	rate2string (double rate) const

void	setSupportedSampleFormats (const QList< Kwave::SampleFormat::Format > &formats)

void	setSampleFormat (Kwave::SampleFormat::Format sample_format)

void	updateBufferState (unsigned int count, unsigned int total)

void	updateEffects (unsigned int track, Kwave::SampleArray &buffer)

void	showDevicePage ()

Private Slots
void	methodSelected (int index)

void	sourceBufferCountChanged (int value)

void	sourceBufferSizeChanged (int value)

void	selectRecordDevice ()

void	listEntrySelected (QTreeWidgetItem current, QTreeWidgetItem previous)

void	listItemExpanded (QTreeWidgetItem *item)

void	updateListSelection ()

void	tracksChanged (int tracks)

void	sampleRateChanged (const QString &rate)

void	compressionChanged (int index)

void	bitsPerSampleChanged (int bits)

void	sampleFormatChanged (int index)

void	setState (Kwave::RecordState state)

void	updateBufferProgressBar ()

void	preRecordingChecked (bool enabled)

void	preRecordingTimeChanged (int time)

void	recordTimeChecked (bool limited)

void	recordTimeChanged (int record_time)

void	startTimeChecked (bool enabled)

void	startTimeChanged (const QDateTime &datetime)

void	triggerChecked (bool enabled)

void	triggerChanged (int trigger)

void	invokeHelp ()

Private Member Functions
double	string2rate (const QString &rate) const

void	updateRecordButton ()

Private Attributes
Kwave::RecordTypesMap	m_methods_map

QString	m_file_filter

QMap< QTreeWidgetItem *, QString >	m_devices_list_map

Kwave::RecordState	m_state

Kwave::RecordParams	m_params

QList< unsigned int >	m_supported_resolutions

unsigned int	m_buffer_progress_count

unsigned int	m_buffer_progress_total

QTimer	m_buffer_progress_timer

bool	m_record_enabled

sample_index_t	m_samples_recorded

bool	m_enable_setDevice

Kwave::StatusWidget *	m_state_icon_widget

struct {
QLabel * m_state

QLabel * m_time

QLabel * m_sample_rate

QLabel * m_bits_per_sample

QLabel * m_tracks

}	m_status_bar

Detailed Description

Definition at line 49 of file RecordDialog.h.

Member Enumeration Documentation

◆ Mode

enum Kwave::RecordDialog::Mode

Enumerator
SETTINGS_DEFAULT	default page (setup, tab 0)
SETTINGS_FORMAT	format settings
SETTINGS_SOURCE	source settings
START_RECORDING	directly start recording!

Definition at line 55 of file RecordDialog.h.

                      {
             SETTINGS_DEFAULT = 0, 
             SETTINGS_FORMAT,      
             SETTINGS_SOURCE,      
             START_RECORDING       
         } Mode;

Constructor & Destructor Documentation

◆ RecordDialog()

Kwave::RecordDialog::RecordDialog	(	QWidget *	parent,
		QStringList &	params,
		Kwave::RecordController *	controller,
		Mode	mode
	)

Constructor

Definition at line 90 of file RecordDialog.cpp.

References _, bitsPerSampleChanged(), Kwave::RecordParams::buffer_count, Kwave::RecordParams::buffer_size, compressionChanged(), Kwave::connect(), Kwave::TypesMap< IDX, DATA >::count(), Kwave::TypesMap< IDX, DATA >::description(), Kwave::RecordParams::fromList(), invokeHelp(), listEntrySelected(), listItemExpanded(), m_buffer_progress_timer, m_methods_map, m_params, m_state_icon_widget, m_status_bar, methodSelected(), preRecordingChecked(), preRecordingTimeChanged(), Kwave::REC_EMPTY, recordTimeChanged(), recordTimeChecked(), sampleFormatChanged(), sampleRateChanged(), selectRecordDevice(), setDevice(), setState(), SETTINGS_DEFAULT, SETTINGS_FORMAT, SETTINGS_SOURCE, sourceBufferCountChanged(), sourceBufferSizeChanged(), START_RECORDING, Kwave::RecordParams::start_time, Kwave::RecordParams::start_time_enabled, startTimeChanged(), startTimeChecked(), STD_SETUP, STD_SETUP_SLIDER, tracksChanged(), triggerChanged(), triggerChecked(), updateBufferProgressBar(), and updateListSelection().

     :QDialog(parent), Ui::RecordDlg(), m_methods_map(),
      m_file_filter(), m_devices_list_map(),
      m_state(Kwave::REC_EMPTY), m_params(),
      m_supported_resolutions(), m_buffer_progress_count(0),
      m_buffer_progress_total(0), m_buffer_progress_timer(this),
      m_record_enabled(true), m_samples_recorded(0),
      m_enable_setDevice(true), m_state_icon_widget(Q_NULLPTR)
 {
     m_status_bar.m_state           = Q_NULLPTR;
     m_status_bar.m_time            = Q_NULLPTR;
     m_status_bar.m_sample_rate     = Q_NULLPTR;
     m_status_bar.m_bits_per_sample = Q_NULLPTR;
     m_status_bar.m_tracks          = Q_NULLPTR;
 
     setupUi(this);
 
     /* get initial parameters */
     m_params.fromList(params);
 
     /* set the icons of the record control buttons */
     btNew->setIcon(   QIcon::fromTheme(_("document-new")));
     btStop->setIcon(  QIcon::fromTheme(_("kwave_player_stop")));
     btPause->setIcon( QIcon::fromTheme(_("kwave_player_pause")));
     btRecord->setIcon(QIcon::fromTheme(_("kwave_player_record")));
 
     // fill the combo box with playback methods
     unsigned int index=0;
     for (index = 0; index < m_methods_map.count(); ++index) {
         cbMethod->addItem(m_methods_map.description(index, true));
     }
     cbMethod->setEnabled(cbMethod->count() > 1);
 
     /* --- set up all controls with their default/startup values --- */
 
     // pre-record
     STD_SETUP_SLIDER(pre_record_enabled, pre_record_time, RecordPre);
     connect(chkRecordPre, SIGNAL(toggled(bool)),
             this,         SLOT(preRecordingChecked(bool)));
     connect(sbRecordPre,  SIGNAL(valueChanged(int)),
             this,         SLOT(preRecordingTimeChanged(int)));
 
     // record time (duration)
     STD_SETUP(record_time_limited, record_time, RecordTime);
 
     // start time (date & time)
     chkRecordStartTime->setChecked(m_params.start_time_enabled);
     startTime->setDateTime(m_params.start_time);
 
     // record trigger
     STD_SETUP_SLIDER(record_trigger_enabled, record_trigger, RecordTrigger);
 
     // amplification
     STD_SETUP_SLIDER(amplification_enabled, amplification, LevelAmplify);
 
     // AGC
     STD_SETUP_SLIDER(agc_enabled, agc_decay, LevelAGC);
 
     // fade in
     STD_SETUP(fade_in_enabled, fade_in_time, LevelFadeIn);
 
     // fade out
     STD_SETUP(fade_out_enabled, fade_out_time, LevelFadeOut);
 
     // sample rate, bits per sample, track
     // -> will be initialized later, by the plugin
 
     // number of buffers
     slSourceBufferCount->setValue(m_params.buffer_count);
 
     // power of buffer size
     slSourceBufferSize->setValue(m_params.buffer_size);
     sourceBufferSizeChanged(m_params.buffer_size);
 
     // after this point all controls have their initial values
 
     /* --- connect some missing low level GUI functionality --- */
 
     connect(cbMethod, SIGNAL(activated(int)),
             this, SLOT(methodSelected(int)));
 
     // record buffer size and count
     slSourceBufferCount->setValue(m_params.buffer_count);
     slSourceBufferSize->setValue(m_params.buffer_size);
     connect(slSourceBufferSize, SIGNAL(valueChanged(int)),
             this, SLOT(sourceBufferSizeChanged(int)));
     connect(slSourceBufferCount, SIGNAL(valueChanged(int)),
             this, SLOT(sourceBufferCountChanged(int)));
 
     // device treeview
     connect(listDevices,
             SIGNAL(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)),
             SLOT(listEntrySelected(QTreeWidgetItem*,QTreeWidgetItem*)));
     connect(listDevices, SIGNAL(itemExpanded(QTreeWidgetItem*)),
             SLOT(listItemExpanded(QTreeWidgetItem*)));
     connect(listDevices, SIGNAL(focusLost()),
             SLOT(updateListSelection()));
 
     // "select device..." button
     connect(btSourceSelect, SIGNAL(clicked()),
             this, SLOT(selectRecordDevice()));
     connect(cbDevice, SIGNAL(activated(QString)),
             this, SLOT(setDevice(QString)));
 
     // setup controls
     connect(chkRecordTime, SIGNAL(toggled(bool)),
             this, SLOT(recordTimeChecked(bool)));
     connect(sbRecordTime, SIGNAL(valueChanged(int)),
             this, SLOT(recordTimeChanged(int)));
 
     connect(chkRecordStartTime, SIGNAL(toggled(bool)),
             this, SLOT(startTimeChecked(bool)));
     connect(startTime, SIGNAL(dateTimeChanged(QDateTime)),
             this, SLOT(startTimeChanged(QDateTime)));
 
     connect(chkRecordTrigger, SIGNAL(toggled(bool)),
             this, SLOT(triggerChecked(bool)));
     connect(sbRecordTrigger, SIGNAL(valueChanged(int)),
             this, SLOT(triggerChanged(int)));
 
     connect(cbFormatSampleRate, SIGNAL(editTextChanged(QString)),
             this, SLOT(sampleRateChanged(QString)));
     connect(cbFormatSampleRate, SIGNAL(activated(QString)),
             this, SLOT(sampleRateChanged(QString)));
 
     connect(sbFormatTracks, SIGNAL(valueChanged(int)),
             this, SLOT(tracksChanged(int)));
 
     connect(cbFormatCompression, SIGNAL(activated(int)),
             this, SLOT(compressionChanged(int)));
 
     connect(sbFormatResolution, SIGNAL(valueChanged(int)),
             this, SLOT(bitsPerSampleChanged(int)));
 
     connect(cbFormatSampleFormat, SIGNAL(activated(int)),
             this, SLOT(sampleFormatChanged(int)));
 
     // connect the buttons to the record controller
     connect(btNew, SIGNAL(clicked()),
             controller, SLOT(actionReset()));
     connect(btStop, SIGNAL(clicked()),
             controller, SLOT(actionStop()));
     connect(btPause, SIGNAL(clicked()),
             controller, SLOT(actionPause()));
     connect(btRecord, SIGNAL(clicked()),
             controller, SLOT(actionStart()));
 
     // stop recording when the window gets closed
     connect(this, SIGNAL(rejected()), controller, SLOT(actionStop()));
     connect(this, SIGNAL(accepted()), controller, SLOT(actionStop()));
 
     // connect the notifications/commands of the record controller
     connect(controller, SIGNAL(stateChanged(Kwave::RecordState)),
             this, SLOT(setState(Kwave::RecordState)));
 
     // timer for updating the buffer progress bar
     connect(&m_buffer_progress_timer, SIGNAL(timeout()),
             this, SLOT(updateBufferProgressBar()));
 
     // help button
     connect(buttonBox->button(QDialogButtonBox::Help), SIGNAL(clicked()),
             this,   SLOT(invokeHelp()));
 
     // status bar
     m_state_icon_widget = new Kwave::StatusWidget(this);
     Q_ASSERT(m_state_icon_widget);
     if (!m_state_icon_widget) return;
 
     m_state_icon_widget->setFixedSize(16, 16);
     lbl_state->addWidget(m_state_icon_widget);
 
     m_status_bar.m_state = new (std::nothrow) QLabel(_(" "));
     Q_ASSERT(m_status_bar.m_state);
     if (!m_status_bar.m_state) return;
     m_status_bar.m_state->setAlignment(Qt::AlignLeft | Qt::AlignVCenter);
     lbl_state->addWidget(m_status_bar.m_state);
 
     m_status_bar.m_time = new (std::nothrow) QLabel(_(" "));
     Q_ASSERT(m_status_bar.m_time);
     if (!m_status_bar.m_time) return;
     m_status_bar.m_time->setAlignment(Qt::AlignLeft | Qt::AlignVCenter);
     lbl_state->addWidget(m_status_bar.m_time);
 
     m_status_bar.m_sample_rate = new (std::nothrow) QLabel(_(" "));
     Q_ASSERT(m_status_bar.m_sample_rate);
     if (!m_status_bar.m_sample_rate) return;
     m_status_bar.m_sample_rate->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     lbl_state->addWidget(m_status_bar.m_sample_rate);
 
     m_status_bar.m_bits_per_sample = new (std::nothrow) QLabel(_(" "));
     Q_ASSERT(m_status_bar.m_bits_per_sample);
     if (!m_status_bar.m_bits_per_sample) return;
     m_status_bar.m_bits_per_sample->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     lbl_state->addWidget(m_status_bar.m_bits_per_sample);
 
     m_status_bar.m_tracks = new (std::nothrow) QLabel(_(" "));
     Q_ASSERT(m_status_bar.m_tracks);
     if (!m_status_bar.m_tracks) return;
     m_status_bar.m_tracks->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     lbl_state->addWidget(m_status_bar.m_tracks);
 
     m_state_icon_widget->setFixedSize(16, lbl_state->childrenRect().height());
 
     // set the initial state of the dialog to "Reset/Empty"
     setState(Kwave::REC_EMPTY);
 
     // disable the "level" tab, it is not implemented yet
     tabRecord->setCurrentIndex(1);
     QWidget *page = tabRecord->currentWidget();
     tabRecord->setCurrentIndex(0);
     if (page) delete page;
 
     // add the "Done" button manually, otherwise it would have "Cancel" semantic
     QPushButton *bt_done =
         buttonBox->addButton(i18n("&Done"), QDialogButtonBox::AcceptRole);
     Q_ASSERT(bt_done);
     if (!bt_done) return;
     connect(bt_done, SIGNAL(clicked(bool)), this, SLOT(accept()));
 
     switch (mode)
     {
         case Kwave::RecordDialog::SETTINGS_FORMAT:
             tabRecord->setCurrentIndex(1);
             break;
         case Kwave::RecordDialog::SETTINGS_SOURCE:
             tabRecord->setCurrentIndex(2);
             break;
         case Kwave::RecordDialog::START_RECORDING:  /* FALLTHROUGH */
         case Kwave::RecordDialog::SETTINGS_DEFAULT: /* FALLTHROUGH */
         default:
             tabRecord->setCurrentIndex(0);
             // set the focus onto the "Record" button
             btRecord->setFocus();
             break;
     }
 }

Here is the call graph for this function:

◆ ~RecordDialog()

Kwave::RecordDialog::~RecordDialog ( )

virtual

Destructor

Definition at line 330 of file RecordDialog.cpp.

References updateBufferState().

 {
     updateBufferState(0,0);
 }

Here is the call graph for this function:

Member Function Documentation

◆ bitsPerSampleChanged

void Kwave::RecordDialog::bitsPerSampleChanged ( int bits )

privateslot

called when the resolution in bits per sample has changed

Definition at line 890 of file RecordDialog.cpp.

References Kwave::RecordParams::bits_per_sample, m_params, m_supported_resolutions, and sigBitsPerSampleChanged().

Referenced by RecordDialog().

 {
     if (bits < 1) return; // no device
     int last = m_params.bits_per_sample;
     if (bits == last) return;
 
     // round up or down to the next supported resolution in bits per sample
     if (!m_supported_resolutions.isEmpty()) {
         if (bits > last) {
             // step up to the next supported value
             QListIterator<unsigned int> it(m_supported_resolutions);
             while (it.hasNext()) {
                 bits = it.next();
                 if (bits > last) break;
             }
             if (bits < last) bits = m_supported_resolutions.last();
         } else {
             // step down to the next supported value
             QListIterator<unsigned int> it(m_supported_resolutions);
             it.toBack();
             while (it.hasPrevious()) {
                 bits = it.previous();
                 if (bits < last) break;
             }
             if (bits > last) bits = m_supported_resolutions.first();
         }
     }
 
     m_params.bits_per_sample = bits;
 
     if (sbFormatResolution && (bits != sbFormatResolution->value()))
         sbFormatResolution->setValue(bits);
 
     emit sigBitsPerSampleChanged(bits);
 }

Here is the caller graph for this function:

◆ compressionChanged

void Kwave::RecordDialog::compressionChanged ( int index )

privateslot

called when a new compression type has been set

Definition at line 846 of file RecordDialog.cpp.

References Kwave::RecordParams::compression, Kwave::Compression::fromInt(), m_params, and sigCompressionChanged().

Referenced by RecordDialog().

 {
     Kwave::Compression::Type compression = Kwave::Compression::fromInt(
         cbFormatCompression->itemData(index).toInt());
     if (compression != m_params.compression)
         emit sigCompressionChanged(compression);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ invokeHelp

void Kwave::RecordDialog::invokeHelp ( )

privateslot

invoke the online help

Definition at line 1345 of file RecordDialog.cpp.

References _.

Referenced by RecordDialog().

 {
     KHelpClient::invokeHelp(_("recording"));
 }

Here is the caller graph for this function:

◆ listEntrySelected

void Kwave::RecordDialog::listEntrySelected	(	QTreeWidgetItem *	current,
		QTreeWidgetItem *	previous
	)

privateslot

selection in the device list view has changed

Definition at line 511 of file RecordDialog.cpp.

References m_devices_list_map, and setDevice().

Referenced by RecordDialog().

 {
     Q_ASSERT(listDevices);
     Q_UNUSED(previous);
     if (!current || !listDevices) return;
 
     if (m_devices_list_map.contains(current))
         setDevice(m_devices_list_map[current]);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ listItemExpanded

void Kwave::RecordDialog::listItemExpanded ( QTreeWidgetItem * item )

privateslot

selection in the device list view has changed

Definition at line 523 of file RecordDialog.cpp.

References updateListSelection().

Referenced by RecordDialog().

 {
     Q_UNUSED(item);
     updateListSelection();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ message

void Kwave::RecordDialog::message ( const QString & message )

slot

show a message in the status bar

Definition at line 1351 of file RecordDialog.cpp.

Referenced by Kwave::RecordPlugin::notice().

 {
     if (lbl_state) lbl_state->showMessage(message, 3000);
 }

Here is the caller graph for this function:

◆ methodSelected

void Kwave::RecordDialog::methodSelected ( int index )

privateslot

called when a new recording method has been selected from the combo box

Parameters

index the position within the combo box

Definition at line 350 of file RecordDialog.cpp.

References Kwave::TypesMap< IDX, DATA >::data(), m_methods_map, m_params, Kwave::RecordParams::method, Kwave::RECORD_INVALID, Kwave::RECORD_NONE, setMethod(), and sigMethodChanged().

Referenced by RecordDialog().

 {
     Kwave::record_method_t method = m_methods_map.data(index);
 //     qDebug("RecordDialog::methodSelected(%d) - %d", index, (int)method);
 
     Q_ASSERT(method > Kwave::RECORD_NONE);
     Q_ASSERT(method < Kwave::RECORD_INVALID);
     if (method <= Kwave::RECORD_NONE) return;
     if (method >= Kwave::RECORD_INVALID) return;
 
     if (method != m_params.method) {
         setMethod(method);
         emit sigMethodChanged(method);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ params()

Kwave::RecordParams & Kwave::RecordDialog::params ( )

returns the list of record parameters, for the next time

Definition at line 336 of file RecordDialog.cpp.

References m_params.

 {
     return m_params;
 }

Here is the caller graph for this function:

◆ preRecordingChecked

void Kwave::RecordDialog::preRecordingChecked ( bool enabled )

privateslot

prerecording has been enabled/disabled

Definition at line 1227 of file RecordDialog.cpp.

References m_params, Kwave::RecordParams::pre_record_enabled, and sigPreRecordingChanged().

Referenced by RecordDialog().

 {
     m_params.pre_record_enabled = enabled;
     emit sigPreRecordingChanged(enabled);
 }

Here is the caller graph for this function:

◆ preRecordingTimeChanged

void Kwave::RecordDialog::preRecordingTimeChanged ( int time )

privateslot

the prerecording time has been changed

Definition at line 1234 of file RecordDialog.cpp.

References m_params, and Kwave::RecordParams::pre_record_time.

Referenced by RecordDialog().

 {
     m_params.pre_record_time = time;
 }

Here is the caller graph for this function:

◆ rate2string()

QString Kwave::RecordDialog::rate2string ( double rate ) const

Convert a sample rate into a string, using current locale settings. Trailing zeroes and thousands separators are removed, the precision is set to three digits.

Parameters

rate	sample rate [samples/second]

Returns: the rate formatted as string

Definition at line 642 of file RecordDialog.cpp.

References _.

Referenced by Kwave::RecordPlugin::changeSampleRate(), setSampleRate(), and setSupportedSampleRates().

 {
     QLocale locale;
     const QString dot  = locale.decimalPoint();
     const QString tsep = locale.groupSeparator();
 
     // format number with 3 digits
     QString s = locale.toString(rate, 'f', 3);
 
     // remove thousands separator (looks ugly)
     s.remove(tsep);
 
     // remove trailing zeroes
     while (s.endsWith(_("0"))) s.remove(s.length()-1, 1);
 
     // remove decimal point if necessary
     if (s.endsWith(dot)) s.remove(s.length()-1, 1);
 
     return s;
 }

Here is the caller graph for this function:

◆ recordTimeChanged

void Kwave::RecordDialog::recordTimeChanged ( int record_time )

privateslot

record time has been changed

Definition at line 1247 of file RecordDialog.cpp.

References m_params, Kwave::RecordParams::record_time, sigRecordTimeChanged(), and updateRecordButton().

Referenced by RecordDialog().

 {
     m_params.record_time = limit;
     emit sigRecordTimeChanged(chkRecordTime->isChecked() ?
                               limit : -1);
     updateRecordButton();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ recordTimeChecked

void Kwave::RecordDialog::recordTimeChecked ( bool limited )

privateslot

record time has been enabled/disabled

Definition at line 1240 of file RecordDialog.cpp.

References m_params, Kwave::RecordParams::record_time_limited, and sigRecordTimeChanged().

Referenced by RecordDialog().

 {
     m_params.record_time_limited = limited;
     emit sigRecordTimeChanged(limited ? sbRecordTime->value() : -1);
 }

Here is the caller graph for this function:

◆ sampleFormatChanged

void Kwave::RecordDialog::sampleFormatChanged ( int index )

privateslot

called when a new sample format has been selected

Definition at line 969 of file RecordDialog.cpp.

References Kwave::SampleFormat::fromInt(), m_params, Kwave::RecordParams::sample_format, and sigSampleFormatChanged().

Referenced by RecordDialog().

 {
     Q_ASSERT(cbFormatSampleFormat);
     if (!cbFormatSampleFormat) return;
 
     Kwave::SampleFormat format;
     format.fromInt(cbFormatSampleFormat->itemData(index).toInt());
 
     if (format == m_params.sample_format) return;
 
     emit sigSampleFormatChanged(format);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sampleRateChanged [1/2]

void Kwave::RecordDialog::sampleRateChanged ( double rate )

signal

emitted when a new sample rate has been selected

Referenced by RecordDialog(), and sampleRateChanged().

Here is the caller graph for this function:

◆ sampleRateChanged [2/2]

void Kwave::RecordDialog::sampleRateChanged ( const QString & rate )

privateslot

called when another sample rate has been selected

Definition at line 791 of file RecordDialog.cpp.

References m_params, Kwave::RecordParams::sample_rate, sampleRateChanged(), and string2rate().

 {
     if (!rate.length()) return; // no rate selected, combo box clear
     double sample_rate = string2rate(rate);
     if (qFuzzyCompare(sample_rate, m_params.sample_rate)) return;
 
     m_params.sample_rate = sample_rate;
     emit sampleRateChanged(sample_rate);
 }

Here is the call graph for this function:

◆ selectRecordDevice

void Kwave::RecordDialog::selectRecordDevice ( )

privateslot

show a "file open" dialog for selecting a record device

Definition at line 612 of file RecordDialog.cpp.

References _, Kwave::RecordParams::device_name, m_enable_setDevice, m_params, Kwave::FileDialog::OpenFile, Kwave::FileDialog::selectUrl(), and sigDeviceChanged().

Referenced by RecordDialog().

 {
     if (!m_enable_setDevice) return;
 
     QString filter;
     filter += _("dsp*|")    + i18n("OSS record device (dsp*)");
     filter += _("\nadsp*|") + i18n("ALSA record device (adsp*)");
     filter += _("\n*|")     + i18n("Any device (*)");
 
     QPointer<Kwave::FileDialog> dlg = new(std::nothrow) Kwave::FileDialog(
         _("kfiledialog:///kwave_record_device"),
         Kwave::FileDialog::OpenFile, filter, this,
         QUrl(_("file:/dev"))
     );
     if (!dlg) return;
     dlg->setWindowTitle(i18n("Select Record Device"));
     if (!m_params.device_name.startsWith(_("#")))
         dlg->selectUrl(QUrl(_("file:") + m_params.device_name));
     else
         dlg->selectUrl(QUrl(_("file:/dev/*")));
     if (dlg->exec() == QDialog::Accepted) {
         // selected new device
         QString new_device = dlg->selectedUrl().path();
         if (new_device != m_params.device_name)
             emit sigDeviceChanged(new_device);
     }
     delete dlg;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setBitsPerSample()

void Kwave::RecordDialog::setBitsPerSample ( unsigned int bits )

sets a new resolution in bits per sample

Definition at line 871 of file RecordDialog.cpp.

References Kwave::RecordParams::bits_per_sample, m_params, m_status_bar, and m_supported_resolutions.

Referenced by Kwave::RecordPlugin::changeBitsPerSample().

 {
     Q_ASSERT(sbFormatResolution);
     Q_ASSERT(m_status_bar.m_bits_per_sample);
     if (!sbFormatResolution || !m_status_bar.m_bits_per_sample) return;
 
     if (!bits ) {
         sbFormatResolution->setEnabled(false);
         return;
     } else {
         sbFormatResolution->setEnabled(m_supported_resolutions.count() > 1);
         m_params.bits_per_sample = bits;
     }
 
     m_status_bar.m_bits_per_sample->setText(i18n("%1 bit", bits));
     sbFormatResolution->setValue(bits);
 }

Here is the caller graph for this function:

◆ setCompression()

void Kwave::RecordDialog::setCompression ( int compression )

sets a new compression type

Parameters

compression type of the compression, numeric

See also: Kwave::Compression

Definition at line 827 of file RecordDialog.cpp.

References Kwave::RecordParams::compression, Kwave::Compression::fromInt(), m_params, and Kwave::Compression::name().

Referenced by Kwave::RecordPlugin::changeCompression().

 {
     Q_ASSERT(cbFormatCompression);
     if (!cbFormatCompression) return;
 
     if (compression < 0) {
         cbFormatCompression->setEnabled(false);
         return;
     } else {
         bool have_choice = (cbFormatCompression->count() > 1);
         cbFormatCompression->setEnabled(have_choice);
         m_params.compression = Kwave::Compression::fromInt(compression);
     }
 
     const Kwave::Compression comp(Kwave::Compression::fromInt(compression));
     cbFormatCompression->setCurrentItem(comp.name(), true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setDevice

void Kwave::RecordDialog::setDevice ( const QString & device )

slot

selects a new record device

Definition at line 537 of file RecordDialog.cpp.

References Kwave::RecordParams::device_name, m_devices_list_map, m_params, and sigDeviceChanged().

Referenced by listEntrySelected(), RecordDialog(), Kwave::RecordPlugin::setDevice(), and updateListSelection().

 {
     Q_ASSERT(cbDevice);
     Q_ASSERT(listDevices);
     if (!cbDevice || !listDevices) return;
 
     bool device_changed = (device != m_params.device_name);
     m_params.device_name = device;
 //     qDebug("RecordDialog::setDevice(%s)", device.local8Bit().data());
 
     if (listDevices->isEnabled()) {
         // treeview mode
         QTreeWidgetItem *node = m_devices_list_map.key(device, Q_NULLPTR);
         if (node) {
             node->setSelected(true);
             listDevices->scrollToItem(node);
             listDevices->setCurrentItem(node);
         }
     } else if (cbDevice->isEditable() && device.length()) {
         // user defined device name
         if (!device.isEmpty() && (cbDevice->currentText() != device)) {
             cbDevice->setCurrentIndex(cbDevice->findText(device));
             cbDevice->setEditText(device);
         }
     } else {
         // just take one from the list
         if (cbDevice->findText(device) >= 0) {
             cbDevice->setCurrentIndex(cbDevice->findText(device));
         } else if (cbDevice->count()) {
             cbDevice->setCurrentIndex(0);
         }
     }
 
     if (device_changed) emit sigDeviceChanged(device);
 }

Here is the caller graph for this function:

◆ setFileFilter

void Kwave::RecordDialog::setFileFilter ( const QString & filter )

slot

set the file filter used for the "Select..." dialog

Definition at line 605 of file RecordDialog.cpp.

References m_file_filter.

Referenced by Kwave::RecordPlugin::setMethod().

 {
     m_file_filter = filter;
     if (btSourceSelect) btSourceSelect->setEnabled(m_file_filter.length());
 }

Here is the caller graph for this function:

◆ setMethod()

void Kwave::RecordDialog::setMethod ( Kwave::record_method_t method )

selects a new recording method

Definition at line 342 of file RecordDialog.cpp.

References Kwave::TypesMap< IDX, DATA >::findFromData(), m_methods_map, m_params, and Kwave::RecordParams::method.

Referenced by methodSelected(), and Kwave::RecordPlugin::setMethod().

 {
     m_params.method = method;
     cbMethod->setCurrentIndex(m_methods_map.findFromData(
         m_params.method));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setRecordedSamples

void Kwave::RecordDialog::setRecordedSamples ( sample_index_t samples_recorded )

slot

updates the number of recorded samples

Definition at line 1323 of file RecordDialog.cpp.

References m_samples_recorded, and updateRecordButton().

 {
     // if (!m_params.record_time_limited) return; // not of interest
     m_samples_recorded = samples_recorded;
     updateRecordButton();
 }

Here is the call graph for this function:

◆ setSampleFormat()

void Kwave::RecordDialog::setSampleFormat ( Kwave::SampleFormat::Format sample_format )

sets a new sample format

Parameters

sample_format format of the samples, like signed/unsigned

See also: SampleFormat

Definition at line 948 of file RecordDialog.cpp.

References m_params, Kwave::RecordParams::sample_format, Kwave::toInt(), and Kwave::SampleFormat::Unknown.

Referenced by Kwave::RecordPlugin::changeSampleFormat().

 {
     Q_ASSERT(cbFormatSampleFormat);
     if (!cbFormatSampleFormat) return;
 
     if (sample_format == Kwave::SampleFormat::Unknown) {
         cbFormatSampleFormat->setEnabled(false);
         return;
     } else {
         bool have_choice = (cbFormatSampleFormat->count() > 1);
         cbFormatSampleFormat->setEnabled(have_choice);
         m_params.sample_format = sample_format;
     }
 
     int cb_index = cbFormatSampleFormat->findData(
         Kwave::SampleFormat(sample_format).toInt());
     cbFormatSampleFormat->setCurrentIndex(cb_index);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setSampleRate()

void Kwave::RecordDialog::setSampleRate ( double new_rate )

sets a new sample rate

Parameters

new_rate the new sample rate [samples/second]

Definition at line 769 of file RecordDialog.cpp.

References m_params, m_status_bar, rate2string(), and Kwave::RecordParams::sample_rate.

Referenced by Kwave::RecordPlugin::changeSampleRate().

 {
     Q_ASSERT(cbFormatSampleRate);
     Q_ASSERT(m_status_bar.m_sample_rate);
     if (!cbFormatSampleRate || !m_status_bar.m_sample_rate) return;
 
     if (new_rate <= 0) {
         cbFormatSampleRate->setEnabled(false);
         return;
     } else {
         bool have_choice = (cbFormatSampleRate->count() > 1);
         cbFormatSampleRate->setEnabled(have_choice);
         m_params.sample_rate = new_rate;
     }
 
     QString rate;
     rate = rate2string(new_rate);
     cbFormatSampleRate->setCurrentItem(rate, true);
     m_status_bar.m_sample_rate->setText(i18n("%1 Hz", rate));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setState

void Kwave::RecordDialog::setState ( Kwave::RecordState state )

privateslot

sets a new state of the dialog, enable/disable controls etc...

Definition at line 983 of file RecordDialog.cpp.

References _, Kwave::RecordParams::device_name, m_params, m_record_enabled, m_state, m_state_icon_widget, m_status_bar, Kwave::REC_BUFFERING, Kwave::REC_DONE, Kwave::REC_EMPTY, Kwave::REC_PAUSED, Kwave::REC_PRERECORDING, Kwave::REC_RECORDING, Kwave::REC_UNINITIALIZED, Kwave::REC_WAITING_FOR_TRIGGER, Kwave::StatusWidget::setPixmaps(), and updateRecordButton().

Referenced by RecordDialog().

 {
     Q_ASSERT(m_status_bar.m_state);
     if (!m_status_bar.m_state) return;
 
     bool enable_new = false;
     bool enable_pause = false;
     bool enable_stop = false;
     bool enable_record = false;
     bool enable_settings = false;
     bool enable_trigger = false;
     QString state_text = _("");
     QVector<QPixmap> pixmaps;
     unsigned int animation_time = 500;
 
     m_state = state;
     switch (state) {
         case Kwave::REC_UNINITIALIZED:
             state_text = i18n("Please check the source device settings...");
             enable_new      = true;
             enable_pause    = false;
             enable_stop     = false;
             enable_record   = false;
             enable_settings = true;
             enable_trigger  = true;
             pixmaps.push_back(QPixmap(stop_hand_xpm));
             pixmaps.push_back(QPixmap(ledred_xpm));
             m_status_bar.m_time->setText(_(""));
             break;
         case Kwave::REC_EMPTY:
             state_text = i18n("(empty)");
             enable_new      = true;
             enable_pause    = false;
             enable_stop     = false;
             enable_record   = m_params.device_name.length();
             enable_settings = true;
             enable_trigger  = true;
             pixmaps.push_back(QPixmap(ledgreen_xpm));
             m_status_bar.m_time->setText(_(""));
             break;
         case Kwave::REC_BUFFERING:
             state_text = i18n("Buffering...");
             enable_new      = true; /* throw away current FIFO content */
             enable_pause    = false;
             enable_stop     = true;
             enable_record   = true; /* acts as "trigger now" */
             enable_settings = false;
             enable_trigger  = true;
             pixmaps.push_back(QPixmap(ledgreen_xpm));
             pixmaps.push_back(QPixmap(ledlightgreen_xpm));
             break;
         case Kwave::REC_PRERECORDING:
             state_text = i18n("Prerecording...");
             enable_new      = false;
             enable_pause    = false;
             enable_stop     = true;
             enable_record   = true;
             enable_settings = false;
             enable_trigger  = true;
             pixmaps.push_back(QPixmap(ledgreen_xpm));
             pixmaps.push_back(QPixmap(ledlightgreen_xpm));
             break;
         case Kwave::REC_WAITING_FOR_TRIGGER:
             state_text = i18n("Waiting for trigger...");
             enable_new      = false;
             enable_pause    = false;
             enable_stop     = true;
             enable_record   = true; /* acts as "trigger now" */
             enable_settings = false;
             enable_trigger  = true;
             pixmaps.push_back(QPixmap(ledgreen_xpm));
             pixmaps.push_back(QPixmap(ledlightgreen_xpm));
             break;
         case Kwave::REC_RECORDING:
             state_text = i18n("Recording...");
             enable_new      = false;
             enable_pause    = true;
             enable_stop     = true;
             enable_record   = false;
             enable_settings = false;
             enable_trigger  = false;
             pixmaps.push_back(QPixmap(walk_r1_xpm));
             pixmaps.push_back(QPixmap(walk_r2_xpm));
             pixmaps.push_back(QPixmap(walk_r3_xpm));
             pixmaps.push_back(QPixmap(walk_r4_xpm));
             pixmaps.push_back(QPixmap(walk_r5_xpm));
             pixmaps.push_back(QPixmap(walk_r6_xpm));
             pixmaps.push_back(QPixmap(walk_r7_xpm));
             pixmaps.push_back(QPixmap(walk_r8_xpm));
             animation_time = 100;
             break;
         case Kwave::REC_PAUSED:
             state_text = i18n("Paused");
             enable_new      = true; /* start again */
             enable_pause    = true; /* used for "continue" */
             enable_stop     = true;
             enable_record   = true; /* used for "continue" */
             enable_settings = false;
             enable_trigger  = false;
             pixmaps.push_back(QPixmap(ledgreen_xpm));
             pixmaps.push_back(QPixmap(ledyellow_xpm));
             break;
         case Kwave::REC_DONE:
             state_text = i18n("Done");
             enable_new      = true;
             enable_pause    = false;
             enable_stop     = false;
             enable_record   = true;
             enable_settings = true;
             enable_trigger  = true;
             pixmaps.push_back(QPixmap(ok_xpm));
             break;
     }
     m_status_bar.m_state->setText(state_text);
     m_state_icon_widget->setPixmaps(pixmaps, animation_time);
 
     // enable/disable the record control buttons
     btNew->setEnabled(enable_new);
     btPause->setEnabled(enable_pause);
     btStop->setEnabled(enable_stop);
     m_record_enabled = enable_record;
     updateRecordButton();
 
     // enable disable all controls (groups) for setup
     chkRecordPre->setEnabled(enable_settings);
     sbRecordPre->setEnabled(enable_settings &&
                             chkRecordPre->isChecked());
     slRecordPre->setEnabled(enable_settings &&
                             chkRecordPre->isChecked());
 
     chkRecordStartTime->setEnabled(enable_settings);
     chkRecordTime->setEnabled(enable_settings);
     sbRecordTime->setEnabled(enable_settings &&
                              chkRecordTime->isChecked());
     chkRecordTrigger->setEnabled(enable_settings);
 
     // it is not really necessary to disable these ;-)
     sbRecordTrigger->setEnabled(enable_trigger &&
                                 chkRecordTrigger->isChecked());
     slRecordTrigger->setEnabled(enable_trigger &&
                                 chkRecordTrigger->isChecked());
     startTime->setEnabled(enable_settings &&
                           chkRecordStartTime->isChecked());
 
     grpFormat->setEnabled(enable_settings);
     grpSource->setEnabled(enable_settings);
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setSupportedBits()

void Kwave::RecordDialog::setSupportedBits ( const QList< unsigned int > & bits )

sets a list of supported number of bits per sample

Definition at line 855 of file RecordDialog.cpp.

References m_supported_resolutions.

Referenced by Kwave::RecordPlugin::changeBitsPerSample().

 {
     Q_ASSERT(sbFormatResolution);
     if (!sbFormatResolution) return;
 
     m_supported_resolutions = bits;
     if (bits.count()) {
         sbFormatResolution->setMinimum(bits.first());
         sbFormatResolution->setMaximum(bits.last());
     }
 
     // enable only if there is a choice
     sbFormatResolution->setEnabled(bits.count() > 1);
 }

Here is the caller graph for this function:

◆ setSupportedCompressions()

void Kwave::RecordDialog::setSupportedCompressions ( const QList< Kwave::Compression::Type > & comps )

sets the list of supported compressions

Parameters

comps list of supported compressions, can be empty

Definition at line 802 of file RecordDialog.cpp.

References Kwave::Compression::name(), Kwave::Compression::NONE, and Kwave::Compression::toInt().

Referenced by Kwave::RecordPlugin::changeCompression().

 {
     Q_ASSERT(cbFormatCompression);
     if (!cbFormatCompression) return;
 
     cbFormatCompression->clear();
 
     if (comps.isEmpty()) {
         // no compressions -> add "none" manually
         const Kwave::Compression comp(Kwave::Compression::NONE);
         cbFormatCompression->addItem(comp.name());
     } else {
         foreach (Kwave::Compression::Type c, comps) {
             const Kwave::Compression comp(c);
             cbFormatCompression->addItem(comp.name(), comp.toInt());
         }
     }
 
     bool have_choice = (cbFormatCompression->count() > 1);
     cbFormatCompression->setEnabled(have_choice);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setSupportedDevices()

void Kwave::RecordDialog::setSupportedDevices ( QStringList devices )

Sets the list of supported devices, just entries for the device selection combo box.

Definition at line 367 of file RecordDialog.cpp.

References _, Kwave::RecordParams::device_name, m_devices_list_map, m_enable_setDevice, and m_params.

Referenced by Kwave::RecordPlugin::setMethod().

 {
 //     qDebug("RecordDialog::setSupportedDevices(QStringList devices)");
     Q_ASSERT(cbDevice);
     Q_ASSERT(listDevices);
     if (!cbDevice || !listDevices) return;
     QString current_device = m_params.device_name;
 
     // disable all that noisy stuff that comes from modifying the
     // device controls...
     m_enable_setDevice = false;
 
     KIconLoader *icon_loader = KIconLoader::global();
 
     cbDevice->clearEditText();
     cbDevice->clear();
     listDevices->clear();
 
     if (devices.contains(_("#EDIT#"))) {
         devices.removeAll(_("#EDIT#"));
         cbDevice->setEditable(true);
     } else {
         cbDevice->setEditable(false);
     }
 
     if (devices.contains(_("#SELECT#"))) {
         devices.removeAll(_("#SELECT#"));
         btSourceSelect->setEnabled(true);
         btSourceSelect->show();
     } else {
         btSourceSelect->setEnabled(false);
         btSourceSelect->hide();
     }
 
     if (devices.contains(_("#TREE#"))) {
         // treeview mode
         devices.removeAll(_("#TREE#"));
         listDevices->setEnabled(true);
         cbDevice->setEnabled(false);
         cbDevice->hide();
         m_devices_list_map.clear();
 
         // build a tree with all nodes in the list
         foreach (QString dev_id, devices) {
             QTreeWidgetItem *parent = Q_NULLPTR;
 
             QStringList list = dev_id.split(_("||"), QString::KeepEmptyParts);
             foreach (QString token, list) {
                 QTreeWidgetItem *item = Q_NULLPTR;
 
                 // split the icon name from the token
                 QString icon_name;
                 int pos = token.indexOf(QLatin1Char('|'));
                 if (pos > 0) {
                     icon_name = token.mid(pos+1);
                     token     = token.left(pos);
                 }
 
                 // find the first item with the same text
                 // and the same root
                 if (parent) {
                     for (int i = 0; i < parent->childCount(); i++) {
                         QTreeWidgetItem *node = parent->child(i);
                         if (node && node->text(0) == token) {
                             item = node;
                             break;
                         }
                     }
                 } else {
                     QList<QTreeWidgetItem *> matches =
                         listDevices->findItems(token, Qt::MatchExactly);
                     if (matches.count())
                         item = matches.takeFirst();
                 }
 
                 if (item) {
                     // already in the list
                     parent = item;
                 } else if (parent) {
                     // new leaf, add to the parent
                     item = new QTreeWidgetItem(parent);
                     Q_ASSERT(item);
                     if (item) {
                         item->setText(0, token);
                         m_devices_list_map.insert(item, dev_id);
                     }
 
                     parent->setExpanded(true);
                     parent->setFlags(parent->flags() &
                         ~(Qt::ItemIsUserCheckable | Qt::ItemIsSelectable));
                     if (m_devices_list_map.contains(parent)) {
                         // make the parent not selectable
                         m_devices_list_map.remove(parent);
                     }
                 } else {
                     // new root node
                     item = new QTreeWidgetItem(listDevices);
                     Q_ASSERT(item);
                     if (item) {
                         item->setText(0, token);
                         m_devices_list_map.insert(item, dev_id);
                     }
                 }
 
                 if (item && icon_name.length() && icon_loader) {
                     QIcon icon = icon_loader->loadIcon(
                         icon_name, KIconLoader::User);
                     item->setIcon(0, icon);
                 }
 
                 // use the current item as parent for the next pass
                 parent = item;
             }
         }
     } else {
         // combo box mode
         cbDevice->addItems(devices);
         cbDevice->show();
         listDevices->setEnabled(false);
 
         if (devices.contains(current_device)) {
             // current device is in the list
             cbDevice->setCurrentIndex(cbDevice->findText(current_device));
         } else {
             if (cbDevice->isEditable() && current_device.length()) {
                 // user defined device name
                 cbDevice->setEditText(current_device);
             } else if (devices.count()) {
                 // one or more other possibilities -> take the first one
                 cbDevice->setCurrentIndex(0);
             } else {
                 // empty list of possibilities
                 cbDevice->clearEditText();
                 cbDevice->clear();
             }
         }
         cbDevice->setEnabled(devices.count() > 1);
     }
 
     // enable changes in the device controls again
     m_enable_setDevice = true;
 }

Here is the caller graph for this function:

◆ setSupportedSampleFormats()

void Kwave::RecordDialog::setSupportedSampleFormats ( const QList< Kwave::SampleFormat::Format > & formats )

sets the list of supported sample formats

Parameters

formats list of supported sample formats, must not be empty

Definition at line 927 of file RecordDialog.cpp.

References Kwave::TypesMap< IDX, DATA >::description(), Kwave::TypesMap< IDX, DATA >::findFromData(), and Kwave::SampleFormat::toInt().

Referenced by Kwave::RecordPlugin::changeSampleFormat().

 {
     Q_ASSERT(cbFormatSampleFormat);
     if (!cbFormatSampleFormat) return;
 
     cbFormatSampleFormat->clear();
     Kwave::SampleFormat::Map types;
     foreach (Kwave::SampleFormat::Format format, formats) {
         int index = types.findFromData(format);
         cbFormatSampleFormat->addItem(
             types.description(index, true),
             Kwave::SampleFormat(format).toInt()
         );
     }
 
     bool have_choice = (cbFormatSampleFormat->count() > 1);
     cbFormatSampleFormat->setEnabled(have_choice);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setSupportedSampleRates()

void Kwave::RecordDialog::setSupportedSampleRates ( const QList< double > & rates )

sets the list of supported sample rates

Definition at line 748 of file RecordDialog.cpp.

References rate2string().

Referenced by Kwave::RecordPlugin::changeSampleRate().

 {
     Q_ASSERT(cbFormatSampleRate);
     if (!cbFormatSampleRate) return;
 
     cbFormatSampleRate->clearEditText();
     cbFormatSampleRate->setEditable(false);
     cbFormatSampleRate->clear();
 
     foreach (double r, rates) {
         QString rate = rate2string(r);
         Q_ASSERT(rate.length());
         if (!rate.length()) continue; // string was zero?
         cbFormatSampleRate->addItem(rate);
     }
 
     bool have_choice = (cbFormatSampleRate->count() > 1);
     cbFormatSampleRate->setEnabled(have_choice);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setSupportedTracks()

void Kwave::RecordDialog::setSupportedTracks	(	unsigned int	min,
		unsigned int	max
	)

sets the range of supported tracks

Definition at line 678 of file RecordDialog.cpp.

Referenced by Kwave::RecordPlugin::changeTracks().

 {
     Q_ASSERT(sbFormatTracks);
     if (!sbFormatTracks) return;
 
     if ((min == max) || (!max)) {
         sbFormatTracks->setEnabled(false);
         return;
     } else
         sbFormatTracks->setEnabled(true);
 
     if (sbFormatTracks->value() < sbFormatTracks->minimum()) {
         sbFormatTracks->setMaximum(max);
         sbFormatTracks->setMinimum(min);
     } else {
         sbFormatTracks->setMinimum(min);
         sbFormatTracks->setMaximum(max);
     }
 
 }

Here is the caller graph for this function:

◆ setTracks()

void Kwave::RecordDialog::setTracks ( unsigned int tracks )

sets a new number of tracks

Definition at line 701 of file RecordDialog.cpp.

References _, m_params, m_status_bar, and Kwave::RecordParams::tracks.

Referenced by Kwave::RecordPlugin::changeTracks().

 {
 //     qDebug("+++ RecordDialog::setTracks(%u)", tracks);
     Q_ASSERT(sbFormatTracks);
     Q_ASSERT(m_status_bar.m_tracks);
     if (!sbFormatTracks || !m_status_bar.m_tracks) return;
     if (!tracks) return;
 
     m_params.tracks = tracks;
     QString tracks_str;
 
     switch (tracks) {
         case 1:
             tracks_str = i18n("Mono");
             break;
         case 2:
             tracks_str = i18n("Stereo");
             break;
         case 4:
             tracks_str = i18n("Quadro");
             break;
         default:
             tracks_str = _("");
     }
 
     if (tracks_str.length()) {
         lblTracksVerbose->setText(_("(") + tracks_str + _(")"));
         m_status_bar.m_tracks->setText(tracks_str);
     } else {
         lblTracksVerbose->setText(_(""));
         m_status_bar.m_tracks->setText(i18n("%1 tracks", tracks));
     }
 
     sbFormatTracks->setValue(tracks);
 }

Here is the caller graph for this function:

◆ showDevicePage()

void Kwave::RecordDialog::showDevicePage ( )

Show the "source" device tab, usually if the setup was not successful.

Definition at line 1357 of file RecordDialog.cpp.

Referenced by Kwave::RecordPlugin::setDevice().

 {
     if (tabRecord) tabRecord->setCurrentIndex(2);
 }

Here is the caller graph for this function:

◆ sigBitsPerSampleChanged

void Kwave::RecordDialog::sigBitsPerSampleChanged ( unsigned int bits )

signal

emitted when the resoluton in bits per sample changed

Referenced by bitsPerSampleChanged().

Here is the caller graph for this function:

◆ sigBuffersChanged

void Kwave::RecordDialog::sigBuffersChanged ( )

signal

emitted when the number and/or size of buffers has changed

Referenced by sourceBufferCountChanged(), and sourceBufferSizeChanged().

Here is the caller graph for this function:

◆ sigCompressionChanged

void Kwave::RecordDialog::sigCompressionChanged ( Kwave::Compression::Type compression )

signal

emitted when the compression has changed

Referenced by compressionChanged().

Here is the caller graph for this function:

◆ sigDeviceChanged

void Kwave::RecordDialog::sigDeviceChanged ( const QString & device )

signal

emitted when a new record device has been selected

Referenced by selectRecordDevice(), and setDevice().

Here is the caller graph for this function:

◆ sigMethodChanged

void Kwave::RecordDialog::sigMethodChanged ( Kwave::record_method_t method )

signal

emits changes in the currently selected record method

Referenced by methodSelected().

Here is the caller graph for this function:

◆ sigPreRecordingChanged

void Kwave::RecordDialog::sigPreRecordingChanged ( bool enabled )

signal

emitted when the prerecording has been enabled/disabled

Referenced by preRecordingChecked().

Here is the caller graph for this function:

◆ sigRecordTimeChanged

void Kwave::RecordDialog::sigRecordTimeChanged ( int limit )

signal

emitted when the record time has been changed

Referenced by recordTimeChanged(), and recordTimeChecked().

Here is the caller graph for this function:

◆ sigSampleFormatChanged

void Kwave::RecordDialog::sigSampleFormatChanged ( Kwave::SampleFormat::Format sample_format )

signal

emitted when the sample format has changed

Referenced by sampleFormatChanged().

Here is the caller graph for this function:

◆ sigTracksChanged

void Kwave::RecordDialog::sigTracksChanged ( unsigned int tracks )

signal

emitted when the number of tracks has changed

Referenced by tracksChanged().

Here is the caller graph for this function:

◆ sigTriggerChanged

void Kwave::RecordDialog::sigTriggerChanged ( bool enabled )

signal

emitted when the record trigger has been enabled/disabled

Referenced by startTimeChecked(), and triggerChecked().

Here is the caller graph for this function:

◆ sourceBufferCountChanged

void Kwave::RecordDialog::sourceBufferCountChanged ( int value )

privateslot

updates the record buffer count

Definition at line 574 of file RecordDialog.cpp.

References Kwave::RecordParams::buffer_count, m_params, and sigBuffersChanged().

Referenced by RecordDialog().

 {
     Q_ASSERT(value >=  4);
     Q_ASSERT(value <= 64);
     if (value < 4)  value = 4;
     if (value > 64) value = 64;
 
     // take the value into our struct
     m_params.buffer_count = value;
     emit sigBuffersChanged();
 }

Here is the caller graph for this function:

◆ sourceBufferSizeChanged

void Kwave::RecordDialog::sourceBufferSizeChanged ( int value )

privateslot

updates the record buffer size

Definition at line 587 of file RecordDialog.cpp.

References Kwave::RecordParams::buffer_size, m_params, and sigBuffersChanged().

Referenced by RecordDialog().

 {
     Q_ASSERT(value >= 10);
     Q_ASSERT(value <= 18);
     if (value < 10) value = 10;
     if (value > 18) value = 18;
 
     // take the value into our struct
     m_params.buffer_size = value;
 
     // update the text
     unsigned int buffer_size = (1 << value);
     txtSourceBuffer->setText(i18n("%1 samples", buffer_size));
 
     emit sigBuffersChanged();
 }

Here is the caller graph for this function:

◆ startTimeChanged

void Kwave::RecordDialog::startTimeChanged ( const QDateTime & datetime )

privateslot

start time has been changed

Definition at line 1263 of file RecordDialog.cpp.

References m_params, and Kwave::RecordParams::start_time.

Referenced by RecordDialog().

 {
     m_params.start_time = datetime;
 
     // force seconds to zero
     QTime t = m_params.start_time.time();
     t.setHMS(t.hour(), t.minute(), 0, 0);
     m_params.start_time.setTime(t);
 }

Here is the caller graph for this function:

◆ startTimeChecked

void Kwave::RecordDialog::startTimeChecked ( bool enabled )

privateslot

start time has been enabled/disabled

Definition at line 1256 of file RecordDialog.cpp.

References m_params, Kwave::RecordParams::record_trigger_enabled, sigTriggerChanged(), and Kwave::RecordParams::start_time_enabled.

Referenced by RecordDialog().

 {
     m_params.start_time_enabled = enabled;
     emit sigTriggerChanged(enabled || m_params.record_trigger_enabled);
 }

Here is the caller graph for this function:

◆ string2rate()

double Kwave::RecordDialog::string2rate ( const QString & rate ) const

private

Convert a formated sample rate string back to a numeric sample rate (the opposite of rate2string() )

Parameters

rate	the sample rate, formatted as string

Returns: the numeric sample rate [samples/second]

Definition at line 664 of file RecordDialog.cpp.

Referenced by sampleRateChanged().

 {
     QLocale locale;
     const QString s = rate;
     double r;
     bool ok;
     r = locale.toDouble(rate, &ok);
     Q_ASSERT(ok);
     if (!ok) return s.toDouble();
 
     return r;
 }

Here is the caller graph for this function:

◆ tracksChanged

void Kwave::RecordDialog::tracksChanged ( int tracks )

privateslot

forwards a sigTracksChanged signal

Definition at line 738 of file RecordDialog.cpp.

References m_params, sigTracksChanged(), Kwave::toInt(), and Kwave::RecordParams::tracks.

Referenced by RecordDialog().

 {
     if (tracks < 1) return; // no device
     if (tracks == Kwave::toInt(m_params.tracks)) return;
 
     m_params.tracks = tracks;
     emit sigTracksChanged(tracks);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ triggerChanged

void Kwave::RecordDialog::triggerChanged ( int trigger )

privateslot

record trigger has changed

Definition at line 1281 of file RecordDialog.cpp.

References m_params, and Kwave::RecordParams::record_trigger.

Referenced by RecordDialog().

 {
     m_params.record_trigger = trigger;
 }

Here is the caller graph for this function:

◆ triggerChecked

void Kwave::RecordDialog::triggerChecked ( bool enabled )

privateslot

record trigger has been enabled/disabled

Definition at line 1274 of file RecordDialog.cpp.

References m_params, Kwave::RecordParams::record_trigger_enabled, sigTriggerChanged(), and Kwave::RecordParams::start_time_enabled.

Referenced by RecordDialog().

 {
     m_params.record_trigger_enabled = enabled;
     emit sigTriggerChanged(enabled || m_params.start_time_enabled);
 }

Here is the caller graph for this function:

◆ updateBufferProgressBar

void Kwave::RecordDialog::updateBufferProgressBar ( )

privateslot

updates the buffer progress bar

Definition at line 1287 of file RecordDialog.cpp.

References m_buffer_progress_count, m_buffer_progress_timer, and m_buffer_progress_total.

Referenced by RecordDialog(), and updateBufferState().

 {
     unsigned int count = m_buffer_progress_count;
     unsigned int total = m_buffer_progress_total;
 //     qDebug("RecordDialog::updateBufferProgressBar(): %u/%u",
 //            count, total);
 
     /*
      * @note: QProgressBar has a bug when handling small numbers,
      *        therefore we multiply everything by 100
      */
     progress_bar->setTextVisible(true);
     progress_bar->setMinimum(0);
     progress_bar->setMaximum(100 * total);
     progress_bar->setValue(100 * count);
 
     m_buffer_progress_timer.setSingleShot(true);
     m_buffer_progress_timer.setInterval(100);
     m_buffer_progress_timer.start();
 }

Here is the caller graph for this function:

◆ updateBufferState()

void Kwave::RecordDialog::updateBufferState	(	unsigned int	count,
		unsigned int	total
	)

updates the progress bar with the buffer fill state.

Parameters

count	number of filled/available buffers
total	maximum amount of buffers

Definition at line 1133 of file RecordDialog.cpp.

References _, m_buffer_progress_count, m_buffer_progress_timer, m_buffer_progress_total, m_params, m_samples_recorded, m_state, m_status_bar, Kwave::ms2string(), Kwave::REC_BUFFERING, Kwave::REC_DONE, Kwave::REC_EMPTY, Kwave::REC_PAUSED, Kwave::REC_PRERECORDING, Kwave::REC_RECORDING, Kwave::REC_UNINITIALIZED, Kwave::REC_WAITING_FOR_TRIGGER, Kwave::RecordParams::sample_rate, Kwave::samples2string(), Kwave::RecordParams::start_time, Kwave::RecordParams::start_time_enabled, Kwave::toInt(), and updateBufferProgressBar().

Referenced by Kwave::RecordPlugin::stateChanged(), Kwave::RecordPlugin::updateBufferProgressBar(), and ~RecordDialog().

 {
     Q_ASSERT(progress_bar);
     Q_ASSERT(m_status_bar.m_state);
     if (!progress_bar || !m_status_bar.m_state) return;
 
     if (total == 0) {
         // we are done: stop update timer and reset buffer percentage
         m_buffer_progress_timer.stop();
         m_buffer_progress_count = 0;
         m_buffer_progress_total = 0;
         progress_bar->setTextVisible(false);
         progress_bar->setMinimum(0);
         progress_bar->setMaximum(100);
         progress_bar->setValue(0);
         progress_bar->reset();
     } else {
         m_buffer_progress_count = count;
         m_buffer_progress_total = total;
 
         if (!m_buffer_progress_timer.isActive())
             updateBufferProgressBar();
     }
 
     // update recording time
     QString txt;
     switch (m_state) {
         case Kwave::REC_UNINITIALIZED:
         case Kwave::REC_EMPTY:
         case Kwave::REC_BUFFERING:
         case Kwave::REC_PRERECORDING:
             txt = _("");
             break;
         case Kwave::REC_WAITING_FOR_TRIGGER: {
             txt = _("");
             QString state_text;
             QDateTime now     = QDateTime::currentDateTime();
             QDateTime t_start = m_params.start_time;
 
             if (m_params.start_time_enabled && (now < t_start)) {
                 // waiting for start time to come...
 
                 int s = Kwave::toInt(now.secsTo(t_start));
                 int m = s / 60;
                 s %= 60;
                 int h = m / 60;
                 m %= 60;
                 int d = h / 24;
                 h %= 24;
 
                 QString days    = (d) ?
                     i18np("one day ",    "%1 days ",    d) : _("");
                 QString hours   = (h) ?
                     i18np("one hour ",   "%1 hours ",   h) : _("");
                 QString minutes = (m) ?
                     i18np("one minute ", "%1 minutes ", m) : _("");
                 QString seconds =
                     (d | h | m) ?
                     i18np("and %1 second", "and %1 seconds", s) :
                     i18np("%1 second", "%1 seconds", s);
 
                 state_text = i18nc(
                     "%1=days; %2=hours; %3=minutes; %4=seconds",
                     "Waiting for start in %1%2%3%4...",
                     days, hours, minutes, seconds);
             } else {
                 // waiting for trigger...
                 state_text = i18n("Waiting for trigger...");
             }
             m_status_bar.m_state->setText(state_text);
 
             break;
         }
         case Kwave::REC_RECORDING:
         case Kwave::REC_PAUSED:
         case Kwave::REC_DONE: {
             if (m_samples_recorded > 1) {
                 double rate = m_params.sample_rate;
                 double ms = (rate > 0) ?
                     ((static_cast<double>(m_samples_recorded) / rate) * 1E3)
                     : 0;
                 txt = _(" ") +
                     i18n("Length: %1", Kwave::ms2string(ms)) +
                     _(" ") + i18n("(%1 samples)",
                     Kwave::samples2string(m_samples_recorded));
             } else txt = _("");
             break;
         }
     }
     m_status_bar.m_time->setText(txt);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ updateEffects()

void Kwave::RecordDialog::updateEffects	(	unsigned int	track,
		Kwave::SampleArray &	buffer
	)

updates all enabled visual effects

Parameters

track	index of the track that is updated
buffer	array with Kwave sample data

Definition at line 1309 of file RecordDialog.cpp.

References m_params, Kwave::RecordParams::sample_rate, Kwave::SampleArray::size(), and Kwave::RecordParams::tracks.

Referenced by Kwave::RecordPlugin::processBuffer().

 {
     if (!buffer.size()) return;
 
     if (level_meter) {
         level_meter->setTracks(m_params.tracks);
         level_meter->setSampleRate(m_params.sample_rate);
         level_meter->updateTrack(track, buffer);
     }
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ updateListSelection

void Kwave::RecordDialog::updateListSelection ( )

privateslot

updates/fixes the device selection when the tree view has lost focus, to avoid that nothing is selected

Definition at line 530 of file RecordDialog.cpp.

References Kwave::RecordParams::device_name, m_params, and setDevice().

Referenced by listItemExpanded(), and RecordDialog().

 {
     // set the current device again, otherwise nothing will be selected
     setDevice(m_params.device_name);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ updateRecordButton()

void Kwave::RecordDialog::updateRecordButton ( )

private

enabled or disables the record button by evaluating m_record_enabled and m_seconds_recording

Definition at line 1331 of file RecordDialog.cpp.

References m_params, m_record_enabled, m_samples_recorded, Kwave::RecordParams::record_time, Kwave::RecordParams::record_time_limited, and Kwave::RecordParams::sample_rate.

Referenced by recordTimeChanged(), setRecordedSamples(), and setState().

 {
     bool old_enable = btRecord->isEnabled();
     bool new_enable;
 
     // enabled if not disabled by status and also not limited or
     // less than the limit has been recorded
     new_enable = m_record_enabled && (!m_params.record_time_limited ||
         (m_samples_recorded < m_params.record_time * m_params.sample_rate));
 
     if (new_enable != old_enable) btRecord->setEnabled(new_enable);
 }

Here is the caller graph for this function:

Member Data Documentation

◆ m_bits_per_sample

QLabel* Kwave::RecordDialog::m_bits_per_sample

status bar id: number of tracks

Definition at line 355 of file RecordDialog.h.

◆ m_buffer_progress_count

unsigned int Kwave::RecordDialog::m_buffer_progress_count

private

accumulated current buffer progress

Definition at line 327 of file RecordDialog.h.

Referenced by updateBufferProgressBar(), and updateBufferState().

◆ m_buffer_progress_timer

QTimer Kwave::RecordDialog::m_buffer_progress_timer

private

timer for slowly updating the buffer progress bar

Definition at line 333 of file RecordDialog.h.

Referenced by RecordDialog(), updateBufferProgressBar(), and updateBufferState().

◆ m_buffer_progress_total

unsigned int Kwave::RecordDialog::m_buffer_progress_total

private

accumulated total buffer progress

Definition at line 330 of file RecordDialog.h.

Referenced by updateBufferProgressBar(), and updateBufferState().

◆ m_devices_list_map

QMap<QTreeWidgetItem *, QString> Kwave::RecordDialog::m_devices_list_map

private

map for items in the list view

Definition at line 315 of file RecordDialog.h.

Referenced by listEntrySelected(), setDevice(), and setSupportedDevices().

◆ m_enable_setDevice

bool Kwave::RecordDialog::m_enable_setDevice

private

if false, do nothing in setDevice

Definition at line 346 of file RecordDialog.h.

Referenced by selectRecordDevice(), and setSupportedDevices().

◆ m_file_filter

QString Kwave::RecordDialog::m_file_filter

private

file filter for the "Select..." dialog (optional)

Definition at line 312 of file RecordDialog.h.

Referenced by setFileFilter().

◆ m_methods_map

Kwave::RecordTypesMap Kwave::RecordDialog::m_methods_map

private

map of playback methods/types

Definition at line 309 of file RecordDialog.h.

Referenced by methodSelected(), RecordDialog(), and setMethod().

◆ m_params

Kwave::RecordParams Kwave::RecordDialog::m_params

private

◆ m_record_enabled

bool Kwave::RecordDialog::m_record_enabled

private

determines if recording is to be enabled by the current state

Definition at line 336 of file RecordDialog.h.

Referenced by setState(), and updateRecordButton().

◆ m_sample_rate

QLabel* Kwave::RecordDialog::m_sample_rate

status bar id: sample rate

Definition at line 354 of file RecordDialog.h.

◆ m_samples_recorded

sample_index_t Kwave::RecordDialog::m_samples_recorded

private

holds the recorded samples for comparing with the recording time limit, for determining if recording should be enabled or not. Also used in status bar for displaying the recorded time.

Definition at line 343 of file RecordDialog.h.

Referenced by setRecordedSamples(), updateBufferState(), and updateRecordButton().

◆ m_state [1/2]

Kwave::RecordState Kwave::RecordDialog::m_state

private

state of the record plugin

Definition at line 318 of file RecordDialog.h.

Referenced by setState(), and updateBufferState().

◆ m_state [2/2]

QLabel* Kwave::RecordDialog::m_state

status bar id: state text

Definition at line 352 of file RecordDialog.h.

◆ m_state_icon_widget

Kwave::StatusWidget* Kwave::RecordDialog::m_state_icon_widget

private

widget with a icon in the status bar

Definition at line 349 of file RecordDialog.h.

Referenced by RecordDialog(), and setState().

◆ m_status_bar

struct { ... } Kwave::RecordDialog::m_status_bar

Referenced by RecordDialog(), setBitsPerSample(), setSampleRate(), setState(), setTracks(), and updateBufferState().

◆ m_supported_resolutions

QList<unsigned int> Kwave::RecordDialog::m_supported_resolutions

private

a list with supported bits per sample

Definition at line 324 of file RecordDialog.h.

Referenced by bitsPerSampleChanged(), setBitsPerSample(), and setSupportedBits().

◆ m_time

QLabel* Kwave::RecordDialog::m_time

status bar id: recorded time

Definition at line 353 of file RecordDialog.h.

◆ m_tracks

QLabel* Kwave::RecordDialog::m_tracks

status bar id: number of tracks

Definition at line 356 of file RecordDialog.h.

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

plugins/record/RecordDialog.h
plugins/record/RecordDialog.cpp

Public Types

Public Slots

Signals

Public Member Functions

Private Slots

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ Mode

Constructor & Destructor Documentation

◆ RecordDialog()

◆ ~RecordDialog()

Member Function Documentation

◆ bitsPerSampleChanged

◆ compressionChanged

◆ invokeHelp

◆ listEntrySelected

◆ listItemExpanded

◆ message

◆ methodSelected

◆ params()

◆ preRecordingChecked

◆ preRecordingTimeChanged

◆ rate2string()

◆ recordTimeChanged

◆ recordTimeChecked

◆ sampleFormatChanged

◆ sampleRateChanged [1/2]

◆ sampleRateChanged [2/2]

◆ selectRecordDevice

◆ setBitsPerSample()

◆ setCompression()

◆ setDevice

◆ setFileFilter

◆ setMethod()

◆ setRecordedSamples

◆ setSampleFormat()

◆ setSampleRate()

◆ setState

◆ setSupportedBits()

◆ setSupportedCompressions()

◆ setSupportedDevices()

◆ setSupportedSampleFormats()

◆ setSupportedSampleRates()

◆ setSupportedTracks()

◆ setTracks()

◆ showDevicePage()

◆ sigBitsPerSampleChanged

◆ sigBuffersChanged

◆ sigCompressionChanged

◆ sigDeviceChanged

◆ sigMethodChanged

◆ sigPreRecordingChanged

◆ sigRecordTimeChanged

◆ sigSampleFormatChanged

◆ sigTracksChanged

◆ sigTriggerChanged

◆ sourceBufferCountChanged

◆ sourceBufferSizeChanged

◆ startTimeChanged

◆ startTimeChecked

◆ string2rate()

◆ tracksChanged

◆ triggerChanged

◆ triggerChecked

◆ updateBufferProgressBar

◆ updateBufferState()

◆ updateEffects()

◆ updateListSelection

◆ updateRecordButton()

Member Data Documentation

◆ m_bits_per_sample

◆ m_buffer_progress_count

◆ m_buffer_progress_timer

◆ m_buffer_progress_total

◆ m_devices_list_map

◆ m_enable_setDevice

◆ m_file_filter

◆ m_methods_map