Annotation of /trunk/kdebase/kdebase-3.4.1-hal-0.5.patch
Parent Directory | Revision Log
Revision 27 -
(hide annotations)
(download)
Sun Jun 26 15:30:03 2005 UTC (19 years, 3 months ago) by niro
File size: 29587 byte(s)
Sun Jun 26 15:30:03 2005 UTC (19 years, 3 months ago) by niro
File size: 29587 byte(s)
new
1 | niro | 27 | This patch adds hal-0.5.x support to kdebase-3.4.1 |
2 | Niels Rogalla, <niro@magellan-linux.net> | ||
3 | |||
4 | --- kdebase-3.4.1/kioslave/media/configure.in.in.orig 2005-05-23 12:14:18.000000000 +0000 | ||
5 | +++ kdebase-3.4.1/kioslave/media/configure.in.in 2005-06-12 15:20:57.000000000 +0000 | ||
6 | @@ -12,100 +12,100 @@ | ||
7 | AC_ARG_WITH(hal,AC_HELP_STRING([--with-hal],[Enable HAL support [default=check]]),[hal_test="$withval"],[hal_test="yes"]) | ||
8 | |||
9 | if test "x$hal_test" = "xyes" ; then | ||
10 | - | ||
11 | -########### Check for the HAL, version 0.4.x | ||
12 | - | ||
13 | - AC_MSG_CHECKING(for the HAL 0.4) | ||
14 | - | ||
15 | + | ||
16 | +########### Check for the HAL | ||
17 | + | ||
18 | + AC_MSG_CHECKING(for the HAL) | ||
19 | + | ||
20 | hal_inc=NOTFOUND | ||
21 | hal_lib=NOTFOUND | ||
22 | hal=NOTFOUND | ||
23 | - | ||
24 | - search_incs="$kde_includes /usr/include /usr/local/include /usr/include/hal /usr/local/include/hal" | ||
25 | + | ||
26 | + search_incs="$kde_includes /usr/include /usr/include/hal /usr/local/include /usr/local/include/hal" | ||
27 | AC_FIND_FILE(libhal.h libhal-storage.h, $search_incs, hal_incdir) | ||
28 | - | ||
29 | + | ||
30 | if [test -r $hal_incdir/libhal.h] && [test -r $hal_incdir/libhal-storage.h] ; then | ||
31 | HAL_INCS="-I$hal_incdir" | ||
32 | hal_inc=FOUND | ||
33 | fi | ||
34 | - | ||
35 | + | ||
36 | + if test -r $hal_incdir/libhal-storage.h ; then | ||
37 | + hal_storage_version=4 | ||
38 | + grep LibHalVolume $hal_incdir/libhal-storage.h \ | ||
39 | + > /dev/null 2>&1 && hal_storage_version=5 | ||
40 | + if test $hal_storage_version = 4 ; then | ||
41 | + AC_DEFINE(HAL_0_4, , [HAL API version 0.4]) | ||
42 | + fi | ||
43 | + fi | ||
44 | + | ||
45 | search_libs="$kde_libraries /usr/lib /usr/local/lib" | ||
46 | AC_FIND_FILE(libhal.so libhal-storage.so, $search_libs, hal_libdir) | ||
47 | - | ||
48 | + | ||
49 | if [test -r $hal_libdir/libhal.so] && [test -r $hal_libdir/libhal-storage.so] ; then | ||
50 | HAL_LIBS="-L$hal_libdir -lhal -lhal-storage" | ||
51 | hal_lib=FOUND | ||
52 | fi | ||
53 | - | ||
54 | - if test -r $hal_incdir/libhal.h ; then | ||
55 | - hal_version=5 | ||
56 | - grep LibHalFunctions $hal_incdir/libhal.h \ | ||
57 | - > /dev/null 2>&1 && hal_version=4 | ||
58 | - if test $hal_version = 5 ; then | ||
59 | - hal_lib=NOT_FOUND | ||
60 | - fi | ||
61 | - fi | ||
62 | - | ||
63 | - | ||
64 | + | ||
65 | + | ||
66 | if [test $hal_inc = FOUND] && [test $hal_lib = FOUND] ; then | ||
67 | AC_MSG_RESULT(headers $hal_incdir libraries $hal_libdir) | ||
68 | hal=FOUND | ||
69 | else | ||
70 | AC_MSG_RESULT(searched but not found) | ||
71 | fi | ||
72 | - | ||
73 | + | ||
74 | AC_SUBST(HAL_INCS) | ||
75 | AC_SUBST(HAL_LIBS) | ||
76 | - | ||
77 | - | ||
78 | + | ||
79 | + | ||
80 | ########### Check for DBus | ||
81 | - | ||
82 | + | ||
83 | AC_MSG_CHECKING(for DBus) | ||
84 | - | ||
85 | + | ||
86 | dbus_inc=NOTFOUND | ||
87 | dbus_lib=NOTFOUND | ||
88 | dbus=NOTFOUND | ||
89 | - | ||
90 | - search_incs="$kde_includes /usr/include /usr/local/include /usr/include/dbus-1.0 /usr/local/include/dbus-1.0" | ||
91 | + | ||
92 | + search_incs="$kde_includes /usr/include /usr/include/dbus-1.0 /usr/local/include /usr/local/include/dbus-1.0" | ||
93 | AC_FIND_FILE(dbus/dbus.h, $search_incs, dbus_incdir) | ||
94 | - | ||
95 | + | ||
96 | search_incs_arch_deps="$kde_includes /usr/lib/dbus-1.0/include /usr/local/lib/dbus-1.0/include" | ||
97 | AC_FIND_FILE(dbus/dbus-arch-deps.h, $search_incs_arch_deps, dbus_incdir_arch_deps) | ||
98 | - | ||
99 | + | ||
100 | if [test -r $dbus_incdir/dbus/dbus.h] && [test -r $dbus_incdir_arch_deps/dbus/dbus-arch-deps.h] ; then | ||
101 | DBUS_INCS="-I$dbus_incdir -I$dbus_incdir_arch_deps" | ||
102 | dbus_inc=FOUND | ||
103 | fi | ||
104 | - | ||
105 | + | ||
106 | search_libs="$kde_libraries /usr/lib /usr/local/lib" | ||
107 | AC_FIND_FILE(libdbus-1.so, $search_libs, dbus_libdir) | ||
108 | - | ||
109 | + | ||
110 | if test -r $dbus_libdir/libdbus-1.so ; then | ||
111 | DBUS_LIBS="-L$dbus_libdir -ldbus-1" | ||
112 | dbus_lib=FOUND | ||
113 | fi | ||
114 | - | ||
115 | + | ||
116 | if [test $dbus_inc = FOUND] && [test $dbus_lib = FOUND] ; then | ||
117 | AC_MSG_RESULT(headers $dbus_incdir $dbus_incdir_arch_deps libraries $dbus_libdir) | ||
118 | dbus=FOUND | ||
119 | else | ||
120 | AC_MSG_RESULT(searched but not found) | ||
121 | fi | ||
122 | - | ||
123 | + | ||
124 | AC_SUBST(DBUS_INCS) | ||
125 | AC_SUBST(DBUS_LIBS) | ||
126 | - | ||
127 | + | ||
128 | ########### Check for DBus-Qt bindings | ||
129 | - | ||
130 | + | ||
131 | AC_MSG_CHECKING(for DBus-Qt bindings) | ||
132 | - | ||
133 | + | ||
134 | dbusqt_inc=NOTFOUND | ||
135 | dbusqt_lib=NOTFOUND | ||
136 | dbusqt=NOTFOUND | ||
137 | - | ||
138 | - search_incs="$kde_includes /usr/include /usr/local/include /usr/include/dbus-1.0 /usr/local/include/dbus-1.0" | ||
139 | + | ||
140 | + search_incs="$kde_includes /usr/include /usr/include/dbus-1.0 /usr/local/include /usr/local/include/dbus-1.0" | ||
141 | AC_FIND_FILE(dbus/connection.h, $search_incs, dbusqt_incdir) | ||
142 | - | ||
143 | + | ||
144 | if test -r $dbusqt_incdir/dbus/connection.h ; then | ||
145 | have_qt_patch=0 | ||
146 | grep dbus_connection_setup_with_qt_main $dbusqt_incdir/dbus/connection.h \ | ||
147 | @@ -115,15 +115,15 @@ | ||
148 | dbusqt_inc=FOUND | ||
149 | fi | ||
150 | fi | ||
151 | - | ||
152 | + | ||
153 | search_libs="$kde_libraries /usr/lib /usr/local/lib" | ||
154 | AC_FIND_FILE(libdbus-qt-1.so, $search_libs, dbusqt_libdir) | ||
155 | - | ||
156 | + | ||
157 | if test -r $dbusqt_libdir/libdbus-qt-1.so ; then | ||
158 | DBUSQT_LIBS="-L$dbusqt_libdir -ldbus-qt-1" | ||
159 | dbusqt_lib=FOUND | ||
160 | fi | ||
161 | - | ||
162 | + | ||
163 | if [test $dbusqt_inc = FOUND] && [test $dbusqt_lib = FOUND] ; then | ||
164 | AC_MSG_RESULT(headers $dbusqt_incdir libraries $dbusqt_libdir) | ||
165 | dbusqt=FOUND | ||
166 | --- kdebase-3.4.1/kioslave/media/kdedmodule/halbackend.h.orig 2005-05-23 12:14:18.000000000 +0000 | ||
167 | +++ kdebase-3.4.1/kioslave/media/kdedmodule/halbackend.h 2005-06-12 15:16:27.000000000 +0000 | ||
168 | @@ -35,6 +35,8 @@ | ||
169 | #include <qstringlist.h> | ||
170 | #include <qstring.h> | ||
171 | |||
172 | +#include <config.h> | ||
173 | + | ||
174 | /* We acknowledge the the dbus API is unstable */ | ||
175 | #define DBUS_API_SUBJECT_TO_CHANGE | ||
176 | /* DBus-Qt bindings */ | ||
177 | @@ -43,6 +45,65 @@ | ||
178 | #include <libhal.h> | ||
179 | #include <libhal-storage.h> | ||
180 | |||
181 | +/* The HAL API changed between 0.4 and 0.5 series. | ||
182 | +These defines enable backward compatibility */ | ||
183 | +#ifdef HAL_0_4 | ||
184 | + // libhal-storage 0.4 API | ||
185 | + #define LibHalStoragePolicy HalStoragePolicy | ||
186 | + #define LibHalDrive HalDrive | ||
187 | + #define LibHalVolume HalVolume | ||
188 | + #define LibHalVolumeDiscType HalVolumeDiscType | ||
189 | + #define libhal_storage_policy_free hal_storage_policy_free | ||
190 | + #define libhal_storage_policy_new hal_storage_policy_new | ||
191 | + #define libhal_drive_from_udi hal_drive_from_udi | ||
192 | + #define libhal_drive_find_all_volumes hal_drive_find_all_volumes | ||
193 | + #define libhal_drive_get_type hal_drive_get_type | ||
194 | + #define libhal_drive_get_device_file hal_drive_get_device_file | ||
195 | + #define libhal_drive_free hal_drive_free | ||
196 | + #define libhal_drive_policy_compute_display_name hal_drive_policy_compute_display_name | ||
197 | + #define libhal_drive_is_hotpluggable hal_drive_is_hotpluggable | ||
198 | + #define libhal_volume_from_udi hal_volume_from_udi | ||
199 | + #define libhal_volume_get_device_file hal_volume_get_device_file | ||
200 | + #define libhal_volume_get_mount_point hal_volume_get_mount_point | ||
201 | + #define libhal_volume_get_fstype hal_volume_get_fstype | ||
202 | + #define libhal_volume_is_mounted hal_volume_is_mounted | ||
203 | + #define libhal_volume_get_disc_type hal_volume_get_disc_type | ||
204 | + #define libhal_volume_free hal_volume_free | ||
205 | + #define libhal_volume_policy_compute_display_name hal_volume_policy_compute_display_name | ||
206 | + #define libhal_volume_disc_has_data hal_volume_disc_has_data | ||
207 | + #define libhal_volume_disc_has_audio hal_volume_disc_has_audio | ||
208 | + #define libhal_volume_disc_is_blank hal_volume_disc_is_blank | ||
209 | + #define libhal_volume_is_disc hal_volume_is_disc | ||
210 | + #define libhal_volume_get_storage_device_udi hal_volume_get_storage_device_udi | ||
211 | + #define LIBHAL_VOLUME_DISC_TYPE_CDROM HAL_VOLUME_DISC_TYPE_CDROM | ||
212 | + #define LIBHAL_VOLUME_DISC_TYPE_CDR HAL_VOLUME_DISC_TYPE_CDR | ||
213 | + #define LIBHAL_VOLUME_DISC_TYPE_CDRW HAL_VOLUME_DISC_TYPE_CDRW | ||
214 | + #define LIBHAL_VOLUME_DISC_TYPE_DVDROM HAL_VOLUME_DISC_TYPE_DVDROM | ||
215 | + #define LIBHAL_VOLUME_DISC_TYPE_DVDRAM HAL_VOLUME_DISC_TYPE_DVDRAM | ||
216 | + #define LIBHAL_VOLUME_DISC_TYPE_DVDR HAL_VOLUME_DISC_TYPE_DVDR | ||
217 | + #define LIBHAL_VOLUME_DISC_TYPE_DVDRW HAL_VOLUME_DISC_TYPE_DVDRW | ||
218 | + #define LIBHAL_VOLUME_DISC_TYPE_DVDPLUSR HAL_VOLUME_DISC_TYPE_DVDPLUSR | ||
219 | + #define LIBHAL_VOLUME_DISC_TYPE_DVDPLUSRW HAL_VOLUME_DISC_TYPE_DVDPLUSRW | ||
220 | + #define LIBHAL_DRIVE_TYPE_COMPACT_FLASH HAL_DRIVE_TYPE_COMPACT_FLASH | ||
221 | + #define LIBHAL_DRIVE_TYPE_MEMORY_STICK HAL_DRIVE_TYPE_MEMORY_STICK | ||
222 | + #define LIBHAL_DRIVE_TYPE_SMART_MEDIA HAL_DRIVE_TYPE_SMART_MEDIA | ||
223 | + #define LIBHAL_DRIVE_TYPE_SD_MMC HAL_DRIVE_TYPE_SD_MMC | ||
224 | + #define LIBHAL_DRIVE_TYPE_PORTABLE_AUDIO_PLAYER HAL_DRIVE_TYPE_PORTABLE_AUDIO_PLAYER | ||
225 | + #define LIBHAL_DRIVE_TYPE_CAMERA HAL_DRIVE_TYPE_CAMERA | ||
226 | + #define LIBHAL_DRIVE_TYPE_TAPE HAL_DRIVE_TYPE_TAPE | ||
227 | + | ||
228 | + // libhal 0.4 API | ||
229 | + #define libhal_free_string hal_free_string | ||
230 | + #define libhal_device_exists(ctx, udi, error) hal_device_exists(ctx, udi) | ||
231 | + #define libhal_device_property_watch_all(ctx, error) hal_device_property_watch_all(ctx) | ||
232 | + #define libhal_get_all_devices(ctx, num_devices, error) hal_get_all_devices(ctx, num_devices) | ||
233 | + #define libhal_device_property_exists(ctx, udi, key, error) hal_device_property_exists(ctx, udi, key) | ||
234 | + #define libhal_device_get_property_bool(ctx, udi, key, error) hal_device_get_property_bool(ctx, udi, key) | ||
235 | + #define libhal_device_get_property_string(ctx, udi, key, error) hal_device_get_property_string(ctx, udi, key) | ||
236 | + #define libhal_device_query_capability(ctx, udi, capability, error) hal_device_query_capability(ctx, udi, capability) | ||
237 | +#endif | ||
238 | + | ||
239 | + | ||
240 | /** | ||
241 | * A handy function to query a hal string | ||
242 | * | ||
243 | @@ -137,12 +198,14 @@ | ||
244 | |||
245 | /* Hal call-backs -- from gvm*/ | ||
246 | public: | ||
247 | +#ifdef HAL_0_4 | ||
248 | /** Invoked by libhal for integration with our mainloop. | ||
249 | * | ||
250 | * @param ctx LibHal context | ||
251 | * @param dbus_connection D-BUS connection to integrate | ||
252 | */ | ||
253 | static void hal_main_loop_integration(LibHalContext *ctx, DBusConnection *dbus_connection); | ||
254 | +#endif | ||
255 | |||
256 | /** Invoked when a device is added to the Global Device List. | ||
257 | * | ||
258 | @@ -175,7 +238,13 @@ | ||
259 | * @param message D-BUS message with variable parameters depending on condition | ||
260 | */ | ||
261 | static void hal_device_condition(LibHalContext *ctx, const char *udi, | ||
262 | - const char *condition_name, DBusMessage *message); | ||
263 | + const char *condition_name, | ||
264 | + #ifdef HAL_0_4 | ||
265 | + DBusMessage *message | ||
266 | + #else | ||
267 | + const char* message | ||
268 | + #endif | ||
269 | + ); | ||
270 | |||
271 | /* HAL and DBus structures */ | ||
272 | private: | ||
273 | @@ -184,15 +253,17 @@ | ||
274 | */ | ||
275 | LibHalContext* m_halContext; | ||
276 | |||
277 | +#ifdef HAL_0_4 | ||
278 | /** | ||
279 | * Structure defining the hal callback function for devices events | ||
280 | */ | ||
281 | LibHalFunctions m_halFunctions; | ||
282 | +#endif | ||
283 | |||
284 | /** | ||
285 | * libhal-storage HAL policy, e.g. for icon names | ||
286 | */ | ||
287 | - HalStoragePolicy* m_halStoragePolicy; | ||
288 | + LibHalStoragePolicy* m_halStoragePolicy; | ||
289 | |||
290 | /** | ||
291 | * The DBus-Qt bindings connection for mainloop integration | ||
292 | --- kdebase-3.4.1/kioslave/media/kdedmodule/halbackend.cpp.orig 2005-05-23 12:14:18.000000000 +0000 | ||
293 | +++ kdebase-3.4.1/kioslave/media/kdedmodule/halbackend.cpp 2005-06-12 15:16:27.000000000 +0000 | ||
294 | @@ -19,11 +19,13 @@ | ||
295 | #include "halbackend.h" | ||
296 | #include "linuxcdpolling.h" | ||
297 | |||
298 | +#include <stdlib.h> | ||
299 | + | ||
300 | #include <klocale.h> | ||
301 | #include <kurl.h> | ||
302 | #include <kdebug.h> | ||
303 | |||
304 | -#define MOUNT_SUFFIX (hal_volume_is_mounted(halVolume) ? QString("_mounted") : QString("_unmounted")) | ||
305 | +#define MOUNT_SUFFIX (libhal_volume_is_mounted(halVolume) ? QString("_mounted") : QString("_unmounted")) | ||
306 | |||
307 | /* Static instance of this class, for static HAL callbacks */ | ||
308 | static HALBackend* s_HALBackend; | ||
309 | @@ -33,9 +35,9 @@ | ||
310 | { | ||
311 | char* _ppt_string; | ||
312 | QString _ppt_QString; | ||
313 | - _ppt_string = hal_device_get_property_string(ctx, udi, key); | ||
314 | + _ppt_string = libhal_device_get_property_string(ctx, udi, key, NULL); | ||
315 | _ppt_QString = QString(_ppt_string ? _ppt_string : ""); | ||
316 | - hal_free_string(_ppt_string); | ||
317 | + libhal_free_string(_ppt_string); | ||
318 | return _ppt_QString; | ||
319 | } | ||
320 | |||
321 | @@ -55,14 +57,24 @@ | ||
322 | { | ||
323 | /* Close HAL connection */ | ||
324 | if (m_halContext) | ||
325 | + { | ||
326 | + #ifdef HAL_0_4 | ||
327 | hal_shutdown(m_halContext); | ||
328 | + #else | ||
329 | + libhal_ctx_shutdown(m_halContext, NULL); | ||
330 | + libhal_ctx_free(m_halContext); | ||
331 | + #endif | ||
332 | + } | ||
333 | if (m_halStoragePolicy) | ||
334 | - hal_storage_policy_free(m_halStoragePolicy); | ||
335 | + libhal_storage_policy_free(m_halStoragePolicy); | ||
336 | + | ||
337 | + /** @todo empty media list ? */ | ||
338 | } | ||
339 | |||
340 | /* Connect to the HAL */ | ||
341 | bool HALBackend::InitHal() | ||
342 | { | ||
343 | +#ifdef HAL_0_4 /* HAL API 0.4 */ | ||
344 | /* libhal initialization */ | ||
345 | m_halFunctions.main_loop_integration = HALBackend::hal_main_loop_integration; | ||
346 | m_halFunctions.device_added = HALBackend::hal_device_added; | ||
347 | @@ -75,19 +87,57 @@ | ||
348 | m_halContext = hal_initialize(&m_halFunctions, FALSE); | ||
349 | if (!m_halContext) | ||
350 | { | ||
351 | - kdDebug()<<"Failed to initialize HAL!"<<endl; | ||
352 | + kdDebug(1219) << "Failed to initialize HAL!" << endl; | ||
353 | + return false; | ||
354 | + } | ||
355 | + | ||
356 | +#else /* HAL API >= 0.5 */ | ||
357 | + kdDebug(1219) << "Context new" << endl; | ||
358 | + m_halContext = libhal_ctx_new(); | ||
359 | + if (!m_halContext) | ||
360 | + { | ||
361 | + kdDebug(1219) << "Failed to initialize HAL!" << endl; | ||
362 | + return false; | ||
363 | + } | ||
364 | + | ||
365 | + // Main loop integration | ||
366 | + kdDebug(1219) << "Main loop integration" << endl; | ||
367 | + DBusError error; | ||
368 | + dbus_error_init(&error); | ||
369 | + DBusConnection *dbus_connection = dbus_bus_get(DBUS_BUS_SYSTEM, &error); | ||
370 | + if (dbus_error_is_set(&error)) | ||
371 | + return false; | ||
372 | + MainLoopIntegration(dbus_connection); | ||
373 | + libhal_ctx_set_dbus_connection(m_halContext, dbus_connection); | ||
374 | + | ||
375 | + // HAL callback functions | ||
376 | + kdDebug(1219) << "Callback functions" << endl; | ||
377 | + libhal_ctx_set_device_added(m_halContext, HALBackend::hal_device_added); | ||
378 | + libhal_ctx_set_device_removed(m_halContext, HALBackend::hal_device_removed); | ||
379 | + libhal_ctx_set_device_new_capability (m_halContext, NULL); | ||
380 | + libhal_ctx_set_device_lost_capability (m_halContext, NULL); | ||
381 | + libhal_ctx_set_device_property_modified (m_halContext, HALBackend::hal_device_property_modified); | ||
382 | + libhal_ctx_set_device_condition(m_halContext, HALBackend::hal_device_condition); | ||
383 | + | ||
384 | + kdDebug(1219) << "Context Init" << endl; | ||
385 | + if (!libhal_ctx_init(m_halContext, NULL)) | ||
386 | + { | ||
387 | + kdDebug(1219) << "Failed to init HAL context!" << endl; | ||
388 | return false; | ||
389 | } | ||
390 | +#endif | ||
391 | |||
392 | /** @todo customize watch policy */ | ||
393 | - if (hal_device_property_watch_all(m_halContext)) | ||
394 | + kdDebug(1219) << "Watch properties" << endl; | ||
395 | + if (libhal_device_property_watch_all(m_halContext, NULL)) | ||
396 | { | ||
397 | - kdDebug()<<"Failed to watch HAL properties!"<<endl; | ||
398 | + kdDebug(1219) << "Failed to watch HAL properties!" << endl; | ||
399 | return false; | ||
400 | } | ||
401 | |||
402 | /* libhal-storage initialization */ | ||
403 | - m_halStoragePolicy = hal_storage_policy_new(); | ||
404 | + kdDebug(1219) << "Storage Policy" << endl; | ||
405 | + m_halStoragePolicy = libhal_storage_policy_new(); | ||
406 | /** @todo define libhal-storage icon policy */ | ||
407 | |||
408 | /* List devices at startup */ | ||
409 | @@ -97,13 +147,15 @@ | ||
410 | /* List devices (at startup)*/ | ||
411 | bool HALBackend::ListDevices() | ||
412 | { | ||
413 | + kdDebug(1219) << "ListDevices" << endl; | ||
414 | + | ||
415 | int numDevices; | ||
416 | - char** halDeviceList = hal_get_all_devices(m_halContext, &numDevices); | ||
417 | + char** halDeviceList = libhal_get_all_devices(m_halContext, &numDevices, NULL); | ||
418 | |||
419 | if (!halDeviceList) | ||
420 | return false; | ||
421 | |||
422 | - kdDebug() << "HALBackend::ListDevices : " << numDevices << " devices found" << endl; | ||
423 | + kdDebug(1219) << "HALBackend::ListDevices : " << numDevices << " devices found" << endl; | ||
424 | for (int i = 0; i < numDevices; i++) | ||
425 | AddDevice(halDeviceList[i]); | ||
426 | |||
427 | @@ -116,7 +168,7 @@ | ||
428 | { | ||
429 | /* We don't deal with devices that do not expose their capabilities. | ||
430 | If we don't check this, we will get a lot of warning messages from libhal */ | ||
431 | - if (!hal_device_property_exists(m_halContext, udi, "info.capabilities")) | ||
432 | + if (!libhal_device_property_exists(m_halContext, udi, "info.capabilities", NULL)) | ||
433 | return; | ||
434 | |||
435 | /* If the device is already listed, do not process. | ||
436 | @@ -126,11 +178,11 @@ | ||
437 | return; | ||
438 | |||
439 | /* Add volume block devices */ | ||
440 | - if (hal_device_query_capability(m_halContext, udi, "volume")) | ||
441 | + if (libhal_device_query_capability(m_halContext, udi, "volume", NULL)) | ||
442 | { | ||
443 | /* We only list volume that have a filesystem or volume that have an audio track*/ | ||
444 | if ( (hal_device_get_property_QString(m_halContext, udi, "volume.fsusage") != "filesystem") && | ||
445 | - (!hal_device_get_property_bool(m_halContext, udi, "volume.disc.has_audio")) ) | ||
446 | + (!libhal_device_get_property_bool(m_halContext, udi, "volume.disc.has_audio", NULL)) ) | ||
447 | return; | ||
448 | /* Query drive udi */ | ||
449 | QString driveUdi = hal_device_get_property_QString(m_halContext, udi, "block.storage_device"); | ||
450 | @@ -150,7 +202,7 @@ | ||
451 | } | ||
452 | |||
453 | /* Floppy & zip drives */ | ||
454 | - if (hal_device_query_capability(m_halContext, udi, "storage")) | ||
455 | + if (libhal_device_query_capability(m_halContext, udi, "storage", NULL)) | ||
456 | if ((hal_device_get_property_QString(m_halContext, udi, "storage.drive_type") == "floppy") || | ||
457 | (hal_device_get_property_QString(m_halContext, udi, "storage.drive_type") == "zip")) | ||
458 | { | ||
459 | @@ -162,7 +214,7 @@ | ||
460 | } | ||
461 | |||
462 | /* Camera handled by gphoto2*/ | ||
463 | - if (hal_device_query_capability(m_halContext, udi, "camera")) | ||
464 | + if (libhal_device_query_capability(m_halContext, udi, "camera", NULL)) | ||
465 | |||
466 | { | ||
467 | /* Create medium */ | ||
468 | @@ -194,7 +246,7 @@ | ||
469 | return; | ||
470 | |||
471 | QString conditionName = QString(condition); | ||
472 | - kdDebug() << "Processing device condition " << conditionName << " for " << udi << endl; | ||
473 | + kdDebug(1219) << "Processing device condition " << conditionName << " for " << udi << endl; | ||
474 | |||
475 | /* TODO: Warn the user that (s)he should unmount devices before unplugging */ | ||
476 | if (conditionName == "VolumeUnmountForced") | ||
477 | @@ -229,8 +281,8 @@ | ||
478 | return medium->id().ascii(); | ||
479 | |||
480 | /* Hard part : this is a volume whose drive is registered */ | ||
481 | - if (hal_device_property_exists(m_halContext, udi, "info.capabilities")) | ||
482 | - if (hal_device_query_capability(m_halContext, udi, "volume")) | ||
483 | + if (libhal_device_property_exists(m_halContext, udi, "info.capabilities", NULL)) | ||
484 | + if (libhal_device_query_capability(m_halContext, udi, "volume", NULL)) | ||
485 | { | ||
486 | QString driveUdi = hal_device_get_property_QString(m_halContext, udi, "block.storage_device"); | ||
487 | return findMediumUdiFromUdi(driveUdi.ascii()); | ||
488 | @@ -241,14 +293,14 @@ | ||
489 | |||
490 | void HALBackend::ResetProperties(const char* mediumUdi) | ||
491 | { | ||
492 | - kdDebug() << "HALBackend::setProperties" << endl; | ||
493 | + kdDebug(1219) << "HALBackend::setProperties" << endl; | ||
494 | |||
495 | Medium* m = new Medium(mediumUdi, ""); | ||
496 | - if (hal_device_query_capability(m_halContext, mediumUdi, "volume")) | ||
497 | + if (libhal_device_query_capability(m_halContext, mediumUdi, "volume", NULL)) | ||
498 | setVolumeProperties(m); | ||
499 | - if (hal_device_query_capability(m_halContext, mediumUdi, "storage")) | ||
500 | + if (libhal_device_query_capability(m_halContext, mediumUdi, "storage", NULL)) | ||
501 | setFloppyProperties(m); | ||
502 | - if (hal_device_query_capability(m_halContext, mediumUdi, "camera")) | ||
503 | + if (libhal_device_query_capability(m_halContext, mediumUdi, "camera", NULL)) | ||
504 | setCameraProperties(m); | ||
505 | |||
506 | m_mediaList.changeMediumState(*m); | ||
507 | @@ -258,38 +310,39 @@ | ||
508 | |||
509 | void HALBackend::setVolumeProperties(Medium* medium) | ||
510 | { | ||
511 | - kdDebug() << "HALBackend::setVolumeProperties for " << medium->id() << endl; | ||
512 | + kdDebug(1219) << "HALBackend::setVolumeProperties for " << medium->id() << endl; | ||
513 | |||
514 | const char* udi = medium->id().ascii(); | ||
515 | /* Check if the device still exists */ | ||
516 | - if (!hal_device_exists(m_halContext, udi)) | ||
517 | + if (!libhal_device_exists(m_halContext, udi, NULL)) | ||
518 | return; | ||
519 | |||
520 | /* Get device information from libhal-storage */ | ||
521 | - HalVolume* halVolume = hal_volume_from_udi(m_halContext, udi); | ||
522 | + LibHalVolume* halVolume = libhal_volume_from_udi(m_halContext, udi); | ||
523 | if (!halVolume) | ||
524 | return; | ||
525 | - | ||
526 | - QString driveUdi = hal_volume_get_storage_device_udi(halVolume); | ||
527 | - HalDrive* halDrive = hal_drive_from_udi(m_halContext, driveUdi.ascii()); | ||
528 | + QString driveUdi = libhal_volume_get_storage_device_udi(halVolume); | ||
529 | + LibHalDrive* halDrive = libhal_drive_from_udi(m_halContext, driveUdi.ascii()); | ||
530 | |||
531 | medium->setName( | ||
532 | - generateName(hal_volume_get_device_file(halVolume)) ); | ||
533 | + generateName(libhal_volume_get_device_file(halVolume)) ); | ||
534 | |||
535 | medium->mountableState( | ||
536 | - hal_volume_get_device_file(halVolume), /* Device node */ | ||
537 | - hal_volume_get_mount_point(halVolume), /* Mount point */ | ||
538 | - hal_volume_get_fstype(halVolume), /* Filesystem type */ | ||
539 | - hal_volume_is_mounted(halVolume) ); /* Mounted ? */ | ||
540 | + libhal_volume_get_device_file(halVolume), /* Device node */ | ||
541 | + libhal_volume_get_mount_point(halVolume), /* Mount point */ | ||
542 | + libhal_volume_get_fstype(halVolume), /* Filesystem type */ | ||
543 | + libhal_volume_is_mounted(halVolume) ); /* Mounted ? */ | ||
544 | |||
545 | QString mimeType; | ||
546 | - if (hal_volume_is_disc(halVolume)) | ||
547 | + if (libhal_volume_is_disc(halVolume)) | ||
548 | { | ||
549 | mimeType = "media/cdrom" + MOUNT_SUFFIX; | ||
550 | |||
551 | - HalVolumeDiscType discType = hal_volume_get_disc_type(halVolume); | ||
552 | - if ((discType == HAL_VOLUME_DISC_TYPE_CDR) || (discType == HAL_VOLUME_DISC_TYPE_CDRW)) | ||
553 | - if (hal_volume_disc_is_blank(halVolume)) | ||
554 | + LibHalVolumeDiscType discType = libhal_volume_get_disc_type(halVolume); | ||
555 | + if ((discType == LIBHAL_VOLUME_DISC_TYPE_CDROM) || | ||
556 | + (discType == LIBHAL_VOLUME_DISC_TYPE_CDR) || | ||
557 | + (discType == LIBHAL_VOLUME_DISC_TYPE_CDRW)) | ||
558 | + if (libhal_volume_disc_is_blank(halVolume)) | ||
559 | { | ||
560 | mimeType = "media/blankcd"; | ||
561 | medium->unmountableState(""); | ||
562 | @@ -297,10 +350,10 @@ | ||
563 | else | ||
564 | mimeType = "media/cdwriter" + MOUNT_SUFFIX; | ||
565 | |||
566 | - if ((discType == HAL_VOLUME_DISC_TYPE_DVDROM) || (discType == HAL_VOLUME_DISC_TYPE_DVDRAM) || | ||
567 | - (discType == HAL_VOLUME_DISC_TYPE_DVDR) || (discType == HAL_VOLUME_DISC_TYPE_DVDRW) || | ||
568 | - (discType == HAL_VOLUME_DISC_TYPE_DVDPLUSR) || (discType == HAL_VOLUME_DISC_TYPE_DVDPLUSRW) ) | ||
569 | - if (hal_volume_disc_is_blank(halVolume)) | ||
570 | + if ((discType == LIBHAL_VOLUME_DISC_TYPE_DVDROM) || (discType == LIBHAL_VOLUME_DISC_TYPE_DVDRAM) || | ||
571 | + (discType == LIBHAL_VOLUME_DISC_TYPE_DVDR) || (discType == LIBHAL_VOLUME_DISC_TYPE_DVDRW) || | ||
572 | + (discType == LIBHAL_VOLUME_DISC_TYPE_DVDPLUSR) || (discType == LIBHAL_VOLUME_DISC_TYPE_DVDPLUSRW) ) | ||
573 | + if (libhal_volume_disc_is_blank(halVolume)) | ||
574 | { | ||
575 | mimeType = "media/blankdvd"; | ||
576 | medium->unmountableState(""); | ||
577 | @@ -308,16 +361,16 @@ | ||
578 | else | ||
579 | mimeType = "media/dvd" + MOUNT_SUFFIX; | ||
580 | |||
581 | - if (hal_volume_disc_has_audio(halVolume) && !hal_volume_disc_has_data(halVolume)) | ||
582 | + if (libhal_volume_disc_has_audio(halVolume) && !libhal_volume_disc_has_data(halVolume)) | ||
583 | { | ||
584 | mimeType = "media/audiocd"; | ||
585 | - medium->unmountableState( "audiocd:/?device=" + QString(hal_volume_get_device_file(halVolume)) ); | ||
586 | + medium->unmountableState( "audiocd:/?device=" + QString(libhal_volume_get_device_file(halVolume)) ); | ||
587 | } | ||
588 | |||
589 | medium->setIconName(QString::null); | ||
590 | - | ||
591 | + | ||
592 | /* check if the disc id a vcd or a video dvd */ | ||
593 | - DiscType type = LinuxCDPolling::identifyDiscType(hal_volume_get_device_file(halVolume)); | ||
594 | + DiscType type = LinuxCDPolling::identifyDiscType(libhal_volume_get_device_file(halVolume)); | ||
595 | switch (type) | ||
596 | { | ||
597 | case DiscType::VCD: | ||
598 | @@ -334,81 +387,85 @@ | ||
599 | else | ||
600 | { | ||
601 | mimeType = "media/hdd" + MOUNT_SUFFIX; | ||
602 | - if (hal_drive_is_hotpluggable(halDrive)) | ||
603 | - { | ||
604 | + if (libhal_drive_is_hotpluggable(halDrive)) | ||
605 | + { | ||
606 | mimeType = "media/removable" + MOUNT_SUFFIX; | ||
607 | medium->needMounting(); | ||
608 | - switch (hal_drive_get_type(halDrive)) { | ||
609 | - case HAL_DRIVE_TYPE_COMPACT_FLASH: | ||
610 | + switch (libhal_drive_get_type(halDrive)) { | ||
611 | + case LIBHAL_DRIVE_TYPE_COMPACT_FLASH: | ||
612 | medium->setIconName("compact_flash" + MOUNT_SUFFIX); | ||
613 | break; | ||
614 | - case HAL_DRIVE_TYPE_MEMORY_STICK: | ||
615 | + case LIBHAL_DRIVE_TYPE_MEMORY_STICK: | ||
616 | medium->setIconName("memory_stick" + MOUNT_SUFFIX); | ||
617 | break; | ||
618 | - case HAL_DRIVE_TYPE_SMART_MEDIA: | ||
619 | + case LIBHAL_DRIVE_TYPE_SMART_MEDIA: | ||
620 | medium->setIconName("smart_media" + MOUNT_SUFFIX); | ||
621 | break; | ||
622 | - case HAL_DRIVE_TYPE_SD_MMC: | ||
623 | + case LIBHAL_DRIVE_TYPE_SD_MMC: | ||
624 | medium->setIconName("sd_mmc" + MOUNT_SUFFIX); | ||
625 | break; | ||
626 | - case HAL_DRIVE_TYPE_PORTABLE_AUDIO_PLAYER: | ||
627 | + case LIBHAL_DRIVE_TYPE_PORTABLE_AUDIO_PLAYER: | ||
628 | medium->setIconName(QString::null); //FIXME need icon | ||
629 | break; | ||
630 | - case HAL_DRIVE_TYPE_CAMERA: | ||
631 | + case LIBHAL_DRIVE_TYPE_CAMERA: | ||
632 | medium->setIconName("camera" + MOUNT_SUFFIX); | ||
633 | - break; | ||
634 | - case HAL_DRIVE_TYPE_TAPE: | ||
635 | + break; | ||
636 | + case LIBHAL_DRIVE_TYPE_TAPE: | ||
637 | medium->setIconName(QString::null); //FIXME need icon | ||
638 | - break; | ||
639 | - default: | ||
640 | + break; | ||
641 | + default: | ||
642 | medium->setIconName(QString::null); | ||
643 | }; | ||
644 | }; | ||
645 | } | ||
646 | medium->setMimeType(mimeType); | ||
647 | |||
648 | - medium->setLabel(QString::fromUtf8( hal_volume_policy_compute_display_name(halDrive, | ||
649 | - halVolume, m_halStoragePolicy) ) ); | ||
650 | + char* name = libhal_volume_policy_compute_display_name(halDrive, halVolume, m_halStoragePolicy); | ||
651 | + //char* name = libhal_drive_policy_compute_display_name(halDrive, halVolume, m_halStoragePolicy); | ||
652 | + QString volume_name = QString::fromUtf8(name); | ||
653 | + QString media_name = volume_name; | ||
654 | + medium->setLabel(media_name); | ||
655 | + free(name); | ||
656 | |||
657 | - hal_drive_free(halDrive); | ||
658 | - hal_volume_free(halVolume); | ||
659 | + libhal_drive_free(halDrive); | ||
660 | + libhal_volume_free(halVolume); | ||
661 | } | ||
662 | |||
663 | // Handle floppies and zip drives | ||
664 | void HALBackend::setFloppyProperties(Medium* medium) | ||
665 | { | ||
666 | - kdDebug() << "HALBackend::setFloppyProperties for " << medium->id() << endl; | ||
667 | + kdDebug(1219) << "HALBackend::setFloppyProperties for " << medium->id() << endl; | ||
668 | |||
669 | const char* udi = medium->id().ascii(); | ||
670 | /* Check if the device still exists */ | ||
671 | - if (!hal_device_exists(m_halContext, udi)) | ||
672 | + if (!libhal_device_exists(m_halContext, udi, NULL)) | ||
673 | return; | ||
674 | |||
675 | - HalDrive* halDrive = hal_drive_from_udi(m_halContext, udi); | ||
676 | + LibHalDrive* halDrive = libhal_drive_from_udi(m_halContext, udi); | ||
677 | if (!halDrive) | ||
678 | return; | ||
679 | int numVolumes; | ||
680 | - char** volumes = hal_drive_find_all_volumes(m_halContext, halDrive, &numVolumes); | ||
681 | - HalVolume* halVolume = NULL; | ||
682 | - kdDebug() << " found " << numVolumes << " volumes" << endl; | ||
683 | + char** volumes = libhal_drive_find_all_volumes(m_halContext, halDrive, &numVolumes); | ||
684 | + LibHalVolume* halVolume = NULL; | ||
685 | + kdDebug(1219) << " found " << numVolumes << " volumes" << endl; | ||
686 | if (numVolumes) | ||
687 | - halVolume = hal_volume_from_udi(m_halContext, volumes[0]); | ||
688 | + halVolume = libhal_volume_from_udi(m_halContext, volumes[0]); | ||
689 | |||
690 | medium->setName( | ||
691 | - generateName(hal_drive_get_device_file(halDrive)) ); | ||
692 | + generateName(libhal_drive_get_device_file(halDrive)) ); | ||
693 | |||
694 | if (halVolume) | ||
695 | { | ||
696 | medium->mountableState( | ||
697 | - hal_volume_get_device_file(halVolume), /* Device node */ | ||
698 | - hal_volume_get_mount_point(halVolume), /* Mount point */ | ||
699 | - hal_volume_get_fstype(halVolume), /* Filesystem type */ | ||
700 | - hal_volume_is_mounted(halVolume) ); /* Mounted ? */ | ||
701 | + libhal_volume_get_device_file(halVolume), /* Device node */ | ||
702 | + libhal_volume_get_mount_point(halVolume), /* Mount point */ | ||
703 | + libhal_volume_get_fstype(halVolume), /* Filesystem type */ | ||
704 | + libhal_volume_is_mounted(halVolume) ); /* Mounted ? */ | ||
705 | } | ||
706 | else | ||
707 | { | ||
708 | medium->mountableState( | ||
709 | - hal_drive_get_device_file(halDrive), /* Device node */ | ||
710 | + libhal_drive_get_device_file(halDrive), /* Device node */ | ||
711 | "", /* Mount point */ | ||
712 | "", /* Filesystem type */ | ||
713 | false ); /* Mounted ? */ | ||
714 | @@ -421,7 +478,7 @@ | ||
715 | else | ||
716 | medium->setMimeType("media/floppy_unmounted"); | ||
717 | } | ||
718 | - | ||
719 | + | ||
720 | if (hal_device_get_property_QString(m_halContext, udi, "storage.drive_type") == "zip") | ||
721 | { | ||
722 | if (halVolume) | ||
723 | @@ -429,23 +486,38 @@ | ||
724 | else | ||
725 | medium->setMimeType("media/zip_unmounted"); | ||
726 | } | ||
727 | - | ||
728 | + | ||
729 | medium->setIconName(QString::null); | ||
730 | |||
731 | - medium->setLabel(QString::fromUtf8( hal_drive_policy_compute_display_name(halDrive, | ||
732 | - halVolume, m_halStoragePolicy) ) ); | ||
733 | + QString media_name; | ||
734 | + if (halVolume) | ||
735 | + { | ||
736 | + char* name = libhal_drive_policy_compute_display_name(halDrive, halVolume, m_halStoragePolicy); | ||
737 | + QString volume_name = QString::fromUtf8(name); | ||
738 | + media_name = volume_name; | ||
739 | + free(name); | ||
740 | + } | ||
741 | + else | ||
742 | + { | ||
743 | + char* name = libhal_drive_policy_compute_display_name(halDrive, halVolume, m_halStoragePolicy); | ||
744 | + QString drive_name = QString::fromUtf8(name); | ||
745 | + media_name = drive_name; | ||
746 | + free(name); | ||
747 | + } | ||
748 | + medium->setLabel(media_name); | ||
749 | |||
750 | - hal_drive_free(halDrive); | ||
751 | - hal_volume_free(halVolume); | ||
752 | + free(volumes); | ||
753 | + libhal_drive_free(halDrive); | ||
754 | + libhal_volume_free(halVolume); | ||
755 | } | ||
756 | |||
757 | void HALBackend::setCameraProperties(Medium* medium) | ||
758 | { | ||
759 | - kdDebug() << "HALBackend::setCameraProperties for " << medium->id() << endl; | ||
760 | + kdDebug(1219) << "HALBackend::setCameraProperties for " << medium->id() << endl; | ||
761 | |||
762 | const char* udi = medium->id().ascii(); | ||
763 | /* Check if the device still exists */ | ||
764 | - if (!hal_device_exists(m_halContext, udi)) | ||
765 | + if (!libhal_device_exists(m_halContext, udi, NULL)) | ||
766 | return; | ||
767 | |||
768 | /** @todo find name */ | ||
769 | @@ -467,24 +539,26 @@ | ||
770 | ** HAL CALL-BACKS ** | ||
771 | ******************************************/ | ||
772 | |||
773 | +#ifdef HAL_0_4 | ||
774 | void HALBackend::hal_main_loop_integration(LibHalContext *ctx, | ||
775 | DBusConnection *dbus_connection) | ||
776 | { | ||
777 | - kdDebug() << "HALBackend::hal_main_loop_integration" << endl; | ||
778 | + kdDebug(1219) << "HALBackend::hal_main_loop_integration" << endl; | ||
779 | Q_UNUSED(ctx); | ||
780 | s_HALBackend->MainLoopIntegration(dbus_connection); | ||
781 | } | ||
782 | +#endif | ||
783 | |||
784 | void HALBackend::hal_device_added(LibHalContext *ctx, const char *udi) | ||
785 | { | ||
786 | - kdDebug() << "HALBackend::hal_device_added " << udi << endl; | ||
787 | + kdDebug(1219) << "HALBackend::hal_device_added " << udi << endl; | ||
788 | Q_UNUSED(ctx); | ||
789 | s_HALBackend->AddDevice(udi); | ||
790 | } | ||
791 | |||
792 | void HALBackend::hal_device_removed(LibHalContext *ctx, const char *udi) | ||
793 | { | ||
794 | - kdDebug() << "HALBackend::hal_device_removed " << udi << endl; | ||
795 | + kdDebug(1219) << "HALBackend::hal_device_removed " << udi << endl; | ||
796 | Q_UNUSED(ctx); | ||
797 | s_HALBackend->RemoveDevice(udi); | ||
798 | } | ||
799 | @@ -492,16 +566,23 @@ | ||
800 | void HALBackend::hal_device_property_modified(LibHalContext *ctx, const char *udi, | ||
801 | const char *key, dbus_bool_t is_removed, dbus_bool_t is_added) | ||
802 | { | ||
803 | - kdDebug() << "HALBackend::hal_property_modified " << udi << " -- " << key << endl; | ||
804 | + kdDebug(1219) << "HALBackend::hal_property_modified " << udi << " -- " << key << endl; | ||
805 | Q_UNUSED(ctx); | ||
806 | Q_UNUSED(is_removed); | ||
807 | Q_UNUSED(is_added); | ||
808 | s_HALBackend->ModifyDevice(udi, key); | ||
809 | } | ||
810 | + | ||
811 | void HALBackend::hal_device_condition(LibHalContext *ctx, const char *udi, | ||
812 | - const char *condition_name, DBusMessage *message) | ||
813 | + const char *condition_name, | ||
814 | + #ifdef HAL_0_4 | ||
815 | + DBusMessage *message | ||
816 | + #else | ||
817 | + const char* message | ||
818 | + #endif | ||
819 | + ) | ||
820 | { | ||
821 | - kdDebug() << "HALBackend::hal_device_condition " << udi << " -- " << condition_name << endl; | ||
822 | + kdDebug(1219) << "HALBackend::hal_device_condition " << udi << " -- " << condition_name << endl; | ||
823 | Q_UNUSED(ctx); | ||
824 | Q_UNUSED(message); | ||
825 | s_HALBackend->DeviceCondition(udi, condition_name); |
Properties
Name | Value |
---|---|
svn:executable | * |