← Back to branch summary

~ubuntu-branches/ubuntu/saucy/sflphone/saucy

« back to all changes in this revision

Viewing changes to sflphone-client-gnome/src/config/audioconf.c

  • Committer: Bazaar Package Importer
  • Author(s): Francois Marier
  • Date: 2010-12-24 16:33:55 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20101224163355-tkvvikqxbrbav6up
Tags: 0.9.11-1
* New upstream release
* Add new build dependencies on libwebkit-dev and libyaml-dev

* Bump Standards-Version up to 3.9.1
* Bump debhelper compatibility to 8
* Patch another typo in the upstream code (lintian notice)

Show diffs side-by-side

added added

removed removed

Lines of Context:
sflphone-client-gnome/src/config/audioconf.c
28
28
 *  as that of the covered work.
29
29
 */
30
30
 
 
31
 
31
32
#include <audioconf.h>
32
33
#include <utils.h>
33
34
#include <string.h>
 
35
#include <eel-gconf-extensions.h>
 
36
#include "dbus/dbus.h"
34
37
 
35
38
GtkListStore *pluginlist;
36
39
GtkListStore *outputlist;
37
40
GtkListStore *inputlist;
 
41
GtkListStore *ringtonelist;
38
42
 
39
43
GtkWidget *output;
40
44
GtkWidget *input;
 
45
GtkWidget *ringtone;
41
46
GtkWidget *plugin;
42
47
GtkWidget *codecMoveUpButton;
43
48
GtkWidget *codecMoveDownButton;
45
50
GtkWidget *pulse;
46
51
GtkWidget *alsabox;
47
52
GtkWidget *alsa_conf;
 
53
GtkWidget *noisebox;
48
54
GtkWidget *noise_conf;
49
55
 
50
56
// Codec properties ID
51
57
enum {
52
 
        COLUMN_CODEC_ACTIVE,
53
 
        COLUMN_CODEC_NAME,
54
 
        COLUMN_CODEC_FREQUENCY,
55
 
        COLUMN_CODEC_BITRATE,
56
 
        COLUMN_CODEC_BANDWIDTH,
57
 
        CODEC_COLUMN_COUNT
 
58
    COLUMN_CODEC_ACTIVE,
 
59
    COLUMN_CODEC_NAME,
 
60
    COLUMN_CODEC_FREQUENCY,
 
61
    COLUMN_CODEC_BITRATE,
 
62
    COLUMN_CODEC_BANDWIDTH,
 
63
    CODEC_COLUMN_COUNT
58
64
};
59
65
 
60
66
/**
61
67
 * Fills the tree list with supported codecs
62
68
 */
63
 
void preferences_dialog_fill_codec_list (account_t **a) {
64
 
 
65
 
        GtkListStore *codecStore;
66
 
        GtkTreeIter iter;
67
 
        GQueue *current;
68
 
 
69
 
        // Get model of view and clear it
70
 
        codecStore = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (codecTreeView)));
71
 
        gtk_list_store_clear (codecStore);
72
 
 
73
 
        if ((*a) != NULL) {
74
 
                current = (*a)->codecs;
75
 
        }
76
 
        else {
77
 
                // Failover
78
 
                current = get_system_codec_list ();
79
 
        }
80
 
 
81
 
 
82
 
        // Insert codecs
83
 
        unsigned int i;
84
 
        for(i = 0; i < current->length; i++)
85
 
        {
86
 
                codec_t *c = codec_list_get_nth (i, current);
87
 
                if (c)
88
 
                {
89
 
                        DEBUG ("%s", c->name);
90
 
                        gtk_list_store_append (codecStore, &iter);
91
 
                        gtk_list_store_set (codecStore, &iter,
92
 
                                        COLUMN_CODEC_ACTIVE,    c->is_active,                                                                   // Active
93
 
                                        COLUMN_CODEC_NAME,              c->name,                                                                                // Name
94
 
                                        COLUMN_CODEC_FREQUENCY, g_strdup_printf("%d kHz", c->sample_rate/1000), // Frequency (kHz)
95
 
                                        COLUMN_CODEC_BITRATE,   g_strdup_printf("%.1f kbps", c->_bitrate),              // Bitrate (kbps)
96
 
                                        COLUMN_CODEC_BANDWIDTH, g_strdup_printf("%.1f kbps", c->_bandwidth),    // Bandwidth (kpbs)
97
 
                                        -1);
98
 
                }
99
 
        }
 
69
void preferences_dialog_fill_codec_list (account_t **a)
 
70
{
 
71
 
 
72
    GtkListStore *codecStore;
 
73
    GtkTreeIter iter;
 
74
    GQueue *current;
 
75
 
 
76
    // Get model of view and clear it
 
77
    codecStore = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (codecTreeView)));
 
78
    gtk_list_store_clear (codecStore);
 
79
 
 
80
    if ( (*a) != NULL) {
 
81
        current = (*a)->codecs;
 
82
    } else {
 
83
        // Failover
 
84
        current = get_system_codec_list ();
 
85
    }
 
86
 
 
87
 
 
88
    // Insert codecs
 
89
    unsigned int i;
 
90
 
 
91
    for (i = 0; i < current->length; i++) {
 
92
        codec_t *c = codec_list_get_nth (i, current);
 
93
 
 
94
        if (c) {
 
95
            DEBUG ("%s", c->name);
 
96
            gtk_list_store_append (codecStore, &iter);
 
97
            gtk_list_store_set (codecStore, &iter,
 
98
                                COLUMN_CODEC_ACTIVE,    c->is_active,                                                                   // Active
 
99
                                COLUMN_CODEC_NAME,              c->name,                                                                                // Name
 
100
                                COLUMN_CODEC_FREQUENCY, g_strdup_printf ("%d kHz", c->sample_rate/1000),        // Frequency (kHz)
 
101
                                COLUMN_CODEC_BITRATE,   g_strdup_printf ("%.1f kbps", c->_bitrate),             // Bitrate (kbps)
 
102
                                COLUMN_CODEC_BANDWIDTH, g_strdup_printf ("%.1f kbps", c->_bandwidth),   // Bandwidth (kpbs)
 
103
                                -1);
 
104
        }
 
105
    }
100
106
}
101
107
 
102
108
/**
103
109
 * Fill store with output audio plugins
104
110
 */
105
 
        void
106
 
preferences_dialog_fill_output_audio_plugin_list()
 
111
void
 
112
preferences_dialog_fill_audio_plugin_list()
107
113
{
108
 
        GtkTreeIter iter;
109
 
        gchar** list;
110
 
        gchar* managerName;
111
 
 
112
 
        gtk_list_store_clear(pluginlist);
113
 
 
114
 
        // Call dbus to retreive list
115
 
        list = dbus_get_output_audio_plugin_list();
116
 
        // For each API name included in list
117
 
        int c = 0;
118
 
 
119
 
        if (list != NULL){
120
 
                for(managerName = list[c]; managerName != NULL; managerName = list[c])
121
 
                {
122
 
                        c++;
123
 
                        gtk_list_store_append(pluginlist, &iter);
124
 
                        gtk_list_store_set(pluginlist, &iter, 0 , managerName, -1);
125
 
                }
126
 
        }
127
 
        list = NULL;
 
114
    GtkTreeIter iter;
 
115
    gchar** list;
 
116
    gchar* managerName;
 
117
 
 
118
    gtk_list_store_clear (pluginlist);
 
119
 
 
120
    // Call dbus to retreive list
 
121
    list = dbus_get_audio_plugin_list();
 
122
    // For each API name included in list
 
123
    int c = 0;
 
124
 
 
125
    if (list != NULL) {
 
126
        for (managerName = list[c]; managerName != NULL; managerName = list[c]) {
 
127
            c++;
 
128
            gtk_list_store_append (pluginlist, &iter);
 
129
            gtk_list_store_set (pluginlist, &iter, 0 , managerName, -1);
 
130
        }
 
131
    }
 
132
 
 
133
    list = NULL;
128
134
}
129
135
 
 
136
 
130
137
/**
131
138
 * Fill output audio device store
132
139
 */
133
 
        void
 
140
void
134
141
preferences_dialog_fill_output_audio_device_list()
135
142
{
136
143
 
137
 
        GtkTreeIter iter;
138
 
        gchar** list;
139
 
        gchar** audioDevice;
140
 
        int index;
141
 
 
142
 
        gtk_list_store_clear(outputlist);
143
 
 
144
 
        // Call dbus to retreive list
145
 
        list = dbus_get_audio_output_device_list();
146
 
 
147
 
        // For each device name included in list
148
 
        int c = 0;
149
 
        for(audioDevice = list; *list ; list++)
150
 
        {
151
 
                index = dbus_get_audio_device_index( *list );
152
 
                gtk_list_store_append(outputlist, &iter);
153
 
                gtk_list_store_set(outputlist, &iter, 0, *list, 1, index, -1);
154
 
                c++;
155
 
        }
156
 
}
 
144
    GtkTreeIter iter;
 
145
    gchar** list;
 
146
    gchar** audioDevice;
 
147
    int index;
 
148
 
 
149
    gtk_list_store_clear (outputlist);
 
150
 
 
151
    // Call dbus to retreive list
 
152
    list = dbus_get_audio_output_device_list();
 
153
 
 
154
    // For each device name included in list
 
155
    int c = 0;
 
156
 
 
157
    for (audioDevice = list; *list ; list++) {
 
158
        index = dbus_get_audio_device_index (*list);
 
159
        gtk_list_store_append (outputlist, &iter);
 
160
        gtk_list_store_set (outputlist, &iter, 0, *list, 1, index, -1);
 
161
        c++;
 
162
    }
 
163
}
 
164
 
 
165
 
 
166
/**
 
167
 * Fill rigntone audio device store
 
168
 */
 
169
 
 
170
void
 
171
preferences_dialog_fill_ringtone_audio_device_list()
 
172
{
 
173
 
 
174
    GtkTreeIter iter;
 
175
    gchar** list;
 
176
    gchar** audioDevice;
 
177
    int index;
 
178
 
 
179
    gtk_list_store_clear (ringtonelist);
 
180
 
 
181
    // Call dbus to retreive output device
 
182
    list = dbus_get_audio_output_device_list();
 
183
 
 
184
    // For each device name in the list
 
185
    int c = 0;
 
186
 
 
187
    for (audioDevice = list; *list; list++) {
 
188
        index = dbus_get_audio_device_index (*list);
 
189
        gtk_list_store_append (ringtonelist, &iter);
 
190
        gtk_list_store_set (ringtonelist, &iter, 0, *list, 1, index, -1);
 
191
        c++;
 
192
    }
 
193
}
 
