mirror of
https://github.com/edeproject/ede.git
synced 2023-08-10 21:13:03 +03:00
65018f75b7
emenueditor
625 lines
22 KiB
C++
Executable File
625 lines
22 KiB
C++
Executable File
/*
|
|
* $Id$
|
|
*
|
|
* Volume control application
|
|
* Part of Equinox Desktop Environment (EDE).
|
|
* Copyright (c) 2000-2006 EDE Authors.
|
|
*
|
|
* This program is licenced under terms of the
|
|
* GNU General Public Licence version 2 or newer.
|
|
* See COPYING for details.
|
|
*/
|
|
|
|
|
|
// TODO:
|
|
// At the moment evolume is ALSA only - patches for OSS support
|
|
// are welcome
|
|
|
|
#include "prefs.h"
|
|
#include "evolume.h"
|
|
#include "../edeconf.h"
|
|
|
|
#include "../edelib2/about_dialog.h"
|
|
|
|
#include <fltk/events.h>
|
|
#include <fltk/run.h>
|
|
|
|
|
|
using namespace fltk;
|
|
using namespace edelib;
|
|
|
|
|
|
|
|
|
|
// Global variables
|
|
|
|
char device[1024]={0};
|
|
Window *main_window=0;
|
|
|
|
Config globalConfig("EDE Team", "evolume");
|
|
bool simplemode = true;
|
|
|
|
|
|
// Main ALSA device functions
|
|
|
|
void set_device(int mixer_fd, int device, Slider *device_sl, Slider *balance)
|
|
{
|
|
int l = (unsigned int) ((1.0-(balance->value()) ) * device_sl->value() );
|
|
int r = (unsigned int) ( (balance->value()) * device_sl->value());
|
|
int v = (r << 8) | l;
|
|
if (ioctl (mixer_fd, MIXER_WRITE (device), &v) < 0)
|
|
alert(_("Cannot setup device, sorry."));
|
|
}
|
|
|
|
void get_device_info(int mixer_dev, Slider *sl, Slider *bal,
|
|
CheckButton *ck, int device)
|
|
{
|
|
unsigned int devmask, recmask, recsrc, stereo;
|
|
volume real_volume;
|
|
|
|
real_volume.left = real_volume.right = 0;
|
|
devmask = recmask = recsrc = stereo = 0;
|
|
|
|
if (ioctl(mixer_dev, SOUND_MIXER_READ_DEVMASK, &devmask) == -1)
|
|
fprintf(stderr, "Read devmask failed.\n");
|
|
if (devmask & (1 << (device)))
|
|
sl->activate();
|
|
else
|
|
sl->deactivate();
|
|
|
|
if (ioctl(mixer_dev, SOUND_MIXER_READ_STEREODEVS, &stereo) == -1)
|
|
fprintf(stderr, "Read recsrc failed.\n");
|
|
if ( stereo & (1 << (device) ) ) bal->activate();
|
|
else ck->deactivate();
|
|
|
|
if (ioctl(mixer_dev, SOUND_MIXER_READ_RECMASK, &recmask) == -1)
|
|
fprintf(stderr, "Read recmask failed.\n");
|
|
if ( recmask & (1 << (device) ) ) ck->activate();
|
|
else ck->deactivate();
|
|
|
|
if (ioctl(mixer_dev, SOUND_MIXER_READ_RECSRC, &recsrc) == -1)
|
|
fprintf(stderr, "Read recsrc failed.\n");
|
|
if ( recsrc & (1 << (device) ) ) ck->set();
|
|
else ck->clear();
|
|
|
|
if ( ioctl(mixer_dev, MIXER_READ(device), &real_volume) < 0 ) {
|
|
fprintf(stderr, "Can't obtain current volume settings.\n");
|
|
}
|
|
|
|
float volume = real_volume.left + real_volume.right;
|
|
|
|
float balance = 0;
|
|
balance = ( (1.0 * (unsigned char)real_volume.right ) /
|
|
(1.0 * ((unsigned char)real_volume.left + (unsigned char)real_volume.right)) );
|
|
|
|
if (volume == 0)
|
|
volume=1;
|
|
if (balance < 0)
|
|
balance=0.5;
|
|
sl->value(volume);
|
|
bal->value(balance);
|
|
}
|
|
|
|
void set_mute(int mixer_fd, int device, Slider *device_sl, Slider *balance, CheckButton *check_button)
|
|
{
|
|
int vol = 0;
|
|
|
|
if ( check_button->value() )
|
|
{
|
|
if (ioctl(mixer_fd, MIXER_WRITE(device), &vol) < 0 )
|
|
fprintf(stderr, "Cannot set mute.\n");
|
|
}
|
|
else {
|
|
volume real_volume;
|
|
double old_volume = device_sl->value();
|
|
double old_balance = balance->value();
|
|
real_volume.left = (unsigned char) ( (1.0 - (old_balance)) * old_volume );
|
|
real_volume.right = (unsigned char) ( (old_balance) * old_volume);
|
|
if ( ioctl(mixer_fd, MIXER_WRITE(device), &real_volume) < 0 )
|
|
{
|
|
fprintf(stderr, "Cannot setup volume, sorry.\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
void set_rec(int mixer_fd, int device, CheckButton *ck)
|
|
{
|
|
unsigned int recsrc;
|
|
|
|
if (ioctl(mixer_fd, SOUND_MIXER_READ_RECSRC, &recsrc) == -1)
|
|
printf("read recsrc failed\n");
|
|
unsigned int new_recsrc = recsrc ^ ( 1 << device );
|
|
|
|
if (ioctl(mixer_fd, SOUND_MIXER_WRITE_RECSRC, &new_recsrc) == -1)
|
|
printf("oh no\n");
|
|
}
|
|
|
|
void update_info()
|
|
{
|
|
mixer_info minfo;
|
|
|
|
if (ioctl(mixer_device, SOUND_MIXER_INFO, &minfo) < 0)
|
|
fprintf(stderr, "Read device info failed.\n");
|
|
else
|
|
{
|
|
char *title = (char*)malloc(strlen(_("Volume control: [%s]"))+strlen(minfo.name));
|
|
sprintf(title,_("Volume control: [%s]"), minfo.name);
|
|
main_window->label(title);
|
|
}
|
|
}
|
|
|
|
|
|
// These functions set parameters for default look of sliders
|
|
|
|
void default_look(Slider* slider)
|
|
{
|
|
slider->type(Slider::TICK_BOTH);
|
|
slider->set_vertical();
|
|
slider->minimum(-100);
|
|
slider->maximum(100);
|
|
slider->value(1);
|
|
slider->step(1);
|
|
slider->align(ALIGN_TOP);
|
|
}
|
|
|
|
void default_look_b(Slider* balance_slider)
|
|
{
|
|
balance_slider->type(1);
|
|
balance_slider->minimum(0.00);
|
|
balance_slider->maximum(1.00);
|
|
balance_slider->step(0.01);
|
|
balance_slider->value(0.01);
|
|
}
|
|
|
|
|
|
// Functions for various control groups - this is mostly copy-paste
|
|
|
|
void cb_volume(Slider* o, void *i)
|
|
{
|
|
int x = (int) i;
|
|
if (x == 1) set_device(mixer_device, SOUND_MIXER_VOLUME, volume_slider, volume_balance);
|
|
if (x == 2) set_device(mixer_device, SOUND_MIXER_VOLUME, volume_slider, volume_balance);
|
|
if (x == 3) set_mute(mixer_device, SOUND_MIXER_VOLUME, volume_slider, volume_balance, volume_mute);
|
|
if (x == 4) set_rec(mixer_device, SOUND_MIXER_VOLUME, volume_rec);
|
|
}
|
|
|
|
void cb_cd(Slider* o, void *i) {
|
|
int x = (int) i;
|
|
if (x == 1) set_device(mixer_device, SOUND_MIXER_CD, cd_slider, cd_balance);
|
|
if (x == 2) set_device(mixer_device, SOUND_MIXER_CD, cd_slider, cd_balance);
|
|
if (x == 3) set_mute(mixer_device, SOUND_MIXER_CD, cd_slider, cd_balance, cd_mute);
|
|
if (x == 4) set_rec(mixer_device, SOUND_MIXER_CD, cd_rec);
|
|
}
|
|
|
|
void cb_pcm(Slider* o, void *i)
|
|
{
|
|
int x = (int) i;
|
|
if (x == 1) set_device(mixer_device, SOUND_MIXER_PCM, pcm_slider, pcm_balance);
|
|
if (x == 2) set_device(mixer_device, SOUND_MIXER_PCM, pcm_slider, pcm_balance);
|
|
if (x == 3) set_mute(mixer_device, SOUND_MIXER_PCM, pcm_slider, pcm_balance, pcm_mute);
|
|
if (x == 4) set_rec(mixer_device, SOUND_MIXER_PCM, pcm_rec);
|
|
}
|
|
|
|
void cb_synth(Slider* o, void *i)
|
|
{
|
|
int x = (int) i;
|
|
if (x == 1) set_device(mixer_device, SOUND_MIXER_SYNTH, synth_slider, synth_balance);
|
|
if (x == 2) set_device(mixer_device, SOUND_MIXER_SYNTH, synth_slider, synth_balance);
|
|
if (x == 3) set_mute(mixer_device, SOUND_MIXER_SYNTH, synth_slider, synth_balance, synth_mute);
|
|
if (x == 4) set_rec(mixer_device, SOUND_MIXER_SYNTH, synth_rec);
|
|
}
|
|
|
|
void cb_line(Slider* o, void *i)
|
|
{
|
|
int x = (int) i;
|
|
if (x == 1) set_device(mixer_device, SOUND_MIXER_LINE, line_slider, line_balance);
|
|
if (x == 2) set_device(mixer_device, SOUND_MIXER_LINE, line_slider, line_balance);
|
|
if (x == 3) set_mute(mixer_device, SOUND_MIXER_LINE, line_slider, line_balance, line_mute);
|
|
if (x == 4) set_rec(mixer_device, SOUND_MIXER_LINE, line_rec);
|
|
}
|
|
|
|
void cb_bass(Slider* o, void *i)
|
|
{
|
|
int x = (int) i;
|
|
if (x == 1) set_device(mixer_device, SOUND_MIXER_BASS, bass_slider, bass_balance);
|
|
if (x == 2) set_device(mixer_device, SOUND_MIXER_BASS, bass_slider, bass_balance);
|
|
if (x == 3) set_mute(mixer_device, SOUND_MIXER_BASS, bass_slider, bass_balance, bass_mute);
|
|
if (x == 4) set_rec(mixer_device, SOUND_MIXER_BASS, bass_rec);
|
|
}
|
|
|
|
void cb_treble(Slider* o, void *i)
|
|
{
|
|
int x = (int) i;
|
|
if (x == 1) set_device(mixer_device, SOUND_MIXER_TREBLE, treble_slider, treble_balance);
|
|
if (x == 2) set_device(mixer_device, SOUND_MIXER_TREBLE, treble_slider, treble_balance);
|
|
if (x == 3) set_mute(mixer_device, SOUND_MIXER_TREBLE, treble_slider, treble_balance, treble_mute);
|
|
if (x == 4) set_rec(mixer_device, SOUND_MIXER_TREBLE, treble_rec);
|
|
}
|
|
|
|
void cb_mic(Slider* o, void *i)
|
|
{
|
|
int x = (int) i;
|
|
if (x == 1) set_device(mixer_device, SOUND_MIXER_MIC, mic_slider, mic_balance);
|
|
if (x == 2) set_device(mixer_device, SOUND_MIXER_MIC, mic_slider, mic_balance);
|
|
if (x == 3) set_mute(mixer_device, SOUND_MIXER_MIC, mic_slider, mic_balance, mic_mute);
|
|
if (x == 4) set_rec(mixer_device, SOUND_MIXER_MIC, mic_rec);
|
|
}
|
|
|
|
void cb_speaker(Slider* o, void *i)
|
|
{
|
|
int x = (int) i;
|
|
if (x == 1) set_device(mixer_device, SOUND_MIXER_SPEAKER, speaker_slider, speaker_balance);
|
|
if (x == 2) set_device(mixer_device, SOUND_MIXER_SPEAKER, speaker_slider, speaker_balance);
|
|
if (x == 3) set_mute(mixer_device, SOUND_MIXER_SPEAKER, speaker_slider, speaker_balance, speaker_mute);
|
|
if (x == 4) set_rec(mixer_device, SOUND_MIXER_SPEAKER, speaker_rec);
|
|
}
|
|
|
|
void cb_imix(Slider* o, void *i)
|
|
{
|
|
int x = (int) i;
|
|
if (x == 1) set_device(mixer_device, SOUND_MIXER_IMIX, imix_slider, imix_balance);
|
|
if (x == 2) set_device(mixer_device, SOUND_MIXER_IMIX, imix_slider, imix_balance);
|
|
if (x == 3) set_mute(mixer_device, SOUND_MIXER_IMIX, imix_slider, imix_balance, imix_mute);
|
|
if (x == 4) set_rec(mixer_device, SOUND_MIXER_IMIX, imix_rec);
|
|
}
|
|
|
|
void cb_igain(Slider* o, void *i)
|
|
{
|
|
int x = (int) i;
|
|
if (x == 1) set_device(mixer_device, SOUND_MIXER_IGAIN, igain_slider, igain_balance);
|
|
if (x == 2) set_device(mixer_device, SOUND_MIXER_IGAIN, igain_slider, igain_balance);
|
|
if (x == 3) set_mute(mixer_device, SOUND_MIXER_IGAIN, igain_slider, igain_balance, igain_mute);
|
|
if (x == 4) set_rec(mixer_device, SOUND_MIXER_IGAIN, igain_rec);
|
|
}
|
|
|
|
void cb_ogain(Slider* o, void *i)
|
|
{
|
|
int x = (int) i;
|
|
if (x == 1) set_device(mixer_device, SOUND_MIXER_OGAIN, ogain_slider, ogain_balance);
|
|
if (x == 2) set_device(mixer_device, SOUND_MIXER_OGAIN, ogain_slider, ogain_balance);
|
|
if (x == 3) set_mute(mixer_device, SOUND_MIXER_OGAIN, ogain_slider, ogain_balance, ogain_mute);
|
|
if (x == 4) set_rec(mixer_device, SOUND_MIXER_OGAIN, ogain_rec);
|
|
}
|
|
|
|
|
|
// Menu callback functions
|
|
|
|
void cb_Quit(Widget*, void*)
|
|
{
|
|
main_window->hide();
|
|
}
|
|
|
|
static void cb_About(Item*, void*) {
|
|
about_dialog("Volume Control","1.0","");
|
|
}
|
|
|
|
void cb_SimpleMode(Widget*, void*) {
|
|
if (!simplemode) {
|
|
simplemode = true;
|
|
synth_slider->hide();
|
|
synth_balance->hide();
|
|
synth_mute->hide();
|
|
synth_rec->hide();
|
|
bass_slider->hide();
|
|
bass_balance->hide();
|
|
bass_mute->hide();
|
|
bass_rec->hide();
|
|
treble_slider->hide();
|
|
treble_balance->hide();
|
|
treble_mute->hide();
|
|
treble_rec->hide();
|
|
mic_slider->hide();
|
|
mic_balance->hide();
|
|
mic_mute->hide();
|
|
mic_rec->hide();
|
|
speaker_slider->hide();
|
|
speaker_balance->hide();
|
|
speaker_mute->hide();
|
|
speaker_rec->hide();
|
|
imix_slider->hide();
|
|
imix_balance->hide();
|
|
imix_mute->hide();
|
|
imix_rec->hide();
|
|
igain_slider->hide();
|
|
igain_balance->hide();
|
|
igain_mute->hide();
|
|
igain_rec->hide();
|
|
ogain_slider->hide();
|
|
ogain_balance->hide();
|
|
ogain_mute->hide();
|
|
ogain_rec->hide();
|
|
main_window->resize(250,205);
|
|
} else {
|
|
simplemode = false;
|
|
synth_slider->show();
|
|
synth_balance->show();
|
|
synth_mute->show();
|
|
synth_rec->show();
|
|
bass_slider->show();
|
|
bass_balance->show();
|
|
bass_mute->show();
|
|
bass_rec->show();
|
|
treble_slider->show();
|
|
treble_balance->show();
|
|
treble_mute->show();
|
|
treble_rec->show();
|
|
mic_slider->show();
|
|
mic_balance->show();
|
|
mic_mute->show();
|
|
mic_rec->show();
|
|
speaker_slider->show();
|
|
speaker_balance->show();
|
|
speaker_mute->show();
|
|
speaker_rec->show();
|
|
imix_slider->show();
|
|
imix_balance->show();
|
|
imix_mute->show();
|
|
imix_rec->show();
|
|
igain_slider->show();
|
|
igain_balance->show();
|
|
igain_mute->show();
|
|
igain_rec->show();
|
|
ogain_slider->show();
|
|
ogain_balance->show();
|
|
ogain_mute->show();
|
|
ogain_rec->show();
|
|
main_window->resize(720,205);
|
|
}
|
|
globalConfig.set("Sound mixer", "Simplemode", simplemode);
|
|
}
|
|
|
|
|
|
// Main window design
|
|
|
|
int main (int argc, char **argv)
|
|
{
|
|
// fl_init_locale_support("evolume", PREFIX"/share/locale");
|
|
|
|
globalConfig.get("Sound mixer", "Device", device, "/dev/mixer", sizeof(device));
|
|
globalConfig.get("Sound mixer", "Simplemode", simplemode, true);
|
|
|
|
main_window = new Window(720, 205, _("Volume control"));
|
|
if (simplemode) main_window->resize(250,205);
|
|
main_window->begin();
|
|
|
|
MenuBar *vc_menubar = new MenuBar(0, 0, 724, 25);
|
|
vc_menubar->begin();
|
|
|
|
ItemGroup file(_("&File"));
|
|
file.begin();
|
|
Item* pref_item = new Item(_("Preferences"));
|
|
pref_item->shortcut(CTRL+'p');
|
|
pref_item->callback(PreferencesDialog);
|
|
|
|
Item* quit_item = new Item(_("Quit"));
|
|
quit_item->shortcut(CTRL+'q');
|
|
quit_item->callback(cb_Quit);
|
|
|
|
file.end();
|
|
|
|
ItemGroup view(_("&View"));
|
|
view.begin();
|
|
Item* mode_item = new Item(_("Simple mode"));
|
|
mode_item->shortcut(CTRL+'s');
|
|
mode_item->type(Item::TOGGLE);
|
|
mode_item->callback(cb_SimpleMode);
|
|
if (simplemode) mode_item->set();
|
|
view.end();
|
|
|
|
ItemGroup help(_("&Help"));
|
|
help.begin();
|
|
Item* about_item = new Item(_("About"));
|
|
about_item->shortcut(CTRL+'a');
|
|
about_item->callback((Callback*)cb_About);
|
|
help.end();
|
|
vc_menubar->end();
|
|
|
|
{Divider* o = new Divider();
|
|
o->resize(0, 24, 724, 3);
|
|
}
|
|
|
|
volume_slider = new Slider(20, 50, 20, 80, "VOL");
|
|
default_look(volume_slider);
|
|
volume_balance = new Slider(10, 135, 40, 15, "Balance");
|
|
default_look_b(volume_balance);
|
|
volume_mute = new CheckButton(5, 165, 20, 20, "Mute");
|
|
volume_mute->align(ALIGN_BOTTOM);
|
|
volume_rec = new CheckButton(35, 165, 20, 20, "Rec");
|
|
volume_rec->align(ALIGN_BOTTOM);
|
|
|
|
cd_slider = new Slider(80, 50, 20, 80, "CD");
|
|
default_look(cd_slider);
|
|
cd_balance = new Slider(70, 135, 40, 15, "Balance");
|
|
default_look_b(cd_balance);
|
|
cd_mute = new CheckButton(65, 165, 20, 20, "Mute");
|
|
cd_mute->align(ALIGN_BOTTOM);
|
|
cd_rec = new CheckButton(95, 165, 20, 20, "Rec");
|
|
cd_rec->align(ALIGN_BOTTOM);
|
|
|
|
pcm_slider = new Slider(140, 50, 20, 80, "PCM");
|
|
default_look(pcm_slider);
|
|
pcm_balance = new Slider(130, 135, 40, 15, "Balance");
|
|
default_look_b(pcm_balance);
|
|
pcm_mute = new CheckButton(125, 165, 20, 20, "Mute");
|
|
pcm_mute->align(ALIGN_BOTTOM);
|
|
pcm_rec = new CheckButton(155, 165, 20, 20, "Rec");
|
|
pcm_rec->align(ALIGN_BOTTOM);
|
|
|
|
line_slider = new Slider(200, 50, 20, 80, "LINE");
|
|
default_look(line_slider);
|
|
line_balance = new Slider(190, 135, 40, 15, "Balance");
|
|
default_look_b(line_balance);
|
|
line_mute = new CheckButton(185, 165, 20, 20, "Mute");
|
|
line_mute->align(ALIGN_BOTTOM);
|
|
line_rec = new CheckButton(215, 165, 20, 20, "Rec");
|
|
line_rec->align(ALIGN_BOTTOM);
|
|
|
|
synth_slider = new Slider(260, 50, 20, 80, "SYNTH");
|
|
default_look(synth_slider);
|
|
synth_balance = new Slider(250, 135, 40, 15, "Balance");
|
|
default_look_b(synth_balance);
|
|
synth_mute = new CheckButton(245, 165, 20, 20, "Mute");
|
|
synth_mute->align(ALIGN_BOTTOM);
|
|
synth_rec = new CheckButton(275, 165, 20, 20, "Rec");
|
|
synth_rec->align(ALIGN_BOTTOM);
|
|
|
|
bass_slider = new Slider(320, 50, 20, 80, "BASS");
|
|
default_look(bass_slider);
|
|
bass_balance = new Slider(310, 135, 40, 15, "Balance");
|
|
default_look_b(bass_balance);
|
|
bass_mute = new CheckButton(305, 165, 20, 20, "Mute");
|
|
bass_mute->align(ALIGN_BOTTOM);
|
|
bass_rec = new CheckButton(335, 165, 20, 20, "Rec");
|
|
bass_rec->align(ALIGN_BOTTOM);
|
|
|
|
treble_slider = new Slider(380, 50, 20, 80, "TREBLE");
|
|
default_look(treble_slider);
|
|
treble_balance = new Slider(370, 135, 40, 15, "Balance");
|
|
default_look_b(treble_balance);
|
|
treble_mute = new CheckButton(365, 165, 20, 20, "Mute");
|
|
treble_mute->align(ALIGN_BOTTOM);
|
|
treble_rec = new CheckButton(395, 165, 20, 20, "Rec");
|
|
treble_rec->align(ALIGN_BOTTOM);
|
|
|
|
mic_slider = new Slider(440, 50, 20, 80, "MIC");
|
|
default_look(mic_slider);
|
|
mic_balance = new Slider(430, 135, 40, 15, "Balance");
|
|
default_look_b(mic_balance);
|
|
mic_mute = new CheckButton(425, 165, 20, 20, "Mute");
|
|
mic_mute->align(ALIGN_BOTTOM);
|
|
mic_rec = new CheckButton(455, 165, 20, 20, "Rec");
|
|
mic_rec->align(ALIGN_BOTTOM);
|
|
|
|
speaker_slider = new Slider(500, 50, 20, 80, "SPK");
|
|
default_look(speaker_slider);
|
|
speaker_balance = new Slider(490, 135, 40, 15, "Balance");
|
|
default_look_b(speaker_balance);
|
|
speaker_mute = new CheckButton(485, 165, 20, 20, "Mute");
|
|
speaker_mute->align(ALIGN_BOTTOM);
|
|
speaker_rec = new CheckButton(515, 165, 20, 20, "Rec");
|
|
speaker_rec->align(ALIGN_BOTTOM);
|
|
|
|
imix_slider = new Slider(560, 50, 20, 80, "IMIX");
|
|
default_look(imix_slider);
|
|
imix_balance = new Slider(550, 135, 40, 15, "Balance");
|
|
default_look_b(imix_balance);
|
|
imix_mute = new CheckButton(545, 165, 20, 20, "Mute");
|
|
imix_mute->align(ALIGN_BOTTOM);
|
|
imix_rec = new CheckButton(575, 165, 20, 20, "Rec");
|
|
imix_rec->align(ALIGN_BOTTOM);
|
|
|
|
igain_slider = new Slider(620, 50, 20, 80, "IGAIN");
|
|
default_look(igain_slider);
|
|
igain_balance = new Slider(610, 135, 40, 15, "Balance");
|
|
default_look_b(igain_balance);
|
|
igain_mute = new CheckButton(605, 165, 20, 20, "Mute");
|
|
igain_mute->align(ALIGN_BOTTOM);
|
|
igain_rec = new CheckButton(635, 165, 20, 20, "Rec");
|
|
igain_rec->align(ALIGN_BOTTOM);
|
|
|
|
ogain_slider = new Slider(680, 50, 20, 80, "OGAIN");
|
|
default_look(ogain_slider);
|
|
ogain_balance = new Slider(670, 135, 40, 15, "Balance");
|
|
default_look_b(ogain_balance);
|
|
ogain_mute = new CheckButton(665, 165, 20, 20, "Mute");
|
|
ogain_mute->align(ALIGN_BOTTOM);
|
|
ogain_rec = new CheckButton(695, 165, 20, 20, "Rec");
|
|
ogain_rec->align(ALIGN_BOTTOM);
|
|
|
|
mixer_device = open(device, O_RDWR);
|
|
|
|
if (mixer_device == -1)
|
|
{
|
|
alert(_("Opening mixer device %s failed. Setup correct device in configuration dialog."), device);
|
|
volume_slider->deactivate(); cd_slider->deactivate();
|
|
pcm_slider->deactivate(); synth_slider->deactivate();
|
|
line_slider->deactivate(); bass_slider->deactivate();
|
|
treble_slider->deactivate(); mic_slider->deactivate();
|
|
speaker_slider->deactivate(); imix_slider->deactivate();
|
|
igain_slider->deactivate(); ogain_slider->deactivate();
|
|
}
|
|
|
|
update_info();
|
|
|
|
volume_slider->callback( (Callback*) cb_volume, (void*) 1 );
|
|
volume_balance->callback( (Callback*) cb_volume,(void *) 2 );
|
|
volume_mute->callback( (Callback*) cb_volume,(void *) 3 );
|
|
volume_rec->callback( (Callback*) cb_volume,(void *) 4 );
|
|
get_device_info(mixer_device, volume_slider, volume_balance, volume_rec, SOUND_MIXER_VOLUME);
|
|
|
|
cd_slider->callback( (Callback*) cb_cd, (void *) 1 );
|
|
cd_balance->callback( (Callback*) cb_cd,(void *) 2 );
|
|
cd_mute->callback( (Callback*) cb_cd,(void *) 3 );
|
|
cd_rec->callback( (Callback*) cb_cd,(void *) 4 );
|
|
get_device_info(mixer_device, cd_slider, cd_balance, cd_rec, SOUND_MIXER_CD);
|
|
|
|
pcm_slider->callback( (Callback*) cb_pcm, (void *) 1 );
|
|
pcm_balance->callback( (Callback*) cb_pcm,(void *) 2 );
|
|
pcm_mute->callback( (Callback*) cb_pcm,(void *) 3 );
|
|
pcm_rec->callback( (Callback*) cb_pcm,(void *) 4 );
|
|
get_device_info(mixer_device, pcm_slider, pcm_balance, pcm_rec, SOUND_MIXER_PCM);
|
|
|
|
synth_slider->callback( (Callback*) cb_synth, (void *) 1 );
|
|
synth_balance->callback( (Callback*) cb_synth,(void *) 2 );
|
|
synth_mute->callback( (Callback*) cb_synth,(void *) 3 );
|
|
synth_rec->callback( (Callback*) cb_synth,(void *) 4 );
|
|
get_device_info(mixer_device, synth_slider, synth_balance, synth_rec, SOUND_MIXER_SYNTH);
|
|
|
|
line_slider->callback( (Callback*) cb_line, (void *) 1 );
|
|
line_balance->callback( (Callback*) cb_line,(void *) 2 );
|
|
line_mute->callback( (Callback*) cb_line,(void *) 3 );
|
|
line_rec->callback( (Callback*) cb_line,(void *) 4 );
|
|
get_device_info(mixer_device, line_slider, line_balance, line_rec, SOUND_MIXER_LINE);
|
|
|
|
bass_slider->callback( (Callback*) cb_bass, (void *) 1 );
|
|
bass_balance->callback( (Callback*) cb_bass,(void *) 2 );
|
|
bass_mute->callback( (Callback*) cb_bass,(void *) 3 );
|
|
bass_rec->callback( (Callback*) cb_bass,(void *) 4 );
|
|
get_device_info(mixer_device, bass_slider, bass_balance, bass_rec, SOUND_MIXER_BASS);
|
|
|
|
treble_slider->callback( (Callback*) cb_treble, (void *) 1 );
|
|
treble_balance->callback( (Callback*) cb_treble,(void *) 2 );
|
|
treble_mute->callback( (Callback*) cb_treble,(void *) 3 );
|
|
treble_rec->callback( (Callback*) cb_treble,(void *) 4 );
|
|
get_device_info(mixer_device, treble_slider, treble_balance, treble_rec, SOUND_MIXER_TREBLE);
|
|
|
|
mic_slider->callback( (Callback*) cb_mic, (void *) 1 );
|
|
mic_balance->callback( (Callback*) cb_mic,(void *) 2 );
|
|
mic_mute->callback( (Callback*) cb_mic,(void *) 3 );
|
|
mic_rec->callback( (Callback*) cb_mic,(void *) 4 );
|
|
get_device_info(mixer_device, mic_slider, mic_balance, mic_rec, SOUND_MIXER_MIC);
|
|
|
|
speaker_slider->callback( (Callback*) cb_speaker, (void *) 1 );
|
|
speaker_balance->callback( (Callback*) cb_speaker,(void *) 2 );
|
|
speaker_mute->callback( (Callback*) cb_speaker,(void *) 3 );
|
|
speaker_rec->callback( (Callback*) cb_speaker,(void *) 4 );
|
|
get_device_info(mixer_device, speaker_slider, speaker_balance, speaker_rec, SOUND_MIXER_SPEAKER);
|
|
|
|
imix_slider->callback( (Callback*) cb_imix, (void *) 1 );
|
|
imix_balance->callback( (Callback*) cb_imix,(void *) 2 );
|
|
imix_mute->callback( (Callback*) cb_imix,(void *) 3 );
|
|
imix_rec->callback( (Callback*) cb_imix,(void *) 4 );
|
|
get_device_info(mixer_device, imix_slider, imix_balance, imix_rec, SOUND_MIXER_IMIX);
|
|
|
|
igain_slider->callback( (Callback*) cb_igain, (void *) 1 );
|
|
igain_balance->callback( (Callback*) cb_igain,(void *) 2 );
|
|
igain_mute->callback( (Callback*) cb_igain,(void *) 3 );
|
|
igain_rec->callback( (Callback*) cb_igain,(void *) 4 );
|
|
get_device_info(mixer_device, igain_slider, igain_balance, igain_rec, SOUND_MIXER_IGAIN);
|
|
|
|
ogain_slider->callback( (Callback*) cb_ogain, (void *) 1 );
|
|
ogain_balance->callback( (Callback*) cb_ogain,(void *) 2 );
|
|
ogain_mute->callback( (Callback*) cb_ogain,(void *) 3 );
|
|
ogain_rec->callback( (Callback*) cb_ogain,(void *) 4 );
|
|
get_device_info(mixer_device, ogain_slider, ogain_balance, ogain_rec, SOUND_MIXER_OGAIN);
|
|
|
|
main_window->end();
|
|
main_window->show(argc, argv);
|
|
|
|
simplemode = !simplemode; // cb_SimpleMode inverts meaning
|
|
cb_SimpleMode(0,0);
|
|
|
|
return run();
|
|
}
|
|
|