← Back to branch summary

~cairo-dock-team/ubuntu/quantal/cairo-dock-plug-ins/3.0.2

« back to all changes in this revision

Viewing changes to Network-Monitor/src/applet-connections.c

Tags: upstream-2.2.0~0beta4
Import upstream version 2.2.0~0beta4

Show diffs side-by-side

added added

removed removed

Lines of Context:
Network-Monitor/src/applet-connections.c
40
40
 
41
41
gboolean cd_NetworkMonitor_connect_to_bus (void)
42
42
{
43
 
        g_print ("%s ()\n", __func__);
 
43
        cd_debug ("%s ()\n", __func__);
44
44
        //\_____________ On verifie la presence de NM sur le bus.
45
45
        if (! cairo_dock_dbus_detect_system_application("org.freedesktop.NetworkManager"))
46
46
                return FALSE;
83
83
 
84
84
gboolean cd_NetworkMonitor_get_device (void)
85
85
{
86
 
        g_print ("%s ()\n", __func__);
 
86
        cd_debug ("%s ()\n", __func__);
87
87
        //\_____________ On recupere la liste des devices.
88
88
        GPtrArray *paDevices = cairo_dock_dbus_get_array (myData.dbus_proxy_NM, "GetDevices");
89
89
        g_return_val_if_fail (paDevices != NULL, FALSE);
90
90
        
91
91
        //\_____________ On choisit celui defini en conf, ou un par defaut (wifi de preference).
92
 
        g_print ("%d devices\n", paDevices->len);
 
92
        cd_debug ("%d devices\n", paDevices->len);
93
93
        DBusGProxy *dbus_proxy_Device, *dbus_proxy_Device_prop;
94
94
        gchar *cDevice;
95
95
        int i;
103
103
                        "org.freedesktop.DBus.Properties");
104
104
                if (!DBUS_IS_G_PROXY (dbus_proxy_Device_prop))
105
105
                        continue;
106
 
                g_print (" device %s\n", cDevice);
 
106
                cd_debug (" device %s\n", cDevice);
107
107
                
108
108
                // on regarde son type.
109
109
                guint iDeviceType = cairo_dock_dbus_get_property_as_uint (dbus_proxy_Device_prop, "org.freedesktop.NetworkManager.Device", "DeviceType");  // 1 : ethernet, 2 : wifi
110
 
                g_print (" device type : %d\n", iDeviceType);
 
110
                cd_debug (" device type : %d\n", iDeviceType);
111
111
                if (iDeviceType != 1 && iDeviceType != 2)  // ne nous insteresse pas.
112
112
                {
113
 
                        g_print (" useless device type\n");
 
113
                        cd_debug (" useless device type\n");
114
114
                        g_object_unref (dbus_proxy_Device_prop);
115
115
                        continue;
116
116
                }
117
117
                
118
118
                // on recupere son interface.
119
119
                gchar *cInterface = cairo_dock_dbus_get_property_as_string (dbus_proxy_Device_prop, "org.freedesktop.NetworkManager.Device", "Interface");
120
 
                g_print (" interface :%s\n", cInterface);
 
120
                cd_debug (" interface :%s\n", cInterface);
121
121
                
122
122
                // on regarde si on doit le selectionner ou pas.
123
123
                if (myData.cDevice != NULL)  // on a deja trouve un device, on regarde si celui-ci convient mieux.
143
143
                }
144
144
                if (myData.cDevice == NULL)  // aucun autre device, on selectionne celui-la.
145
145
                {
146
 
                        g_print (" on selectionne ce device\n");
 
146
                        cd_debug (" on selectionne ce device\n");
147
147
                        myData.dbus_proxy_Device_prop = dbus_proxy_Device_prop;
148
148
                        myData.cInterface = cInterface;
149
149
                        myData.cDevice = g_strdup (cDevice);
151
151
                        myData.bWirelessExt = (iDeviceType == 2);
152
152
                        if (myConfig.cInterface && cInterface && strcmp (cInterface, myConfig.cInterface) == 0)
153
153
                        {
154
 
                                g_print ("  c'est l'interface qu'on veut\n");
 
154
                                cd_debug ("  c'est l'interface qu'on veut\n");
155
155
                                break;
156
156
                        }
157
157
                }