194
 
 
195
 
157
196
 
158
197
/**
159
198
 * Select active output audio device
160
199
 */
161
 
        void
 
200
void
162
201
select_active_output_audio_device()
163
202
{
164
 
        if( SHOW_ALSA_CONF )
165
 
        {
166
 
 
167
 
                GtkTreeModel* model;
168
 
                GtkTreeIter iter;
169
 
                gchar** devices;
170
 
                int currentDeviceIndex;
171
 
                int deviceIndex;
172
 
 
173
 
                // Select active output device on server
174
 
                devices = dbus_get_current_audio_devices_index();
175
 
                currentDeviceIndex = atoi(devices[0]);
176
 
                DEBUG("audio device index for output = %d", currentDeviceIndex);
177
 
                model = gtk_combo_box_get_model(GTK_COMBO_BOX(output));
178
 
 
179
 
                // Find the currently set output device
180
 
                gtk_tree_model_get_iter_first(model, &iter);
181
 
                do {
182
 
                        gtk_tree_model_get(model, &iter, 1, &deviceIndex, -1);
183
 
                        if(deviceIndex == currentDeviceIndex)
184
 
                        {
185
 
                                // Set current iteration the active one
186
 
                                gtk_combo_box_set_active_iter(GTK_COMBO_BOX(output), &iter);
187
 
                                return;
188
 
                        }
189
 
                } while(gtk_tree_model_iter_next(model, &iter));
190
 
 
191
 
                // No index was found, select first one
192
 
                WARN("Warning : No active output device found");
193
 
                gtk_combo_box_set_active(GTK_COMBO_BOX(output), 0);
194
 
        }
 
203
    if (SHOW_ALSA_CONF) {
 
204
 
 
205
        GtkTreeModel* model;
 
206
        GtkTreeIter iter;
 
207
        gchar** devices;
 
208
        int currentDeviceIndex;
 
209
        int deviceIndex;
 
210
 
 
211
        // Select active output device on server
 
212
        devices = dbus_get_current_audio_devices_index();
 
213
        currentDeviceIndex = atoi (devices[0]);
 
214
        DEBUG ("audio device index for output = %d", currentDeviceIndex);
 
215
        model = gtk_combo_box_get_model (GTK_COMBO_BOX (output));
 
216
 
 
217
        // Find the currently set output device
 
218
        gtk_tree_model_get_iter_first (model, &iter);
 
219
 
 
220
        do {
 
221
            gtk_tree_model_get (model, &iter, 1, &deviceIndex, -1);
 
222
 
 
223
            if (deviceIndex == currentDeviceIndex) {
 
224
                // Set current iteration the active one
 
225
                gtk_combo_box_set_active_iter (GTK_COMBO_BOX (output), &iter);
 
226
                return;
 
227
            }
 
228
        } while (gtk_tree_model_iter_next (model, &iter));
 
229
 
 
230
        // No index was found, select first one
 
231
        WARN ("Warning : No active output device found");
 
232
        gtk_combo_box_set_active (GTK_COMBO_BOX (output), 0);
 
233
    }
 
234
}
 
235
 
 
236
 
 
237
/**
 
238
 * Select active output audio device
 
239
 */
 
240
void
 
241
select_active_ringtone_audio_device()
 
242
{
 
243
    if (SHOW_ALSA_CONF) {
 
244
 
 
245
        GtkTreeModel* model;
 
246
        GtkTreeIter iter;
 
247
        gchar** devices;
 
248
        int currentDeviceIndex;
 
249
        int deviceIndex;
 
250
 
 
251
        // Select active ringtone device on server
 
252
        devices = dbus_get_current_audio_devices_index();
 
253
        currentDeviceIndex = atoi (devices[2]);
 
254
        DEBUG ("audio device index for ringtone = %d", currentDeviceIndex);
 
255
        model = gtk_combo_box_get_model (GTK_COMBO_BOX (ringtone));
 
256
 
 
257
        // Find the currently set ringtone device
 
258
        gtk_tree_model_get_iter_first (model, &iter);
 
259
 
 
260
        do {
 
261
            gtk_tree_model_get (model, &iter, 1, &deviceIndex, -1);
 
262
 
 
263
            if (deviceIndex == currentDeviceIndex) {
 
264
                // Set current iteration the active one
 
265
                gtk_combo_box_set_active_iter (GTK_COMBO_BOX (ringtone), &iter);
 
266
                return;
 
267
            }
 
268
        } while (gtk_tree_model_iter_next (model, &iter));
 
269
 
 
270
        // No index was found, select first one
 
271
        WARN ("Warning : No active ringtone device found");
 
272
        gtk_combo_box_set_active (GTK_COMBO_BOX (ringtone), 0);
 
273
    }
195
274
}
196
275
 
197
276
/**
198
277
 * Fill input audio device store
199
278
 */
200
 
        void
 
279
void
201
280
preferences_dialog_fill_input_audio_device_list()
202
281
{
203
282
 
204
 
        GtkTreeIter iter;
205
 
        gchar** list;
206
 
        gchar** audioDevice;
207
 
        int index ;
208
 
        gtk_list_store_clear(inputlist);
209
 
 
210
 
        // Call dbus to retreive list
211
 
        list = dbus_get_audio_input_device_list();
212
 
 
213
 
        // For each device name included in list
214
 
        //int c = 0;
215
 
        for(audioDevice = list; *list; list++)
216
 
        {
217
 
                index = dbus_get_audio_device_index( *list );
218
 
                gtk_list_store_append(inputlist, &iter);
219
 
                gtk_list_store_set(inputlist, &iter, 0, *list, 1, index, -1);
220
 
                //c++;
221
 
        }
 
283
    GtkTreeIter iter;
 
284
    gchar** list;
 
285
    gchar** audioDevice;
 
286
    int index ;
 
287
    gtk_list_store_clear (inputlist);
 
288
 
 
289
    // Call dbus to retreive list
 
290
    list = dbus_get_audio_input_device_list();
 
291
 
 
292
    // For each device name included in list
 
293
    //int c = 0;
 
294
    for (audioDevice = list; *list; list++) {
 
295
        index = dbus_get_audio_device_index (*list);
 
296
        gtk_list_store_append (inputlist, &iter);
 
297
        gtk_list_store_set (inputlist, &iter, 0, *list, 1, index, -1);
 
298
        //c++;
 
299
    }
222
300
 
223
301
}
224
302
 
225
303
/**
226
304
 * Select active input audio device
227
305
 */
228
 
        void
 
306
void
229
307
select_active_input_audio_device()
230
308
{
231
 
        if( SHOW_ALSA_CONF)
232
 
        {
233
 
 
234
 
                GtkTreeModel* model;
235
 
                GtkTreeIter iter;
236
 
                gchar** devices;
237
 
                int currentDeviceIndex;
238
 
                int deviceIndex;
239
 
 
240
 
                // Select active input device on server
241
 
                devices = dbus_get_current_audio_devices_index();
242
 
                currentDeviceIndex = atoi(devices[1]);
243
 
                model = gtk_combo_box_get_model(GTK_COMBO_BOX(input));
244
 
 
245
 
                // Find the currently set input device
246
 
                gtk_tree_model_get_iter_first(model, &iter);
247
 
                do {
248
 
                        gtk_tree_model_get(model, &iter, 1, &deviceIndex, -1);
249
 
                        if(deviceIndex == currentDeviceIndex)
250
 
                        {
251
 
                                // Set current iteration the active one
252
 
                                gtk_combo_box_set_active_iter(GTK_COMBO_BOX(input), &iter);
253
 
                                return;
254
 
                        }
255
 
                } while(gtk_tree_model_iter_next(model, &iter));
256
 
 
257
 
                // No index was found, select first one
258
 
                WARN("Warning : No active input device found");
259
 
                gtk_combo_box_set_active(GTK_COMBO_BOX(input), 0);
260
 
        }
 
309
    if (SHOW_ALSA_CONF) {
 
310
 
 
311
        GtkTreeModel* model;
 
312
        GtkTreeIter iter;
 
313
        gchar** devices;
 
314
        int currentDeviceIndex;
 
315
        int deviceIndex;
 
316
 
 
317
        // Select active input device on server
 
318
        devices = dbus_get_current_audio_devices_index();
 
319
        currentDeviceIndex = atoi (devices[1]);
 
320
        model = gtk_combo_box_get_model (GTK_COMBO_BOX (input));
 
321
 
 
322
        // Find the currently set input device
 
323
        gtk_tree_model_get_iter_first (model, &iter);
 
324
 
 
325
        do {
 
326
            gtk_tree_model_get (model, &iter, 1, &deviceIndex, -1);
 
327
 
 
328
            if (deviceIndex == currentDeviceIndex) {
 
329
                // Set current iteration the active one
 
330
                gtk_combo_box_set_active_iter (GTK_COMBO_BOX (input), &iter);
 
331
                return;
 
332
            }
 
333
        } while (gtk_tree_model_iter_next (model, &iter));
 
334
 
 
335
        // No index was found, select first one
 
336
        WARN ("Warning : No active input device found");
 
337
        gtk_combo_box_set_active (GTK_COMBO_BOX (input), 0);
 
338
    }
261
339
}
262
340
 
263
341
/**
264
342
 * Select the output audio plugin by calling the server
265
343
 */
266
 
        static void
267
 
select_output_audio_plugin(GtkComboBox* widget, gpointer data UNUSED)
 
344
static void
 
