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