gio/gwin32appinfo.c

   1 /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright (C) 2006-2007 Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  *
  20  * Author: Alexander Larsson <alexl@redhat.com>
  21  */
  22
  23 #include "config.h"
  24
  25 #include <string.h>
  26
  27 #include "gcontenttypeprivate.h"
  28 #include "gwin32appinfo.h"
  29 #include "gappinfo.h"
  30 #include "gioerror.h"
  31 #include "gfile.h"
  32 #include <glib/gstdio.h>
  33 #include "glibintl.h"
  34
  35 #include <windows.h>
  36 #include <shlwapi.h>
  37
  38
  39 #ifndef ASSOCF_INIT_BYEXENAME
  40 #define ASSOCF_INIT_BYEXENAME 0x00000002
  41 #endif
  42
  43 /* These were wrong in MingW */
  44 #define REAL_ASSOCSTR_COMMAND 1
  45 #define REAL_ASSOCSTR_EXECUTABLE 2
  46 #define REAL_ASSOCSTR_FRIENDLYDOCNAME 3
  47 #define REAL_ASSOCSTR_FRIENDLYAPPNAME 4
  48
  49 #ifndef AssocQueryString
  50 #pragma message("AssocQueryString not available with SDK used")
  51 #endif
  52
  53 static void g_win32_app_info_iface_init (GAppInfoIface *iface);
  54
  55 struct _GWin32AppInfo
  56 {
  57   GObject parent_instance;
  58   wchar_t *id;
  59   char *id_utf8;
  60   gboolean id_is_exename;
  61   char *executable;
  62   char *name;
  63   gboolean no_open_with;
  64 };
  65
  66 G_DEFINE_TYPE_WITH_CODE (GWin32AppInfo, g_win32_app_info, G_TYPE_OBJECT,
  67                          G_IMPLEMENT_INTERFACE (G_TYPE_APP_INFO,
  68                                                 g_win32_app_info_iface_init))
  69
  70
  71 static void
  72 g_win32_app_info_finalize (GObject *object)
  73 {
  74   GWin32AppInfo *info;
  75
  76   info = G_WIN32_APP_INFO (object);
  77
  78   g_free (info->id);
  79   g_free (info->id_utf8);
  80   g_free (info->name);
  81   g_free (info->executable);
  82
  83   G_OBJECT_CLASS (g_win32_app_info_parent_class)->finalize (object);
  84 }
  85
  86 static void
  87 g_win32_app_info_class_init (GWin32AppInfoClass *klass)
  88 {
  89   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
  90
  91   gobject_class->finalize = g_win32_app_info_finalize;
  92 }
  93
  94 static void
  95 g_win32_app_info_init (GWin32AppInfo *local)
  96 {
  97 }
  98
  99 static GAppInfo *
 100 g_desktop_app_info_new_from_id (wchar_t *id /* takes ownership */,
 101                                 gboolean id_is_exename)
 102 {
 103 #ifdef AssocQueryString
 104   ASSOCF flags;
 105 #endif
 106   wchar_t buffer[1024];
 107   DWORD buffer_size;
 108   GWin32AppInfo *info;
 109   HKEY app_key;
 110
 111   info = g_object_new (G_TYPE_WIN32_APP_INFO, NULL);
 112   info->id = id; /* Takes ownership */
 113   info->id_utf8 = g_utf16_to_utf8 (id, -1, NULL, NULL, NULL);
 114   info->id_is_exename = id_is_exename;
 115
 116 #ifdef AssocQueryString
 117   flags = 0;
 118   if (id_is_exename)
 119     flags |= ASSOCF_INIT_BYEXENAME;
 120
 121   buffer_size = 1024;
 122   if (AssocQueryStringW(flags,
 123                         REAL_ASSOCSTR_EXECUTABLE,
 124                         id,
 125                         NULL,
 126                         buffer,
 127                         &buffer_size) == S_OK)
 128     info->executable = g_utf16_to_utf8 (buffer, -1, NULL, NULL, NULL);
 129
 130   buffer_size = 1024;
 131   if (AssocQueryStringW(flags,
 132                         REAL_ASSOCSTR_FRIENDLYAPPNAME,
 133                         id,
 134                         NULL,
 135                         buffer,
 136                         &buffer_size) == S_OK)
 137     info->name = g_utf16_to_utf8 (buffer, -1, NULL, NULL, NULL);
 138 #endif
 139
 140   if (info->name == NULL)
 141     {
 142       /* TODO: Should look up name from executable resources */
 143       if (info->executable)
 144         info->name = g_path_get_basename (info->executable);
 145       else
 146         info->name = g_strdup (info->id_utf8);
 147     }
 148
 149 #ifdef AssocQueryString
 150   if (AssocQueryKeyW(flags,
 151                      ASSOCKEY_APP,
 152                      info->id,
 153                      NULL,
 154                      &app_key) == S_OK)
 155     {
 156       if (RegQueryValueExW (app_key, L"NoOpenWith", 0,
 157                             NULL, NULL, NULL) == ERROR_SUCCESS)
 158         info->no_open_with = TRUE;
 159       RegCloseKey (app_key);
 160     }
 161 #endif
 162
 163   return G_APP_INFO (info);
 164 }
 165
 166 static wchar_t *
 167 dup_wstring (wchar_t *str)
 168 {
 169   gsize len;
 170   for (len = 0; str[len] != 0; len++)
 171     ;
 172   return (wchar_t *)g_memdup (str, (len + 1) * 2);
 173 }
 174
 175 static GAppInfo *
 176 g_win32_app_info_dup (GAppInfo *appinfo)
 177 {
 178   GWin32AppInfo *info = G_WIN32_APP_INFO (appinfo);
 179   GWin32AppInfo *new_info;
 180
 181   new_info = g_object_new (G_TYPE_WIN32_APP_INFO, NULL);
 182
 183   new_info->id = dup_wstring (info->id);
 184   new_info->id_utf8 = g_strdup (info->id_utf8);
 185   new_info->id_is_exename = info->id_is_exename;
 186   new_info->name = g_strdup (info->name);
 187   new_info->executable = g_strdup (info->executable);
 188   new_info->no_open_with = info->no_open_with;
 189
 190   return G_APP_INFO (new_info);
 191 }
 192
 193 static gboolean
 194 g_win32_app_info_equal (GAppInfo *appinfo1,
 195                         GAppInfo *appinfo2)
 196 {
 197   GWin32AppInfo *info1 = G_WIN32_APP_INFO (appinfo1);
 198   GWin32AppInfo *info2 = G_WIN32_APP_INFO (appinfo2);
 199
 200   if (info1->executable == NULL ||
 201       info2->executable == NULL)
 202     return FALSE;
 203
 204   return strcmp (info1->executable, info2->executable) == 0;
 205 }
 206
 207 static const char *
 208 g_win32_app_info_get_id (GAppInfo *appinfo)
 209 {
 210   GWin32AppInfo *info = G_WIN32_APP_INFO (appinfo);
 211
 212   return info->id_utf8;
 213 }
 214
 215 static const char *
 216 g_win32_app_info_get_name (GAppInfo *appinfo)
 217 {
 218   GWin32AppInfo *info = G_WIN32_APP_INFO (appinfo);
 219
 220   if (info->name == NULL)
 221     return _("Unnamed");
 222
 223   return info->name;
 224 }
 225
 226 static const char *
 227 g_win32_app_info_get_description (GAppInfo *appinfo)
 228 {
 229   /* Win32 has no app descriptions */
 230   return NULL;
 231 }
 232
 233 static const char *
 234 g_win32_app_info_get_executable (GAppInfo *appinfo)
 235 {
 236   GWin32AppInfo *info = G_WIN32_APP_INFO (appinfo);
 237
 238   return info->executable;
 239 }
 240
 241 static GIcon *
 242 g_win32_app_info_get_icon (GAppInfo *appinfo)
 243 {
 244   /* GWin32AppInfo *info = G_WIN32_APP_INFO (appinfo); */
 245
 246   /* TODO: How to handle icons */
 247   return NULL;
 248 }
 249
 250 static gboolean
 251 g_win32_app_info_launch (GAppInfo           *appinfo,
 252                          GList              *files,
 253                          GAppLaunchContext  *launch_context,
 254                          GError            **error)
 255 {
 256   GWin32AppInfo *info = G_WIN32_APP_INFO (appinfo);
 257 #ifdef AssocQueryString
 258   ASSOCF flags;
 259 #endif
 260   HKEY class_key;
 261   SHELLEXECUTEINFOW exec_info = {0};
 262   GList *l;
 263
 264   /* TODO:  What might startup_id mean on win32? */
 265 #ifdef AssocQueryString
 266   flags = 0;
 267   if (info->id_is_exename)
 268     flags |= ASSOCF_INIT_BYEXENAME;
 269
 270   if (AssocQueryKeyW (flags,
 271                       ASSOCKEY_SHELLEXECCLASS,
 272                       info->id,
 273                       NULL,
 274                       &class_key) != S_OK)
 275     {
 276       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, _("Can't find application"));
 277       return FALSE;
 278     }
 279 #endif
 280
 281   for (l = files; l != NULL; l = l->next)
 282     {
 283       char *path = g_file_get_path (l->data);
 284       wchar_t *wfilename = g_utf8_to_utf16 (path, -1, NULL, NULL, NULL);
 285
 286       g_free (path);
 287
 288       memset (&exec_info, 0, sizeof (exec_info));
 289       exec_info.cbSize = sizeof (exec_info);
 290       exec_info.fMask = SEE_MASK_FLAG_DDEWAIT | SEE_MASK_CLASSKEY;
 291       exec_info.lpFile = wfilename;
 292       exec_info.nShow = SW_SHOWNORMAL;
 293       exec_info.hkeyClass = class_key;
 294
 295       if (!ShellExecuteExW (&exec_info))
 296         {
 297           char *message_utf8 = g_win32_error_message (GetLastError ());
 298
 299           g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, _("Error launching application: %s"), message_utf8);
 300           g_free (message_utf8);
 301
 302           g_free (wfilename);
 303           RegCloseKey (class_key);
 304           return FALSE;
 305         }
 306
 307       g_free (wfilename);
 308     }
 309
 310   RegCloseKey (class_key);
 311
 312   return TRUE;
 313 }
 314
 315 static gboolean
 316 g_win32_app_info_supports_uris (GAppInfo *appinfo)
 317 {
 318   return FALSE;
 319 }
 320
 321 static gboolean
 322 g_win32_app_info_supports_files (GAppInfo *appinfo)
 323 {
 324   return TRUE;
 325 }
 326
 327 static gboolean
 328 g_win32_app_info_launch_uris (GAppInfo           *appinfo,
 329                               GList              *uris,
 330                               GAppLaunchContext  *launch_context,
 331                               GError            **error)
 332 {
 333   g_set_error_literal (error, G_IO_ERROR,
 334                        G_IO_ERROR_NOT_SUPPORTED,
 335                        _("URIs not supported"));
 336   return FALSE;
 337 }
 338
 339 static gboolean
 340 g_win32_app_info_should_show (GAppInfo *appinfo)
 341 {
 342   GWin32AppInfo *info = G_WIN32_APP_INFO (appinfo);
 343
 344   if (info->no_open_with)
 345     return FALSE;
 346
 347   return TRUE;
 348 }
 349
 350 static gboolean
 351 g_win32_app_info_set_as_default_for_type (GAppInfo    *appinfo,
 352                                           const char  *content_type,
 353                                           GError     **error)
 354 {
 355   g_set_error_literal (error, G_IO_ERROR,
 356                        G_IO_ERROR_NOT_SUPPORTED,
 357                        _("association changes not supported on win32"));
 358   return FALSE;
 359 }
 360
 361 GAppInfo *
 362 g_app_info_create_from_commandline (const char           *commandline,
 363                                     const char           *application_name,
 364                                     GAppInfoCreateFlags   flags,
 365                                     GError              **error)
 366 {
 367   g_set_error_literal (error, G_IO_ERROR,
 368                        G_IO_ERROR_NOT_SUPPORTED,
 369                        _("Association creation not supported on win32"));
 370   return NULL;
 371 }
 372
 373
 374 static void
 375 g_win32_app_info_iface_init (GAppInfoIface *iface)
 376 {
 377   iface->dup = g_win32_app_info_dup;
 378   iface->equal = g_win32_app_info_equal;
 379   iface->get_id = g_win32_app_info_get_id;
 380   iface->get_name = g_win32_app_info_get_name;
 381   iface->get_description = g_win32_app_info_get_description;
 382   iface->get_executable = g_win32_app_info_get_executable;
 383   iface->get_icon = g_win32_app_info_get_icon;
 384   iface->launch = g_win32_app_info_launch;
 385   iface->supports_uris = g_win32_app_info_supports_uris;
 386   iface->supports_files = g_win32_app_info_supports_files;
 387   iface->launch_uris = g_win32_app_info_launch_uris;
 388   iface->should_show = g_win32_app_info_should_show;
 389   iface->set_as_default_for_type = g_win32_app_info_set_as_default_for_type;
 390 }
 391
 392 static void
 393 enumerate_open_with_list (HKEY    dir_key,
 394                           GList **prognames)
 395 {
 396   DWORD index;
 397   wchar_t name[256];
 398   DWORD name_len, nbytes;
 399   wchar_t data[256];
 400   wchar_t *data_alloc;
 401   DWORD type;
 402
 403   /* Must also look inside for a,b,c, + MRUList */
 404   index = 0;
 405   name_len = 256;
 406   nbytes = sizeof (data) - 2;
 407   while (RegEnumValueW (dir_key,
 408                         index,
 409                         name,
 410                         &name_len,
 411                         0,
 412                         &type,
 413                         (LPBYTE)data,
 414                         &nbytes) == ERROR_SUCCESS)
 415     {
 416       data[nbytes/2] = '\0';
 417       if (type == REG_SZ &&
 418           /* Ignore things like MRUList, just look at 'a', 'b', 'c', etc */
 419           name_len == 1)
 420         {
 421           data_alloc = (wchar_t *)g_memdup (data, nbytes + 2);
 422           data_alloc[nbytes/2] = 0;
 423           *prognames = g_list_prepend (*prognames, data_alloc);
 424         }
 425       index++;
 426       name_len = 256;
 427       nbytes = sizeof (data) - 2;
 428     }
 429
 430   index = 0;
 431   name_len = 256;
 432   while (RegEnumKeyExW (dir_key,
 433                         index,
 434                         name,
 435                         &name_len,
 436                         NULL,
 437                         NULL,
 438                         NULL,
 439                         NULL) == ERROR_SUCCESS)
 440     {
 441       *prognames = g_list_prepend (*prognames, g_memdup (name, (name_len + 1) * 2));
 442       index++;
 443       name_len = 256;
 444     }
 445 }
 446
 447 static void
 448 enumerate_open_with_progids (HKEY dir_key,
 449                              GList **progids)
 450 {
 451   DWORD index;
 452   wchar_t name[256];
 453   DWORD name_len, type;
 454
 455   index = 0;
 456   name_len = 256;
 457   while (RegEnumValueW (dir_key,
 458                         index,
 459                         name,
 460                         &name_len,
 461                         0,
 462                         &type,
 463                         NULL,
 464                         0) == ERROR_SUCCESS)
 465     {
 466       *progids = g_list_prepend (*progids, g_memdup (name, (name_len + 1) * 2));
 467       index++;
 468       name_len = 256;
 469     }
 470 }
 471
 472 static void
 473 enumerate_open_with_root (HKEY    dir_key,
 474                           GList **progids,
 475                           GList **prognames)
 476 {
 477   HKEY reg_key = NULL;
 478
 479   if (RegOpenKeyExW (dir_key, L"OpenWithList", 0,
 480                      KEY_READ, &reg_key) == ERROR_SUCCESS)
 481     {
 482       enumerate_open_with_list (reg_key, prognames);
 483       RegCloseKey (reg_key);
 484     }
 485
 486   if (RegOpenKeyExW (dir_key, L"OpenWithProgids", 0,
 487                      KEY_QUERY_VALUE, &reg_key) == ERROR_SUCCESS)
 488     {
 489       enumerate_open_with_progids (reg_key, progids);
 490       RegCloseKey (reg_key);
 491     }
 492 }
 493
 494 static gboolean
 495 app_info_in_list (GAppInfo *info,
 496                   GList    *list)
 497 {
 498   while (list != NULL)
 499     {
 500       if (g_app_info_equal (info, list->data))
 501         return TRUE;
 502       list = list->next;
 503     }
 504   return FALSE;
 505 }
 506
 507 GList *
 508 g_app_info_get_all_for_type (const char *content_type)
 509 {
 510   GList *progids = NULL;
 511   GList *prognames = NULL;
 512   HKEY reg_key, sys_file_assoc_key, reg_key2;
 513   wchar_t percieved_type[128];
 514   DWORD nchars, key_type;
 515   wchar_t *wc_key;
 516   GList *l;
 517   GList *infos;
 518
 519   wc_key = g_utf8_to_utf16 (content_type, -1, NULL, NULL, NULL);
 520   if (RegOpenKeyExW (HKEY_CLASSES_ROOT, wc_key, 0,
 521                      KEY_QUERY_VALUE, &reg_key) == ERROR_SUCCESS)
 522     {
 523       enumerate_open_with_root (reg_key, &progids, &prognames);
 524
 525       nchars = sizeof (percieved_type) / sizeof(wchar_t);
 526       if (RegQueryValueExW (reg_key, L"PerceivedType", 0,
 527                             &key_type, (LPBYTE) percieved_type, &nchars) == ERROR_SUCCESS)
 528         {
 529           if (key_type == REG_SZ &&
 530               RegOpenKeyExW (HKEY_CLASSES_ROOT, L"SystemFileAssociations", 0,
 531                              KEY_QUERY_VALUE, &sys_file_assoc_key) == ERROR_SUCCESS)
 532             {
 533               if (RegOpenKeyExW (sys_file_assoc_key, percieved_type, 0,
 534                                  KEY_QUERY_VALUE, &reg_key2) == ERROR_SUCCESS)
 535                 {
 536                   enumerate_open_with_root (reg_key2, &progids, &prognames);
 537                   RegCloseKey (reg_key2);
 538                 }
 539
 540               RegCloseKey (sys_file_assoc_key);
 541             }
 542         }
 543       RegCloseKey (reg_key);
 544     }
 545
 546   if (RegOpenKeyExW (HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\FileExts", 0,
 547                      KEY_QUERY_VALUE, &reg_key) == ERROR_SUCCESS)
 548     {
 549       if (RegOpenKeyExW (reg_key, wc_key, 0,
 550                          KEY_QUERY_VALUE, &reg_key2) == ERROR_SUCCESS)
 551         {
 552           enumerate_open_with_root (reg_key2, &progids, &prognames);
 553           RegCloseKey (reg_key2);
 554         }
 555
 556       RegCloseKey (reg_key);
 557     }
 558
 559   infos = NULL;
 560   for (l = prognames; l != NULL; l = l->next)
 561     {
 562       GAppInfo *info;
 563
 564       /* l->data ownership is taken */
 565       info = g_desktop_app_info_new_from_id ((wchar_t *)l->data, TRUE);
 566       if (app_info_in_list (info, infos))
 567         g_object_unref (info);
 568       else
 569         infos = g_list_prepend (infos, info);
 570     }
 571   g_list_free (prognames);
 572
 573   for (l = progids; l != NULL; l = l->next)
 574     {
 575       GAppInfo *info;
 576
 577       /* l->data ownership is taken */
 578       info = g_desktop_app_info_new_from_id ((wchar_t *)l->data, FALSE);
 579       if (app_info_in_list (info, infos))
 580         g_object_unref (info);
 581       else
 582         infos = g_list_prepend (infos, info);
 583     }
 584   g_list_free (progids);
 585
 586   g_free (wc_key);
 587   return g_list_reverse (infos);
 588 }
 589
 590 GList *
 591 g_app_info_get_recommended_for_type (const char *content_type)
 592 {
 593   /* FIXME: this should generate a list of applications that are registered
 594    * as direct handlers for the given content type, without using MIME subclassing.
 595    * See g_app_info_get_recommended_for_type() in gdesktopappinfo.c for a reference
 596    * UNIX implementation.
 597    */
 598   return g_app_info_get_all_for_type (content_type);
 599 }
 600
 601 GList *
 602 g_app_info_get_fallback_for_type (const char *content_type)
 603 {
 604   /* FIXME: this should generate a list of applications that are registered
 605    * as handlers for a superclass of the given content type, but are not
 606    * direct handlers for the content type itself. See g_app_info_get_fallback_for_type()
 607    * in gdesktopappinfo.c for a reference UNIX implementation.
 608    */
 609   return g_app_info_get_all_for_type (content_type);
 610 }
 611
 612 GAppInfo *
 613 g_app_info_get_default_for_type (const char *content_type,
 614                                  gboolean    must_support_uris)
 615 {
 616   wchar_t *wtype;
 617   wchar_t buffer[1024];
 618   DWORD buffer_size;
 619
 620   wtype = g_utf8_to_utf16 (content_type, -1, NULL, NULL, NULL);
 621
 622   /* Verify that we have some sort of app registered for this type */
 623 #ifdef AssocQueryString
 624   buffer_size = 1024;
 625   if (AssocQueryStringW (0,
 626                          REAL_ASSOCSTR_COMMAND,
 627                          wtype,
 628                          NULL,
 629                          buffer,
 630                          &buffer_size) == S_OK)
 631     /* Takes ownership of wtype */
 632     return g_desktop_app_info_new_from_id (wtype, FALSE);
 633 #endif
 634
 635   g_free (wtype);
 636   return NULL;
 637 }
 638
 639 GAppInfo *
 640 g_app_info_get_default_for_uri_scheme (const char *uri_scheme)
 641 {
 642   /* TODO: Implement */
 643   return NULL;
 644 }
 645
 646 GList *
 647 g_app_info_get_all (void)
 648 {
 649   DWORD index;
 650   wchar_t name[256];
 651   DWORD name_len;
 652   HKEY reg_key;
 653   GList *infos;
 654   GAppInfo *info;
 655
 656   if (RegOpenKeyExW (HKEY_CLASSES_ROOT, L"Applications", 0,
 657                      KEY_READ, &reg_key) != ERROR_SUCCESS)
 658     return NULL;
 659
 660   infos = NULL;
 661   index = 0;
 662   name_len = 256;
 663   while (RegEnumKeyExW (reg_key,
 664                         index,
 665                         name,
 666                         &name_len,
 667                         NULL,
 668                         NULL,
 669                         NULL,
 670                         NULL) == ERROR_SUCCESS)
 671     {
 672       wchar_t *name_dup = g_memdup (name, (name_len+1)*2);
 673       /* name_dup ownership is taken */
 674       info = g_desktop_app_info_new_from_id (name_dup, TRUE);
 675       infos = g_list_prepend (infos, info);
 676
 677       index++;
 678       name_len = 256;
 679     }
 680
 681   RegCloseKey (reg_key);
 682
 683   return g_list_reverse (infos);
 684 }
 685
 686 void
 687 g_app_info_reset_type_associations (const char *content_type)
 688 {
 689   /* nothing to do */
 690 }