345
select_output_audio_plugin (GtkComboBox* widget, gpointer data UNUSED)
268
346
{
269
 
        GtkTreeModel* model;
270
 
        GtkTreeIter iter;
271
 
        int comboBoxIndex;
272
 
        gchar* pluginName;
273
 
 
274
 
        comboBoxIndex = gtk_combo_box_get_active(widget);
275
 
 
276
 
        if(comboBoxIndex >= 0)
277
 
        {
278
 
                model = gtk_combo_box_get_model(widget);
279
 
                gtk_combo_box_get_active_iter(widget, &iter);
280
 
                gtk_tree_model_get(model, &iter, 0, &pluginName, -1);
281
 
                dbus_set_output_audio_plugin(pluginName);
282
 
                //update_combo_box( pluginName);
283
 
        }
 
347
    GtkTreeModel* model;
 
348
    GtkTreeIter iter;
 
349
    int comboBoxIndex;
 
350
    gchar* pluginName;
 
351
 
 
352
    comboBoxIndex = gtk_combo_box_get_active (widget);
 
353
 
 
354
    if (comboBoxIndex >= 0) {
 
355
        model = gtk_combo_box_get_model (widget);
 
356
        gtk_combo_box_get_active_iter (widget, &iter);
 
357
        gtk_tree_model_get (model, &iter, 0, &pluginName, -1);
 
358
        dbus_set_audio_plugin (pluginName);
 
359
        //update_combo_box( pluginName);
 
360
    }
284
361
}
285
362
 
286
363
/**
287
364
 * Select active output audio plugin
288
365
 */
289
 
        void
 
366
void
290
367
select_active_output_audio_plugin()
291
368
{
292
 
        GtkTreeModel* model;
293
 
        GtkTreeIter iter;
294
 
        gchar* pluginname;
295
 
        gchar* tmp;
296
 
 
297
 
        // Select active output device on server
298
 
        pluginname = dbus_get_current_audio_output_plugin();
299
 
        tmp = pluginname;
300
 
        model = gtk_combo_box_get_model(GTK_COMBO_BOX(plugin));
301
 
 
302
 
        // Find the currently alsa plugin
303
 
        gtk_tree_model_get_iter_first(model, &iter);
304
 
        do {
305
 
                gtk_tree_model_get(model, &iter, 0, &pluginname , -1);
306
 
                if( g_strcasecmp( tmp , pluginname ) == 0 )
307
 
                {
308
 
                        // Set current iteration the active one
309
 
                        gtk_combo_box_set_active_iter(GTK_COMBO_BOX(plugin), &iter);
310
 
                        //update_combo_box( plugin );
311
 
                        return;
312
 
                }
313
 
        } while(gtk_tree_model_iter_next(model, &iter));
314
 
 
315
 
        // No index was found, select first one
316
 
        WARN("Warning : No active output device found");
317
 
        gtk_combo_box_set_active(GTK_COMBO_BOX(plugin), 0);
 
369
    GtkTreeModel* model;
 
370
    GtkTreeIter iter;
 
371
    gchar* pluginname;
 
372
    gchar* tmp;
 
373
 
 
374
    // Select active output device on server
 
375
    pluginname = dbus_get_current_audio_output_plugin();
 
376
    tmp = pluginname;
 
377
    model = gtk_combo_box_get_model (GTK_COMBO_BOX (plugin));
 
378
 
 
379
    // Find the currently alsa plugin
 
380
    gtk_tree_model_get_iter_first (model, &iter);
 
381
 
 
382
    do {
 
383
        gtk_tree_model_get (model, &iter, 0, &pluginname , -1);
 
384
 
 
385
        if (g_strcasecmp (tmp , pluginname) == 0) {
 
386
            // Set current iteration the active one
 
387
            gtk_combo_box_set_active_iter (GTK_COMBO_BOX (plugin), &iter);
 
388
            //update_combo_box( plugin );
 
389
            return;
 
390
        }
 
391
    } while (gtk_tree_model_iter_next (model, &iter));
 
392
 
 
393
    // No index was found, select first one
 
394
    WARN ("Warning : No active output device found");
 
395
    gtk_combo_box_set_active (GTK_COMBO_BOX (plugin), 0);
318
396
}
319
397
 
320
398
 
321
399
/**
322
400
 * Set the audio output device on the server with its index
323
401
 */
324
 
        static void
325
 
select_audio_output_device(GtkComboBox* comboBox, gpointer data UNUSED)
 
402
static void
 
403
select_audio_output_device (GtkComboBox* comboBox, gpointer data UNUSED)
326
404
{
327
 
        GtkTreeModel* model;
328
 
        GtkTreeIter iter;
329
 
        int comboBoxIndex;
330
 
        int deviceIndex;
331
 
 
332
 
        comboBoxIndex = gtk_combo_box_get_active(comboBox);
333
 
 
334
 
        if(comboBoxIndex >= 0)
335
 
        {
336
 
                model = gtk_combo_box_get_model(comboBox);
337
 
                gtk_combo_box_get_active_iter(comboBox, &iter);
338
 
                gtk_tree_model_get(model, &iter, 1, &deviceIndex, -1);
339
 
 
340
 
                dbus_set_audio_output_device(deviceIndex);
341
 
        }
 
405
    GtkTreeModel* model;
 
406
    GtkTreeIter iter;
 
407
    int comboBoxIndex;
 
408
    int deviceIndex;
 
409
 
 
410
    comboBoxIndex = gtk_combo_box_get_active (comboBox);
 
411
 
 
412
    if (comboBoxIndex >= 0) {
 
413
        model = gtk_combo_box_get_model (comboBox);
 
414
        gtk_combo_box_get_active_iter (comboBox, &iter);
 
415
        gtk_tree_model_get (model, &iter, 1, &deviceIndex, -1);
 
416
 
 
417
        dbus_set_audio_output_device (deviceIndex);
 
418
    }
342
419
}
343
420
 
344
421
/**
345
422
 * Set the audio input device on the server with its index
346
423
 */
347
 
        static void
348
 
select_audio_input_device(GtkComboBox* comboBox, gpointer data UNUSED)
349
 
{
350
 
        GtkTreeModel* model;
351
 
        GtkTreeIter iter;
352
 
        int comboBoxIndex;
353
 
        int deviceIndex;
354
 
 
355
 
        comboBoxIndex = gtk_combo_box_get_active(comboBox);
356
 
 
357
 
        if(comboBoxIndex >= 0)
358
 
        {
359
 
                model = gtk_combo_box_get_model(comboBox);
360
 
                gtk_combo_box_get_active_iter(comboBox, &iter);
361
 
                gtk_tree_model_get(model, &iter, 1, &deviceIndex, -1);
362
 
 
363
 
                dbus_set_audio_input_device(deviceIndex);
364
 
        }
365
 
}
 
424
static void
 
425
select_audio_input_device (GtkComboBox* comboBox, gpointer data UNUSED)
 
426
{
 
427
    GtkTreeModel* model;
 
428
    GtkTreeIter iter;
 
429
    int comboBoxIndex;
 
430
    int deviceIndex;
 
431
 
 
432
    comboBoxIndex = gtk_combo_box_get_active (comboBox);
 
433
 
 
434
    if (comboBoxIndex >= 0) {
 
435
        model = gtk_combo_box_get_model (comboBox);
 
436
        gtk_combo_box_get_active_iter (comboBox, &iter);
 
437
        gtk_tree_model_get (model, &iter, 1, &deviceIndex, -1);
 
438
 
 
439
        dbus_set_audio_input_device (deviceIndex);
 
440
    }
 
441
}
 
442
 
 
443
 
 
444
/**
 
445
+ * Set the audio ringtone device on the server with its index
 
446
+ */
 
447
static void
 
448
select_audio_ringtone_device (GtkComboBox *comboBox, gpointer data UNUSED)
 
449
{
 
450
    GtkTreeModel *model;
 
451
    GtkTreeIter iter;
 
452
    int comboBoxIndex;
 
453
    int deviceIndex;
 
454
 
 
455
    comboBoxIndex = gtk_combo_box_get_active (comboBox);
 
456
 
 
457
    if (comboBoxIndex >= 0) {
 
458
        model = gtk_combo_box_get_model (comboBox);
 
459
        gtk_combo_box_get_active_iter (comboBox, &iter);
 
460
 
 
461
        gtk_tree_model_get (model, &iter, 1, &deviceIndex, -1);
 
462
 
 
463
        dbus_set_audio_ringtone_device (deviceIndex);
 
464
    }
 
465
}
 
466
 
366
467
 
367
468
/**
368
469
 * Toggle move buttons on if a codec is selected, off elsewise
369
470
 */
370
 
        static void
371
 
select_codec(GtkTreeSelection *selection, GtkTreeModel *model)
 
471
static void
 
472
select_codec (GtkTreeSelection *selection, GtkTreeModel *model)
372
473
{
373
 
        GtkTreeIter iter;
 
474
    GtkTreeIter iter;
374
475
 
375
 
        if(!gtk_tree_selection_get_selected(selection, &model, &iter))
376
 
        {
377
 
                gtk_widget_set_sensitive(GTK_WIDGET(codecMoveUpButton), FALSE);
378
 
                gtk_widget_set_sensitive(GTK_WIDGET(codecMoveDownButton), FALSE);
379
 
        }
380
 
        else
381
 
        {
382
 
                gtk_widget_set_sensitive(GTK_WIDGET(codecMoveUpButton), TRUE);
383
 
                gtk_widget_set_sensitive(GTK_WIDGET(codecMoveDownButton), TRUE);
384
 
        }
 
476
    if (!gtk_tree_selection_get_selected (selection, &model, &iter)) {
 
477
        gtk_widget_set_sensitive (GTK_WIDGET (codecMoveUpButton), FALSE);
 
478
        gtk_widget_set_sensitive (GTK_WIDGET (codecMoveDownButton), FALSE);
 
479
    } else {
 
480
        gtk_widget_set_sensitive (GTK_WIDGET (codecMoveUpButton), TRUE);
 
481
        gtk_widget_set_sensitive (GTK_WIDGET (codecMoveDownButton), TRUE);
 
482
    }
385
483
}
386
484
 
387
485
/**
388
486
 * Toggle active value of codec on click and update changes to the deamon
389
487
 * and in configuration files
390
488
 */
391
 
        static void
392
 
codec_active_toggled (GtkCellRendererToggle *renderer UNUSED, gchar *path, gpointer data )
 
489
static void
 