203
203
 
204
204
gboolean cd_NetworkMonitor_get_connection (void)
205
205
{
206
 
        g_print ("%s ()\n", __func__);
 
206
        cd_debug ("%s ()\n", __func__);
207
207
        
208
208
        myData.cServiceName = g_strdup ("org.freedesktop.NetworkManagerUserSettings");
209
209
        
213
213
                "/org/freedesktop/NetworkManagerSettings",
214
214
                "org.freedesktop.NetworkManagerSettings");
215
215
        GPtrArray *paConnections = cairo_dock_dbus_get_array (dbus_proxy_Settings, "ListConnections");
216
 
        g_print ("%d connections\n", paConnections->len);
 
216
        cd_debug ("%d connections\n", paConnections->len);
217
217
        
218
218
        //\_____________ On en choisit une.
219
219
        gchar *cConnection;
221
221
        for (i = 0; i < paConnections->len; i++)
222
222
        {
223
223
                cConnection = (gchar *)g_ptr_array_index(paConnections, i);
224
 
                g_print (" Connection path : %s\n", cConnection);
 
224
                cd_debug (" Connection path : %s\n", cConnection);
225
225
                
226
226
                myData.cConnection = g_strdup (cConnection);
227
227
        }
234
234
 
235
235
gboolean cd_NetworkMonitor_get_active_connection_info (void)
236
236
{
237
 
        g_print ("%s ()\n", __func__);
 
237
        cd_debug ("%s ()\n", __func__);
238
238
        //\_____________ on reset tout.
239
239
        myData.bWiredExt = myData.bWirelessExt = FALSE;
240
240
        g_free (myData.cDevice);
266
266
        
267
267
        //\_____________ On recupere la liste des connexions actives (ce sont les configs tout-en-un de NM qui sont actuellement utilisees).
268
268
        paActiveConnections = (GPtrArray*) cairo_dock_dbus_get_property_as_boxed (myData.dbus_proxy_NM_prop, "org.freedesktop.NetworkManager", "ActiveConnections");
269
 
        g_print ("%d connections\n", paActiveConnections->len);
 
269
        cd_debug ("%d connections\n", paActiveConnections->len);
270
270
        for (j=0; j<paActiveConnections->len; j++)
271
271
        {
272
272
                cActiveConnection = (gchar *)g_ptr_array_index(paActiveConnections,j);
273
 
                g_print ("Network-Monitor : Active Connection path : %s\n", cActiveConnection);
 
273
                cd_debug ("Network-Monitor : Active Connection path : %s\n", cActiveConnection);
274
274
                
275
275
                // on recupere les proprietes de la connexion.
276
276
                dbus_proxy_ActiveConnection_prop = cairo_dock_create_new_system_proxy (
292
292
                        g_object_unref (dbus_proxy_ActiveConnection_prop);
293
293
                        continue;
294
294
                }
295
 
                g_print (" c'est la connexion par defaut\n");
 
295
                cd_debug (" c'est la connexion par defaut\n");
296
296
                myData.cActiveConnection = g_strdup (cActiveConnection);
297
297
                
298
298
                // on recupere le SpecificObject qui contient le point d'acces courant.
301
301
                if (v && G_VALUE_HOLDS_BOXED (v))
302
302
                {
303
303
                        cAccessPointPath = g_value_get_boxed (v);
304
 
                        g_print (" cAccessPointPath : %s\n", cAccessPointPath);
 
304
                        cd_debug (" cAccessPointPath : %s\n", cAccessPointPath);
305
305
                }
306
306
                
307
307
                // on recupere le nom du service qui fournit cette connexion.
310
310
                if (v && G_VALUE_HOLDS_STRING (v))
311
311
                {
312
312
                        cServiceName = g_value_get_string (v);
313
 
                        g_print (" cServiceName : %s\n", cServiceName);
 
313
                        cd_debug (" cServiceName : %s\n", cServiceName);
314
314
                }
315
315
                
316
316
                // on recupere le chemin de la connection.
319
319
                if (v && G_VALUE_HOLDS (v, DBUS_TYPE_G_OBJECT_PATH))
320
320
                {
321
321
                        cConnection = g_value_get_boxed (v);
322
 
                        g_print (" cConnectionPath : %s\n", cConnection);
 
322
                        cd_debug (" cConnectionPath : %s\n", cConnection);
323
323
                }
324
324
                
325
325
                // on parcourt la liste des devices associes.
327
327
                if (v && G_VALUE_HOLDS_BOXED (v))
328
328
                {
329
329
                        GPtrArray *paDevices = g_value_get_boxed (v);
330
 
                        g_print (" %d devices\n", paDevices->len);
 
330
                        cd_debug (" %d devices\n", paDevices->len);
331
331
                        for (k=0; k<paDevices->len; k++)
332
332
                        {
333
333
                                // on recupere le device.
334
334
                                cDevice = (gchar *)g_ptr_array_index(paDevices,k);
335
 
                                g_print (" device path : %s\n", cDevice);
 
335
                                cd_debug (" device path : %s\n", cDevice);
336
336
                                dbus_proxy_Device_prop = cairo_dock_create_new_system_proxy (
337
337
                                        "org.freedesktop.NetworkManager",
338
338
                                        cDevice,
340
340
                                
341
341
                                // on regarde son type.
342
342
                                guint iDeviceType = cairo_dock_dbus_get_property_as_uint (dbus_proxy_Device_prop, "org.freedesktop.NetworkManager.Device", "DeviceType");  // 1 : ethernet, 2 : wifi
343
 
                                g_print (" device type : %d\n", iDeviceType);
 
343
                                cd_debug (" device type : %d\n", iDeviceType);
344
344
                                if (iDeviceType != 1 && iDeviceType != 2)  // ne nous insteresse pas.
345
345
                                {
346
346
                                        g_object_unref (dbus_proxy_Device_prop);
349
349
                                
350
350
                                // on recupere son interface.
351
351
                                gchar *cInterface = cairo_dock_dbus_get_property_as_string (dbus_proxy_Device_prop, "org.freedesktop.NetworkManager.Device", "Interface");
352
 
                                g_print (" interface :%s\n", cInterface);
 
352
                                cd_debug (" interface :%s\n", cInterface);
353
353
                                
354
354
                                // on garde toutes les infos en memoire.
355
355
                                myData.cInterface = cInterface;
389
389
                                
390
390
                                if (iDeviceType == 1)
391
391
                                {
392
 
                                        g_print (" => Network-Monitor : Connexion filaire\n");
 
392
                                        cd_debug (" => Network-Monitor : Connexion filaire\n");
393
393
                                        myData.bWiredExt = TRUE;
394
394
                                        
395
395
                                        // on se connecte au changement de la propriete Carrier.
406
406
                                }
407
407
                                else
408
408
                                {
409
 
                                        g_print (" => Network-Monitor : Connexion sans fil\n");
 
409
                                        cd_debug (" => Network-Monitor : Connexion sans fil\n");
410
410
                                        myData.bWirelessExt = TRUE;
411
411
                                        
412
412
                                        // on se connecte au changement de la propriete ActiveAccessPoint.
442
442
 
443
443
void cd_NetworkMonitor_get_wireless_connection_infos (void)
444
444
{
445
 
        g_print ("%s ()\n", __func__);
 
445
        cd_debug ("%s ()\n", __func__);
446
446
        GHashTable *hProperties;
447
447
        GValue *v;
448
448
        
458
458
        if (v && G_VALUE_HOLDS_UINT (v))
459
459
        {
460
460
                myData.iSpeed = g_value_get_uint (v);
461
 
                g_print ("  Bitrate : %d\n",myData.iSpeed);
 
461
                cd_debug ("  Bitrate : %d\n",myData.iSpeed);
462
462
        }
463
463
        
464
464
        v = (GValue *)g_hash_table_lookup (hProperties, "HwAddress");
465
465
        if (v && G_VALUE_HOLDS_STRING (v))
466
466
        {
467
467
                myData.cAccessPointHwAdress = g_strdup(g_value_get_string (v));
468
 
                g_print ("  Adresse physique : %s\n",myData.cAccessPointHwAdress);
 
468
                cd_debug ("  Adresse physique : %s\n",myData.cAccessPointHwAdress);
469
469
        }
470
470
        
471
471
        v = (GValue *)g_hash_table_lookup (hProperties, "ActiveAccessPoint");
472
472
        if (v && G_VALUE_HOLDS (v, DBUS_TYPE_G_OBJECT_PATH))
473
473
        {
474
474
                gchar *cAccessPoint = g_value_get_boxed (v);
475
 
                g_print ("  Access point : %s\n", cAccessPoint);
 
475
                cd_debug ("  Access point : %s\n", cAccessPoint);
476
476
                if (cAccessPoint && strncmp (cAccessPoint, "/org/freedesktop/NetworkManager/AccessPoint/", 44) == 0)
477
477
                {
478
478
                        g_free (myData.cAccessPoint);
492
492
 
493
493
void cd_NetworkMonitor_get_wired_connection_infos (void)
494
494
{
495
 
        g_print ("%s ()\n", __func__);
 
495
        cd_debug ("%s ()\n", __func__);
496
496
        GHashTable *hProperties;
497
497
        GValue *v;
498
498
        
578
578
        if (v != NULL && G_VALUE_HOLDS_UCHAR (v))
579
579
        {
580
580
                myData.iPercent = MIN (100, (gint) g_value_get_uchar (v));  // pas clair si c'est deja des % ou s'il faut convertir par 100/255, des fois on se chope des 255 ...
581
 
                g_print ("Network-Monitor : Force du signal : %d %%\n", myData.iPercent);
 
581
                cd_debug ("Network-Monitor : Force du signal : %d %%\n", myData.iPercent);
582
582
                cd_NetworkMonitor_quality ();
583
583
                cd_NetworkMonitor_draw_icon ();
584
584
        }
587
587
        if (v != NULL && G_VALUE_HOLDS_STRING (v))
588
588
        {
589
589
                myData.cAccessPointHwAdress = g_strdup(g_value_get_string (v));
590
 
                g_print ("Network-Monitor : Adresse physique de l'AP active : %s\n", myData.cAccessPointHwAdress);
 
590
                cd_debug ("Network-Monitor : Adresse physique de l'AP active : %s\n", myData.cAccessPointHwAdress);
591
591
        }
592
592
        
593
593
        v = (GValue *)g_hash_table_lookup (hProperties, "Ssid");
599
599
                {
600
600
                        myData.cESSID[i] = a->data[i];
601
601
                }
602
 
                g_print ("Network-Monitor : SSID : %s\n", myData.cESSID);
 
602
                cd_debug ("Network-Monitor : SSID : %s\n", myData.cESSID);
603
603
        }
604
604
 
605
605
        v = (GValue *)g_hash_table_lookup (hProperties, "MaxBitrate");  // in kilobits/second (Kb/s).
626
626
        myData.iQuality = WIFI_QUALITY_NO_SIGNAL;
627
627
        if (myData.cAccessPoint != NULL)
628
628
        {
629
 
                g_print (" on recupere le nouveau point d'acces...\n");
 
629
                cd_debug (" on recupere le nouveau point d'acces...\n");
630
630
                if (myData.dbus_proxy_ActiveAccessPoint)
631
631
                {
632
632
                        dbus_g_proxy_disconnect_signal(myData.dbus_proxy_ActiveAccessPoint, "PropertiesChanged",