1 # HG changeset patch |
|
2 # User Chris Coulson |
|
3 # Parent 0ebe30f9eacfe67fa0b699457e524d5a9c96359e |
|
4 Bug 611953 - GNOME 3.0 readiness (patch 2 + 3) |
|
5 |
|
6 diff --git a/toolkit/system/gnome/nsGIOService.cpp b/toolkit/system/gnome/nsGIOService.cpp |
|
7 --- a/toolkit/system/gnome/nsGIOService.cpp |
|
8 +++ b/toolkit/system/gnome/nsGIOService.cpp |
|
9 @@ -101,25 +101,25 @@ nsGIOMimeApp::GetName(nsACString& aName) |
|
10 return NS_OK; |
|
11 } |
|
12 |
|
13 NS_IMETHODIMP |
|
14 nsGIOMimeApp::GetCommand(nsACString& aCommand) |
|
15 { |
|
16 get_commandline_t g_app_info_get_commandline_ptr; |
|
17 |
|
18 - void *libHandle = dlopen("libgio-2.0.so", RTLD_LAZY); |
|
19 + void *libHandle = dlopen("libgio-2.0.so.0", RTLD_LAZY); |
|
20 if (!libHandle) { |
|
21 return NS_ERROR_FAILURE; |
|
22 } |
|
23 dlerror(); /* clear any existing error */ |
|
24 g_app_info_get_commandline_ptr = |
|
25 (get_commandline_t) dlsym(libHandle, "g_app_info_get_commandline"); |
|
26 - if (dlerror() != NULL) { |
|
27 - const char cmd = *g_app_info_get_commandline_ptr(mApp); |
|
28 + if (dlerror() == NULL) { |
|
29 + const char *cmd = g_app_info_get_commandline_ptr(mApp); |
|
30 if (!cmd) { |
|
31 dlclose(libHandle); |
|
32 return NS_ERROR_FAILURE; |
|
33 } |
|
34 aCommand.Assign(cmd); |
|
35 } |
|
36 dlclose(libHandle); |
|
37 return NS_OK; |
|
38 @@ -277,16 +277,43 @@ nsGIOMimeApp::SetAsDefaultForFileExtensi |
|
39 } else { |
|
40 *ext_pos = '\0'; |
|
41 } |
|
42 } |
|
43 g_free(extensions); |
|
44 return NS_OK; |
|
45 } |
|
46 |
|
47 +/** |
|
48 + * Set default application for URI's of a particular scheme |
|
49 + * @param aURIScheme string containing the URI scheme |
|
50 + * @return NS_OK when application was set as default for URI scheme, |
|
51 + * NS_ERROR_FAILURE otherwise |
|
52 + */ |
|
53 +NS_IMETHODIMP |
|
54 +nsGIOMimeApp::SetAsDefaultForURIScheme(nsACString const& aURIScheme) |
|
55 +{ |
|
56 + GError *error = NULL; |
|
57 + nsCAutoString contentType("x-scheme-handler/"); |
|
58 + contentType.Append(aURIScheme); |
|
59 + |
|
60 + g_app_info_set_as_default_for_type(mApp, |
|
61 + contentType.get(), |
|
62 + &error); |
|
63 + if (error) { |
|
64 + g_warning("Cannot set application as default for URI scheme (%s): %s", |
|
65 + PromiseFlatCString(aURIScheme).get(), |
|
66 + error->message); |
|
67 + g_error_free(error); |
|
68 + return NS_ERROR_FAILURE; |
|
69 + } |
|
70 + |
|
71 + return NS_OK; |
|
72 +} |
|
73 + |
|
74 nsresult |
|
75 nsGIOService::Init() |
|
76 { |
|
77 // do nothing, gvfs/gio does not init. |
|
78 return NS_OK; |
|
79 } |
|
80 |
|
81 NS_IMPL_ISUPPORTS1(nsGIOService, nsIGIOService) |
|
82 @@ -317,29 +344,45 @@ nsGIOService::GetMimeTypeFromExtension(c |
|
83 g_free(mime_type); |
|
84 g_free(content_type); |
|
85 |
|
86 return NS_OK; |
|
87 } |
|
88 // used in nsGNOMERegistry |
|
89 // ----------------------------------------------------------------------------- |
|
90 NS_IMETHODIMP |
|
91 +nsGIOService::GetAppForURIScheme(const nsACString& aURIScheme, |
|
92 + nsIGIOMimeApp** aApp) |
|
93 +{ |
|
94 + *aApp = nsnull; |
|
95 + |
|
96 + GAppInfo *app_info = g_app_info_get_default_for_uri_scheme( |
|
97 + PromiseFlatCString(aURIScheme).get()); |
|
98 + if (app_info) { |
|
99 + nsGIOMimeApp *mozApp = new nsGIOMimeApp(app_info); |
|
100 + NS_ADDREF(*aApp = mozApp); |
|
101 + } else { |
|
102 + return NS_ERROR_FAILURE; |
|
103 + } |
|
104 + return NS_OK; |
|
105 +} |
|
106 + |
|
107 +NS_IMETHODIMP |
|
108 nsGIOService::GetAppForMimeType(const nsACString& aMimeType, |
|
109 nsIGIOMimeApp** aApp) |
|
110 { |
|
111 *aApp = nsnull; |
|
112 char *content_type = |
|
113 get_content_type_from_mime_type(PromiseFlatCString(aMimeType).get()); |
|
114 if (!content_type) |
|
115 return NS_ERROR_FAILURE; |
|
116 |
|
117 GAppInfo *app_info = g_app_info_get_default_for_type(content_type, false); |
|
118 if (app_info) { |
|
119 nsGIOMimeApp *mozApp = new nsGIOMimeApp(app_info); |
|
120 - NS_ENSURE_TRUE(mozApp, NS_ERROR_OUT_OF_MEMORY); |
|
121 NS_ADDREF(*aApp = mozApp); |
|
122 } else { |
|
123 g_free(content_type); |
|
124 return NS_ERROR_FAILURE; |
|
125 } |
|
126 g_free(content_type); |
|
127 return NS_OK; |
|
128 } |
|
129 @@ -414,75 +457,46 @@ nsGIOService::CreateAppFromCommand(nsACS |
|
130 nsIGIOMimeApp** appInfo) |
|
131 { |
|
132 GError *error = NULL; |
|
133 *appInfo = nsnull; |
|
134 |
|
135 GAppInfo *app_info = NULL, *app_info_from_list = NULL; |
|
136 GList *apps = g_app_info_get_all(); |
|
137 GList *apps_p = apps; |
|
138 - get_commandline_t g_app_info_get_commandline_ptr; |
|
139 - |
|
140 - void *libHandle = dlopen("libgio-2.0.so", RTLD_LAZY); |
|
141 - if (!libHandle) { |
|
142 - return NS_ERROR_FAILURE; |
|
143 - } |
|
144 - dlerror(); /* clear any existing error */ |
|
145 - g_app_info_get_commandline_ptr = |
|
146 - (get_commandline_t) dlsym(libHandle, "g_app_info_get_commandline"); |
|
147 - if (dlerror() != NULL) { |
|
148 - g_app_info_get_commandline_ptr = NULL; |
|
149 - } |
|
150 |
|
151 // Try to find relevant and existing GAppInfo in all installed application |
|
152 + // We do this by comparing each GAppInfo's executable with out own |
|
153 while (apps_p) { |
|
154 app_info_from_list = (GAppInfo*) apps_p->data; |
|
155 - /* This is a silly test. It just compares app names but not |
|
156 - * commands. This is due to old version of Glib/Gio. The required |
|
157 - * function which allows to do a regular check of existence of desktop file |
|
158 - * is possible by using function g_app_info_get_commandline. This function |
|
159 - * has been introduced in Glib 2.20. */ |
|
160 - if (app_info_from_list && strcmp(g_app_info_get_name(app_info_from_list), |
|
161 - PromiseFlatCString(appName).get()) == 0 ) |
|
162 - { |
|
163 - if (g_app_info_get_commandline_ptr) |
|
164 - { |
|
165 - /* Following test is only possible with Glib >= 2.20. |
|
166 - * Compare path only by using strncmp */ |
|
167 - if (strncmp(g_app_info_get_commandline_ptr(app_info_from_list), |
|
168 - PromiseFlatCString(cmd).get(), |
|
169 - strlen(PromiseFlatCString(cmd).get())) == 0) |
|
170 - { |
|
171 - app_info = app_info_from_list; |
|
172 - break; |
|
173 - } else { |
|
174 - g_object_unref(app_info_from_list); |
|
175 - } |
|
176 - } else { |
|
177 + if (!app_info) { |
|
178 + // If the executable is not absolute, get it's full path |
|
179 + char *executable = g_find_program_in_path(g_app_info_get_executable(app_info_from_list)); |
|
180 + |
|
181 + if (executable && strcmp(executable, PromiseFlatCString(cmd).get()) == 0) { |
|
182 + g_object_ref (app_info_from_list); |
|
183 app_info = app_info_from_list; |
|
184 - break; |
|
185 } |
|
186 - } else { |
|
187 - g_object_unref(app_info_from_list); |
|
188 + g_free(executable); |
|
189 } |
|
190 + |
|
191 + g_object_unref(app_info_from_list); |
|
192 apps_p = apps_p->next; |
|
193 } |
|
194 g_list_free(apps); |
|
195 |
|
196 if (!app_info) { |
|
197 app_info = g_app_info_create_from_commandline(PromiseFlatCString(cmd).get(), |
|
198 PromiseFlatCString(appName).get(), |
|
199 G_APP_INFO_CREATE_SUPPORTS_URIS, |
|
200 &error); |
|
201 } |
|
202 |
|
203 if (!app_info) { |
|
204 g_warning("Cannot create application info from command: %s", error->message); |
|
205 g_error_free(error); |
|
206 - dlclose(libHandle); |
|
207 return NS_ERROR_FAILURE; |
|
208 } |
|
209 nsGIOMimeApp *mozApp = new nsGIOMimeApp(app_info); |
|
210 NS_ENSURE_TRUE(mozApp, NS_ERROR_OUT_OF_MEMORY); |
|
211 NS_ADDREF(*appInfo = mozApp); |
|
212 - dlclose(libHandle); |
|
213 return NS_OK; |
|
214 } |
|
215 diff --git a/xpcom/system/nsIGIOService.idl b/xpcom/system/nsIGIOService.idl |
|
216 --- a/xpcom/system/nsIGIOService.idl |
|
217 +++ b/xpcom/system/nsIGIOService.idl |
|
218 @@ -39,17 +39,17 @@ |
|
219 |
|
220 #include "nsISupports.idl" |
|
221 |
|
222 interface nsIUTF8StringEnumerator; |
|
223 interface nsIURI; |
|
224 |
|
225 /* nsIGIOMimeApp holds information about an application that is looked up |
|
226 with nsIGIOService::GetAppForMimeType. */ |
|
227 -// 66009894-9877-405b-9321-bf30420e34e6 prev uuid |
|
228 +// e77021b4-4012-407d-b686-7a1f18050109 prev uuid |
|
229 |
|
230 [scriptable, uuid(e77021b4-4012-407d-b686-7a1f18050109)] |
|
231 interface nsIGIOMimeApp : nsISupports |
|
232 { |
|
233 const long EXPECTS_URIS = 0; |
|
234 const long EXPECTS_PATHS = 1; |
|
235 const long EXPECTS_URIS_FOR_NON_FILES = 2; |
|
236 |
|
237 @@ -57,41 +57,45 @@ interface nsIGIOMimeApp : nsISupports |
|
238 readonly attribute AUTF8String name; |
|
239 readonly attribute AUTF8String command; |
|
240 readonly attribute long expectsURIs; // see constants above |
|
241 readonly attribute nsIUTF8StringEnumerator supportedURISchemes; |
|
242 |
|
243 void launch(in AUTF8String uri); |
|
244 void setAsDefaultForMimeType(in AUTF8String mimeType); |
|
245 void setAsDefaultForFileExtensions(in AUTF8String extensions); |
|
246 + void setAsDefaultForURIScheme(in AUTF8String uriScheme); |
|
247 }; |
|
248 |
|
249 /* |
|
250 * The VFS service makes use of two distinct registries. |
|
251 * |
|
252 * The application registry holds information about applications (uniquely |
|
253 * identified by id), such as which MIME types and URI schemes they are |
|
254 * capable of handling, whether they run in a terminal, etc. |
|
255 * |
|
256 * The MIME registry holds information about MIME types, such as which |
|
257 * extensions map to a given MIME type. The MIME registry also stores the |
|
258 * id of the application selected to handle each MIME type. |
|
259 */ |
|
260 |
|
261 -// prev id dea20bf0-4e4d-48c5-b932-dc3e116dc64b |
|
262 -[scriptable, uuid(47e372c2-78bb-4899-8114-56aa7d9cdac5)] |
|
263 +// prev id 47e372c2-78bb-4899-8114-56aa7d9cdac5 |
|
264 +[scriptable, uuid(74ca8791-330d-4786-9569-2a2a19f0b486)] |
|
265 interface nsIGIOService : nsISupports |
|
266 { |
|
267 |
|
268 /*** MIME registry methods ***/ |
|
269 |
|
270 /* Obtain the MIME type registered for an extension. The extension |
|
271 should not include a leading dot. */ |
|
272 AUTF8String getMimeTypeFromExtension(in AUTF8String extension); |
|
273 |
|
274 + /* Obtain the preferred application for opening a given URI scheme */ |
|
275 + nsIGIOMimeApp getAppForURIScheme(in AUTF8String aURIScheme); |
|
276 + |
|
277 /* Obtain the preferred application for opening a given MIME type */ |
|
278 nsIGIOMimeApp getAppForMimeType(in AUTF8String mimeType); |
|
279 |
|
280 /* Obtain the preferred application for opening a given MIME type */ |
|
281 nsIGIOMimeApp createAppFromCommand(in AUTF8String cmd, |
|
282 in AUTF8String appName); |
|
283 |
|
284 /* Obtain a description for the given MIME type */ |
|