490
codec_active_toggled (GtkCellRendererToggle *renderer UNUSED, gchar *path, gpointer data)
393
491
{
394
 
        GtkTreeIter iter;
395
 
        GtkTreePath *treePath;
396
 
        GtkTreeModel *model;
397
 
        gboolean active;
398
 
        char* name;
399
 
        char* srate;
400
 
        codec_t* codec;
401
 
        account_t *acc;
402
 
 
403
 
        // Get path of clicked codec active toggle box
404
 
        treePath = gtk_tree_path_new_from_string(path);
405
 
        model = gtk_tree_view_get_model (GTK_TREE_VIEW (codecTreeView));
406
 
        gtk_tree_model_get_iter(model, &iter, treePath);
407
 
 
408
 
        // Retrieve userdata
409
 
        acc = (account_t*) data;
410
 
 
411
 
        if (!acc)
412
 
                ERROR ("Aie, no account selected");
413
 
 
414
 
        // Get active value and name at iteration
415
 
        gtk_tree_model_get(model, &iter,
416
 
                        COLUMN_CODEC_ACTIVE, &active,
417
 
                        COLUMN_CODEC_NAME, &name,
418
 
                        COLUMN_CODEC_FREQUENCY, &srate,
419
 
                        -1);
420
 
 
421
 
        printf("%s, %s\n", name, srate);
422
 
        printf("%i\n", g_queue_get_length (acc->codecs));
423
 
 
424
 
        // codec_list_get_by_name(name);
425
 
        if ((g_strcasecmp(name,"speex")==0) && (g_strcasecmp(srate,"8 kHz")==0))
426
 
                codec = codec_list_get_by_payload((gconstpointer) 110, acc->codecs);
427
 
        else if ((g_strcasecmp(name,"speex")==0) && (g_strcasecmp(srate,"16 kHz")==0))
428
 
                codec = codec_list_get_by_payload((gconstpointer) 111, acc->codecs);
429
 
        else if ((g_strcasecmp(name,"speex")==0) && (g_strcasecmp(srate,"32 kHz")==0))
430
 
                codec = codec_list_get_by_payload((gconstpointer) 112, acc->codecs);
431
 
        else
432
 
                codec = codec_list_get_by_name ((gconstpointer) name, acc->codecs);
433
 
 
434
 
        // Toggle active value
435
 
        active = !active;
436
 
 
437
 
        // Store value
438
 
        gtk_list_store_set(GTK_LIST_STORE(model), &iter,
439
 
                        COLUMN_CODEC_ACTIVE, active,
440
 
                        -1);
441
 
 
442
 
        gtk_tree_path_free(treePath);
443
 
 
444
 
        // Modify codec queue to represent change
445
 
        if (active)
446
 
                codec_set_active (&codec);
447
 
        else
448
 
                codec_set_inactive (&codec);
449
 
 
450
 
        // Perpetuate changes to the deamon
451
 
        // codec_list_update_to_daemon (acc);
 
492
    GtkTreeIter iter;
 
493
    GtkTreePath *treePath;
 
494
    GtkTreeModel *model;
 
495
    gboolean active;
 
496
    char* name;
 
497
    char* srate;
 
498
    codec_t* codec;
 
499
    account_t *acc;
 
500
 
 
501
    // Get path of clicked codec active toggle box
 
502
    treePath = gtk_tree_path_new_from_string (path);
 
503
    model = gtk_tree_view_get_model (GTK_TREE_VIEW (codecTreeView));
 
504
    gtk_tree_model_get_iter (model, &iter, treePath);
 
505
 
 
506
    // Retrieve userdata
 
507
    acc = (account_t*) data;
 
508
 
 
509
    if (!acc)
 
510
        ERROR ("Aie, no account selected");
 
511
 
 
512
    // Get active value and name at iteration
 
513
    gtk_tree_model_get (model, &iter,
 
514
                        COLUMN_CODEC_ACTIVE, &active,
 
515
                        COLUMN_CODEC_NAME, &name,
 
516
                        COLUMN_CODEC_FREQUENCY, &srate,
 
517
                        -1);
 
518
 
 
519
    printf ("%s, %s\n", name, srate);
 
520
    printf ("%i\n", g_queue_get_length (acc->codecs));
 
521
 
 
522
    // codec_list_get_by_name(name);
 
523
    if ( (g_strcasecmp (name,"speex") ==0) && (g_strcasecmp (srate,"8 kHz") ==0))
 
524
        codec = codec_list_get_by_payload ( (gconstpointer) 110, acc->codecs);
 
525
    else if ( (g_strcasecmp (name,"speex") ==0) && (g_strcasecmp (srate,"16 kHz") ==0))
 
526
        codec = codec_list_get_by_payload ( (gconstpointer) 111, acc->codecs);
 
527
    else if ( (g_strcasecmp (name,"speex") ==0) && (g_strcasecmp (srate,"32 kHz") ==0))
 
528
        codec = codec_list_get_by_payload ( (gconstpointer) 112, acc->codecs);
 
529
    else
 
530
        codec = codec_list_get_by_name ( (gconstpointer) name, acc->codecs);
 
531
 
 
532
    // Toggle active value
 
533
    active = !active;
 
534
 
 
535
    // Store value
 
536
    gtk_list_store_set (GTK_LIST_STORE (model), &iter,
 
537
                        COLUMN_CODEC_ACTIVE, active,
 
538
                        -1);
 
539
 
 
540
    gtk_tree_path_free (treePath);
 
541
 
 
542
    // Modify codec queue to represent change
 
543
    if (active)
 
544
        codec_set_active (&codec);
 
545
    else
 
546
        codec_set_inactive (&codec);
 
547
 
 
548
    // Perpetuate changes to the deamon
 
549
    // codec_list_update_to_daemon (acc);
452
550
}
453
551
 
454
552
/**
455
553
 * Move codec in list depending on direction and selected codec and
456
554
 * update changes in the daemon list and the configuration files
457
555
 */
458
 
static void codec_move (gboolean moveUp, gpointer data) {
459
 
 
460
 
        GtkTreeIter iter;
461
 
        GtkTreeIter *iter2;
462
 
        GtkTreeView *treeView;
463
 
        GtkTreeModel *model;
464
 
        GtkTreeSelection *selection;
465
 
        GtkTreePath *treePath;
466
 
        gchar *path;
467
 
        account_t *acc;
468
 
        GQueue *acc_q;
469
 
 
470
 
        // Get view, model and selection of codec store
471
 
        model = gtk_tree_view_get_model(GTK_TREE_VIEW(codecTreeView));
472
 
        selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(codecTreeView));
473
 
 
474
 
        // Retrieve the user data
475
 
        acc = (account_t*) data;
476
 
        if (acc)
477
 
                acc_q = acc->codecs;
478
 
 
479
 
        // Find selected iteration and create a copy
480
 
        gtk_tree_selection_get_selected(GTK_TREE_SELECTION(selection), &model, &iter);
481
 
        iter2 = gtk_tree_iter_copy(&iter);
482
 
 
483
 
        // Find path of iteration
484
 
        path = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(model), &iter);
485
 
        treePath = gtk_tree_path_new_from_string(path);
486
 
        gint *indices = gtk_tree_path_get_indices(treePath);
487
 
        gint indice = indices[0];
488
 
 
489
 
        // Depending on button direction get new path
490
 
        if(moveUp)
491
 
                gtk_tree_path_prev(treePath);
492
 
        else
493
 
                gtk_tree_path_next(treePath);
494
 
        gtk_tree_model_get_iter(model, &iter, treePath);
495
 
 
496
 
        // Swap iterations if valid
497
 
        if(gtk_list_store_iter_is_valid(GTK_LIST_STORE(model), &iter))
498
 
                gtk_list_store_swap(GTK_LIST_STORE(model), &iter, iter2);
499
 
 
500
 
        // Scroll to new position
501
 
        gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (codecTreeView), treePath, NULL, FALSE, 0, 0);
502
 
 
503
 
        // Free resources
504
 
        gtk_tree_path_free(treePath);
505
 
        gtk_tree_iter_free(iter2);
506
 
        g_free(path);
507
 
 
508
 
        // Perpetuate changes in codec queue
509
 
        if(moveUp)
510
 
                codec_list_move_codec_up (indice, &acc_q);
511
 
        else
512
 
                codec_list_move_codec_down (indice, &acc_q);
 
556
static void codec_move (gboolean moveUp, gpointer data)
 
557
{
 
558
 
 
559
    GtkTreeIter iter;
 
560
    GtkTreeIter *iter2;
 
561
    GtkTreeModel *model;
 
562
    GtkTreeSelection *selection;
 
563
    GtkTreePath *treePath;
 
564
    gchar *path;
 
565
    account_t *acc;
 
566
    GQueue *acc_q;
 
567
 
 
568
    // Get view, model and selection of codec store
 
569
    model = gtk_tree_view_get_model (GTK_TREE_VIEW (codecTreeView));
 
570
    selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (codecTreeView));
 
571
 
 
572
    // Retrieve the user data
 
573
    acc = (account_t*) data;
 
574
 
 
575
    if (acc)
 
576
        acc_q = acc->codecs;
 
577
 
 
578
    // Find selected iteration and create a copy
 
579
    gtk_tree_selection_get_selected (GTK_TREE_SELECTION (selection), &model, &iter);
 
580
    iter2 = gtk_tree_iter_copy (&iter);
 
581
 
 
582
    // Find path of iteration
 
583
    path = gtk_tree_model_get_string_from_iter (GTK_TREE_MODEL (model), &iter);
 
584
    treePath = gtk_tree_path_new_from_string (path);
 
585
    gint *indices = gtk_tree_path_get_indices (treePath);
 
586
    gint indice = indices[0];
 
587
 
 
588
    // Depending on button direction get new path
 
589
    if (moveUp)
 
590
        gtk_tree_path_prev (treePath);
 
591
    else
 
592
        gtk_tree_path_next (treePath);
 
593
 
 
594
    gtk_tree_model_get_iter (model, &iter, treePath);
 
595
 
 
596
    // Swap iterations if valid
 
597
    if (gtk_list_store_iter_is_valid (GTK_LIST_STORE (model), &iter))
 
598
        gtk_list_store_swap (GTK_LIST_STORE (model), &iter, iter2);
 
599
 
 
600
    // Scroll to new position
 
601
    gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (codecTreeView), treePath, NULL, FALSE, 0, 0);
 
602
 
 
603
    // Free resources
 
604
    gtk_tree_path_free (treePath);
 
605
    gtk_tree_iter_free (iter2);
 
606
    g_free (path);
 
607
 
 
608
    // Perpetuate changes in codec queue
 
609
    if (moveUp)
 
610
        codec_list_move_codec_up (indice, &acc_q);
 
