mirror/ede
1
0
Fork 0
mirror of https://github.com/edeproject/ede.git synced 2023-08-10 21:13:03 +03:00
Code Issues Projects Releases Wiki Activity
53f9fdadaa
ede/evolume/evolume.cpp
Sanel Zukan fcf808bd82 Now did a real chmod -x.
2007-03-15 01:06:18 +00:00

625 lines
22 KiB
C++
Raw Blame History

/*
* $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();
}
Reference in New Issue View Git Blame Copy Permalink