611
    else
 
612
        codec_list_move_codec_down (indice, &acc_q);
513
613
 
514
614
}
515
615
 
516
616
/**
517
617
 * Called from move up codec button signal
518
618
 */
519
 
static void codec_move_up (GtkButton *button UNUSED, gpointer data) {
 
619
static void codec_move_up (GtkButton *button UNUSED, gpointer data)
 
620
{
520
621
 
521
 
        // Change tree view ordering and get indice changed
522
 
        codec_move (TRUE, data);
 
622
    // Change tree view ordering and get indice changed
 
623
    codec_move (TRUE, data);
523
624
}
524
625
 
525
626
/**
526
627
 * Called from move down codec button signal
527
628
 */
528
 
static void codec_move_down(GtkButton *button UNUSED, gpointer data) {
529
 
 
530
 
        // Change tree view ordering and get indice changed
531
 
        codec_move (FALSE, data);
532
 
}
533
 
 
534
 
        int
535
 
is_ringtone_enabled( void )
536
 
{
537
 
        return dbus_is_ringtone_enabled();
538
 
}
539
 
 
540
 
        void
541
 
ringtone_enabled( void )
542
 
{
543
 
        dbus_ringtone_enabled();
544
 
}
545
 
 
546
 
        void
547
 
ringtone_changed( GtkFileChooser *chooser , GtkLabel *label UNUSED)
548
 
{
549
 
        gchar* tone = gtk_file_chooser_get_filename( GTK_FILE_CHOOSER( chooser ));
550
 
        dbus_set_ringtone_choice( tone );
551
 
}
552
 
 
553
 
        gchar*
554
 
get_ringtone_choice( void )
555
 
{
556
 
        return dbus_get_ringtone_choice();
557
 
}
558
 
 
 
629
static void codec_move_down (GtkButton *button UNUSED, gpointer data)
 
630
{
 
631
 
 
632
    // Change tree view ordering and get indice changed
 
633
    codec_move (FALSE, data);
 
634
}
559
635
 
560
636
GtkWidget* codecs_box (account_t **a)
561
637
{
562
 
        GtkWidget *ret;
563
 
        GtkWidget *scrolledWindow;
564
 
        GtkWidget *buttonBox;
565
 
 
566
 
        GtkListStore *codecStore;
567
 
        GtkCellRenderer *renderer;
568
 
        GtkTreeSelection *treeSelection;
569
 
        GtkTreeViewColumn *treeViewColumn;
570
 
 
571
 
        ret = gtk_hbox_new(FALSE, 10);
572
 
        gtk_container_set_border_width(GTK_CONTAINER(ret), 10);
573
 
 
574
 
        scrolledWindow = gtk_scrolled_window_new(NULL, NULL);
575
 
        gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
576
 
        gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledWindow), GTK_SHADOW_IN);
577
 
 
578
 
        gtk_box_pack_start(GTK_BOX(ret), scrolledWindow, TRUE, TRUE, 0);
579
 
        codecStore = gtk_list_store_new(CODEC_COLUMN_COUNT,
580
 
                        G_TYPE_BOOLEAN,         // Active
581
 
                        G_TYPE_STRING,          // Name
582
 
                        G_TYPE_STRING,          // Frequency
583
 
                        G_TYPE_STRING,          // Bit rate
584
 
                        G_TYPE_STRING           // Bandwith
585
 
                        );
586
 
 
587
 
        // Create codec tree view with list store
588
 
        codecTreeView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(codecStore));
589
 
 
590
 
        // Get tree selection manager
591
 
        treeSelection = gtk_tree_view_get_selection(GTK_TREE_VIEW(codecTreeView));
592
 
        g_signal_connect(G_OBJECT(treeSelection), "changed",
593
 
                        G_CALLBACK (select_codec),
594
 
                        codecStore);
595
 
 
596
 
        // Active column
597
 
        renderer = gtk_cell_renderer_toggle_new();
598
 
        treeViewColumn = gtk_tree_view_column_new_with_attributes("", renderer, "active", COLUMN_CODEC_ACTIVE, NULL);
599
 
        gtk_tree_view_append_column(GTK_TREE_VIEW(codecTreeView), treeViewColumn);
600
 
 
601
 
        // Toggle codec active property on clicked
602
 
        g_signal_connect(G_OBJECT(renderer), "toggled", G_CALLBACK (codec_active_toggled), (gpointer) *a);
603
 
 
604
 
        // Name column
605
 
        renderer = gtk_cell_renderer_text_new();
606
 
        treeViewColumn = gtk_tree_view_column_new_with_attributes(_("Name"), renderer, "markup", COLUMN_CODEC_NAME, NULL);
607
 
        gtk_tree_view_append_column(GTK_TREE_VIEW(codecTreeView), treeViewColumn);
608
 
 
609
 
        // Bit rate column
610
 
        renderer = gtk_cell_renderer_text_new();
611
 
        treeViewColumn = gtk_tree_view_column_new_with_attributes(_("Frequency"), renderer, "text", COLUMN_CODEC_FREQUENCY, NULL);
612
 
        gtk_tree_view_append_column(GTK_TREE_VIEW(codecTreeView), treeViewColumn);
613
 
 
614
 
        // Bandwith column
615
 
        renderer = gtk_cell_renderer_text_new();
616
 
        treeViewColumn = gtk_tree_view_column_new_with_attributes(_("Bitrate"), renderer, "text", COLUMN_CODEC_BITRATE, NULL);
617
 
        gtk_tree_view_append_column(GTK_TREE_VIEW(codecTreeView), treeViewColumn);
618
 
 
619
 
        // Frequency column
620
 
        renderer = gtk_cell_renderer_text_new();
621
 
        treeViewColumn = gtk_tree_view_column_new_with_attributes(_("Bandwidth"), renderer, "text", COLUMN_CODEC_BANDWIDTH, NULL);
622
 
        gtk_tree_view_append_column(GTK_TREE_VIEW(codecTreeView), treeViewColumn);
623
 
 
624
 
        g_object_unref(G_OBJECT(codecStore));
625
 
        gtk_container_add(GTK_CONTAINER(scrolledWindow), codecTreeView);
626
 
 
627
 
        // Create button box
628
 
        buttonBox = gtk_vbox_new(FALSE, 0);
629
 
        gtk_container_set_border_width(GTK_CONTAINER(buttonBox), 10);
630
 
        gtk_box_pack_start(GTK_BOX(ret), buttonBox, FALSE, FALSE, 0);
631
 
 
632
 
        codecMoveUpButton = gtk_button_new_from_stock(GTK_STOCK_GO_UP);
633
 
        gtk_widget_set_sensitive(GTK_WIDGET(codecMoveUpButton), FALSE);
634
 
        gtk_box_pack_start(GTK_BOX(buttonBox), codecMoveUpButton, FALSE, FALSE, 0);
635
 
        g_signal_connect(G_OBJECT(codecMoveUpButton), "clicked", G_CALLBACK(codec_move_up), *a);
636
 
 
637
 
        codecMoveDownButton = gtk_button_new_from_stock(GTK_STOCK_GO_DOWN);
638
 
        gtk_widget_set_sensitive(GTK_WIDGET(codecMoveDownButton), FALSE);
639
 
        gtk_box_pack_start(GTK_BOX(buttonBox), codecMoveDownButton, FALSE, FALSE, 0);
640
 
        g_signal_connect(G_OBJECT(codecMoveDownButton), "clicked", G_CALLBACK(codec_move_down), *a);
641
 
 
642
 
        preferences_dialog_fill_codec_list (a);
643
 
 
644
 
        return ret;
645
 
}
646
 
 
647
 
        void
648
 
select_audio_manager( void )
649
 
{
650
 
 
651
 
        DEBUG("audio manager selected\n");
652
 
 
653
 
        if( !SHOW_ALSA_CONF && !gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(pulse) ) )
654
 
        {
655
 
                dbus_set_audio_manager( ALSA );
656
 
                DEBUG(" display alsa conf panel");
657
 
                alsabox = alsa_box();
658
 
                gtk_container_add( GTK_CONTAINER(alsa_conf ) , alsabox);
659
 
                gtk_widget_show( alsa_conf );
660
 
                gtk_widget_set_sensitive(GTK_WIDGET(alsa_conf), TRUE);
661
 
 
662
 
                gtk_action_set_sensitive (GTK_ACTION (volumeToggle), TRUE);
663
 
        }
664
 
        else if( SHOW_ALSA_CONF && gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(pulse) ))
665
 
        {
666
 
                dbus_set_audio_manager( PULSEAUDIO );
667
 
                DEBUG(" remove alsa conf panel");
668
 
                gtk_container_remove( GTK_CONTAINER(alsa_conf) , alsabox );
669
 
                gtk_widget_hide( alsa_conf );
670
 
                if (gtk_toggle_action_get_active ( GTK_TOGGLE_ACTION (volumeToggle)))
671
 
                {
672
 
                        main_window_volume_controls(FALSE);
673
 
                        dbus_set_volume_controls (FALSE);
674
 
                        gtk_toggle_action_set_active ( GTK_TOGGLE_ACTION (volumeToggle), FALSE);
675
 
                }
676
 
                gtk_action_set_sensitive (GTK_ACTION (volumeToggle), FALSE);
677
 
        } else {
678
 
                DEBUG("alsa conf panel...nothing");
679
 
        }
 
638
    GtkWidget *ret;
 
639
    GtkWidget *scrolledWindow;
 
640
    GtkWidget *buttonBox;
 
641
 
 
642
    GtkListStore *codecStore;
 
643
    GtkCellRenderer *renderer;
 
644
    GtkTreeSelection *treeSelection;
 
645
    GtkTreeViewColumn *treeViewColumn;
 
646
 
 
647
    ret = gtk_hbox_new (FALSE, 10);
 
648
    gtk_container_set_border_width (GTK_CONTAINER (ret), 10);
 
649
 
 
650
    scrolledWindow = gtk_scrolled_window_new (NULL, NULL);
 
651
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 
652
    gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledWindow), GTK_SHADOW_IN);
 
653
 
 
654
    gtk_box_pack_start (GTK_BOX (ret), scrolledWindow, TRUE, TRUE, 0);
 
655
    codecStore = gtk_list_store_new (CODEC_COLUMN_COUNT,
 
656
                                     G_TYPE_BOOLEAN,            // Active
 
657
                                     G_TYPE_STRING,             // Name
 
658
                                     G_TYPE_STRING,             // Frequency
 
659
                                     G_TYPE_STRING,             // Bit rate
 
660
                                     G_TYPE_STRING              // Bandwith
 
661
                                    );
 
662
 
 
663
    // Create codec tree view with list store
 
664
    codecTreeView = gtk_tree_view_new_with_model (GTK_TREE_MODEL (codecStore));
 
665
 
 
666
    // Get tree selection manager
 
667
    treeSelection = gtk_tree_view_get_selection (GTK_TREE_VIEW (codecTreeView));
 
668
    g_signal_connect (G_OBJECT (treeSelection), "changed",
 
669
                      G_CALLBACK (select_codec),
 
670
                      codecStore);
 
671
 
 
672
    // Active column
 
673
    renderer = gtk_cell_renderer_toggle_new();
 
674
    treeViewColumn = gtk_tree_view_column_new_with_attributes ("", renderer, "active", COLUMN_CODEC_ACTIVE, NULL);
 
675
    gtk_tree_view_append_column (GTK_TREE_VIEW (codecTreeView), treeViewColumn);
 
676
 
 
677
    // Toggle codec active property on clicked
 
678
    g_signal_connect (G_OBJECT (renderer), "toggled", G_CALLBACK (codec_active_toggled), (gpointer) *a);
 
679
 
 
680
    // Name column
 
681
    renderer = gtk_cell_renderer_text_new();
 
682
    treeViewColumn = gtk_tree_view_column_new_with_attributes (_ ("Name"), renderer, "markup", COLUMN_CODEC_NAME, NULL);
 
683
    gtk_tree_view_append_column (GTK_TREE_VIEW (codecTreeView), treeViewColumn);
 
684
 
 
685
    // Bit rate column
 
686
    renderer = gtk_cell_renderer_text_new();
 
687
    treeViewColumn = gtk_tree_view_column_new_with_attributes (_ ("Frequency"), renderer, "text", COLUMN_CODEC_FREQUENCY, NULL);
 
688
    gtk_tree_view_append_column (GTK_TREE_VIEW (codecTreeView), treeViewColumn);
 
689
 
 
690
    // Bandwith column
 
691
    renderer = gtk_cell_renderer_text_new();
 
692
    treeViewColumn = gtk_tree_view_column_new_with_attributes (_ ("Bitrate"), renderer, "text", COLUMN_CODEC_BITRATE, NULL);
 
693
    gtk_tree_view_append_column (GTK_TREE_VIEW (codecTreeView), treeViewColumn);
 
694
 
 
695
    // Frequency column
 
696
    renderer = gtk_cell_renderer_text_new();
 
697
    treeViewColumn = gtk_tree_view_column_new_with_attributes (_ ("Bandwidth"), renderer, "text", COLUMN_CODEC_BANDWIDTH, NULL);
 
698
    gtk_tree_view_append_column (GTK_TREE_VIEW (codecTreeView), treeViewColumn);
 
699
 
 
700
    g_object_unref (G_OBJECT (codecStore));
 
701
    gtk_container_add (GTK_CONTAINER (scrolledWindow), codecTreeView);
 
702
 
 
703
    // Create button box
 
704
    buttonBox = gtk_vbox_new (FALSE, 0);
 
705
    gtk_container_set_border_width (GTK_CONTAINER (buttonBox), 10);
 
706
    gtk_box_pack_start (GTK_BOX (ret), buttonBox, FALSE, FALSE, 0);
 
707
 
 
708
    codecMoveUpButton = gtk_button_new_from_stock (GTK_STOCK_GO_UP);
 
709
    gtk_widget_set_sensitive (GTK_WIDGET (codecMoveUpButton), FALSE);
 
710
    gtk_box_pack_start (GTK_BOX (buttonBox), codecMoveUpButton, FALSE, FALSE, 0);
 
711
    g_signal_connect (G_OBJECT (codecMoveUpButton), "clicked", G_CALLBACK (codec_move_up), *a);
 
712
 
 
713
    codecMoveDownButton = gtk_button_new_from_stock (GTK_STOCK_GO_DOWN);
 
714
    gtk_widget_set_sensitive (GTK_WIDGET (codecMoveDownButton), FALSE);
 
715
    gtk_box_pack_start (GTK_BOX (buttonBox), codecMoveDownButton, FALSE, FALSE, 0);
 
716
    g_signal_connect (G_OBJECT (codecMoveDownButton), "clicked", G_CALLBACK (codec_move_down), *a);
 
717
 
 
718
    preferences_dialog_fill_codec_list (a);
 
719
 
 
720
    return ret;
 
721
}
 
722
 
 
723
void
 
724
select_audio_manager (void)
 
725
{
 
726
    DEBUG ("audio manager selected");
 
727
 
 
728
    if (!SHOW_ALSA_CONF && !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pulse))) {
 
729
        dbus_set_audio_manager (ALSA);
 
730
        DEBUG (" display alsa conf panel");
 
731
        alsabox = alsa_box();
 
732
        gtk_container_add (GTK_CONTAINER (alsa_conf) , alsabox);
 
733
        gtk_widget_show (alsa_conf);
 
734
        gtk_widget_set_sensitive (GTK_WIDGET (alsa_conf), TRUE);
 
735
 
 
736
        gtk_action_set_sensitive (GTK_ACTION (volumeToggle), TRUE);
 
737
    } else if (SHOW_ALSA_CONF && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pulse))) {
 
738
        dbus_set_audio_manager (PULSEAUDIO);
 
739
        DEBUG (" remove alsa conf panel");
 
740
        gtk_container_remove (GTK_CONTAINER (alsa_conf) , alsabox);
 
741
        gtk_widget_hide (alsa_conf);
 
742
 
 
743
        if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (volumeToggle))) {
 
744
            main_window_volume_controls (FALSE);
 
745
            eel_gconf_set_integer (SHOW_VOLUME_CONTROLS, FALSE);
 
746
            gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (volumeToggle), FALSE);
 
747
        }
 
748
 
 
749
        gtk_action_set_sensitive (GTK_ACTION (volumeToggle), FALSE);
 
750
    } else {
 
751
        DEBUG ("alsa conf panel...nothing");
 
752
    }
 
753
 
 
754
}
 
755
 
 
756
void
 
757
active_noise_suppress (void)
 
758
{
 
759
 
 
760
    gchar *state;
 
761
    gchar *newstate;
 
762
 
 
763
    DEBUG ("Audio: Active noise suppression clicked");
 
764
    state = dbus_get_noise_suppress_state();
 
765
 
 
766
    DEBUG ("Audio: Get noise suppression cancel state %s", state);
 
767
 
 
768
    if (strcmp (state, "enabled") == 0)
 
769
        newstate = "disabled";
 
770
    else
 
771
        newstate = "enabled";
 
772
 
 
773
    dbus_set_noise_suppress_state (newstate);
 
774
 
680
775
 
681
776
}
682
777
 
683
778
GtkWidget* alsa_box()
684
779
{
685
 
        GtkWidget *ret;
686
 
        GtkWidget *table;
687
 
        GtkWidget *item;
688
 
        GtkCellRenderer *renderer;
689
 
 
690
 
        ret = gtk_hbox_new(FALSE, 10);
691
 
        gtk_widget_show( ret );
692
 
 
693
 
        table = gtk_table_new(4, 3, FALSE);
694
 
        gtk_table_set_col_spacing(GTK_TABLE(table), 0, 40);
695
 
        gtk_box_pack_start( GTK_BOX(ret) , table , TRUE , TRUE , 1);
696
 
        gtk_widget_show(table);
697
 
 
698
 
        DEBUG("plugin");
699
 
        item = gtk_label_new(_("ALSA plugin"));
700
 
        gtk_misc_set_alignment(GTK_MISC(item), 0, 0.5);
701
 
        gtk_table_attach(GTK_TABLE(table), item, 1, 2, 1, 2, GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
702
 
        gtk_widget_show( item );
703
 
        // Set choices of audio managers
704
 
        pluginlist = gtk_list_store_new(1, G_TYPE_STRING);
705
 
        preferences_dialog_fill_output_audio_plugin_list();
706
 
        plugin = gtk_combo_box_new_with_model(GTK_TREE_MODEL(pluginlist));
707
 
        select_active_output_audio_plugin();
708
 
        gtk_label_set_mnemonic_widget(GTK_LABEL(item), plugin);
709
 
        g_signal_connect(G_OBJECT(plugin), "changed", G_CALLBACK(select_output_audio_plugin), plugin);
710
 
 
711
 
        // Set rendering
712
 
        renderer = gtk_cell_renderer_text_new();
713
 
        gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(plugin), renderer, TRUE);
714
 
        gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(plugin), renderer, "text", 0, NULL);
715
 
        gtk_table_attach(GTK_TABLE(table), plugin, 2, 3, 1, 2, GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
716
 
        gtk_widget_show(plugin);
717
 
 
718
 
        // Device : Output device
719
 
        // Create title label
720
 
        DEBUG("output");
721
 
        item = gtk_label_new(_("Output"));
722
 
        gtk_misc_set_alignment(GTK_MISC(item), 0, 0.5);
723
 
        gtk_table_attach(GTK_TABLE(table), item, 1, 2, 2, 3, GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
724
 
        gtk_widget_show(item);
725
 
        // Set choices of output devices
726
 
        outputlist = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
727
 
        preferences_dialog_fill_output_audio_device_list();
728
 
        output = gtk_combo_box_new_with_model(GTK_TREE_MODEL(outputlist));
729
 
        select_active_output_audio_device();
730
 
        gtk_label_set_mnemonic_widget(GTK_LABEL(item), output);
731
 
        g_signal_connect(G_OBJECT(output), "changed", G_CALLBACK(select_audio_output_device), output);
732
 
 
733
 
        // Set rendering
734
 
        renderer = gtk_cell_renderer_text_new();
735
 
        gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(output), renderer, TRUE);
736
 
        gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(output), renderer, "text", 0, NULL);
737
 
        gtk_table_attach(GTK_TABLE(table), output, 2, 3, 2, 3, GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
738
 
        gtk_widget_show(output);
739
 
 
740
 
        // Device : Input device
741
 
        // Create title label
742
 
        DEBUG("input");
743
 
        item = gtk_label_new(_("Input"));
744
 
        gtk_misc_set_alignment(GTK_MISC(item), 0, 0.5);
745
 
        gtk_table_attach(GTK_TABLE(table), item, 1, 2, 3, 4, GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
746
 
        gtk_widget_show(item);
747
 
 
748
 
        // Set choices of output devices
749
 
        inputlist = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
750
 
        preferences_dialog_fill_input_audio_device_list();
751
 
        input = gtk_combo_box_new_with_model(GTK_TREE_MODEL(inputlist));
752
 
        select_active_input_audio_device();
753
 
        gtk_label_set_mnemonic_widget(GTK_LABEL(item), input);
754
 
        g_signal_connect(G_OBJECT(input), "changed", G_CALLBACK(select_audio_input_device), input);
755
 
 
756
 
        // Set rendering
757
 
        renderer = gtk_cell_renderer_text_new();
758
 
        gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(input), renderer, TRUE);
759
 
        gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(input), renderer, "text", 0, NULL);
760
 
        gtk_table_attach(GTK_TABLE(table), input, 2, 3, 3, 4, GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
761
 
        gtk_widget_show(input);
762
 
 
763
 
        gtk_widget_show_all(ret);
764
 
 
765
 
        DEBUG("done");
766
 
        return ret;
767
 
}
768
 
 
769
 
GtkWidget* noise_box()
770
 
{
771
 
        GtkWidget *ret;
772
 
        GtkWidget *enableVoiceActivity;
773
 
        GtkWidget *enableNoiseReduction;
774
 
 
775
 
        // check button to enable ringtones
776
 
        ret = gtk_hbox_new( TRUE , 1);
777
 
 
778
 
        enableVoiceActivity = gtk_check_button_new_with_mnemonic( _("_Voice Activity Detection"));
779
 
        //TODO Use the value from D-BUS
780
 
        gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(enableVoiceActivity), FALSE );
781
 
        gtk_box_pack_start( GTK_BOX(ret) , enableVoiceActivity , TRUE , TRUE , 1);
782
 
        //TODO Enable it
783
 
        //gtk_widget_set_sensitive(GTK_WIDGET(noise_conf), FALSE);
784
 
        //TODO Add a callback function
785
 
        //g_signal_connect(G_OBJECT( enableNoiseReduction) , "clicked" , NULL , NULL);
786
 
 
787
 
 
788
 
        enableNoiseReduction = gtk_check_button_new_with_mnemonic( _("_Noise Reduction (Narrow-Band Companding)"));
789
 
        //TODO Use the value from D-BUS
790
 
        gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(enableNoiseReduction), FALSE );
791
 
        gtk_box_pack_start( GTK_BOX(ret) , enableNoiseReduction , TRUE , TRUE , 1);
792
 
        //TODO Enable it
793
 
        // gtk_widget_set_sensitive(GTK_WIDGET(noise_conf), FALSE);
794
 
        //TODO Add a callback function
795
 
        //g_signal_connect(G_OBJECT( enableNoiseReduction) , "clicked" , NULL , NULL);
796
 
 
797
 
        return ret;
798
 
}
799
 
 
800
 
static void record_path_changed( GtkFileChooser *chooser , GtkLabel *label UNUSED)
801
 
{
802
 
        DEBUG("record_path_changed");
803
 
 
804
 
        gchar* path;
805
 
        path = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER( chooser ));
806
 
        DEBUG("path2 %s", path);
807
 
        dbus_set_record_path( path );
 
780
    GtkWidget *ret;
 
781
    GtkWidget *table;
 
782
    GtkWidget *item;
 
783
    GtkCellRenderer *renderer;
 
784
 
 
785
    ret = gtk_hbox_new (FALSE, 10);
 
786
    gtk_widget_show (ret);
 
787
 
 
788
    table = gtk_table_new (5, 3, FALSE);
 
789
    gtk_table_set_col_spacing (GTK_TABLE (table), 0, 40);
 
790
    gtk_box_pack_start (GTK_BOX (ret) , table , TRUE , TRUE , 1);
 
791
    gtk_widget_show (table);
 
792
 
 
793
    DEBUG ("Audio: Configuration plugin");
 
794
    item = gtk_label_new (_ ("ALSA plugin"));
 
795
    gtk_misc_set_alignment (GTK_MISC (item), 0, 0.5);
 
796
    gtk_table_attach (GTK_TABLE (table), item, 1, 2, 1, 2, GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
 
797
    gtk_widget_show (item);
 
798
    // Set choices of audio managers
 
799
    pluginlist = gtk_list_store_new (1, G_TYPE_STRING);
 
800
    preferences_dialog_fill_audio_plugin_list();
 
801
    plugin = gtk_combo_box_new_with_model (GTK_TREE_MODEL (pluginlist));
 
802
    select_active_output_audio_plugin();
 
803
    gtk_label_set_mnemonic_widget (GTK_LABEL (item), plugin);
 
804
    g_signal_connect (G_OBJECT (plugin), "changed", G_CALLBACK (select_output_audio_plugin), plugin);
 
805
 
 
806
    // Set rendering
 
807
    renderer = gtk_cell_renderer_text_new();
 
808
    gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (plugin), renderer, TRUE);
 
809
    gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (plugin), renderer, "text", 0, NULL);
 
810
    gtk_table_attach (GTK_TABLE (table), plugin, 2, 3, 1, 2, GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
 
811
    gtk_widget_show (plugin);
 
812
 
 
813
    // Device : Output device
 
814
    // Create title label
 
815
    DEBUG ("Audio: Configuration output");
 
816
    item = gtk_label_new (_ ("Output"));
 
817
    gtk_misc_set_alignment (GTK_MISC (item), 0, 0.5);
 
818
    gtk_table_attach (GTK_TABLE (table), item, 1, 2, 2, 3, GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
 
819
    gtk_widget_show (item);
 
820
    // Set choices of output devices
 
821
    outputlist = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
 
822
    preferences_dialog_fill_output_audio_device_list();
 
823
    output = gtk_combo_box_new_with_model (GTK_TREE_MODEL (outputlist));
 
824
    select_active_output_audio_device();
 
825
    gtk_label_set_mnemonic_widget (GTK_LABEL (item), output);
 
826
    g_signal_connect (G_OBJECT (output), "changed", G_CALLBACK (select_audio_output_device), output);
 
827
 
 
828
    // Set rendering
 
829
    renderer = gtk_cell_renderer_text_new();
 
830
    gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (output), renderer, TRUE);
 
831
    gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (output), renderer, "text", 0, NULL);
 
832
    gtk_table_attach (GTK_TABLE (table), output, 2, 3, 2, 3, GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
 
833
    gtk_widget_show (output);
 
834
 
 
835
    // Device : Input device
 
836
    // Create title label
 
837
    DEBUG ("Audio: Configuration input");
 
838
    item = gtk_label_new (_ ("Input"));
 
839
    gtk_misc_set_alignment (GTK_MISC (item), 0, 0.5);
 
840
    gtk_table_attach (GTK_TABLE (table), item, 1, 2, 3, 4, GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
 
841
    gtk_widget_show (item);
 
842
 
 
843
    // Set choices of output devices
 
844
    inputlist = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
 
845
    preferences_dialog_fill_input_audio_device_list();
 
846
    input = gtk_combo_box_new_with_model (GTK_TREE_MODEL (inputlist));
 
847
    select_active_input_audio_device();
 
848
    gtk_label_set_mnemonic_widget (GTK_LABEL (item), input);
 
849
    g_signal_connect (G_OBJECT (input), "changed", G_CALLBACK (select_audio_input_device), input);
 
850
 
 
851
    DEBUG ("Audio: Configuration rintgtone");
 
852
    item = gtk_label_new (_ ("Ringtone"));
 
853
    gtk_misc_set_alignment (GTK_MISC (item), 0, 0.5);
 
854
    gtk_table_attach (GTK_TABLE (table), item, 1, 2, 4, 5, GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
 
855
    gtk_widget_show (item);
 
856
    // set choices of ringtone devices
 
857
    ringtonelist = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
 
858
    preferences_dialog_fill_ringtone_audio_device_list();
 
859
    ringtone = gtk_combo_box_new_with_model (GTK_TREE_MODEL (ringtonelist));
 
860
    select_active_ringtone_audio_device();
 
861
    gtk_label_set_mnemonic_widget (GTK_LABEL (item), output);
 
862
    g_signal_connect (G_OBJECT (ringtone), "changed", G_CALLBACK (select_audio_ringtone_device), output);
 
863
 
 
864
    // Set rendering
 
865
    renderer = gtk_cell_renderer_text_new();
 
866
    gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (ringtone), renderer, TRUE);
 
867
    gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (ringtone), renderer, "text", 0, NULL);
 
868
    gtk_table_attach (GTK_TABLE (table), ringtone, 2, 3, 4, 5, GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
 
869
    gtk_widget_show (ringtone);
 
870
 
 
871
 
 
872
    // Set rendering
 
873
    renderer = gtk_cell_renderer_text_new();
 
874
    gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (input), renderer, TRUE);
 
875
    gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (input), renderer, "text", 0, NULL);
 
876
    gtk_table_attach (GTK_TABLE (table), input, 2, 3, 3, 4, GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
 
877
    gtk_widget_show (input);
 
878
 
 
879
    gtk_widget_show_all (ret);
 
880
 
 
881
    DEBUG ("done");
 
882
    return ret;
 
883
}
 
884
 
 
885
static void record_path_changed (GtkFileChooser *chooser , GtkLabel *label UNUSED)
 
886
{
 
887
    DEBUG ("record_path_changed");
 
888
 
 
889
    gchar* path;
 
890
    path = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (chooser));
 
891
    DEBUG ("path2 %s", path);
 
892
    dbus_set_record_path (path);
808
893
}
809
894
 
810
895
GtkWidget* create_audio_configuration()
811
896
{
812
 
        // Main widget
813
 
        GtkWidget *ret;
814
 
        // Sub boxes
815
 
        GtkWidget *box;
816
 
        GtkWidget *frame;
817
 
 
818
 
        ret = gtk_vbox_new(FALSE, 10);
819
 
        gtk_container_set_border_width(GTK_CONTAINER(ret), 10);
820
 
 
821
 
        GtkWidget *alsa;
822
 
        GtkWidget *table;
823
 
 
824
 
        gnome_main_section_new_with_table (_("Sound Manager"), &frame, &table, 1, 2);
825
 
        gtk_box_pack_start(GTK_BOX(ret), frame, FALSE, FALSE, 0);
826
 
 
827
 
        int audio_manager = dbus_get_audio_manager();
828
 
        gboolean pulse_audio = FALSE;
829
 
        if (audio_manager == PULSEAUDIO) {
830
 
                pulse_audio = TRUE;
831
 
        }
832
 
 
833
 
        pulse = gtk_radio_button_new_with_mnemonic( NULL , _("_Pulseaudio"));
834
 
        gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(pulse), pulse_audio);
835
 
        gtk_table_attach ( GTK_TABLE( table ), pulse, 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
836
 
 
837
 
        alsa = gtk_radio_button_new_with_mnemonic_from_widget(GTK_RADIO_BUTTON(pulse),  _("_ALSA"));
838
 
        gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(alsa), !pulse_audio);
839
 
        g_signal_connect(G_OBJECT(alsa), "clicked", G_CALLBACK(select_audio_manager), NULL);
840
 
        gtk_table_attach ( GTK_TABLE( table ), alsa, 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
841
 
 
842
 
        // Box for the ALSA configuration
843
 
        gnome_main_section_new (_("ALSA settings"), &alsa_conf);
844
 
        gtk_box_pack_start(GTK_BOX(ret), alsa_conf, FALSE, FALSE, 0);
845
 
        gtk_widget_show( alsa_conf );
846
 
        if( SHOW_ALSA_CONF )
847
 
        {
848
 
                // Box for the ALSA configuration
849
 
                printf("ALSA Created \n");
850
 
                alsabox = alsa_box();
851
 
                gtk_container_add( GTK_CONTAINER(alsa_conf) , alsabox );
852
 
                gtk_widget_hide( alsa_conf );
853
 
        }
854
 
 
855
 
        // Recorded file saving path
856
 
        GtkWidget *label;
857
 
        GtkWidget *folderChooser;
858
 
        gchar *dftPath;
859
 
 
860
 
        /* Get the path where to save audio files */
861
 
        dftPath = dbus_get_record_path ();
862
 
        DEBUG("load recording path %s\n", dftPath);
863
 
 
864
 
        gnome_main_section_new_with_table (_("Recordings"), &frame, &table, 1, 2);
865
 
        gtk_box_pack_start(GTK_BOX(ret), frame, FALSE, FALSE, 0);
866
 
 
867
 
        // label
868
 
        label = gtk_label_new(_("Destination folder"));
869
 
        gtk_table_attach( GTK_TABLE(table), label, 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 5);
870
 
 
871
 
        // folder chooser button
872
 
        folderChooser = gtk_file_chooser_button_new(_("Select a folder"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
873
 
        gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER( folderChooser), dftPath);
874
 
        g_signal_connect( G_OBJECT( folderChooser ) , "selection_changed" , G_CALLBACK( record_path_changed ) , NULL );
875
 
        gtk_table_attach(GTK_TABLE(table), folderChooser, 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 5);
876
 
 
877
 
        // Box for the ringtones
878
 
        gnome_main_section_new_with_table (_("Ringtones"), &frame, &table, 1, 2);
879
 
        gtk_box_pack_start(GTK_BOX(ret), frame, FALSE, FALSE, 0); 
880
 
 
881
 
        GtkWidget *enableTone;
882
 
        GtkWidget *fileChooser;
883
 
 
884
 
        enableTone = gtk_check_button_new_with_mnemonic( _("_Enable ringtones"));
885
 
        gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(enableTone), dbus_is_ringtone_enabled() );
886
 
        g_signal_connect(G_OBJECT( enableTone) , "clicked" , G_CALLBACK( ringtone_enabled ) , NULL);
887
 
        gtk_table_attach ( GTK_TABLE( table ), enableTone, 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
888
 
 
889
 
        // file chooser button
890
 
        fileChooser = gtk_file_chooser_button_new(_("Choose a ringtone"), GTK_FILE_CHOOSER_ACTION_OPEN);
891
 
        gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER( fileChooser) , g_get_home_dir());
892
 
        gtk_file_chooser_set_filename(GTK_FILE_CHOOSER( fileChooser) , get_ringtone_choice());
893
 
        g_signal_connect( G_OBJECT( fileChooser ) , "selection_changed" , G_CALLBACK( ringtone_changed ) , NULL );
894
 
 
895
 
        GtkFileFilter *filter = gtk_file_filter_new();
896
 
        gtk_file_filter_set_name( filter , _("Audio Files") );
897
 
        gtk_file_filter_add_pattern(filter , "*.wav" );
898
 
        gtk_file_filter_add_pattern(filter , "*.ul" );
899
 
        gtk_file_filter_add_pattern(filter , "*.au" );
900
 
        gtk_file_chooser_add_filter( GTK_FILE_CHOOSER( fileChooser ) , filter);
901
 
        gtk_table_attach ( GTK_TABLE( table ), fileChooser, 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
902
 
 
903
 
        gtk_widget_show_all(ret);
904
 
 
905
 
        if(!pulse_audio) {
906
 
                gtk_widget_show(alsa_conf);
907
 
        }
908
 
        else{
909
 
                gtk_widget_hide(alsa_conf);
910
 
        }
911
 
 
912
 
        return ret;
 
897
    // Main widget
 
898
    GtkWidget *ret;
 
899
    // Sub boxes
 
900
    GtkWidget *frame;
 
901
    GtkWidget *enableNoiseReduction;
 
902
    gboolean noisesuppressActive;
 
903
    gchar *state;
 
904
 
 
905
    ret = gtk_vbox_new (FALSE, 10);
 
906
    gtk_container_set_border_width (GTK_CONTAINER (ret), 10);
 
907
 
 
908
    GtkWidget *alsa;
 
909
    GtkWidget *table;
 
910
 
 
911
    gnome_main_section_new_with_table (_ ("Sound Manager"), &frame, &table, 1, 2);
 
912
    gtk_box_pack_start (GTK_BOX (ret), frame, FALSE, FALSE, 0);
 
913
 
 
914
    int audio_manager = dbus_get_audio_manager();
 
915
    gboolean pulse_audio = FALSE;
 
916
 
 
917
    if (audio_manager == PULSEAUDIO) {
 
918
        pulse_audio = TRUE;
 
919
    }
 
920
 
 
921
    pulse = gtk_radio_button_new_with_mnemonic (NULL , _ ("_Pulseaudio"));
 
922
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pulse), pulse_audio);
 
923
    gtk_table_attach (GTK_TABLE (table), pulse, 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 
924
 
 
925
    alsa = gtk_radio_button_new_with_mnemonic_from_widget (GTK_RADIO_BUTTON (pulse),  _ ("_ALSA"));
 
926
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (alsa), !pulse_audio);
 
927
    g_signal_connect (G_OBJECT (alsa), "clicked", G_CALLBACK (select_audio_manager), NULL);
 
928
    gtk_table_attach (GTK_TABLE (table), alsa, 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 
929
 
 
930
    // Box for the ALSA configuration
 
931
    gnome_main_section_new (_ ("ALSA settings"), &alsa_conf);
 
932
    gtk_box_pack_start (GTK_BOX (ret), alsa_conf, FALSE, FALSE, 0);
 
933
    gtk_widget_show (alsa_conf);
 
934
 
 
935
    if (SHOW_ALSA_CONF) {
 
936
        // Box for the ALSA configuration
 
937
        alsabox = alsa_box();
 
938
        gtk_container_add (GTK_CONTAINER (alsa_conf) , alsabox);
 
939
        gtk_widget_hide (alsa_conf);
 
940
    }
 
941
 
 
942
    // Recorded file saving path
 
943
    GtkWidget *label;
 
944
    GtkWidget *folderChooser;
 
945
    gchar *dftPath;
 
946
 
 
947
    /* Get the path where to save audio files */
 
948
    dftPath = dbus_get_record_path ();
 
949
    DEBUG ("load recording path %s\n", dftPath);
 
950
 
 
951
    gnome_main_section_new_with_table (_ ("Recordings"), &frame, &table, 1, 2);
 
952
    gtk_box_pack_start (GTK_BOX (ret), frame, FALSE, FALSE, 0);
 
953
 
 
954
    // label
 
955
    label = gtk_label_new (_ ("Destination folder"));
 
956
    gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 5);
 
957
 
 
958
    // folder chooser button
 
959
    folderChooser = gtk_file_chooser_button_new (_ ("Select a folder"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
 
960
    gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (folderChooser), dftPath);
 
961
    g_signal_connect (G_OBJECT (folderChooser) , "selection_changed" , G_CALLBACK (record_path_changed) , NULL);
 
962
    gtk_table_attach (GTK_TABLE (table), folderChooser, 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 5);
 
963
 
 
964
 
 
965
    // Box for the voice enhancement configuration
 
966
    gnome_main_section_new_with_table (_ ("Voice enhancement settings"), &frame, &table, 2, 1);
 
967
    gtk_box_pack_start (GTK_BOX (ret), frame, FALSE, FALSE, 0);
 
968
 
 
969
    enableNoiseReduction = gtk_check_button_new_with_mnemonic (_ ("_Noise Reduction"));
 
970
    state = dbus_get_noise_suppress_state();
 
971
    noisesuppressActive = FALSE;
 
972
 
 
973
    if (strcmp (state, "enabled") == 0)
 
974
        noisesuppressActive = TRUE;
 
975
    else
 
976
        noisesuppressActive = FALSE;
 
977
 
 
978
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (enableNoiseReduction), noisesuppressActive);
 
979
    g_signal_connect (G_OBJECT (enableNoiseReduction), "clicked", active_noise_suppress, NULL);
 
980
    gtk_table_attach (GTK_TABLE (table), enableNoiseReduction, 0, 1, 1, 2, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 
981
 
 
982
    gtk_widget_show_all (ret);
 
983
 
 
984
    if (!pulse_audio) {
 
985
        gtk_widget_show (alsa_conf);
 
986
    } else {
 
987
        gtk_widget_hide (alsa_conf);
 
988
    }
 
989
 
 
990
    return ret;
913
991
}
914
992
/*
915
993
GtkWidget* create_codecs_configuration (account_t **a) {