[gnome-panel/wip/muktupavels/launcher: 4/4] launcher: new module for launcher applet



commit feae79d5532db2e08a7603b7f47d2be8cebb17b0
Author: Alberts Muktupāvels <alberts muktupavels gmail com>
Date:   Sun Apr 12 17:07:26 2020 +0300

    launcher: new module for launcher applet

 configure.ac                                       |    8 +
 data/theme/common.css                              |   13 +-
 modules/Makefile.am                                |    1 +
 modules/launcher/Makefile.am                       |   91 ++
 modules/launcher/custom-launcher-menu.ui           |   14 +
 modules/launcher/gp-custom-launcher-applet.c       |  228 +++
 modules/launcher/gp-custom-launcher-applet.h       |   33 +
 modules/launcher/gp-editor.c                       |  998 ++++++++++++
 modules/launcher/gp-editor.h                       |   66 +
 modules/launcher/gp-icon-name-chooser.c            |  933 +++++++++++
 modules/launcher/gp-icon-name-chooser.h            |   36 +
 modules/launcher/gp-icon-name-chooser.ui           |  295 ++++
 modules/launcher/gp-launcher-applet.c              | 1665 ++++++++++++++++++++
 modules/launcher/gp-launcher-applet.h              |   41 +
 modules/launcher/gp-launcher-button.c              |   47 +
 modules/launcher/gp-launcher-button.h              |   33 +
 modules/launcher/gp-launcher-module.c              |   95 ++
 modules/launcher/gp-launcher-properties.c          |  674 ++++++++
 modules/launcher/gp-launcher-properties.h          |   33 +
 modules/launcher/gp-launcher-utils.c               |  313 ++++
 modules/launcher/gp-launcher-utils.h               |   54 +
 modules/launcher/launcher-menu.ui                  |   14 +
 modules/launcher/launcher.gresource.xml            |    8 +
 ...g.gnome.gnome-panel.applet.launcher.gschema.xml |    9 +
 po/POTFILES.in                                     |    9 +
 25 files changed, 5708 insertions(+), 3 deletions(-)
---
diff --git a/configure.ac b/configure.ac
index 3d0588aa7..e80525452 100644
--- a/configure.ac
+++ b/configure.ac
@@ -154,6 +154,13 @@ PKG_CHECK_MODULES(FISH, gtk+-3.0 >= $GTK_REQUIRED cairo >= $CAIRO_REQUIRED)
 AC_SUBST(FISH_CFLAGS)
 AC_SUBST(FISH_LIBS)
 
+PKG_CHECK_MODULES([LAUNCHER], [
+  gio-unix-2.0 >= $GLIB_REQUIRED
+  gtk+-3.0 >= $GTK_REQUIRED
+  libgnome-menu-3.0 >= $LIBGNOME_MENU_REQUIRED
+  libsystemd >= $LIBSYSTEMD_REQUIRED
+])
+
 PKG_CHECK_MODULES([MENU], [
   gdm
   gio-unix-2.0 >= $GLIB_REQUIRED
@@ -279,6 +286,7 @@ AC_CONFIG_FILES([
   modules/clock/Makefile
   modules/clock/pixmaps/Makefile
   modules/fish/Makefile
+  modules/launcher/Makefile
   modules/menu/Makefile
   modules/notification-area/Makefile
   modules/separator/Makefile
diff --git a/data/theme/common.css b/data/theme/common.css
index 63584cb16..07cae6d09 100644
--- a/data/theme/common.css
+++ b/data/theme/common.css
@@ -31,15 +31,18 @@ panel-toplevel.right gp-applet > menubar > .gp-image-menu-item:not(.image-only)
   margin-top: 5px;
 }
 
-gp-menu-button:hover .icon {
+gp-menu-button:hover .icon,
+gp-launcher-button:hover image {
   -gtk-icon-effect: highlight;
 }
 
-panel-toplevel.horizontal gp-menu-button {
+panel-toplevel.horizontal gp-menu-button,
+panel-toplevel.horizontal gp-launcher-button  {
   padding: 0 2px;
 }
 
-panel-toplevel.vertical gp-menu-button {
+panel-toplevel.vertical gp-menu-button,
+panel-toplevel.vertical gp-launcher-button {
   padding: 2px 0;
 }
 
@@ -87,3 +90,7 @@ gp-arrow-button {
   min-width: 0px;
   min-height: 20px;
 }
+
+.context-row {
+  padding: 4px 10px;
+}
diff --git a/modules/Makefile.am b/modules/Makefile.am
index 586caca48..ef377e340 100644
--- a/modules/Makefile.am
+++ b/modules/Makefile.am
@@ -3,6 +3,7 @@ NULL =
 SUBDIRS = \
        clock \
        fish \
+       launcher \
        menu \
        notification-area \
        separator \
diff --git a/modules/launcher/Makefile.am b/modules/launcher/Makefile.am
new file mode 100644
index 000000000..06d8dcdcb
--- /dev/null
+++ b/modules/launcher/Makefile.am
@@ -0,0 +1,91 @@
+NULL =
+
+launcher_libdir = $(libdir)/gnome-panel/modules
+launcher_lib_LTLIBRARIES = launcher.la
+
+launcher_la_CPPFLAGS = \
+       -DLOCALEDIR=\""$(localedir)"\" \
+       -DGMENU_I_KNOW_THIS_IS_UNSTABLE \
+       -DGRESOURCE_PREFIX=\""/org/gnome/gnome-panel/modules/launcher"\"
+       -DG_LOG_DOMAIN=\""launcher"\" \
+       -DG_LOG_USE_STRUCTURED=1 \
+       -I$(top_srcdir) \
+       $(AM_CPPFLAGS) \
+       $(NULL)
+
+launcher_la_CFLAGS = \
+       $(LIBGNOME_PANEL_CFLAGS) \
+       $(LAUNCHER_CFLAGS) \
+       $(WARN_CFLAGS) \
+       $(AM_CFLAGS) \
+       $(NULL)
+
+launcher_la_SOURCES = \
+       gp-custom-launcher-applet.c \
+       gp-custom-launcher-applet.h \
+       gp-editor.c \
+       gp-editor.h \
+       gp-icon-name-chooser.c \
+       gp-icon-name-chooser.h \
+       gp-launcher-applet.c \
+       gp-launcher-applet.h \
+       gp-launcher-button.c \
+       gp-launcher-button.h \
+       gp-launcher-module.c \
+       gp-launcher-properties.c \
+       gp-launcher-properties.h \
+       gp-launcher-utils.c \
+       gp-launcher-utils.h \
+       $(BUILT_SOURCES) \
+       $(NULL)
+
+launcher_la_LIBADD = \
+       $(top_builddir)/libgnome-panel/libgnome-panel.la \
+       $(LIBGNOME_PANEL_LIBS) \
+       $(LAUNCHER_LIBS) \
+       $(NULL)
+
+launcher_la_LDFLAGS = \
+       -module -avoid-version \
+       $(WARN_LDFLAGS) \
+       $(AM_LDFLAGS) \
+       $(NULL)
+
+gsettings_SCHEMAS = \
+       org.gnome.gnome-panel.applet.launcher.gschema.xml \
+       $(NULL)
+
+@GSETTINGS_RULES@
+
+launcher_resources = \
+       $(shell $(GLIB_COMPILE_RESOURCES) \
+               --sourcedir=$(srcdir) \
+               --generate-dependencies \
+               $(srcdir)/launcher.gresource.xml)
+
+launcher-resources.c: launcher.gresource.xml $(launcher_resources)
+       $(AM_V_GEN) $(GLIB_COMPILE_RESOURCES) \
+               --target=$@ --sourcedir=$(srcdir) \
+               --generate --c-name launcher $<
+
+launcher-resources.h: launcher.gresource.xml
+       $(AM_V_GEN) $(GLIB_COMPILE_RESOURCES) \
+               --target=$@ --sourcedir=$(srcdir) \
+               --generate --c-name launcher $<
+
+BUILT_SOURCES = \
+       launcher-resources.c \
+       launcher-resources.h \
+       $(NULL)
+
+EXTRA_DIST = \
+       launcher.gresource.xml \
+       $(gsettings_SCHEMAS) \
+       $(NULL)
+
+CLEANFILES = \
+       *.gschema.valid \
+       $(BUILT_SOURCES) \
+       $(NULL)
+
+-include $(top_srcdir)/git.mk
diff --git a/modules/launcher/custom-launcher-menu.ui b/modules/launcher/custom-launcher-menu.ui
new file mode 100644
index 000000000..11fa21433
--- /dev/null
+++ b/modules/launcher/custom-launcher-menu.ui
@@ -0,0 +1,14 @@
+<interface>
+  <menu id="custom-launcher-menu">
+    <section>
+      <item>
+        <attribute name="label" translatable="yes">_Launch</attribute>
+        <attribute name="action">custom-launcher.launch</attribute>
+      </item>
+      <item>
+        <attribute name="label" translatable="yes">_Properties</attribute>
+        <attribute name="action">custom-launcher.properties</attribute>
+      </item>
+    </section>
+  </menu>
+</interface>
diff --git a/modules/launcher/gp-custom-launcher-applet.c b/modules/launcher/gp-custom-launcher-applet.c
new file mode 100644
index 000000000..8985bf721
--- /dev/null
+++ b/modules/launcher/gp-custom-launcher-applet.c
@@ -0,0 +1,228 @@
+/*
+ * Copyright (C) 2020 Alberts Muktupāvels
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+#include "gp-custom-launcher-applet.h"
+
+#include "gp-editor.h"
+#include "gp-launcher-utils.h"
+
+typedef struct
+{
+  GpInitialSetupDialog *dialog;
+  GpEditor             *editor;
+} LauncherData;
+
+struct _GpCustomLauncherApplet
+{
+  GpLauncherApplet parent;
+};
+
+G_DEFINE_TYPE (GpCustomLauncherApplet,
+               gp_custom_launcher_applet,
+               GP_TYPE_LAUNCHER_APPLET)
+
+static LauncherData *
+launcher_data_new (GpInitialSetupDialog *dialog)
+{
+  LauncherData *data;
+
+  data = g_new0 (LauncherData, 1);
+  data->dialog = dialog;
+
+  return data;
+}
+
+static void
+launcher_data_free (gpointer user_data)
+{
+  LauncherData *data;
+
+  data = (LauncherData *) user_data;
+
+  g_free (data);
+}
+
+static void
+check_required_info (LauncherData *data)
+{
+  gboolean done;
+  GpEditorType type;
+  const char *type_string;
+
+  type = gp_editor_get_editor_type (data->editor);
+  type_string = NULL;
+
+  if (type == GP_EDITOR_TYPE_APPLICATION ||
+      type == GP_EDITOR_TYPE_TERMINAL_APPLICATION)
+    {
+      type_string = G_KEY_FILE_DESKTOP_TYPE_APPLICATION;
+    }
+  else if (type == GP_EDITOR_TYPE_DIRECTORY ||
+           type == GP_EDITOR_TYPE_FILE)
+    {
+      type_string = G_KEY_FILE_DESKTOP_TYPE_LINK;
+    }
+
+  done = gp_launcher_validate (gp_editor_get_name (data->editor),
+                               type_string,
+                               gp_editor_get_name (data->editor),
+                               gp_editor_get_command (data->editor),
+                               gp_editor_get_comment (data->editor),
+                               NULL);
+
+  gp_initital_setup_dialog_set_done (data->dialog, done);
+}
+
+static void
+icon_changed_cb (GpEditor     *editor,
+                 LauncherData *data)
+{
+  const char *icon;
+  GVariant *variant;
+
+  icon = gp_editor_get_icon (editor);
+  variant = icon != NULL ? g_variant_new_string (icon) : NULL;
+  gp_initital_setup_dialog_set_setting (data->dialog, "icon", variant);
+
+  check_required_info (data);
+}
+
+static void
+type_changed_cb (GpEditor     *editor,
+                 LauncherData *data)
+{
+  GpEditorType type;
+  const char *type_string;
+  GVariant *variant;
+
+  type = gp_editor_get_editor_type (editor);
+  type_string = NULL;
+
+  if (type == GP_EDITOR_TYPE_APPLICATION ||
+      type == GP_EDITOR_TYPE_TERMINAL_APPLICATION)
+    {
+      type_string = G_KEY_FILE_DESKTOP_TYPE_APPLICATION;
+    }
+  else if (type == GP_EDITOR_TYPE_DIRECTORY ||
+           type == GP_EDITOR_TYPE_FILE)
+    {
+      type_string = G_KEY_FILE_DESKTOP_TYPE_LINK;
+    }
+
+  variant = type_string != NULL ? g_variant_new_string (type_string) : NULL;
+  gp_initital_setup_dialog_set_setting (data->dialog, "type", variant);
+
+  if (type == GP_EDITOR_TYPE_TERMINAL_APPLICATION)
+    {
+      variant = g_variant_new_boolean (TRUE);
+      gp_initital_setup_dialog_set_setting (data->dialog, "terminal", variant);
+    }
+  else
+    {
+      gp_initital_setup_dialog_set_setting (data->dialog, "terminal", NULL);
+    }
+
+  check_required_info (data);
+}
+
+static void
+name_changed_cb (GpEditor     *editor,
+                 LauncherData *data)
+{
+  const char *name;
+  GVariant *variant;
+
+  name = gp_editor_get_name (editor);
+  variant = name != NULL ? g_variant_new_string (name) : NULL;
+  gp_initital_setup_dialog_set_setting (data->dialog, "name", variant);
+
+  check_required_info (data);
+}
+
+static void
+command_changed_cb (GpEditor     *editor,
+                    LauncherData *data)
+{
+  const char *command;
+  GVariant *variant;
+
+  command = gp_editor_get_command (editor);
+  variant = command != NULL ? g_variant_new_string (command) : NULL;
+  gp_initital_setup_dialog_set_setting (data->dialog, "command", variant);
+
+  check_required_info (data);
+}
+
+static void
+comment_changed_cb (GpEditor     *editor,
+                    LauncherData *data)
+{
+  const char *comment;
+  GVariant *variant;
+
+  comment = gp_editor_get_comment (editor);
+  variant = comment != NULL ? g_variant_new_string (comment) : NULL;
+  gp_initital_setup_dialog_set_setting (data->dialog, "comment", variant);
+
+  check_required_info (data);
+}
+
+static const char *
+gp_custom_launcher_applet_get_menu_resource (void)
+{
+  return GRESOURCE_PREFIX "/custom-launcher-menu.ui";
+}
+
+static void
+gp_custom_launcher_applet_class_init (GpCustomLauncherAppletClass *self_class)
+{
+  GpLauncherAppletClass *launcher_class;
+
+  launcher_class = GP_LAUNCHER_APPLET_CLASS (self_class);
+
+  launcher_class->get_menu_resource = gp_custom_launcher_applet_get_menu_resource;
+}
+
+static void
+gp_custom_launcher_applet_init (GpCustomLauncherApplet *self)
+{
+}
+
+void
+gp_custom_launcher_applet_initial_setup_dialog (GpInitialSetupDialog *dialog)
+{
+  GtkWidget *editor;
+  LauncherData *data;
+
+  editor = gp_editor_new (FALSE);
+
+  data = launcher_data_new (dialog);
+  data->editor = GP_EDITOR (editor);
+
+  g_signal_connect (editor, "icon-changed", G_CALLBACK (icon_changed_cb), data);
+  g_signal_connect (editor, "type-changed", G_CALLBACK (type_changed_cb), data);
+  g_signal_connect (editor, "name-changed", G_CALLBACK (name_changed_cb), data);
+  g_signal_connect (editor, "command-changed", G_CALLBACK (command_changed_cb), data);
+  g_signal_connect (editor, "comment-changed", G_CALLBACK (comment_changed_cb), data);
+
+  icon_changed_cb (data->editor, data);
+  type_changed_cb (data->editor, data);
+
+  gp_initital_setup_dialog_add_content_widget (dialog, editor, data,
+                                               launcher_data_free);
+}
diff --git a/modules/launcher/gp-custom-launcher-applet.h b/modules/launcher/gp-custom-launcher-applet.h
new file mode 100644
index 000000000..79d62528f
--- /dev/null
+++ b/modules/launcher/gp-custom-launcher-applet.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2020 Alberts Muktupāvels
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GP_CUSTOM_LAUNCHER_APPLET_H
+#define GP_CUSTOM_LAUNCHER_APPLET_H
+
+#include "gp-launcher-applet.h"
+
+G_BEGIN_DECLS
+
+#define GP_TYPE_CUSTOM_LAUNCHER_APPLET (gp_custom_launcher_applet_get_type ())
+G_DECLARE_FINAL_TYPE (GpCustomLauncherApplet, gp_custom_launcher_applet,
+                      GP, CUSTOM_LAUNCHER_APPLET, GpLauncherApplet)
+
+void gp_custom_launcher_applet_initial_setup_dialog (GpInitialSetupDialog *dialog);
+
+G_END_DECLS
+
+#endif
diff --git a/modules/launcher/gp-editor.c b/modules/launcher/gp-editor.c
new file mode 100644
index 000000000..ae41a8c83
--- /dev/null
+++ b/modules/launcher/gp-editor.c
@@ -0,0 +1,998 @@
+/*
+ * Copyright (C) 2004 - 2006 Vincent Untz
+ * Copyright (C) 2010 Novell, Inc.
+ * Copyright (C) 2020 Alberts Muktupāvels
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *     Alberts Muktupāvels <alberts muktupavels gmail com>
+ *     Vincent Untz <vuntz gnome org>
+ */
+
+#include "config.h"
+#include "gp-editor.h"
+
+#include <glib/gi18n-lib.h>
+
+#include "gp-icon-name-chooser.h"
+
+#define FALLBACK_ICON "gnome-panel-launcher"
+
+typedef struct
+{
+  GpEditorType  type;
+  const char   *name;
+} GpTypeComboItem;
+
+static GpTypeComboItem type_combo_items[] =
+{
+  { GP_EDITOR_TYPE_APPLICATION, N_("Application") },
+  { GP_EDITOR_TYPE_TERMINAL_APPLICATION, N_("Application in Terminal") },
+  { GP_EDITOR_TYPE_DIRECTORY, N_("Directory") },
+  { GP_EDITOR_TYPE_FILE, N_("File") },
+  { GP_EDITOR_TYPE_NONE, NULL, }
+};
+
+struct _GpEditor
+{
+  GtkBox        parent;
+
+  gboolean      edit;
+
+  GtkIconTheme *icon_theme;
+
+  char         *icon;
+  GtkWidget    *icon_button;
+  GtkWidget    *icon_image;
+  GtkWidget    *icon_chooser;
+
+  GtkTreeModel *type_model;
+  GtkWidget    *type_label;
+  GtkWidget    *type_combo;
+
+  GtkWidget    *name_label;
+  GtkWidget    *name_entry;
+
+  GtkWidget    *command_label;
+  GtkWidget    *command_entry;
+  GtkWidget    *command_browse;
+  GtkWidget    *command_chooser;
+
+  GtkWidget    *comment_label;
+  GtkWidget    *comment_entry;
+};
+
+enum
+{
+  PROP_0,
+
+  PROP_EDIT,
+
+  LAST_PROP
+};
+
+static GParamSpec *editor_properties[LAST_PROP] = { NULL };
+
+enum
+{
+  ICON_CHANGED,
+  TYPE_CHANGED,
+  NAME_CHANGED,
+  COMMAND_CHANGED,
+  COMMENT_CHANGED,
+
+  LAST_SIGNAL
+};
+
+static guint editor_signals[LAST_SIGNAL] = { 0 };
+
+G_DEFINE_TYPE (GpEditor, gp_editor, GTK_TYPE_BOX)
+
+static GpEditorType
+get_editor_type (GpEditor *self)
+{
+  GtkTreeIter iter;
+  GtkTreeModel *model;
+  GpEditorType type;
+
+  if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (self->type_combo), &iter))
+    return GP_EDITOR_TYPE_NONE;
+
+  model = gtk_combo_box_get_model (GTK_COMBO_BOX (self->type_combo));
+  gtk_tree_model_get (model, &iter, 1, &type, -1);
+
+  return type;
+}
+
+static char *
+filename_to_exec_uri (const char *filename)
+{
+  GString *exec_uri;
+  const char *c;
+
+  if (filename == NULL)
+    return g_strdup ("");
+
+  if (strchr (filename, ' ') == NULL)
+    return g_strdup (filename);
+
+  exec_uri = g_string_new_len (NULL, strlen (filename));
+
+  g_string_append_c (exec_uri, '"');
+
+  for (c = filename; *c != '\0'; c++)
+    {
+      if (*c == '"')
+        g_string_append (exec_uri, "\\\"");
+      else
+        g_string_append_c (exec_uri, *c);
+    }
+
+  g_string_append_c (exec_uri, '"');
+
+  return g_string_free (exec_uri, FALSE);
+}
+
+static void
+update_icon_image (GpEditor *self)
+{
+  const char *icon;
+  GtkIconSize size;
+  int px_size;
+
+  icon = gp_editor_get_icon (self);
+  size = GTK_ICON_SIZE_DIALOG;
+  px_size = 48;
+
+  if (g_path_is_absolute (self->icon))
+    {
+      GdkPixbuf *pixbuf;
+
+      pixbuf = gdk_pixbuf_new_from_file_at_size (icon, px_size, px_size, NULL);
+      gtk_image_set_from_pixbuf (GTK_IMAGE (self->icon_image), pixbuf);
+      g_clear_object (&pixbuf);
+    }
+  else
+    {
+      gtk_image_set_from_icon_name (GTK_IMAGE (self->icon_image), icon, size);
+      gtk_image_set_pixel_size (GTK_IMAGE (self->icon_image), px_size);
+    }
+}
+
+static void
+icon_name_changed (GpEditor   *self,
+                   const char *icon_name)
+{
+  g_clear_pointer (&self->icon, g_free);
+  self->icon = g_strdup (icon_name);
+
+  g_signal_emit (self, editor_signals[ICON_CHANGED], 0);
+  update_icon_image (self);
+}
+
+static void
+icon_chooser_destroy_cb (GtkWidget *widget,
+                         GpEditor  *self)
+{
+  self->icon_chooser = NULL;
+}
+
+static void
+icon_selected_cb (GpIconNameChooser *chooser,
+                  const char        *icon_name,
+                  GpEditor          *self)
+{
+  icon_name_changed (self, icon_name);
+}
+
+static void
+choose_icon_name_activate_cb (GtkMenuItem *item,
+                              GpEditor    *self)
+{
+  if (self->icon_chooser != NULL &&
+      GP_IS_ICON_NAME_CHOOSER (self->icon_chooser))
+    {
+      gtk_window_present (GTK_WINDOW (self->icon_chooser));
+      return;
+    }
+
+  g_clear_pointer (&self->icon_chooser, gtk_widget_destroy);
+
+  self->icon_chooser = gp_icon_name_chooser_new ();
+
+  g_signal_connect (self->icon_chooser,
+                    "icon-selected",
+                    G_CALLBACK (icon_selected_cb),
+                    self);
+
+  g_signal_connect (self->icon_chooser,
+                    "destroy",
+                    G_CALLBACK (icon_chooser_destroy_cb),
+                    self);
+
+  gtk_window_set_destroy_with_parent (GTK_WINDOW (self->icon_chooser), TRUE);
+  gtk_window_present (GTK_WINDOW (self->icon_chooser));
+
+  if (self->icon != NULL && !g_path_is_absolute (self->icon))
+    gp_icon_name_chooser_set_icon_name (GP_ICON_NAME_CHOOSER (self->icon_chooser),
+                                        self->icon);
+}
+
+static void
+icon_chooser_update_preview_cb (GtkFileChooser *chooser,
+                                GtkImage       *preview)
+{
+  gchar *filename;
+  GdkPixbuf *pixbuf;
+
+  filename = gtk_file_chooser_get_preview_filename (chooser);
+  if (!filename)
+    return;
+
+  pixbuf = gdk_pixbuf_new_from_file_at_size (filename, 128, 128, NULL);
+  g_free (filename);
+
+  gtk_file_chooser_set_preview_widget_active (chooser, !!pixbuf);
+  gtk_image_set_from_pixbuf (preview, pixbuf);
+  g_clear_object (&pixbuf);
+}
+
+static void
+icon_chooser_response_cb (GtkFileChooser *chooser,
+                          gint            response_id,
+                          GpEditor       *self)
+{
+  if (response_id == GTK_RESPONSE_ACCEPT)
+    {
+      g_clear_pointer (&self->icon, g_free);
+      self->icon = gtk_file_chooser_get_filename (chooser);
+
+      g_signal_emit (self, editor_signals[ICON_CHANGED], 0);
+      update_icon_image (self);
+    }
+
+  gtk_widget_destroy (GTK_WIDGET (chooser));
+}
+
+static void
+choose_icon_file_activate_cb (GtkMenuItem *item,
+                              GpEditor    *self)
+{
+  GtkWidget *toplevel;
+  GtkFileChooser *chooser;
+  GtkFileFilter *filter;
+  GtkWidget *preview;
+
+  if (self->icon_chooser != NULL &&
+      GTK_IS_FILE_CHOOSER_DIALOG (self->icon_chooser))
+    {
+      gtk_window_present (GTK_WINDOW (self->icon_chooser));
+      return;
+    }
+
+  g_clear_pointer (&self->icon_chooser, gtk_widget_destroy);
+
+  toplevel = gtk_widget_get_toplevel (GTK_WIDGET (self));
+  self->icon_chooser = gtk_file_chooser_dialog_new (_("Choose Icon File"),
+                                                    GTK_WINDOW (toplevel),
+                                                    GTK_FILE_CHOOSER_ACTION_OPEN,
+                                                    _("_Cancel"),
+                                                    GTK_RESPONSE_CANCEL,
+                                                    _("_Open"),
+                                                    GTK_RESPONSE_ACCEPT,
+                                                    NULL);
+
+  chooser = GTK_FILE_CHOOSER (self->icon_chooser);
+
+  filter = gtk_file_filter_new ();
+  gtk_file_filter_add_pixbuf_formats (filter);
+  gtk_file_chooser_set_filter (chooser, filter);
+
+  preview = gtk_image_new ();
+  gtk_file_chooser_set_preview_widget (chooser, preview);
+
+  if (self->icon != NULL && g_path_is_absolute (self->icon))
+    gtk_file_chooser_set_filename (chooser, self->icon);
+
+  g_signal_connect (chooser,
+                    "response",
+                    G_CALLBACK (icon_chooser_response_cb),
+                    self);
+
+  g_signal_connect (chooser,
+                    "update-preview",
+                    G_CALLBACK (icon_chooser_update_preview_cb),
+                    preview);
+
+  g_signal_connect (chooser,
+                    "destroy",
+                    G_CALLBACK (icon_chooser_destroy_cb),
+                    self);
+
+  gtk_window_set_destroy_with_parent (GTK_WINDOW (chooser), TRUE);
+  gtk_window_present (GTK_WINDOW (chooser));
+}
+
+static GtkWidget *
+create_icon_button (GpEditor *self)
+{
+  GtkWidget *button;
+  GtkWidget *menu;
+  GtkWidget *item;
+
+  button = gtk_menu_button_new ();
+
+  self->icon_image = gtk_image_new_from_icon_name (FALLBACK_ICON,
+                                                   GTK_ICON_SIZE_DIALOG);
+
+  gtk_image_set_pixel_size (GTK_IMAGE (self->icon_image), 48);
+  gtk_container_add (GTK_CONTAINER (button), self->icon_image);
+  gtk_widget_show (self->icon_image);
+
+  menu = gtk_menu_new ();
+  gtk_menu_button_set_popup (GTK_MENU_BUTTON (button), menu);
+
+  item = gtk_menu_item_new_with_label (_("Choose Icon Name"));
+  gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
+  gtk_widget_show (item);
+
+  g_signal_connect (item,
+                    "activate",
+                    G_CALLBACK (choose_icon_name_activate_cb),
+                    self);
+
+  item = gtk_menu_item_new_with_label (_("Choose Icon File"));
+  gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
+  gtk_widget_show (item);
+
+  g_signal_connect (item,
+                    "activate",
+                    G_CALLBACK (choose_icon_file_activate_cb),
+                    self);
+
+  return button;
+}
+
+static void
+command_chooser_destroy_cb (GtkWidget *widget,
+                            GpEditor  *self)
+{
+  self->command_chooser = NULL;
+}
+
+static void
+command_chooser_response_cb (GtkFileChooser *chooser,
+                             int             response_id,
+                             GpEditor       *self)
+{
+  if (response_id == GTK_RESPONSE_ACCEPT)
+    {
+      GpEditorType type;
+      char *text;
+      char *uri;
+
+      type = get_editor_type (self);
+      uri = NULL;
+
+      switch (type)
+        {
+          case GP_EDITOR_TYPE_APPLICATION:
+          case GP_EDITOR_TYPE_TERMINAL_APPLICATION:
+            text = gtk_file_chooser_get_filename (chooser);
+            uri = filename_to_exec_uri (text);
+            g_free (text);
+            break;
+
+          case GP_EDITOR_TYPE_DIRECTORY:
+          case GP_EDITOR_TYPE_FILE:
+            uri = gtk_file_chooser_get_uri (chooser);
+            break;
+
+          case GP_EDITOR_TYPE_NONE:
+          default:
+            break;
+        }
+
+      gtk_entry_set_text (GTK_ENTRY (self->command_entry), uri);
+      g_free (uri);
+    }
+
+  gtk_widget_destroy (GTK_WIDGET (chooser));
+}
+
+static void
+command_browse_clicked_cb (GtkButton *button,
+                           GpEditor  *self)
+{
+  GtkWidget *toplevel;
+  GtkWindow *parent;
+  GpEditorType type;
+  GtkFileChooserAction action;
+  const char *title;
+  gboolean local_only;
+  GtkFileChooser *chooser;
+
+  if (self->command_chooser != NULL)
+    {
+      gtk_window_present (GTK_WINDOW (self->command_chooser));
+      return;
+    }
+
+  toplevel = gtk_widget_get_toplevel (GTK_WIDGET (self));
+  parent = GTK_IS_WINDOW (toplevel) ? GTK_WINDOW (toplevel) : NULL;
+
+  type = get_editor_type (self);
+  action = GTK_FILE_CHOOSER_ACTION_OPEN;
+  title = NULL;
+  local_only = TRUE;
+
+  switch (type)
+    {
+      case GP_EDITOR_TYPE_APPLICATION:
+      case GP_EDITOR_TYPE_TERMINAL_APPLICATION:
+        action = GTK_FILE_CHOOSER_ACTION_OPEN;
+        title = _("Choose an application...");
+        break;
+
+      case GP_EDITOR_TYPE_DIRECTORY:
+        action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
+        title = _("Choose a directory...");
+        break;
+
+      case GP_EDITOR_TYPE_FILE:
+        action = GTK_FILE_CHOOSER_ACTION_OPEN;
+        title = _("Choose a file...");
+        local_only = FALSE;
+        break;
+
+      case GP_EDITOR_TYPE_NONE:
+      default:
+        break;
+    }
+
+  self->command_chooser = gtk_file_chooser_dialog_new (title, parent, action,
+                                                       _("_Cancel"),
+                                                       GTK_RESPONSE_CANCEL,
+                                                       _("_Open"),
+                                                       GTK_RESPONSE_ACCEPT,
+                                                       NULL);
+
+  chooser = GTK_FILE_CHOOSER (self->command_chooser);
+  gtk_file_chooser_set_local_only (chooser, local_only);
+
+  g_signal_connect (chooser, "response",
+                    G_CALLBACK (command_chooser_response_cb),
+                    self);
+
+  g_signal_connect (chooser, "destroy",
+                    G_CALLBACK (command_chooser_destroy_cb),
+                    self);
+
+  gtk_window_set_destroy_with_parent (GTK_WINDOW (chooser), TRUE);
+  gtk_window_present (GTK_WINDOW (chooser));
+}
+
+static void
+name_changed_cb (GtkEditable *editable,
+                 GpEditor    *self)
+{
+  g_signal_emit (self, editor_signals[NAME_CHANGED], 0);
+}
+
+static void
+command_changed_cb (GtkEditable *editable,
+                    GpEditor    *self)
+{
+  GpEditorType type;
+
+  type = get_editor_type (self);
+
+  if (type == GP_EDITOR_TYPE_APPLICATION ||
+      type == GP_EDITOR_TYPE_TERMINAL_APPLICATION)
+    {
+      const char *exec;
+      char *icon_name;
+
+      exec = gp_editor_get_command (self);
+      icon_name = g_path_get_basename (exec);
+
+      if (gtk_icon_theme_has_icon (self->icon_theme, icon_name) &&
+          g_strcmp0 (icon_name, self->icon) != 0)
+        icon_name_changed (self, icon_name);
+
+      g_free (icon_name);
+    }
+
+  g_signal_emit (self, editor_signals[COMMAND_CHANGED], 0);
+}
+
+static void
+comment_changed_cb (GtkEditable *editable,
+                    GpEditor    *self)
+{
+  g_signal_emit (self, editor_signals[COMMENT_CHANGED], 0);
+}
+
+static void
+type_combo_changed_cb (GtkComboBox *combo,
+                       GpEditor    *self)
+{
+  GpEditorType type;
+  const char *text;
+  const char *title;
+  GtkFileChooserAction action;
+  gboolean local_only;
+  char *bold;
+
+  type = get_editor_type (self);
+  text = NULL;
+  title = NULL;
+  action = GTK_FILE_CHOOSER_ACTION_OPEN;
+  local_only = TRUE;
+
+  switch (type)
+    {
+      case GP_EDITOR_TYPE_APPLICATION:
+      case GP_EDITOR_TYPE_TERMINAL_APPLICATION:
+        text = _("Comm_and:");
+        title = _("Choose an application...");
+        action = GTK_FILE_CHOOSER_ACTION_OPEN;
+        break;
+
+      case GP_EDITOR_TYPE_DIRECTORY:
+        text = _("_Location:");
+        title = _("Choose a directory...");
+        action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
+        break;
+
+      case GP_EDITOR_TYPE_FILE:
+        text = _("_Location:");
+        title = _("Choose a file...");
+        action = GTK_FILE_CHOOSER_ACTION_OPEN;
+        local_only = FALSE;
+        break;
+
+      case GP_EDITOR_TYPE_NONE:
+      default:
+        break;
+    }
+
+  bold = g_strdup_printf ("<b>%s</b>", text);
+  gtk_label_set_markup_with_mnemonic (GTK_LABEL (self->command_label), bold);
+  g_free (bold);
+
+  if (self->command_chooser != NULL)
+    {
+      GtkFileChooser *chooser;
+
+      chooser = GTK_FILE_CHOOSER (self->command_chooser);
+
+      gtk_file_chooser_set_action (chooser, action);
+      gtk_file_chooser_set_local_only (chooser, local_only);
+      gtk_window_set_title (GTK_WINDOW (chooser), title);
+    }
+
+  g_signal_emit (self, editor_signals[TYPE_CHANGED], 0);
+}
+
+static gboolean
+type_visible_func (GtkTreeModel *model,
+                   GtkTreeIter  *iter,
+                   gpointer      user_data)
+{
+  GpEditor *self;
+  gboolean visible;
+  GpEditorType active_type;
+  GpEditorType type;
+
+  self = GP_EDITOR (user_data);
+
+  if (!self->edit)
+    return TRUE;
+
+  visible = FALSE;
+  active_type = get_editor_type (self);
+
+  gtk_tree_model_get (model, iter, 1, &type, -1);
+
+  if (active_type == GP_EDITOR_TYPE_APPLICATION ||
+      active_type == GP_EDITOR_TYPE_TERMINAL_APPLICATION)
+    {
+      visible = type == GP_EDITOR_TYPE_APPLICATION ||
+                type == GP_EDITOR_TYPE_TERMINAL_APPLICATION;
+    }
+  else if (active_type == GP_EDITOR_TYPE_DIRECTORY)
+    {
+      visible = type == GP_EDITOR_TYPE_DIRECTORY;
+    }
+  else if (active_type == GP_EDITOR_TYPE_FILE)
+    {
+      visible = type == GP_EDITOR_TYPE_FILE;
+    }
+
+  return visible;
+}
+
+static void
+setup_type_combo (GpEditor *self)
+{
+  GtkListStore *store;
+  GtkCellLayout *layout;
+  GtkCellRenderer *renderer;
+  GtkTreeIter iter;
+  guint i;
+
+  store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
+  self->type_model = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL);
+
+  gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (self->type_model),
+                                          type_visible_func,
+                                          self,
+                                          NULL);
+
+  layout = GTK_CELL_LAYOUT (self->type_combo);
+  renderer = gtk_cell_renderer_text_new ();
+
+  gtk_cell_layout_pack_start (layout, renderer, TRUE);
+  gtk_cell_layout_set_attributes (layout, renderer, "text", 0, NULL);
+
+  for (i = 0; type_combo_items[i].type != GP_EDITOR_TYPE_NONE; i++)
+    {
+      gtk_list_store_append (store, &iter);
+      gtk_list_store_set (store, &iter,
+                          0, _(type_combo_items[i].name),
+                          1, type_combo_items[i].type,
+                          -1);
+    }
+
+  g_signal_connect (self->type_combo, "changed",
+                    G_CALLBACK (type_combo_changed_cb), self);
+
+  gtk_combo_box_set_model (GTK_COMBO_BOX (self->type_combo), self->type_model);
+  gtk_combo_box_set_active (GTK_COMBO_BOX (self->type_combo), 0);
+  g_object_unref (store);
+}
+
+static GtkWidget *
+label_new_with_mnemonic (const gchar *text)
+{
+  GtkWidget *label;
+  char *bold;
+
+  bold = g_strdup_printf ("<b>%s</b>", text);
+  label = gtk_label_new_with_mnemonic (bold);
+  g_free (bold);
+
+  gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
+  gtk_label_set_xalign (GTK_LABEL (label), 1.0);
+
+  gtk_widget_show (label);
+
+  return label;
+}
+
+static void
+gp_editor_dispose (GObject *object)
+{
+  GpEditor *self;
+
+  self = GP_EDITOR (object);
+
+  g_clear_object (&self->icon_theme);
+
+  g_clear_object (&self->type_model);
+
+  g_clear_pointer (&self->icon_chooser, gtk_widget_destroy);
+  g_clear_pointer (&self->command_chooser, gtk_widget_destroy);
+
+  G_OBJECT_CLASS (gp_editor_parent_class)->dispose (object);
+}
+
+static void
+gp_editor_finalize (GObject *object)
+{
+  GpEditor *self;
+
+  self = GP_EDITOR (object);
+
+  g_clear_pointer (&self->icon, g_free);
+
+  G_OBJECT_CLASS (gp_editor_parent_class)->finalize (object);
+}
+
+static void
+gp_editor_set_property (GObject      *object,
+                        guint         property_id,
+                        const GValue *value,
+                        GParamSpec   *pspec)
+{
+  GpEditor *self;
+
+  self = GP_EDITOR (object);
+
+  switch (property_id)
+    {
+      case PROP_EDIT:
+        self->edit = g_value_get_boolean (value);
+        break;
+
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+        break;
+    }
+}
+
+static void
+install_properties (GObjectClass *object_class)
+{
+  editor_properties[PROP_EDIT] =
+    g_param_spec_boolean ("edit",
+                          "edit",
+                          "edit",
+                          FALSE,
+                          G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY |
+                          G_PARAM_STATIC_STRINGS);
+
+  g_object_class_install_properties (object_class, LAST_PROP, editor_properties);
+}
+
+static void
+install_signals (void)
+{
+  editor_signals[ICON_CHANGED] =
+    g_signal_new ("icon-changed", GP_TYPE_EDITOR, G_SIGNAL_RUN_LAST,
+                  0, NULL, NULL, NULL, G_TYPE_NONE, 0);
+
+  editor_signals[TYPE_CHANGED] =
+    g_signal_new ("type-changed", GP_TYPE_EDITOR, G_SIGNAL_RUN_LAST,
+                  0, NULL, NULL, NULL, G_TYPE_NONE, 0);
+
+  editor_signals[NAME_CHANGED] =
+    g_signal_new ("name-changed", GP_TYPE_EDITOR, G_SIGNAL_RUN_LAST,
+                  0, NULL, NULL, NULL, G_TYPE_NONE, 0);
+
+  editor_signals[COMMAND_CHANGED] =
+    g_signal_new ("command-changed", GP_TYPE_EDITOR, G_SIGNAL_RUN_LAST,
+                  0, NULL, NULL, NULL, G_TYPE_NONE, 0);
+
+  editor_signals[COMMENT_CHANGED] =
+    g_signal_new ("comment-changed", GP_TYPE_EDITOR, G_SIGNAL_RUN_LAST,
+                  0, NULL, NULL, NULL, G_TYPE_NONE, 0);
+}
+
+static void
+gp_editor_class_init (GpEditorClass *self_class)
+{
+  GObjectClass *object_class;
+
+  object_class = G_OBJECT_CLASS (self_class);
+
+  object_class->dispose = gp_editor_dispose;
+  object_class->finalize = gp_editor_finalize;
+  object_class->set_property = gp_editor_set_property;
+
+  install_properties (object_class);
+  install_signals ();
+}
+
+static void
+gp_editor_init (GpEditor *self)
+{
+  GtkWidget *hbox;
+  GtkWidget *grid;
+
+  self->icon_theme = gtk_icon_theme_new ();
+
+  /* Icon */
+  self->icon = NULL;
+  self->icon_button = create_icon_button (self);
+
+  gtk_box_pack_start (GTK_BOX (self), self->icon_button, FALSE, FALSE, 0);
+  gtk_widget_set_valign (self->icon_button, GTK_ALIGN_START);
+  gtk_widget_show (self->icon_button);
+
+  /* Grid */
+  grid = gtk_grid_new ();
+  gtk_box_pack_end (GTK_BOX (self), grid, TRUE, TRUE, 0);
+  gtk_widget_show (grid);
+
+  gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
+  gtk_grid_set_column_spacing (GTK_GRID (grid), 12);
+
+  /* Type */
+  self->type_label = label_new_with_mnemonic (_("_Type:"));
+  self->type_combo = gtk_combo_box_new ();
+  gtk_grid_attach (GTK_GRID (grid), self->type_label, 0, 0, 1, 1);
+  gtk_grid_attach (GTK_GRID (grid), self->type_combo, 1, 0, 1, 1);
+  gtk_label_set_mnemonic_widget (GTK_LABEL (self->type_label), self->type_combo);
+  gtk_widget_set_hexpand (self->type_combo, TRUE);
+  gtk_widget_show (self->type_combo);
+
+  /* Name */
+  self->name_label = label_new_with_mnemonic (_("_Name:"));
+  self->name_entry = gtk_entry_new ();
+  gtk_grid_attach (GTK_GRID (grid), self->name_label, 0, 1, 1, 1);
+  gtk_grid_attach (GTK_GRID (grid), self->name_entry, 1, 1, 1, 1);
+  gtk_label_set_mnemonic_widget (GTK_LABEL (self->name_label), self->name_entry);
+  gtk_widget_set_hexpand (self->name_entry, TRUE);
+  gtk_widget_show (self->name_entry);
+
+  g_signal_connect (self->name_entry, "changed",
+                    G_CALLBACK (name_changed_cb), self);
+
+  gtk_widget_grab_focus (self->name_entry);
+
+  /* Command */
+  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
+  gtk_widget_set_hexpand (hbox, TRUE);
+  gtk_widget_show (hbox);
+
+  self->command_label = label_new_with_mnemonic (_("Comm_and:"));
+
+  self->command_entry = gtk_entry_new ();
+  gtk_box_pack_start (GTK_BOX (hbox), self->command_entry, TRUE, TRUE, 0);
+  gtk_widget_show (self->command_entry);
+
+  self->command_browse = gtk_button_new_with_mnemonic (_("_Browse..."));
+  gtk_box_pack_start (GTK_BOX (hbox), self->command_browse, FALSE, FALSE, 0);
+  gtk_widget_show (self->command_browse);
+
+  gtk_grid_attach (GTK_GRID (grid), self->command_label, 0, 2, 1, 1);
+  gtk_grid_attach (GTK_GRID (grid), hbox, 1, 2, 1, 1);
+
+  g_signal_connect (self->command_browse, "clicked",
+                    G_CALLBACK (command_browse_clicked_cb), self);
+
+  g_signal_connect (self->command_entry, "changed",
+                    G_CALLBACK (command_changed_cb), self);
+
+  /* Comment */
+  self->comment_label = label_new_with_mnemonic (_("Co_mment:"));
+  self->comment_entry = gtk_entry_new ();
+  gtk_grid_attach (GTK_GRID (grid), self->comment_label, 0, 3, 1, 1);
+  gtk_grid_attach (GTK_GRID (grid), self->comment_entry, 1, 3, 1, 1);
+  gtk_label_set_mnemonic_widget (GTK_LABEL (self->comment_label), self->comment_entry);
+  gtk_widget_set_hexpand (self->comment_entry, TRUE);
+  gtk_widget_show (self->comment_entry);
+
+  g_signal_connect (self->comment_entry, "changed",
+                    G_CALLBACK (comment_changed_cb), self);
+
+  setup_type_combo (self);
+}
+
+GtkWidget *
+gp_editor_new (gboolean edit)
+{
+  return g_object_new (GP_TYPE_EDITOR,
+                       "edit", edit,
+                       "orientation", GTK_ORIENTATION_HORIZONTAL,
+                       "spacing", 12,
+                       NULL);
+}
+
+const char *
+gp_editor_get_icon (GpEditor *self)
+{
+  if (self->icon != NULL)
+    return self->icon;
+
+  return FALLBACK_ICON;
+}
+
+void
+gp_editor_set_icon (GpEditor   *self,
+                    const char *icon)
+{
+  g_clear_pointer (&self->icon_chooser, gtk_widget_destroy);
+
+  if (g_strcmp0 (self->icon, icon) == 0)
+    return;
+
+  g_clear_pointer (&self->icon, g_free);
+  self->icon = g_strdup (icon);
+
+  if (self->icon != NULL)
+    {
+      char *p;
+
+      /* Work around a common mistake in desktop files */
+      if ((p = strrchr (self->icon, '.')) != NULL &&
+          (strcmp (p, ".png") == 0 ||
+           strcmp (p, ".xpm") == 0 ||
+           strcmp (p, ".svg") == 0))
+        *p = '\0';
+    }
+
+  update_icon_image (self);
+}
+
+GpEditorType
+gp_editor_get_editor_type (GpEditor *self)
+{
+  return get_editor_type (self);
+}
+
+void
+gp_editor_set_editor_type (GpEditor     *self,
+                           GpEditorType  type)
+{
+  GtkTreeIter iter;
+
+  gtk_tree_model_get_iter_first (self->type_model, &iter);
+
+  do
+    {
+      GpEditorType tmp;
+
+      gtk_tree_model_get (self->type_model, &iter, 1, &tmp, -1);
+
+      if (type != tmp)
+        continue;
+
+      gtk_combo_box_set_active_iter (GTK_COMBO_BOX (self->type_combo), &iter);
+    }
+  while (gtk_tree_model_iter_next (self->type_model, &iter));
+
+  gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (self->type_model));
+}
+
+const char *
+gp_editor_get_name (GpEditor *self)
+{
+  return gtk_entry_get_text (GTK_ENTRY (self->name_entry));
+}
+
+void
+gp_editor_set_name (GpEditor   *self,
+                    const char *name)
+{
+  if (name == NULL)
+    name = "";
+
+  gtk_entry_set_text (GTK_ENTRY (self->name_entry), name);
+}
+
+const char *
+gp_editor_get_command (GpEditor *self)
+{
+  return gtk_entry_get_text (GTK_ENTRY (self->command_entry));
+}
+
+void
+gp_editor_set_command (GpEditor   *self,
+                       const char *command)
+{
+  if (command == NULL)
+    command = "";
+
+  gtk_entry_set_text (GTK_ENTRY (self->command_entry), command);
+}
+
+const char *
+gp_editor_get_comment (GpEditor *self)
+{
+  return gtk_entry_get_text (GTK_ENTRY (self->comment_entry));
+}
+
+void
+gp_editor_set_comment (GpEditor   *self,
+                       const char *comment)
+{
+  if (comment == NULL)
+    comment = "";
+
+  gtk_entry_set_text (GTK_ENTRY (self->comment_entry), comment);
+}
diff --git a/modules/launcher/gp-editor.h b/modules/launcher/gp-editor.h
new file mode 100644
index 000000000..d2bddf803
--- /dev/null
+++ b/modules/launcher/gp-editor.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2020 Alberts Muktupāvels
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GP_EDITOR_H
+#define GP_EDITOR_H
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+typedef enum
+{
+  GP_EDITOR_TYPE_NONE,
+  GP_EDITOR_TYPE_APPLICATION,
+  GP_EDITOR_TYPE_TERMINAL_APPLICATION,
+  GP_EDITOR_TYPE_DIRECTORY,
+  GP_EDITOR_TYPE_FILE,
+} GpEditorType;
+
+#define GP_TYPE_EDITOR (gp_editor_get_type ())
+G_DECLARE_FINAL_TYPE (GpEditor, gp_editor, GP, EDITOR, GtkBox)
+
+GtkWidget    *gp_editor_new             (gboolean      edit);
+
+const char   *gp_editor_get_icon        (GpEditor     *self);
+
+void          gp_editor_set_icon        (GpEditor     *self,
+                                         const char   *icon);
+
+GpEditorType  gp_editor_get_editor_type (GpEditor     *self);
+
+void          gp_editor_set_editor_type (GpEditor     *self,
+                                         GpEditorType  type);
+
+const char   *gp_editor_get_name        (GpEditor     *self);
+
+void          gp_editor_set_name        (GpEditor     *self,
+                                         const char   *name);
+
+const char   *gp_editor_get_command     (GpEditor     *self);
+
+void          gp_editor_set_command     (GpEditor     *self,
+                                         const char   *command);
+
+const char   *gp_editor_get_comment     (GpEditor     *self);
+
+void          gp_editor_set_comment     (GpEditor     *self,
+                                         const char   *comment);
+
+G_END_DECLS
+
+#endif
diff --git a/modules/launcher/gp-icon-name-chooser.c b/modules/launcher/gp-icon-name-chooser.c
new file mode 100644
index 000000000..ba1f813be
--- /dev/null
+++ b/modules/launcher/gp-icon-name-chooser.c
@@ -0,0 +1,933 @@
+/*
+ * Copyright (C) 2020 Alberts Muktupāvels
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+#include "gp-icon-name-chooser.h"
+
+#include <glib/gi18n-lib.h>
+
+struct _GpIconNameChooser
+{
+  GtkWindow              parent;
+
+  GtkIconTheme          *icon_theme;
+
+  GtkWidget             *header_bar;
+  GtkWidget             *search_button;
+  GtkWidget             *select_button;
+
+  GtkWidget             *search_bar;
+  GtkWidget             *search_entry;
+
+  GtkWidget             *context_list;
+
+  GtkListStore          *icon_store;
+  GtkTreeModelFilter    *icon_filter;
+  GtkWidget             *icon_view;
+  GtkCellRendererPixbuf *pixbuf_cell;
+  GtkCellRendererText   *name_cell;
+
+  GtkWidget             *standard_button;
+
+  char                  *selected_context;
+  char                  *selected_icon;
+};
+
+enum
+{
+  ICON_SELECTED,
+
+  CLOSE,
+
+  LAST_SIGNAL
+};
+
+static guint chooser_signals[LAST_SIGNAL] = { 0 };
+
+G_DEFINE_TYPE (GpIconNameChooser, gp_icon_name_chooser, GTK_TYPE_WINDOW)
+
+typedef struct
+{
+  const char  *name;
+  const char  *directory;
+  const char **icons;
+} GpStandardIcons;
+
+static const char *action_icons[] =
+{
+  "address-book-new",
+  "application-exit",
+  "appointment-new",
+  "call-start",
+  "call-stop",
+  "contact-new",
+  "document-new",
+  "document-open",
+  "document-open-recent",
+  "document-page-setup",
+  "document-print",
+  "document-print-preview",
+  "document-properties",
+  "document-revert",
+  "document-save",
+  "document-save-as",
+  "document-send",
+  "edit-clear",
+  "edit-copy",
+  "edit-cut",
+  "edit-delete",
+  "edit-find",
+  "edit-find-replace",
+  "edit-paste",
+  "edit-redo",
+  "edit-select-all",
+  "edit-undo",
+  "folder-new",
+  "format-indent-less",
+  "format-indent-more",
+  "format-justify-center",
+  "format-justify-fill",
+  "format-justify-left",
+  "format-justify-right",
+  "format-text-direction-ltr",
+  "format-text-direction-rtl",
+  "format-text-bold",
+  "format-text-italic",
+  "format-text-underline",
+  "format-text-strikethrough",
+  "go-bottom",
+  "go-down",
+  "go-first",
+  "go-home",
+  "go-jump",
+  "go-last",
+  "go-next",
+  "go-previous",
+  "go-top",
+  "go-up",
+  "help-about",
+  "help-contents",
+  "help-faq",
+  "insert-image",
+  "insert-link",
+  "insert-object",
+  "insert-text",
+  "list-add",
+  "list-remove",
+  "mail-forward",
+  "mail-mark-important",
+  "mail-mark-junk",
+  "mail-mark-notjunk",
+  "mail-mark-read",
+  "mail-mark-unread",
+  "mail-message-new",
+  "mail-reply-all",
+  "mail-reply-sender",
+  "mail-send",
+  "mail-send-receive",
+  "media-eject",
+  "media-playback-pause",
+  "media-playback-start",
+  "media-playback-stop",
+  "media-record",
+  "media-seek-backward",
+  "media-seek-forward",
+  "media-skip-backward",
+  "media-skip-forward",
+  "object-flip-horizontal",
+  "object-flip-vertical",
+  "object-rotate-left",
+  "object-rotate-right",
+  "process-stop",
+  "system-lock-screen",
+  "system-log-out",
+  "system-run",
+  "system-search",
+  "system-reboot",
+  "system-shutdown",
+  "tools-check-spelling",
+  "view-fullscreen",
+  "view-refresh",
+  "view-restore",
+  "view-sort-ascending",
+  "view-sort-descending",
+  "window-close",
+  "window-new",
+  "zoom-fit-best",
+  "zoom-in",
+  "zoom-original",
+  "zoom-out",
+  NULL
+};
+
+static const char *animation_icons[] =
+{
+  "process-working",
+  NULL
+};
+
+static const char *application_icons[] =
+{
+  "accessories-calculator",
+  "accessories-character-map",
+  "accessories-dictionary",
+  "accessories-text-editor",
+  "help-browser",
+  "multimedia-volume-control",
+  "preferences-desktop-accessibility",
+  "preferences-desktop-font",
+  "preferences-desktop-keyboard",
+  "preferences-desktop-locale",
+  "preferences-desktop-multimedia",
+  "preferences-desktop-screensaver",
+  "preferences-desktop-theme",
+  "preferences-desktop-wallpaper",
+  "system-file-manager",
+  "system-software-install",
+  "system-software-update",
+  "utilities-system-monitor",
+  "utilities-terminal",
+  NULL
+};
+
+static const char *category_icons[] =
+{
+  "applications-accessories",
+  "applications-development",
+  "applications-engineering",
+  "applications-games",
+  "applications-graphics",
+  "applications-internet",
+  "applications-multimedia",
+  "applications-office",
+  "applications-other",
+  "applications-science",
+  "applications-system",
+  "applications-utilities",
+  "preferences-desktop",
+  "preferences-desktop-peripherals",
+  "preferences-desktop-personal",
+  "preferences-other",
+  "preferences-system",
+  "preferences-system-network",
+  "system-help",
+  NULL
+};
+
+static const char *device_icons[] =
+{
+  "audio-card",
+  "audio-input-microphone",
+  "battery",
+  "camera-photo",
+  "camera-video",
+  "camera-web",
+  "computer",
+  "drive-harddisk",
+  "drive-optical",
+  "drive-removable-media",
+  "input-gaming",
+  "input-keyboard",
+  "input-mouse",
+  "input-tablet",
+  "media-flash",
+  "media-floppy",
+  "media-optical",
+  "media-tape",
+  "modem",
+  "multimedia-player",
+  "network-wired",
+  "network-wireless",
+  "pda",
+  "phone",
+  "printer",
+  "scanner",
+  "video-display",
+  NULL
+};
+
+static const char *emblem_icons[] =
+{
+  "emblem-default",
+  "emblem-documents",
+  "emblem-downloads",
+  "emblem-favorite",
+  "emblem-important",
+  "emblem-mail",
+  "emblem-photos",
+  "emblem-readonly",
+  "emblem-shared",
+  "emblem-symbolic-link",
+  "emblem-synchronized",
+  "emblem-system",
+  "emblem-unreadable",
+  NULL
+};
+
+static const char *emotion_icons[] =
+{
+  "face-angel",
+  "face-angry",
+  "face-cool",
+  "face-crying",
+  "face-devilish",
+  "face-embarrassed",
+  "face-kiss",
+  "face-laugh",
+  "face-monkey",
+  "face-plain",
+  "face-raspberry",
+  "face-sad",
+  "face-sick",
+  "face-smile",
+  "face-smile-big",
+  "face-smirk",
+  "face-surprise",
+  "face-tired",
+  "face-uncertain",
+  "face-wink",
+  "face-worried",
+  NULL
+};
+
+static const char *international_icons[] =
+{
+  NULL
+};
+
+static const char *mime_type_icons[] =
+{
+  "application-x-executable",
+  "audio-x-generic",
+  "font-x-generic",
+  "image-x-generic",
+  "package-x-generic",
+  "text-html",
+  "text-x-generic",
+  "text-x-generic-template",
+  "text-x-script",
+  "video-x-generic",
+  "x-office-address-book",
+  "x-office-calendar",
+  "x-office-document",
+  "x-office-presentation",
+  "x-office-spreadsheet",
+  NULL
+};
+
+static const char *place_icons[] =
+{
+  "folder",
+  "folder-remote",
+  "network-server",
+  "network-workgroup",
+  "start-here",
+  "user-bookmarks",
+  "user-desktop",
+  "user-home",
+  "user-trash",
+  NULL
+};
+
+static const char *status_icons[] =
+{
+  "appointment-missed",
+  "appointment-soon",
+  "audio-volume-high",
+  "audio-volume-low",
+  "audio-volume-medium",
+  "audio-volume-muted",
+  "battery-caution",
+  "battery-low",
+  "dialog-error",
+  "dialog-information",
+  "dialog-password",
+  "dialog-question",
+  "dialog-warning",
+  "folder-drag-accept",
+  "folder-open",
+  "folder-visiting",
+  "image-loading",
+  "image-missing",
+  "mail-attachment",
+  "mail-unread",
+  "mail-read",
+  "mail-replied",
+  "mail-signed",
+  "mail-signed-verified",
+  "media-playlist-repeat",
+  "media-playlist-shuffle",
+  "network-error",
+  "network-idle",
+  "network-offline",
+  "network-receive",
+  "network-transmit",
+  "network-transmit-receive",
+  "printer-error",
+  "printer-printing",
+  "security-high",
+  "security-medium",
+  "security-low",
+  "software-update-available",
+  "software-update-urgent",
+  "sync-error",
+  "sync-synchronizing",
+  "task-due",
+  "task-past-due",
+  "user-available",
+  "user-away",
+  "user-idle",
+  "user-offline",
+  "user-trash-full",
+  "weather-clear",
+  "weather-clear-night",
+  "weather-few-clouds",
+  "weather-few-clouds-night",
+  "weather-fog",
+  "weather-overcast",
+  "weather-severe-alert",
+  "weather-showers",
+  "weather-showers-scattered",
+  "weather-snow",
+  "weather-storm",
+  NULL
+};
+
+static GpStandardIcons standard_icon_names[] =
+{
+  { "Actions", "actions", action_icons },
+  { "Animations", "animations", animation_icons },
+  { "Applications", "apps", application_icons },
+  { "Categories", "categories", category_icons },
+  { "Devices", "devices", device_icons },
+  { "Emblems", "emblems", emblem_icons },
+  { "Emotes", "emotes", emotion_icons },
+  { "International", "intl", international_icons },
+  { "MimeTypes", "mimetypes", mime_type_icons },
+  { "Places", "places", place_icons },
+  { "Status", "status", status_icons },
+  { NULL }
+};
+
+static gboolean
+is_standard_icon_name (const char *icon_name,
+                       const char *context)
+{
+  int i;
+
+  for (i = 0; standard_icon_names[i].name != NULL; i++)
+    {
+      int j;
+
+      if (g_strcmp0 (context, standard_icon_names[i].name) != 0)
+        continue;
+
+      for (j = 0; standard_icon_names[i].icons[j] != NULL; j++)
+        {
+          if (g_strcmp0 (icon_name, standard_icon_names[i].icons[j]) == 0)
+            return TRUE;
+        }
+    }
+
+  return FALSE;
+}
+
+static GtkWidget *
+create_context_row (const char *context,
+                    const char *title,
+                    gboolean    standard)
+{
+  GtkWidget *row;
+  GtkStyleContext *style;
+  GtkWidget *label;
+
+  row = gtk_list_box_row_new ();
+  gtk_list_box_row_set_activatable (GTK_LIST_BOX_ROW (row), FALSE);
+  g_object_set_data_full (G_OBJECT (row), "context", g_strdup (context), g_free);
+  g_object_set_data (G_OBJECT (row), "standard", GUINT_TO_POINTER (standard));
+  gtk_widget_show (row);
+
+  style = gtk_widget_get_style_context (row);
+  gtk_style_context_add_class (style, "context-row");
+
+  label = gtk_label_new (title);
+  gtk_label_set_xalign (GTK_LABEL (label), .0);
+  gtk_container_add (GTK_CONTAINER (row), label);
+  gtk_widget_show (label);
+
+  return row;
+}
+
+static void
+load_icon_names (GpIconNameChooser *self)
+{
+  GtkWidget *row;
+  GList *contexts;
+  GList *l1;
+
+  row = create_context_row ("All", _("All"), TRUE);
+  gtk_list_box_prepend (GTK_LIST_BOX (self->context_list), row);
+  gtk_list_box_select_row (GTK_LIST_BOX (self->context_list),
+                           GTK_LIST_BOX_ROW (row));
+
+  contexts = gtk_icon_theme_list_contexts (self->icon_theme);
+
+  for (l1 = contexts; l1 != NULL; l1 = l1->next)
+    {
+      const char *context;
+      gboolean standard;
+      int i;
+      GList *icons;
+      GList *l2;
+
+      context = l1->data;
+
+      standard = FALSE;
+      for (i = 0; standard_icon_names[i].name != NULL; i++)
+        {
+          if (g_strcmp0 (context, standard_icon_names[i].name) == 0)
+            {
+              standard = TRUE;
+              break;
+            }
+        }
+
+      row = create_context_row (context, _(context), standard);
+      gtk_list_box_prepend (GTK_LIST_BOX (self->context_list), row);
+
+      icons = gtk_icon_theme_list_icons (self->icon_theme, context);
+
+      for (l2 = icons; l2 != NULL; l2 = l2->next)
+        {
+          const char *icon_name;
+
+          icon_name = l2->data;
+
+          standard = is_standard_icon_name (icon_name, context);
+
+          gtk_list_store_insert_with_values (self->icon_store,
+                                             NULL,
+                                             -1,
+                                             0, context,
+                                             1, icon_name,
+                                             2, standard,
+                                             -1);
+        }
+
+      g_list_free_full (icons, g_free);
+    }
+
+  g_list_free_full (contexts, g_free);
+}
+
+static void
+cancel_button_clicked_cb (GtkButton         *button,
+                          GpIconNameChooser *self)
+{
+  gtk_widget_destroy (GTK_WIDGET (self));
+}
+
+static void
+select_button_clicked_cb (GtkButton         *button,
+                          GpIconNameChooser *self)
+{
+  g_signal_emit (self, chooser_signals[ICON_SELECTED], 0, self->selected_icon);
+  gtk_widget_destroy (GTK_WIDGET (self));
+}
+
+static void
+search_entry_search_changed_cb (GtkSearchEntry    *entry,
+                                GpIconNameChooser *self)
+{
+  gtk_icon_view_unselect_all (GTK_ICON_VIEW (self->icon_view));
+  gtk_tree_model_filter_refilter (self->icon_filter);
+}
+
+static void
+context_list_row_selected_cb (GtkListBox        *box,
+                              GtkListBoxRow     *row,
+                              GpIconNameChooser *self)
+{
+  const char *context;
+
+  if (row != NULL)
+    context = g_object_get_data (G_OBJECT (row), "context");
+  else
+    context = "All";
+
+  if (g_strcmp0 (self->selected_context, context) == 0)
+    return;
+
+  g_clear_pointer (&self->selected_context, g_free);
+  self->selected_context = g_strdup (context);
+
+  gtk_icon_view_unselect_all (GTK_ICON_VIEW (self->icon_view));
+  gtk_tree_model_filter_refilter (self->icon_filter);
+}
+
+static void
+icon_view_item_activated_cb (GtkIconView       *iconview,
+                             GtkTreePath       *path,
+                             GpIconNameChooser *self)
+{
+  select_button_clicked_cb (GTK_BUTTON (self->select_button), self);
+}
+
+static void
+icon_view_selection_changed_cb (GtkIconView       *icon_view,
+                                GpIconNameChooser *self)
+{
+  GList *selected_items;
+  GtkTreeModel *model;
+  GtkTreeIter iter;
+  char *icon_name;
+
+  selected_items = gtk_icon_view_get_selected_items (icon_view);
+
+  if (selected_items == NULL)
+    {
+      gtk_header_bar_set_subtitle (GTK_HEADER_BAR (self->header_bar), NULL);
+      gtk_widget_set_sensitive (self->select_button, FALSE);
+
+      g_clear_pointer (&self->selected_icon, g_free);
+      return;
+    }
+
+  model = GTK_TREE_MODEL (self->icon_filter);
+
+  gtk_tree_model_get_iter (model, &iter, selected_items->data);
+  gtk_tree_model_get (model, &iter, 1, &icon_name, -1);
+
+  g_list_free_full (selected_items, (GDestroyNotify) gtk_tree_path_free);
+
+  gtk_header_bar_set_subtitle (GTK_HEADER_BAR (self->header_bar), icon_name);
+  gtk_widget_set_sensitive (self->select_button, icon_name != NULL);
+
+  g_clear_pointer (&self->selected_icon, g_free);
+  self->selected_icon = icon_name;
+}
+
+static void
+standard_check_button_toggled_cb (GtkToggleButton   *toggle_button,
+                                  GpIconNameChooser *self)
+{
+  gtk_list_box_invalidate_filter (GTK_LIST_BOX (self->context_list));
+  gtk_tree_model_filter_refilter (self->icon_filter);
+}
+
+static void
+close_cb (GpIconNameChooser *self,
+          gpointer           user_data)
+{
+  gtk_widget_destroy (GTK_WIDGET (self));
+}
+
+static gboolean
+key_press_event_cb (GtkWidget    *window,
+                    GdkEvent     *event,
+                    GtkSearchBar *search_bar)
+{
+  return gtk_search_bar_handle_event (search_bar, event);
+}
+
+static gboolean
+filter_contexts_func (GtkListBoxRow *row,
+                      gpointer       user_data)
+{
+  GpIconNameChooser *self;
+
+  self = GP_ICON_NAME_CHOOSER (user_data);
+
+  if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (self->standard_button)))
+    return TRUE;
+
+  return GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (row), "standard"));
+}
+
+static int
+sort_contexts_func (GtkListBoxRow *row1,
+                    GtkListBoxRow *row2,
+                    gpointer       user_data)
+{
+  const char *context1;
+  const char *context2;
+
+  context1 = g_object_get_data (G_OBJECT (row1), "context");
+  context2 = g_object_get_data (G_OBJECT (row2), "context");
+
+  if (g_strcmp0 (context1, "All") == 0)
+    return -1;
+  else if (g_strcmp0 (context2, "All") == 0)
+    return 1;
+
+  return g_strcmp0 (context1, context2);
+}
+
+static gboolean
+icon_visible_func (GtkTreeModel *model,
+                   GtkTreeIter  *iter,
+                   gpointer      user_data)
+
+{
+  GpIconNameChooser *self;
+  char *context;
+  char *icon_name;
+  gboolean standard;
+  gboolean visible;
+
+  self = GP_ICON_NAME_CHOOSER (user_data);
+
+  gtk_tree_model_get (model, iter,
+                      0, &context,
+                      1, &icon_name,
+                      2, &standard,
+                      -1);
+
+  if (icon_name == NULL)
+    {
+      visible = FALSE;
+    }
+  else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (self->standard_button)) &&
+           !standard)
+    {
+      visible = FALSE;
+    }
+  else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (self->search_button)))
+    {
+      const char *search_text;
+
+      search_text = gtk_entry_get_text (GTK_ENTRY (self->search_entry));
+
+      visible = (g_strcmp0 (self->selected_context, "All") == 0 ||
+                 g_strcmp0 (self->selected_context, context) == 0) &&
+                strstr (icon_name, search_text) != NULL;
+    }
+  else
+    {
+      visible = g_strcmp0 (self->selected_context, "All") == 0 ||
+                g_strcmp0 (self->selected_context, context) == 0;
+    }
+
+  g_free (context);
+  g_free (icon_name);
+
+  return visible;
+}
+
+static void
+gp_icon_name_chooser_dispose (GObject *object)
+{
+  GpIconNameChooser *self;
+
+  self = GP_ICON_NAME_CHOOSER (object);
+
+  g_clear_object (&self->icon_theme);
+
+  G_OBJECT_CLASS (gp_icon_name_chooser_parent_class)->dispose (object);
+}
+
+static void
+gp_icon_name_chooser_finalize (GObject *object)
+{
+  GpIconNameChooser *self;
+
+  self = GP_ICON_NAME_CHOOSER (object);
+
+  g_clear_pointer (&self->selected_context, g_free);
+  g_clear_pointer (&self->selected_icon, g_free);
+
+  G_OBJECT_CLASS (gp_icon_name_chooser_parent_class)->finalize (object);
+}
+
+static void
+install_signals (void)
+{
+  chooser_signals[ICON_SELECTED] =
+    g_signal_new ("icon-selected",
+                  GP_TYPE_ICON_NAME_CHOOSER,
+                  0,
+                  0,
+                  NULL,
+                  NULL,
+                  NULL,
+                  G_TYPE_NONE,
+                  1,
+                  G_TYPE_STRING);
+
+  chooser_signals[CLOSE] =
+    g_signal_new ("close",
+                  GP_TYPE_ICON_NAME_CHOOSER,
+                  G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+                  0,
+                  NULL,
+                  NULL,
+                  NULL,
+                  G_TYPE_NONE,
+                  0);
+}
+
+static void
+gp_icon_name_chooser_class_init (GpIconNameChooserClass *self_class)
+{
+  GObjectClass *object_class;
+  GtkWidgetClass *widget_class;
+  GtkBindingSet *binding_set;
+  const char *resource_name;
+
+  object_class = G_OBJECT_CLASS (self_class);
+  widget_class = GTK_WIDGET_CLASS (self_class);
+
+  object_class->dispose = gp_icon_name_chooser_dispose;
+  object_class->finalize = gp_icon_name_chooser_finalize;
+
+  install_signals ();
+
+  binding_set = gtk_binding_set_by_class (widget_class);
+  gtk_binding_entry_add_signal (binding_set, GDK_KEY_Escape, 0, "close", 0);
+
+  resource_name = GRESOURCE_PREFIX "/gp-icon-name-chooser.ui";
+  gtk_widget_class_set_template_from_resource (widget_class, resource_name);
+
+  gtk_widget_class_bind_template_child (widget_class, GpIconNameChooser, header_bar);
+
+  gtk_widget_class_bind_template_callback (widget_class, cancel_button_clicked_cb);
+
+  gtk_widget_class_bind_template_child (widget_class, GpIconNameChooser, search_button);
+
+  gtk_widget_class_bind_template_child (widget_class, GpIconNameChooser, select_button);
+  gtk_widget_class_bind_template_callback (widget_class, select_button_clicked_cb);
+
+  gtk_widget_class_bind_template_child (widget_class, GpIconNameChooser, search_bar);
+  gtk_widget_class_bind_template_child (widget_class, GpIconNameChooser, search_entry);
+  gtk_widget_class_bind_template_callback (widget_class, search_entry_search_changed_cb);
+
+  gtk_widget_class_bind_template_child (widget_class, GpIconNameChooser, context_list);
+  gtk_widget_class_bind_template_callback (widget_class, context_list_row_selected_cb);
+
+  gtk_widget_class_bind_template_child (widget_class, GpIconNameChooser, icon_store);
+  gtk_widget_class_bind_template_child (widget_class, GpIconNameChooser, icon_filter);
+  gtk_widget_class_bind_template_child (widget_class, GpIconNameChooser, icon_view);
+  gtk_widget_class_bind_template_callback (widget_class, icon_view_item_activated_cb);
+  gtk_widget_class_bind_template_callback (widget_class, icon_view_selection_changed_cb);
+  gtk_widget_class_bind_template_child (widget_class, GpIconNameChooser, pixbuf_cell);
+  gtk_widget_class_bind_template_child (widget_class, GpIconNameChooser, name_cell);
+
+  gtk_widget_class_bind_template_child (widget_class, GpIconNameChooser, standard_button);
+  gtk_widget_class_bind_template_callback (widget_class, standard_check_button_toggled_cb);
+}
+
+static void
+gp_icon_name_chooser_init (GpIconNameChooser *self)
+{
+  gtk_widget_init_template (GTK_WIDGET (self));
+
+  self->icon_theme = gtk_icon_theme_new ();
+
+  g_object_bind_property (self->search_button,
+                          "active",
+                          self->search_bar,
+                          "search-mode-enabled",
+                          G_BINDING_BIDIRECTIONAL);
+
+  g_signal_connect (self, "close", G_CALLBACK (close_cb), NULL);
+
+  g_signal_connect (self,
+                    "key-press-event",
+                    G_CALLBACK (key_press_event_cb),
+                    self->search_bar);
+
+  gtk_list_box_set_filter_func (GTK_LIST_BOX (self->context_list),
+                                filter_contexts_func,
+                                self,
+                                NULL);
+
+  gtk_list_box_set_sort_func (GTK_LIST_BOX (self->context_list),
+                              sort_contexts_func,
+                              self,
+                              NULL);
+
+  gtk_tree_model_filter_set_visible_func (self->icon_filter,
+                                          icon_visible_func,
+                                          self,
+                                          NULL);
+
+  gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (self->icon_store),
+                                        1,
+                                        GTK_SORT_ASCENDING);
+
+  g_object_set (self->name_cell, "xalign", 0.5, NULL);
+
+  load_icon_names (self);
+}
+
+GtkWidget *
+gp_icon_name_chooser_new (void)
+{
+  return g_object_new (GP_TYPE_ICON_NAME_CHOOSER, NULL);
+}
+
+void
+gp_icon_name_chooser_set_icon_name (GpIconNameChooser *self,
+                                    const char        *icon_name)
+{
+  GtkTreeModel *model;
+  gboolean valid;
+  GtkTreeIter iter;
+  GtkTreePath *path;
+
+  if (!gtk_icon_theme_has_icon (self->icon_theme, icon_name))
+    return;
+
+  g_clear_pointer (&self->selected_icon, g_free);
+  self->selected_icon = g_strdup (icon_name);
+
+  gtk_header_bar_set_subtitle (GTK_HEADER_BAR (self->header_bar), self->selected_icon);
+  gtk_widget_set_sensitive (self->select_button, self->selected_icon != NULL);
+
+  model = GTK_TREE_MODEL (self->icon_filter);
+  valid = gtk_tree_model_get_iter_first (model, &iter);
+  path = NULL;
+
+  while (valid)
+    {
+      char *tmp;
+
+      gtk_tree_model_get (model, &iter, 1, &tmp, -1);
+
+      if (g_strcmp0 (self->selected_icon, tmp) == 0)
+        {
+          path = gtk_tree_model_get_path (model, &iter);
+          g_free (tmp);
+          break;
+        }
+
+      valid = gtk_tree_model_iter_next (model, &iter);
+      g_free (tmp);
+    }
+
+  if (path == NULL)
+    return;
+
+  gtk_icon_view_select_path (GTK_ICON_VIEW (self->icon_view), path);
+  gtk_icon_view_scroll_to_path (GTK_ICON_VIEW (self->icon_view),
+                                path,
+                                TRUE,
+                                0.5,
+                                0.5);
+
+  gtk_tree_path_free (path);
+}
diff --git a/modules/launcher/gp-icon-name-chooser.h b/modules/launcher/gp-icon-name-chooser.h
new file mode 100644
index 000000000..df33797a2
--- /dev/null
+++ b/modules/launcher/gp-icon-name-chooser.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2020 Alberts Muktupāvels
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GP_ICON_NAME_CHOOSER_H
+#define GP_ICON_NAME_CHOOSER_H
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define GP_TYPE_ICON_NAME_CHOOSER (gp_icon_name_chooser_get_type ())
+G_DECLARE_FINAL_TYPE (GpIconNameChooser, gp_icon_name_chooser,
+                      GP, ICON_NAME_CHOOSER, GtkWindow)
+
+GtkWidget *gp_icon_name_chooser_new           (void);
+
+void       gp_icon_name_chooser_set_icon_name (GpIconNameChooser *self,
+                                               const char        *icon_name);
+
+G_END_DECLS
+
+#endif
diff --git a/modules/launcher/gp-icon-name-chooser.ui b/modules/launcher/gp-icon-name-chooser.ui
new file mode 100644
index 000000000..915ef6f4a
--- /dev/null
+++ b/modules/launcher/gp-icon-name-chooser.ui
@@ -0,0 +1,295 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated with glade 3.22.2 -->
+<interface>
+  <requires lib="gtk+" version="3.20"/>
+  <object class="GtkListStore" id="icon_store">
+    <columns>
+      <!-- column-name context -->
+      <column type="gchararray"/>
+      <!-- column-name icon-name -->
+      <column type="gchararray"/>
+      <!-- column-name standard -->
+      <column type="gboolean"/>
+    </columns>
+  </object>
+  <object class="GtkTreeModelFilter" id="icon_filter">
+    <property name="child_model">icon_store</property>
+  </object>
+  <template class="GpIconNameChooser" parent="GtkWindow">
+    <property name="can_focus">False</property>
+    <property name="default_width">600</property>
+    <property name="default_height">400</property>
+    <property name="type_hint">dialog</property>
+    <child type="titlebar">
+      <object class="GtkHeaderBar" id="header_bar">
+        <property name="visible">True</property>
+        <property name="can_focus">False</property>
+        <property name="title" translatable="yes">Select Icon Name</property>
+        <child>
+          <object class="GtkButton" id="cancel_button">
+            <property name="label" translatable="yes">Cancel</property>
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">True</property>
+            <signal name="clicked" handler="cancel_button_clicked_cb" object="GpIconNameChooser" 
swapped="no"/>
+          </object>
+        </child>
+        <child>
+          <object class="GtkButton" id="select_button">
+            <property name="label" translatable="yes">Select</property>
+            <property name="visible">True</property>
+            <property name="sensitive">False</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">True</property>
+            <signal name="clicked" handler="select_button_clicked_cb" object="GpIconNameChooser" 
swapped="no"/>
+            <style>
+              <class name="suggested-action"/>
+            </style>
+          </object>
+          <packing>
+            <property name="pack_type">end</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkToggleButton" id="search_button">
+            <property name="visible">True</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">True</property>
+            <child>
+              <object class="GtkImage">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="icon_name">edit-find-symbolic</property>
+              </object>
+            </child>
+          </object>
+          <packing>
+            <property name="pack_type">end</property>
+            <property name="position">2</property>
+          </packing>
+        </child>
+      </object>
+    </child>
+    <child>
+      <object class="GtkBox">
+        <property name="visible">True</property>
+        <property name="can_focus">False</property>
+        <property name="orientation">vertical</property>
+        <child>
+          <object class="GtkSearchBar" id="search_bar">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <child>
+              <object class="GtkSearchEntry" id="search_entry">
+                <property name="width_request">400</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="primary_icon_name">edit-find-symbolic</property>
+                <property name="primary_icon_activatable">False</property>
+                <property name="primary_icon_sensitive">False</property>
+                <signal name="search-changed" handler="search_entry_search_changed_cb" 
object="GpIconNameChooser" swapped="no"/>
+              </object>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkBox">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <property name="margin_left">12</property>
+            <property name="margin_right">12</property>
+            <property name="margin_top">12</property>
+            <property name="margin_bottom">12</property>
+            <property name="orientation">vertical</property>
+            <property name="spacing">6</property>
+            <child>
+              <object class="GtkBox">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="spacing">6</property>
+                <child>
+                  <object class="GtkBox">
+                    <property name="visible">True</property>
+                    <property name="can_focus">False</property>
+                    <property name="orientation">vertical</property>
+                    <property name="spacing">6</property>
+                    <child>
+                      <object class="GtkLabel">
+                        <property name="visible">True</property>
+                        <property name="can_focus">False</property>
+                        <property name="label" translatable="yes">Contexts:</property>
+                        <property name="xalign">0</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">0</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkScrolledWindow">
+                        <property name="visible">True</property>
+                        <property name="can_focus">True</property>
+                        <property name="hscrollbar_policy">never</property>
+                        <property name="shadow_type">in</property>
+                        <child>
+                          <object class="GtkViewport">
+                            <property name="visible">True</property>
+                            <property name="can_focus">False</property>
+                            <child>
+                              <object class="GtkListBox" id="context_list">
+                                <property name="width_request">130</property>
+                                <property name="visible">True</property>
+                                <property name="can_focus">False</property>
+                                <property name="activate_on_single_click">False</property>
+                                <signal name="row-selected" handler="context_list_row_selected_cb" 
object="GpIconNameChooser" swapped="no"/>
+                              </object>
+                            </child>
+                          </object>
+                        </child>
+                        <style>
+                          <class name="view"/>
+                        </style>
+                      </object>
+                      <packing>
+                        <property name="expand">True</property>
+                        <property name="fill">True</property>
+                        <property name="position">1</property>
+                      </packing>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkSeparator">
+                    <property name="visible">True</property>
+                    <property name="can_focus">False</property>
+                    <property name="orientation">vertical</property>
+                  </object>
+                  <packing>
+                    <property name="expand">False</property>
+                    <property name="fill">True</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkBox">
+                    <property name="visible">True</property>
+                    <property name="can_focus">False</property>
+                    <property name="orientation">vertical</property>
+                    <property name="spacing">6</property>
+                    <child>
+                      <object class="GtkLabel">
+                        <property name="visible">True</property>
+                        <property name="can_focus">False</property>
+                        <property name="label" translatable="yes">Icon Names:</property>
+                        <property name="xalign">0</property>
+                      </object>
+                      <packing>
+                        <property name="expand">False</property>
+                        <property name="fill">True</property>
+                        <property name="position">0</property>
+                      </packing>
+                    </child>
+                    <child>
+                      <object class="GtkScrolledWindow">
+                        <property name="visible">True</property>
+                        <property name="can_focus">True</property>
+                        <property name="hscrollbar_policy">never</property>
+                        <property name="shadow_type">in</property>
+                        <child>
+                          <object class="GtkIconView" id="icon_view">
+                            <property name="visible">True</property>
+                            <property name="can_focus">True</property>
+                            <property name="margin">6</property>
+                            <property name="model">icon_filter</property>
+                            <property name="columns">4</property>
+                            <property name="item_width">128</property>
+                            <signal name="item-activated" handler="icon_view_item_activated_cb" 
object="GpIconNameChooser" swapped="no"/>
+                            <signal name="selection-changed" handler="icon_view_selection_changed_cb" 
object="GpIconNameChooser" swapped="no"/>
+                            <child>
+                              <object class="GtkCellRendererPixbuf" id="pixbuf_cell">
+                                <property name="xpad">6</property>
+                                <property name="ypad">6</property>
+                                <property name="stock_size">6</property>
+                              </object>
+                              <attributes>
+                                <attribute name="icon-name">1</attribute>
+                              </attributes>
+                            </child>
+                            <child>
+                              <object class="GtkCellRendererText" id="name_cell">
+                                <property name="xpad">6</property>
+                                <property name="ypad">6</property>
+                                <property name="yalign">0</property>
+                                <property name="alignment">center</property>
+                                <property name="wrap_mode">word-char</property>
+                                <property name="wrap_width">12</property>
+                              </object>
+                              <attributes>
+                                <attribute name="text">1</attribute>
+                              </attributes>
+                            </child>
+                          </object>
+                        </child>
+                        <style>
+                          <class name="view"/>
+                        </style>
+                      </object>
+                      <packing>
+                        <property name="expand">True</property>
+                        <property name="fill">True</property>
+                        <property name="position">1</property>
+                      </packing>
+                    </child>
+                  </object>
+                  <packing>
+                    <property name="expand">True</property>
+                    <property name="fill">True</property>
+                    <property name="position">2</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">True</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkCheckButton" id="standard_button">
+                <property name="label" translatable="yes">Show standard icons only</property>
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="receives_default">False</property>
+                <property name="active">True</property>
+                <property name="draw_indicator">True</property>
+                <signal name="toggled" handler="standard_check_button_toggled_cb" object="GpIconNameChooser" 
swapped="no"/>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">2</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">True</property>
+            <property name="fill">True</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+      </object>
+    </child>
+  </template>
+</interface>
diff --git a/modules/launcher/gp-launcher-applet.c b/modules/launcher/gp-launcher-applet.c
new file mode 100644
index 000000000..5dc04ab50
--- /dev/null
+++ b/modules/launcher/gp-launcher-applet.c
@@ -0,0 +1,1665 @@
+/*
+ * Copyright (C) 1997, 1998, 1999, 2000 The Free Software Foundation
+ * Copyright (C) 2000, 2001 Eazel, Inc.
+ * Copyright (C) 2002 Sun Microsystems Inc
+ * Copyright (C) 2004 Vincent Untz
+ * Copyright (C) 2020 Alberts Muktupāvels
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *     Alberts Muktupāvels <alberts muktupavels gmail com>
+ *     Federico Mena
+ *     George Lebl <jirka 5z com>
+ *     Mark McLoughlin <mark skynet ie>
+ *     Miguel de Icaza
+ *     Vincent Untz <vincent vuntz net>
+ */
+
+#include "config.h"
+#include "gp-launcher-applet.h"
+
+#include <glib/gi18n-lib.h>
+#include <gmenu-tree.h>
+#include <systemd/sd-journal.h>
+
+#include "gp-launcher-button.h"
+#include "gp-launcher-properties.h"
+#include "gp-launcher-utils.h"
+
+#define LAUNCHER_SCHEMA "org.gnome.gnome-panel.applet.launcher"
+#define LOCKDOWN_SCHEMA "org.gnome.desktop.lockdown"
+
+typedef struct
+{
+  GIcon *icon;
+  gchar *text;
+  gchar *path;
+} ApplicationData;
+
+typedef struct
+{
+  GpInitialSetupDialog *dialog;
+  GtkTreeStore         *store;
+  GSList               *applications;
+} LauncherData;
+
+typedef struct
+{
+  GSettings    *applet_settings;
+  GSettings    *lockdown_settings;
+
+  GtkWidget    *button;
+  GtkWidget    *image;
+
+  char         *location;
+  GKeyFile     *key_file;
+  GFileMonitor *monitor;
+
+  GtkWidget    *properties;
+} GpLauncherAppletPrivate;
+
+G_DEFINE_TYPE_WITH_PRIVATE (GpLauncherApplet, gp_launcher_applet, GP_TYPE_APPLET)
+
+static ApplicationData *
+application_data_new (GIcon       *icon,
+                      const gchar *text,
+                      const gchar *path)
+{
+  ApplicationData *data;
+
+  data = g_new0 (ApplicationData, 1);
+
+  data->icon = icon ? g_object_ref (icon) : NULL;
+  data->text = g_strdup (text);
+  data->path = g_strdup (path);
+
+  return data;
+}
+
+static void
+application_data_free (gpointer user_data)
+{
+  ApplicationData *data;
+
+  data = (ApplicationData *) user_data;
+
+  g_clear_object (&data->icon);
+  g_free (data->text);
+  g_free (data->path);
+  g_free (data);
+}
+
+static LauncherData *
+launcher_data_new (GpInitialSetupDialog *dialog)
+{
+  LauncherData *data;
+
+  data = g_new0 (LauncherData, 1);
+  data->dialog = dialog;
+
+  return data;
+}
+
+static void
+launcher_data_free (gpointer user_data)
+{
+  LauncherData *data;
+
+  data = (LauncherData *) user_data;
+
+  g_clear_object (&data->store);
+  g_slist_free_full (data->applications, application_data_free);
+  g_free (data);
+}
+
+static gchar *
+make_text (const gchar *name,
+           const gchar *desc)
+{
+  const gchar *real_name;
+  gchar *result;
+
+  real_name = name ? name : _("(empty)");
+
+  if (desc != NULL && *desc != '\0')
+    result = g_markup_printf_escaped ("<span weight=\"bold\">%s</span>\n%s",
+                                      real_name, desc);
+  else
+    result = g_markup_printf_escaped ("<span weight=\"bold\">%s</span>",
+                                      real_name);
+
+  return result;
+}
+
+static void
+populate_from_root (GtkTreeStore       *store,
+                    GtkTreeIter        *parent,
+                    GMenuTreeDirectory *directory,
+                    LauncherData       *data);
+
+static void
+append_directory (GtkTreeStore       *store,
+                  GtkTreeIter        *parent,
+                  GMenuTreeDirectory *directory,
+                  LauncherData       *data)
+{
+  GIcon *icon;
+  gchar *text;
+  ApplicationData *app_data;
+  GtkTreeIter iter;
+
+  icon = gmenu_tree_directory_get_icon (directory);
+  text = make_text (gmenu_tree_directory_get_name (directory),
+                    gmenu_tree_directory_get_comment (directory));
+
+  app_data = application_data_new (icon, text, NULL);
+  data->applications = g_slist_prepend (data->applications, app_data);
+  g_free (text);
+
+  gtk_tree_store_append (store, &iter, parent);
+  gtk_tree_store_set (store, &iter,
+                      0, app_data->icon,
+                      1, app_data->text,
+                      2, NULL,
+                      -1);
+
+  populate_from_root (store, &iter, directory, data);
+}
+
+static void
+append_entry (GtkTreeStore   *store,
+              GtkTreeIter    *parent,
+              GMenuTreeEntry *entry,
+              LauncherData   *data)
+{
+  GAppInfo *app_info;
+  GIcon *icon;
+  gchar *text;
+  const gchar *path;
+  ApplicationData *app_data;
+  GtkTreeIter iter;
+
+  app_info = G_APP_INFO (gmenu_tree_entry_get_app_info (entry));
+
+  icon = g_app_info_get_icon (app_info);
+  text = make_text (g_app_info_get_display_name (app_info),
+                    g_app_info_get_description (app_info));
+  path = gmenu_tree_entry_get_desktop_file_path (entry);
+
+  app_data = application_data_new (icon, text, path);
+  data->applications = g_slist_prepend (data->applications, app_data);
+  g_free (text);
+
+  gtk_tree_store_append (store, &iter, parent);
+  gtk_tree_store_set (store, &iter,
+                      0, app_data->icon,
+                      1, app_data->text,
+                      2, app_data,
+                      -1);
+}
+
+static void
+append_alias (GtkTreeStore   *store,
+              GtkTreeIter    *parent,
+              GMenuTreeAlias *alias,
+              LauncherData   *data)
+{
+  GMenuTreeItemType type;
+
+  type = gmenu_tree_alias_get_aliased_item_type (alias);
+
+  if (type == GMENU_TREE_ITEM_DIRECTORY)
+    {
+      GMenuTreeDirectory *dir;
+
+      dir = gmenu_tree_alias_get_aliased_directory (alias);
+      append_directory (store, parent, dir, data);
+      gmenu_tree_item_unref (dir);
+    }
+  else if (type == GMENU_TREE_ITEM_ENTRY)
+    {
+      GMenuTreeEntry *entry;
+
+      entry = gmenu_tree_alias_get_aliased_entry (alias);
+      append_entry (store, parent, entry, data);
+      gmenu_tree_item_unref (entry);
+    }
+}
+
+static void
+populate_from_root (GtkTreeStore       *store,
+                    GtkTreeIter        *parent,
+                    GMenuTreeDirectory *directory,
+                    LauncherData       *data)
+{
+  GMenuTreeIter *iter;
+  GMenuTreeItemType next_type;
+
+  iter = gmenu_tree_directory_iter (directory);
+
+  next_type = gmenu_tree_iter_next (iter);
+  while (next_type != GMENU_TREE_ITEM_INVALID)
+    {
+      if (next_type == GMENU_TREE_ITEM_DIRECTORY)
+        {
+          GMenuTreeDirectory *dir;
+
+          dir = gmenu_tree_iter_get_directory (iter);
+          append_directory (store, parent, dir, data);
+          gmenu_tree_item_unref (dir);
+        }
+      else if (next_type == GMENU_TREE_ITEM_ENTRY)
+        {
+          GMenuTreeEntry *entry;
+
+          entry = gmenu_tree_iter_get_entry (iter);
+          append_entry (store, parent, entry, data);
+          gmenu_tree_item_unref (entry);
+        }
+      else if (next_type == GMENU_TREE_ITEM_ALIAS)
+        {
+          GMenuTreeAlias *alias;
+
+          alias = gmenu_tree_iter_get_alias (iter);
+          append_alias (store, parent, alias, data);
+          gmenu_tree_item_unref (alias);
+        }
+
+      next_type = gmenu_tree_iter_next (iter);
+    }
+
+  gmenu_tree_iter_unref (iter);
+}
+
+static void
+populate_model_from_menu (GtkTreeStore *store,
+                          const gchar  *menu,
+                          gboolean      separator,
+                          LauncherData *data)
+{
+  GMenuTree *tree;
+  GMenuTreeDirectory *root;
+
+  tree = gmenu_tree_new (menu, GMENU_TREE_FLAGS_SORT_DISPLAY_NAME);
+
+  if (!gmenu_tree_load_sync (tree, NULL))
+    {
+      g_object_unref (tree);
+      return;
+    }
+
+  root = gmenu_tree_get_root_directory (tree);
+
+  if (root == NULL)
+    {
+      g_object_unref (tree);
+      return;
+    }
+
+  if (separator)
+    {
+      GtkTreeIter iter;
+
+      gtk_tree_store_append (store, &iter, NULL);
+      gtk_tree_store_set (store, &iter, 0, NULL, 1, NULL, 2, NULL, -1);
+    }
+
+  populate_from_root (store, NULL, root, data);
+  gmenu_tree_item_unref (root);
+  g_object_unref (tree);
+}
+
+static gchar *
+get_applications_menu (void)
+{
+  const gchar *xdg_menu_prefx;
+
+  xdg_menu_prefx = g_getenv ("XDG_MENU_PREFIX");
+  if (!xdg_menu_prefx || *xdg_menu_prefx == '\0')
+    return g_strdup ("gnome-applications.menu");
+
+  return g_strdup_printf ("%sapplications.menu", xdg_menu_prefx);
+}
+
+static void
+populate_model (GtkTreeStore *store,
+                LauncherData *data)
+{
+  gchar *menu;
+
+  menu = get_applications_menu ();
+  populate_model_from_menu (store, menu, FALSE, data);
+  g_free (menu);
+
+  menu = g_strdup ("gnomecc.menu");
+  populate_model_from_menu (store, menu, TRUE, data);
+  g_free (menu);
+}
+
+static void
+selection_changed_cb (GtkTreeSelection *selection,
+                      LauncherData     *data)
+{
+  gboolean done;
+  GtkTreeModel *model;
+  GtkTreeIter iter;
+
+  done = FALSE;
+  if (gtk_tree_selection_get_selected (selection, &model, &iter))
+    {
+      ApplicationData *app_data;
+
+      app_data = NULL;
+      gtk_tree_model_get (model, &iter, 2, &app_data, -1);
+
+      if (app_data != NULL)
+        {
+          GVariant *variant;
+
+          variant = g_variant_new_string (app_data->path);
+
+          gp_initital_setup_dialog_set_setting (data->dialog, "location", variant);
+          done = TRUE;
+        }
+    }
+
+  gp_initital_setup_dialog_set_done (data->dialog, done);
+}
+
+static gboolean
+is_this_drop_ok (GtkWidget      *widget,
+                 GdkDragContext *context)
+{
+  GtkWidget *source;
+  GdkAtom text_uri_list;
+  GList *list_targets;
+  GList *l;
+
+  source = gtk_drag_get_source_widget (context);
+
+  if (source == widget)
+    return FALSE;
+
+  if (!(gdk_drag_context_get_actions (context) & GDK_ACTION_COPY))
+    return FALSE;
+
+  text_uri_list = gdk_atom_intern_static_string ("text/uri-list");
+
+  list_targets = gdk_drag_context_list_targets (context);
+
+  for (l = list_targets; l != NULL; l = l->next)
+    {
+      GdkAtom atom;
+
+      atom = GDK_POINTER_TO_ATOM (l->data);
+
+      if (atom == text_uri_list)
+        return TRUE;
+    }
+
+  return FALSE;
+}
+
+static void launch (GpLauncherApplet *self,
+                    GList            *uris);
+
+static void
+drag_data_received_cb (GtkWidget        *widget,
+                       GdkDragContext   *context,
+                       gint              x,
+                       gint              y,
+                       GtkSelectionData *data,
+                       guint             info,
+                       guint             time,
+                       GpLauncherApplet *self)
+{
+  const guchar *selection_data;
+  char **uris;
+  GList *uri_list;
+  int i;
+
+  selection_data = gtk_selection_data_get_data (data);
+  uris = g_uri_list_extract_uris ((const char *) selection_data);
+
+  uri_list = NULL;
+  for (i = 0; uris[i] != NULL; i++)
+    uri_list = g_list_prepend (uri_list, uris[i]);
+
+  uri_list = g_list_reverse (uri_list);
+  launch (self, uri_list);
+
+  g_list_free (uri_list);
+  g_strfreev (uris);
+
+  gtk_drag_finish (context, TRUE, FALSE, time);
+}
+
+static gboolean
+drag_drop_cb (GtkWidget        *widget,
+              GdkDragContext   *context,
+              gint              x,
+              gint              y,
+              guint             time,
+              GpLauncherApplet *self)
+{
+  GdkAtom text_uri_list;
+
+  if (!is_this_drop_ok (widget, context))
+    return FALSE;
+
+  text_uri_list = gdk_atom_intern_static_string ("text/uri-list");
+
+  gtk_drag_get_data (widget, context, text_uri_list, time);
+
+  return TRUE;
+}
+
+static void
+drag_leave_cb (GtkWidget        *widget,
+               GdkDragContext   *context,
+               guint             time,
+               GpLauncherApplet *self)
+{
+  gtk_drag_unhighlight (widget);
+}
+
+static gboolean
+drag_motion_cb (GtkWidget        *widget,
+                GdkDragContext   *context,
+                gint              x,
+                gint              y,
+                guint             time,
+                GpLauncherApplet *self)
+{
+  if (!is_this_drop_ok (widget, context))
+    return FALSE;
+
+  gdk_drag_status (context, GDK_ACTION_COPY, time);
+  gtk_drag_highlight (widget);
+
+  return TRUE;
+}
+
+static void
+setup_drop_destination (GpLauncherApplet *self)
+{
+  GtkTargetList *target_list;
+  GdkAtom target;
+
+  gtk_drag_dest_set (GTK_WIDGET (self), 0, NULL, 0, 0);
+
+  target_list = gtk_target_list_new (NULL, 0);
+
+  target = gdk_atom_intern_static_string ("text/uri-list");
+  gtk_target_list_add (target_list, target, 0, 0);
+
+  gtk_drag_dest_set_target_list (GTK_WIDGET (self), target_list);
+  gtk_target_list_unref (target_list);
+
+  g_signal_connect (self, "drag-data-received",
+                    G_CALLBACK (drag_data_received_cb), self);
+
+  g_signal_connect (self, "drag-drop",
+                    G_CALLBACK (drag_drop_cb), self);
+
+  g_signal_connect (self, "drag-leave",
+                    G_CALLBACK (drag_leave_cb), self);
+
+  g_signal_connect (self, "drag-motion",
+                    G_CALLBACK (drag_motion_cb), self);
+}
+
+static void
+drag_begin_cb (GtkWidget        *widget,
+               GdkDragContext   *context,
+               GpLauncherApplet *self)
+{
+}
+
+static void
+drag_data_delete_cb (GtkWidget        *widget,
+                     GdkDragContext   *context,
+                     GpLauncherApplet *self)
+{
+}
+
+static void
+drag_data_get_cb (GtkWidget        *widget,
+                  GdkDragContext   *context,
+                  GtkSelectionData *data,
+                  guint             info,
+                  guint             time,
+                  GpLauncherApplet *self)
+{
+  GpLauncherAppletPrivate *priv;
+
+  priv = gp_launcher_applet_get_instance_private (self);
+
+  if (info == 1000)
+    {
+       gtk_selection_data_set (data,
+                               gtk_selection_data_get_target (data),
+                               8,
+                               (const guchar *) priv->location,
+                               strlen (priv->location));
+    }
+  else if (info == 2000)
+    {
+      char **uris;
+
+      uris = g_new0 (char *, 2);
+
+      uris[0] = g_filename_to_uri (priv->location, NULL, NULL);
+      uris[1] = NULL;
+
+      gtk_selection_data_set_uris (data, uris);
+      g_strfreev (uris);
+    }
+}
+
+static void
+drag_end_cb (GtkWidget        *widget,
+             GdkDragContext   *context,
+             GpLauncherApplet *self)
+{
+}
+
+static gboolean
+drag_failed_cb (GtkWidget        *widget,
+                GdkDragContext   *context,
+                GtkDragResult     result,
+                GpLauncherApplet *self)
+{
+  return FALSE;
+}
+
+static void
+setup_drag_source (GpLauncherApplet *self)
+{
+  GpLauncherAppletPrivate *priv;
+  GdkModifierType modifiers;
+  GdkDragAction actions;
+  GtkTargetList *target_list;
+  GdkAtom target;
+
+  priv = gp_launcher_applet_get_instance_private (self);
+
+  modifiers = GDK_BUTTON1_MASK;
+  actions = GDK_ACTION_COPY | GDK_ACTION_MOVE;
+
+  gtk_drag_source_set (priv->button, modifiers, NULL, 0, actions);
+
+  target_list = gtk_target_list_new (NULL, 0);
+
+  target = gdk_atom_intern_static_string ("application/x-panel-icon-internal");
+  gtk_target_list_add (target_list, target, 0, 1000);
+
+  target = gdk_atom_intern_static_string ("text/uri-list");
+  gtk_target_list_add (target_list, target, 0, 2000);
+
+  gtk_drag_source_set_target_list (priv->button, target_list);
+  gtk_target_list_unref (target_list);
+
+  g_signal_connect (priv->button, "drag-begin",
+                    G_CALLBACK (drag_begin_cb), self);
+
+  g_signal_connect (priv->button, "drag-data-delete",
+                    G_CALLBACK (drag_data_delete_cb), self);
+
+  g_signal_connect (priv->button, "drag-data-get",
+                    G_CALLBACK (drag_data_get_cb), self);
+
+  g_signal_connect (priv->button, "drag-end",
+                    G_CALLBACK (drag_end_cb), self);
+
+  g_signal_connect (priv->button, "drag-failed",
+                    G_CALLBACK (drag_failed_cb), self);
+}
+
+/* zoom factor, steps and delay if composited (factor must be odd) */
+#define ZOOM_FACTOR 5
+#define ZOOM_STEPS  14
+#define ZOOM_DELAY 10
+
+typedef struct
+{
+  int              size;
+  int              size_start;
+  int              size_end;
+  GtkPositionType  position;
+  double           opacity;
+  GIcon           *icon;
+  guint            timeout_id;
+  GtkWidget       *win;
+} ZoomData;
+
+static gboolean
+zoom_draw_cb (GtkWidget *widget,
+              cairo_t   *cr,
+              ZoomData  *zoom)
+{
+  GtkIconInfo *icon_info;
+  GdkPixbuf *pixbuf;
+  int width;
+  int height;
+  int x;
+  int y;
+
+  icon_info = gtk_icon_theme_lookup_by_gicon (gtk_icon_theme_get_default (),
+                                              zoom->icon,
+                                              zoom->size,
+                                              GTK_ICON_LOOKUP_FORCE_SIZE);
+
+  if (icon_info == NULL)
+    return FALSE;
+
+  pixbuf = gtk_icon_info_load_icon (icon_info, NULL);
+  g_object_unref (icon_info);
+
+  if (pixbuf == NULL)
+    return FALSE;
+
+  gtk_window_get_size (GTK_WINDOW (zoom->win), &width, &height);
+
+  switch (zoom->position)
+    {
+      case GTK_POS_TOP:
+        x = (width - gdk_pixbuf_get_width (pixbuf)) / 2;
+        y = 0;
+        break;
+
+      case GTK_POS_BOTTOM:
+        x = (width - gdk_pixbuf_get_width (pixbuf)) / 2;
+        y = height - gdk_pixbuf_get_height (pixbuf);
+        break;
+
+      case GTK_POS_LEFT:
+        x = 0;
+        y = (height - gdk_pixbuf_get_height (pixbuf)) / 2;
+        break;
+
+      case GTK_POS_RIGHT:
+        x = width - gdk_pixbuf_get_width (pixbuf);
+        y = (height - gdk_pixbuf_get_height (pixbuf)) / 2;
+        break;
+
+      default:
+        g_assert_not_reached ();
+        break;
+    }
+
+  cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
+  cairo_set_source_rgba (cr, 0, 0, 0, 0.0);
+  cairo_rectangle (cr, 0, 0, width, height);
+  cairo_fill (cr);
+
+  gdk_cairo_set_source_pixbuf (cr, pixbuf, x, y);
+  g_object_unref (pixbuf);
+
+  cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
+  cairo_paint_with_alpha (cr, MAX (zoom->opacity, 0));
+
+  return FALSE;
+}
+
+static gboolean
+zoom_timeout_cb (gpointer user_data)
+{
+  ZoomData *zoom;
+
+  zoom = user_data;
+
+  if (zoom->size >= zoom->size_end)
+    {
+      gtk_widget_destroy (zoom->win);
+      g_object_unref (zoom->icon);
+
+      g_slice_free (ZoomData, zoom);
+
+      return G_SOURCE_REMOVE;
+    }
+
+  zoom->size += MAX ((zoom->size_end - zoom->size_start) / ZOOM_STEPS, 1);
+  zoom->opacity -= 1.0 / (ZOOM_STEPS + 1.0);
+
+  gtk_widget_queue_draw (zoom->win);
+
+  return G_SOURCE_CONTINUE;
+}
+
+static void
+draw_zoom_animation (GpLauncherApplet *self,
+                     int               x,
+                     int               y,
+                     int               width,
+                     int               height,
+                     GIcon            *icon,
+                     GtkPositionType   position)
+{
+  ZoomData *zoom;
+  GdkScreen *screen;
+  GdkVisual *visual;
+  int wx;
+  int wy;
+
+  width += 2;
+  height += 2;
+
+  zoom = g_slice_new (ZoomData);
+
+  zoom->size = MIN (width, height);
+  zoom->size_start = zoom->size;
+  zoom->size_end = zoom->size * ZOOM_FACTOR;
+  zoom->position = position;
+  zoom->opacity = 1.0;
+  zoom->icon = g_object_ref (icon);
+  zoom->timeout_id = 0;
+
+  zoom->win = gtk_window_new (GTK_WINDOW_POPUP);
+
+  gtk_window_set_keep_above (GTK_WINDOW (zoom->win), TRUE);
+  gtk_window_set_decorated (GTK_WINDOW (zoom->win), FALSE);
+  gtk_widget_set_app_paintable (zoom->win, TRUE);
+
+  screen = gtk_widget_get_screen (GTK_WIDGET (self));
+  visual = gdk_screen_get_rgba_visual (screen);
+  gtk_widget_set_visual (zoom->win, visual);
+
+  gtk_window_set_gravity (GTK_WINDOW (zoom->win), GDK_GRAVITY_STATIC);
+  gtk_window_set_default_size (GTK_WINDOW (zoom->win),
+                               width * ZOOM_FACTOR,
+                               height * ZOOM_FACTOR);
+
+  switch (position)
+    {
+      case GTK_POS_TOP:
+        wx = x - width * (ZOOM_FACTOR / 2);
+        wy = y;
+        break;
+
+      case GTK_POS_BOTTOM:
+        wx = x - width * (ZOOM_FACTOR / 2);
+        wy = y - height * (ZOOM_FACTOR - 1);
+        break;
+
+      case GTK_POS_LEFT:
+        wx = x;
+        wy = y - height * (ZOOM_FACTOR / 2);
+        break;
+
+      case GTK_POS_RIGHT:
+        wx = x - width * (ZOOM_FACTOR - 1);
+        wy = y - height * (ZOOM_FACTOR / 2);
+        break;
+
+      default:
+        g_assert_not_reached ();
+        break;
+    }
+
+  g_signal_connect (zoom->win, "draw", G_CALLBACK (zoom_draw_cb), zoom);
+
+  gtk_window_move (GTK_WINDOW (zoom->win), wx, wy);
+  gtk_widget_realize (zoom->win);
+  gtk_widget_show (zoom->win);
+
+  zoom->timeout_id = g_timeout_add (ZOOM_DELAY, zoom_timeout_cb, zoom);
+  g_source_set_name_by_id (zoom->timeout_id, "[gnome-panel] zoom_timeout_cb");
+}
+
+static void
+launch_animation (GpLauncherApplet *self)
+{
+  GpLauncherAppletPrivate *priv;
+  GdkScreen *screen;
+  GtkSettings *settings;
+  gboolean enable_animations;
+  GIcon *icon;
+  int x;
+  int y;
+  GtkAllocation allocation;
+  GtkPositionType position;
+
+  priv = gp_launcher_applet_get_instance_private (self);
+
+  screen = gtk_widget_get_screen (GTK_WIDGET (self));
+  settings = gtk_widget_get_settings (GTK_WIDGET (self));
+
+  enable_animations = TRUE;
+  g_object_get (settings, "gtk-enable-animations", &enable_animations, NULL);
+
+  if (!enable_animations || !gdk_screen_is_composited (screen))
+    return;
+
+  icon = NULL;
+  gtk_image_get_gicon (GTK_IMAGE (priv->image), &icon, NULL);
+
+  if (icon == NULL)
+    return;
+
+  gdk_window_get_origin (gtk_widget_get_window (GTK_WIDGET (self)), &x, &y);
+  gtk_widget_get_allocation (GTK_WIDGET (self), &allocation);
+
+  position = gp_applet_get_position (GP_APPLET (self));
+
+  draw_zoom_animation (self,
+                       x,
+                       y,
+                       allocation.width,
+                       allocation.height,
+                       icon,
+                       position);
+}
+
+static void
+child_setup (gpointer user_data)
+{
+  GAppInfo *info;
+  const gchar *id;
+  gint stdout_fd;
+  gint stderr_fd;
+
+  info = G_APP_INFO (user_data);
+  id = g_app_info_get_id (info);
+
+  stdout_fd = sd_journal_stream_fd (id, LOG_INFO, FALSE);
+  if (stdout_fd >= 0)
+    {
+      dup2 (stdout_fd, STDOUT_FILENO);
+      close (stdout_fd);
+    }
+
+  stderr_fd = sd_journal_stream_fd (id, LOG_WARNING, FALSE);
+  if (stderr_fd >= 0)
+    {
+      dup2 (stderr_fd, STDERR_FILENO);
+      close (stderr_fd);
+    }
+}
+
+static void
+close_pid (GPid     pid,
+           gint     status,
+           gpointer user_data)
+{
+  g_spawn_close_pid (pid);
+}
+
+static void
+pid_cb (GDesktopAppInfo *info,
+        GPid             pid,
+        gpointer         user_data)
+{
+  g_child_watch_add (pid, close_pid, NULL);
+}
+
+static void
+launch (GpLauncherApplet *self,
+        GList            *uris)
+{
+  GpLauncherAppletPrivate *priv;
+  char *type;
+  char *command;
+
+  priv = gp_launcher_applet_get_instance_private (self);
+
+  type = NULL;
+  command = NULL;
+
+  if (!gp_launcher_read_from_key_file (priv->key_file,
+                                       NULL,
+                                       &type,
+                                       NULL,
+                                       &command,
+                                       NULL,
+                                       NULL))
+    return;
+
+  launch_animation (self);
+
+  if (g_strcmp0 (type, G_KEY_FILE_DESKTOP_TYPE_APPLICATION) == 0)
+    {
+      GDesktopAppInfo *app_info;
+
+      app_info = g_desktop_app_info_new_from_keyfile (priv->key_file);
+
+      if (app_info != NULL)
+        {
+          GSpawnFlags flags;
+          GError *error;
+
+          flags = G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD;
+
+          error = NULL;
+          g_desktop_app_info_launch_uris_as_manager (app_info,
+                                                     uris,
+                                                     NULL,
+                                                     flags,
+                                                     child_setup,
+                                                     app_info,
+                                                     pid_cb,
+                                                     NULL,
+                                                     &error);
+
+          if (error != NULL)
+            {
+              gp_launcher_show_error_message (NULL,
+                                              _("Could not launch application"),
+                                              error->message);
+
+              g_error_free (error);
+            }
+
+          g_object_unref (app_info);
+        }
+      else
+        {
+          char *error_message;
+
+          error_message = g_strdup_printf (_("Can not execute “%s” command line."),
+                                           command);
+
+          gp_launcher_show_error_message (NULL,
+                                          _("Could not launch application"),
+                                          error_message);
+
+          g_free (error_message);
+        }
+    }
+  else if (g_strcmp0 (type, G_KEY_FILE_DESKTOP_TYPE_LINK) == 0)
+    {
+      GError *error;
+
+      error = NULL;
+      gtk_show_uri_on_window (NULL,
+                              command,
+                              gtk_get_current_event_time (),
+                              &error);
+
+      if (error != NULL)
+        {
+          gp_launcher_show_error_message (NULL,
+                                          _("Could not open location"),
+                                          error->message);
+
+          g_error_free (error);
+        }
+    }
+
+  g_free (type);
+  g_free (command);
+}
+
+static void
+launcher_error (GpLauncherApplet *self,
+                const char       *error)
+{
+  GpLauncherAppletPrivate *priv;
+  guint icon_size;
+
+  priv = gp_launcher_applet_get_instance_private (self);
+
+  gtk_widget_set_tooltip_text (GTK_WIDGET (self), error);
+
+  gtk_image_set_from_icon_name (GTK_IMAGE (priv->image),
+                                "gnome-panel-launcher",
+                                GTK_ICON_SIZE_MENU);
+
+  icon_size = gp_applet_get_panel_icon_size (GP_APPLET (self));
+  gtk_image_set_pixel_size (GTK_IMAGE (priv->image), icon_size);
+}
+
+static void
+update_icon (GpLauncherApplet *self,
+             const char       *icon_name)
+{
+  GpLauncherAppletPrivate *priv;
+  GIcon *icon;
+  guint icon_size;
+
+  priv = gp_launcher_applet_get_instance_private (self);
+  icon = NULL;
+
+  if (icon_name != NULL && *icon_name != '\0')
+    {
+      if (g_path_is_absolute (icon_name))
+        {
+          GFile *file;
+
+          file = g_file_new_for_path (icon_name);
+          icon = g_file_icon_new (file);
+          g_object_unref (file);
+        }
+      else
+        {
+          char *p;
+
+          /* Work around a common mistake in desktop files */
+          if ((p = strrchr (icon_name, '.')) != NULL &&
+              (strcmp (p, ".png") == 0 ||
+               strcmp (p, ".xpm") == 0 ||
+               strcmp (p, ".svg") == 0))
+            *p = '\0';
+
+          icon = g_themed_icon_new (icon_name);
+        }
+    }
+
+  if (icon == NULL)
+    icon = g_themed_icon_new ("gnome-panel-launcher");
+
+  gtk_drag_source_set_icon_gicon (priv->button, icon);
+  gtk_image_set_from_gicon (GTK_IMAGE (priv->image), icon, GTK_ICON_SIZE_MENU);
+  g_object_unref (icon);
+
+  icon_size = gp_applet_get_panel_icon_size (GP_APPLET (self));
+  gtk_image_set_pixel_size (GTK_IMAGE (priv->image), icon_size);
+}
+
+static void
+update_tooltip (GpLauncherApplet *self,
+                const char       *name,
+                const char       *comment)
+{
+  char *tooltip;
+
+  if (name != NULL && *name != '\0' && comment != NULL && *comment != '\0')
+    tooltip = g_strdup_printf ("%s\n%s", name, comment);
+  else if (name != NULL && *name != '\0')
+    tooltip = g_strdup (name);
+  else if (comment != NULL && *comment != '\0')
+    tooltip = g_strdup (comment);
+  else
+    tooltip = NULL;
+
+  gtk_widget_set_tooltip_text (GTK_WIDGET (self), tooltip);
+  g_free (tooltip);
+
+  g_object_bind_property (self,
+                          "enable-tooltips",
+                          self,
+                          "has-tooltip",
+                          G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
+}
+
+static void
+update_launcher (GpLauncherApplet *self)
+{
+  GpLauncherAppletPrivate *priv;
+  GError *error;
+  char *error_message;
+  char *icon;
+  char *name;
+  char *comment;
+
+  priv = gp_launcher_applet_get_instance_private (self);
+
+  error = NULL;
+  g_key_file_load_from_file (priv->key_file,
+                             priv->location,
+                             G_KEY_FILE_NONE,
+                             &error);
+
+  error_message = NULL;
+
+  if (error != NULL)
+    {
+      error_message = g_strdup_printf (_("Failed to load key file “%s”: %s"),
+                                       priv->location,
+                                       error->message);
+
+      g_error_free (error);
+
+      launcher_error (self, error_message);
+      g_free (error_message);
+
+      return;
+    }
+
+  icon = NULL;
+  name = NULL;
+  comment = NULL;
+
+  if (!gp_launcher_read_from_key_file (priv->key_file,
+                                       &icon,
+                                       NULL,
+                                       &name,
+                                       NULL,
+                                       &comment,
+                                       &error_message))
+    {
+      launcher_error (self, error_message);
+      g_free (error_message);
+
+      return;
+    }
+
+  update_icon (self, icon);
+  update_tooltip (self, name, comment);
+
+  g_free (icon);
+  g_free (name);
+  g_free (comment);
+}
+
+static void
+file_changed_cb (GFileMonitor     *monitor,
+                 GFile            *file,
+                 GFile            *other_file,
+                 GFileMonitorEvent event_type,
+                 GpLauncherApplet *self)
+{
+  update_launcher (self);
+}
+
+static void
+location_changed (GpLauncherApplet *self)
+{
+  GpLauncherAppletPrivate *priv;
+  GFile *file;
+
+  priv = gp_launcher_applet_get_instance_private (self);
+
+  g_clear_pointer (&priv->location, g_free);
+  g_clear_pointer (&priv->key_file, g_key_file_unref);
+  g_clear_object (&priv->monitor);
+
+  priv->location = g_settings_get_string (priv->applet_settings, "location");
+  priv->key_file = g_key_file_new ();
+
+  file = g_file_new_for_path (priv->location);
+  priv->monitor = g_file_monitor_file (file, G_FILE_MONITOR_NONE, NULL, NULL);
+  g_file_monitor_set_rate_limit (priv->monitor, 200);
+  g_object_unref (file);
+
+  g_signal_connect (priv->monitor,
+                    "changed",
+                    G_CALLBACK (file_changed_cb),
+                    self);
+
+  update_launcher (self);
+}
+
+static void
+update_properties_action (GpLauncherApplet *self)
+{
+  GpApplet *applet;
+  GpLauncherAppletPrivate *priv;
+  gboolean locked_down;
+  gboolean disable_command_line;
+  GAction *action;
+  gboolean enabled;
+
+  applet = GP_APPLET (self);
+  priv = gp_launcher_applet_get_instance_private (self);
+
+  locked_down = gp_applet_get_locked_down (applet);
+  disable_command_line = g_settings_get_boolean (priv->lockdown_settings,
+                                                 "disable-command-line");
+
+  action = gp_applet_menu_lookup_action (applet, "properties");
+  enabled = !locked_down && !disable_command_line;
+
+  g_simple_action_set_enabled (G_SIMPLE_ACTION (action), enabled);
+}
+
+static void
+applet_settings_changed_cb (GSettings        *settings,
+                            const gchar      *key,
+                            GpLauncherApplet *self)
+{
+  if (g_strcmp0 (key, "location") != 0)
+    return;
+
+  location_changed (self);
+}
+
+static void
+lockdown_settings_changed_cb (GSettings        *settings,
+                              const gchar      *key,
+                              GpLauncherApplet *self)
+{
+  if (g_strcmp0 (key, "disable-command-line") != 0)
+    return;
+
+  update_properties_action (self);
+}
+
+static void
+locked_down_cb (GpApplet         *applet,
+                GParamSpec       *pspec,
+                GpLauncherApplet *self)
+{
+  update_properties_action (self);
+}
+
+static void
+panel_icon_size_cb (GpApplet         *applet,
+                    GParamSpec       *pspec,
+                    GpLauncherApplet *self)
+{
+  GpLauncherAppletPrivate *priv;
+  guint icon_size;
+
+  priv = gp_launcher_applet_get_instance_private (self);
+
+  icon_size = gp_applet_get_panel_icon_size (applet);
+  gtk_image_set_pixel_size (GTK_IMAGE (priv->image), icon_size);
+}
+
+static void
+launch_cb (GSimpleAction *action,
+           GVariant      *parameter,
+           gpointer       user_data)
+{
+  launch (GP_LAUNCHER_APPLET (user_data), NULL);
+}
+
+static void
+properties_cb (GSimpleAction *action,
+               GVariant      *parameter,
+               gpointer       user_data)
+{
+  GpLauncherApplet *self;
+  GpLauncherAppletPrivate *priv;
+
+  self = GP_LAUNCHER_APPLET (user_data);
+  priv = gp_launcher_applet_get_instance_private (self);
+
+  if (priv->properties != NULL)
+    {
+      gtk_window_present (GTK_WINDOW (priv->properties));
+      return;
+    }
+
+  priv->properties = gp_launcher_properties_new (priv->applet_settings);
+  g_object_add_weak_pointer (G_OBJECT (priv->properties),
+                             (gpointer *) &priv->properties);
+
+  gtk_window_present (GTK_WINDOW (priv->properties));
+}
+
+static const GActionEntry launcher_menu_actions[] =
+  {
+    { "launch", launch_cb, NULL, NULL, NULL },
+    { "properties", properties_cb, NULL, NULL, NULL },
+    { NULL }
+  };
+
+static void
+setup_menu (GpLauncherApplet *self)
+{
+  GpApplet *applet;
+  const gchar *resource;
+
+  applet = GP_APPLET (self);
+
+  resource = GP_LAUNCHER_APPLET_GET_CLASS (self)->get_menu_resource ();
+  gp_applet_setup_menu_from_resource (applet, resource, launcher_menu_actions);
+
+  update_properties_action (self);
+}
+
+static void
+clicked_cb (GtkWidget        *widget,
+            GpLauncherApplet *self)
+{
+  launch (self, NULL);
+}
+
+static void
+setup_button (GpLauncherApplet *self)
+{
+  GpLauncherAppletPrivate *priv;
+  guint icon_size;
+
+  priv = gp_launcher_applet_get_instance_private (self);
+
+  priv->button = gp_launcher_button_new ();
+  gtk_container_add (GTK_CONTAINER (self), priv->button);
+  gtk_widget_show (priv->button);
+
+  g_signal_connect (priv->button, "clicked",
+                    G_CALLBACK (clicked_cb), self);
+
+  priv->image = gtk_image_new ();
+  gtk_container_add (GTK_CONTAINER (priv->button), priv->image);
+  gtk_widget_show (priv->image);
+
+  icon_size = gp_applet_get_panel_icon_size (GP_APPLET (self));
+  gtk_image_set_pixel_size (GTK_IMAGE (priv->image), icon_size);
+}
+
+static void
+gp_launcher_applet_setup (GpLauncherApplet *self)
+{
+  GpLauncherAppletPrivate *priv;
+
+  priv = gp_launcher_applet_get_instance_private (self);
+
+  priv->applet_settings = gp_applet_settings_new (GP_APPLET (self),
+                                                  LAUNCHER_SCHEMA);
+
+  priv->lockdown_settings = g_settings_new (LOCKDOWN_SCHEMA);
+
+  g_signal_connect (priv->applet_settings, "changed",
+                    G_CALLBACK (applet_settings_changed_cb), self);
+
+  g_signal_connect (priv->lockdown_settings, "changed::disable-command-line",
+                    G_CALLBACK (lockdown_settings_changed_cb), self);
+
+  g_signal_connect (self, "notify::locked-down",
+                    G_CALLBACK (locked_down_cb), self);
+
+  g_signal_connect (self, "notify::panel-icon-size",
+                    G_CALLBACK (panel_icon_size_cb), self);
+
+  setup_menu (self);
+  setup_button (self);
+
+  setup_drop_destination (self);
+  setup_drag_source (self);
+
+  location_changed (self);
+}
+
+static void
+gp_launcher_applet_constructed (GObject *object)
+{
+  G_OBJECT_CLASS (gp_launcher_applet_parent_class)->constructed (object);
+  gp_launcher_applet_setup (GP_LAUNCHER_APPLET (object));
+}
+
+static void
+gp_launcher_applet_dispose (GObject *object)
+{
+  GpLauncherApplet *self;
+  GpLauncherAppletPrivate *priv;
+
+  self = GP_LAUNCHER_APPLET (object);
+  priv = gp_launcher_applet_get_instance_private (self);
+
+  g_clear_object (&priv->applet_settings);
+  g_clear_object (&priv->lockdown_settings);
+
+  g_clear_pointer (&priv->key_file, g_key_file_unref);
+  g_clear_object (&priv->monitor);
+
+  g_clear_pointer (&priv->properties, gtk_widget_destroy);
+
+  G_OBJECT_CLASS (gp_launcher_applet_parent_class)->dispose (object);
+}
+
+static void
+gp_launcher_applet_finalize (GObject *object)
+{
+  GpLauncherApplet *self;
+  GpLauncherAppletPrivate *priv;
+
+  self = GP_LAUNCHER_APPLET (object);
+  priv = gp_launcher_applet_get_instance_private (self);
+
+  g_clear_pointer (&priv->location, g_free);
+
+  G_OBJECT_CLASS (gp_launcher_applet_parent_class)->finalize (object);
+}
+
+static void
+gp_launcher_applet_initial_setup (GpApplet *applet,
+                                  GVariant *initial_settings)
+{
+  GSettings *settings;
+  const char *location;
+
+  settings = gp_applet_settings_new (applet, LAUNCHER_SCHEMA);
+
+  location = NULL;
+  if (g_variant_lookup (initial_settings, "location", "&s", &location))
+    {
+      g_settings_set_string (settings, "location", location);
+    }
+  else
+    {
+      const char *type;
+      const char *icon;
+      const char *name;
+      const char *command;
+      const char *comment;
+      GKeyFile *file;
+      char *filename;
+      GError *error;
+
+      g_variant_lookup (initial_settings, "type", "&s", &type);
+      g_variant_lookup (initial_settings, "icon", "&s", &icon);
+      g_variant_lookup (initial_settings, "name", "&s", &name);
+      g_variant_lookup (initial_settings, "command", "&s", &command);
+      g_variant_lookup (initial_settings, "comment", "&s", &comment);
+
+      file = g_key_file_new ();
+
+      g_key_file_set_string (file,
+                             G_KEY_FILE_DESKTOP_GROUP,
+                             G_KEY_FILE_DESKTOP_KEY_VERSION, "1.0");
+
+      g_key_file_set_string (file,
+                             G_KEY_FILE_DESKTOP_GROUP,
+                             G_KEY_FILE_DESKTOP_KEY_TYPE,
+                             type);
+
+      g_key_file_set_string (file,
+                             G_KEY_FILE_DESKTOP_GROUP,
+                             G_KEY_FILE_DESKTOP_KEY_ICON,
+                             icon);
+
+      g_key_file_set_string (file,
+                             G_KEY_FILE_DESKTOP_GROUP,
+                             G_KEY_FILE_DESKTOP_KEY_NAME,
+                             name);
+
+      g_key_file_set_string (file,
+                             G_KEY_FILE_DESKTOP_GROUP,
+                             G_KEY_FILE_DESKTOP_KEY_COMMENT,
+                             comment);
+
+      if (g_strcmp0 (type, "Application") == 0)
+        {
+          gboolean terminal;
+
+          g_key_file_set_string (file,
+                                 G_KEY_FILE_DESKTOP_GROUP,
+                                 G_KEY_FILE_DESKTOP_KEY_EXEC,
+                                 command);
+
+          if (g_variant_lookup (initial_settings, "terminal", "b", &terminal))
+            {
+              g_key_file_set_boolean (file,
+                                      G_KEY_FILE_DESKTOP_GROUP,
+                                      G_KEY_FILE_DESKTOP_KEY_TERMINAL,
+                                      terminal);
+            }
+        }
+      else if (g_strcmp0 (type, "Link") == 0)
+        {
+          g_key_file_set_string (file,
+                                 G_KEY_FILE_DESKTOP_GROUP,
+                                 G_KEY_FILE_DESKTOP_KEY_URL,
+                                 command);
+        }
+      else
+        {
+          g_assert_not_reached ();
+        }
+
+      filename = gp_launcher_get_unique_filename ();
+
+      error = NULL;
+      g_key_file_save_to_file (file, filename, &error);
+      g_key_file_unref (file);
+
+      if (error != NULL)
+        {
+          g_warning ("%s", error->message);
+          g_error_free (error);
+        }
+      else
+        {
+          g_settings_set_string (settings, "location", filename);
+        }
+
+      g_free (filename);
+    }
+
+  g_object_unref (settings);
+}
+
+static void
+delete_cb (GObject      *source_object,
+           GAsyncResult *res,
+           gpointer      user_data)
+{
+  GError *error;
+
+  error = NULL;
+  g_file_delete_finish (G_FILE (source_object), res, &error);
+
+  if (error != NULL)
+    {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        g_warning ("Failed to delete launcher file: %s", error->message);
+
+      g_error_free (error);
+      return;
+    }
+}
+
+static void
+gp_launcher_applet_remove_from_panel (GpApplet *applet)
+{
+  GpLauncherApplet *self;
+  GpLauncherAppletPrivate *priv;
+  char *launchers_dir;
+
+  self = GP_LAUNCHER_APPLET (applet);
+  priv = gp_launcher_applet_get_instance_private (self);
+
+  launchers_dir = gp_launcher_get_launchers_dir ();
+
+  if (g_str_has_prefix (priv->location, launchers_dir))
+    {
+      GFile *file;
+
+      file = g_file_new_for_path (priv->location);
+
+      g_file_delete_async (file, G_PRIORITY_DEFAULT, NULL, delete_cb, NULL);
+      g_object_unref (file);
+    }
+
+  g_free (launchers_dir);
+}
+
+static const char *
+gp_launcher_applet_get_menu_resource (void)
+{
+  return GRESOURCE_PREFIX "/launcher-menu.ui";
+}
+
+static void
+gp_launcher_applet_class_init (GpLauncherAppletClass *self_class)
+{
+  GObjectClass *object_class;
+  GpAppletClass *applet_class;
+
+  object_class = G_OBJECT_CLASS (self_class);
+  applet_class = GP_APPLET_CLASS (self_class);
+
+  object_class->constructed = gp_launcher_applet_constructed;
+  object_class->dispose = gp_launcher_applet_dispose;
+  object_class->finalize = gp_launcher_applet_finalize;
+
+  applet_class->initial_setup = gp_launcher_applet_initial_setup;
+  applet_class->remove_from_panel = gp_launcher_applet_remove_from_panel;
+
+  self_class->get_menu_resource = gp_launcher_applet_get_menu_resource;
+}
+
+static void
+gp_launcher_applet_init (GpLauncherApplet *self)
+{
+  GpApplet *applet;
+
+  applet = GP_APPLET (self);
+
+  gp_applet_set_flags (applet, GP_APPLET_FLAGS_EXPAND_MINOR);
+}
+
+void
+gp_launcher_applet_initial_setup_dialog (GpInitialSetupDialog *dialog)
+{
+  LauncherData *data;
+  GtkWidget *scrolled;
+  GtkWidget *tree_view;
+  GtkTreeSelection *selection;
+  GtkTreeViewColumn *column;
+  GtkCellRenderer *renderer;
+
+  data = launcher_data_new (dialog);
+
+  scrolled = gtk_scrolled_window_new (NULL, NULL);
+  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN);
+  gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (scrolled), 460);
+  gtk_scrolled_window_set_min_content_width (GTK_SCROLLED_WINDOW (scrolled), 480);
+  gtk_widget_show (scrolled);
+
+  tree_view = gtk_tree_view_new ();
+  gtk_container_add (GTK_CONTAINER (scrolled), tree_view);
+  gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE);
+  gtk_widget_show (tree_view);
+
+  selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
+  gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
+
+  g_signal_connect (selection, "changed",
+                    G_CALLBACK (selection_changed_cb), data);
+
+  column = gtk_tree_view_column_new ();
+  gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
+
+  renderer = gtk_cell_renderer_pixbuf_new ();
+  gtk_tree_view_column_pack_start (column, renderer, FALSE);
+  gtk_tree_view_column_add_attribute (column, renderer, "gicon", 0);
+
+  g_object_set (renderer,
+                "stock-size", GTK_ICON_SIZE_DND,
+                "xpad", 4, "ypad", 4,
+                NULL);
+
+  renderer = gtk_cell_renderer_text_new ();
+  gtk_tree_view_column_pack_start (column, renderer, TRUE);
+  gtk_tree_view_column_add_attribute (column, renderer, "markup", 1);
+
+  g_object_set (renderer,
+                "ellipsize", PANGO_ELLIPSIZE_END,
+                "xpad", 4, "ypad", 4,
+                NULL);
+
+  data->store = gtk_tree_store_new (3, G_TYPE_ICON, G_TYPE_STRING, G_TYPE_POINTER);
+  populate_model (data->store, data);
+
+  gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view),
+                           GTK_TREE_MODEL (data->store));
+
+  gp_initital_setup_dialog_add_content_widget (dialog, scrolled, data,
+                                               launcher_data_free);
+}
diff --git a/modules/launcher/gp-launcher-applet.h b/modules/launcher/gp-launcher-applet.h
new file mode 100644
index 000000000..43e708b8d
--- /dev/null
+++ b/modules/launcher/gp-launcher-applet.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2020 Alberts Muktupāvels
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GP_LAUNCHER_APPLET_H
+#define GP_LAUNCHER_APPLET_H
+
+#include <libgnome-panel/gp-applet.h>
+#include <libgnome-panel/gp-module.h>
+
+G_BEGIN_DECLS
+
+#define GP_TYPE_LAUNCHER_APPLET (gp_launcher_applet_get_type ())
+G_DECLARE_DERIVABLE_TYPE (GpLauncherApplet, gp_launcher_applet,
+                          GP, LAUNCHER_APPLET, GpApplet)
+
+struct _GpLauncherAppletClass
+{
+  GpAppletClass parent;
+
+  const char * (* get_menu_resource) (void);
+};
+
+void gp_launcher_applet_initial_setup_dialog (GpInitialSetupDialog *dialog);
+
+G_END_DECLS
+
+#endif
diff --git a/modules/launcher/gp-launcher-button.c b/modules/launcher/gp-launcher-button.c
new file mode 100644
index 000000000..d7b4b236a
--- /dev/null
+++ b/modules/launcher/gp-launcher-button.c
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2020 Alberts Muktupāvels
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+#include "gp-launcher-button.h"
+
+struct _GpLauncherButton
+{
+  GtkButton parent;
+};
+
+G_DEFINE_TYPE (GpLauncherButton, gp_launcher_button, GTK_TYPE_BUTTON)
+
+static void
+gp_launcher_button_class_init (GpLauncherButtonClass *button_class)
+{
+  GtkWidgetClass *widget_class;
+
+  widget_class = GTK_WIDGET_CLASS (button_class);
+
+  gtk_widget_class_set_css_name (widget_class, "gp-launcher-button");
+}
+
+static void
+gp_launcher_button_init (GpLauncherButton *button)
+{
+}
+
+GtkWidget *
+gp_launcher_button_new (void)
+{
+  return g_object_new (GP_TYPE_LAUNCHER_BUTTON, NULL);
+}
diff --git a/modules/launcher/gp-launcher-button.h b/modules/launcher/gp-launcher-button.h
new file mode 100644
index 000000000..7c4d9cccd
--- /dev/null
+++ b/modules/launcher/gp-launcher-button.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2020 Alberts Muktupāvels
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GP_LAUNCHER_BUTTON_H
+#define GP_LAUNCHER_BUTTON_H
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define GP_TYPE_LAUNCHER_BUTTON (gp_launcher_button_get_type ())
+G_DECLARE_FINAL_TYPE (GpLauncherButton, gp_launcher_button,
+                      GP, LAUNCHER_BUTTON, GtkButton)
+
+GtkWidget *gp_launcher_button_new (void);
+
+G_END_DECLS
+
+#endif
diff --git a/modules/launcher/gp-launcher-module.c b/modules/launcher/gp-launcher-module.c
new file mode 100644
index 000000000..28709e7df
--- /dev/null
+++ b/modules/launcher/gp-launcher-module.c
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2020 Alberts Muktupāvels
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <glib/gi18n-lib.h>
+#include <libgnome-panel/gp-module.h>
+
+#include "gp-custom-launcher-applet.h"
+#include "gp-launcher-applet.h"
+
+static GpAppletInfo *
+launcher_get_applet_info (const gchar *id)
+{
+  GpGetAppletTypeFunc type_func;
+  const gchar *name;
+  const gchar *description;
+  const gchar *icon;
+  GpInitialSetupDialogFunc initial_setup_func;
+  GpAppletInfo *info;
+
+  initial_setup_func = NULL;
+
+  if (g_strcmp0 (id, "custom-launcher") == 0)
+    {
+      type_func = gp_custom_launcher_applet_get_type;
+      name = _("Custom Application Launcher");
+      description = _("Create a new launcher");
+      icon = "gnome-panel-launcher";
+
+      initial_setup_func = gp_custom_launcher_applet_initial_setup_dialog;
+    }
+  else if (g_strcmp0 (id, "launcher") == 0)
+    {
+      type_func = gp_launcher_applet_get_type;
+      name = _("Application Launcher...");
+      description = _("Copy a launcher from the applications menu");
+      icon = "gnome-panel-launcher";
+
+      initial_setup_func = gp_launcher_applet_initial_setup_dialog;
+    }
+  else
+    {
+      g_assert_not_reached ();
+      return NULL;
+    }
+
+  info = gp_applet_info_new (type_func, name, description, icon);
+
+  if (initial_setup_func != NULL)
+    gp_applet_info_set_initial_setup_dialog (info, initial_setup_func);
+
+  return info;
+}
+
+static const gchar *
+launcher_get_applet_id_from_iid (const gchar *iid)
+{
+  if (g_strcmp0 (iid, "PanelInternalFactory::Launcher") == 0)
+    return "custom-launcher";
+
+  return NULL;
+}
+
+void
+gp_module_load (GpModule *module)
+{
+  bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
+  bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+  gp_module_set_gettext_domain (module, GETTEXT_PACKAGE);
+
+  gp_module_set_abi_version (module, GP_MODULE_ABI_VERSION);
+
+  gp_module_set_id (module, "org.gnome.gnome-panel.launcher");
+  gp_module_set_version (module, PACKAGE_VERSION);
+
+  gp_module_set_applet_ids (module, "custom-launcher", "launcher", NULL);
+
+  gp_module_set_get_applet_info (module, launcher_get_applet_info);
+  gp_module_set_compatibility (module, launcher_get_applet_id_from_iid);
+}
diff --git a/modules/launcher/gp-launcher-properties.c b/modules/launcher/gp-launcher-properties.c
new file mode 100644
index 000000000..b4b84d087
--- /dev/null
+++ b/modules/launcher/gp-launcher-properties.c
@@ -0,0 +1,674 @@
+/*
+ * Copyright (C) 2008 Novell, Inc.
+ * Copyright (C) 2020 Alberts Muktupāvels
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *     Alberts Muktupāvels <alberts muktupavels gmail com>
+ *     Vincent Untz <vincent vuntz net>
+ */
+
+#include "config.h"
+#include "gp-launcher-properties.h"
+
+#include <glib/gi18n-lib.h>
+
+#include "gp-editor.h"
+#include "gp-launcher-utils.h"
+
+enum
+{
+  GP_RESPONSE_REVERT
+};
+
+struct _GpLauncherProperties
+{
+  GtkDialog  parent;
+
+  GpEditor  *editor;
+  GtkWidget *revert_button;
+
+  GSettings *settings;
+
+  GKeyFile  *file;
+  GKeyFile  *revert_file;
+
+  gboolean   dirty;
+
+  guint      save_id;
+};
+
+enum
+{
+  PROP_0,
+
+  PROP_SETTINGS,
+
+  LAST_PROP
+};
+
+static GParamSpec *properties_properties[LAST_PROP] = { NULL };
+
+G_DEFINE_TYPE (GpLauncherProperties, gp_launcher_properties, GTK_TYPE_DIALOG)
+
+static void
+show_error_message (GpLauncherProperties *self,
+                    const char           *error_message)
+{
+  gp_launcher_show_error_message (GTK_WINDOW (self),
+                                  _("Could not save launcher"),
+                                  error_message);
+}
+
+static gboolean
+get_launcher_filename (GpLauncherProperties  *self,
+                       char                 **filename)
+{
+  char *location;
+  char *launchers_dir;
+
+  g_assert (*filename == NULL);
+
+  location = g_settings_get_string (self->settings, "location");
+  launchers_dir = gp_launcher_get_launchers_dir ();
+
+  if (!g_str_has_prefix (location, launchers_dir))
+    {
+      *filename = gp_launcher_get_unique_filename ();
+
+      g_free (location);
+      g_free (launchers_dir);
+
+      return TRUE;
+    }
+
+  *filename = location;
+
+  g_free (launchers_dir);
+
+  return FALSE;
+}
+
+static gboolean
+launcher_save (GpLauncherProperties *self,
+               gboolean              interactive)
+{
+  char *error_message;
+  gboolean location_changed;
+  char *filename;
+  GError *error;
+
+  if (self->save_id != 0)
+    {
+      g_source_remove (self->save_id);
+      self->save_id = 0;
+    }
+
+  if (!self->dirty)
+    return TRUE;
+
+  error_message = NULL;
+  if (!gp_launcher_validate_key_file (self->file, &error_message))
+    {
+      if (interactive)
+        show_error_message (self, error_message);
+      g_free (error_message);
+
+      return FALSE;
+    }
+
+  filename = NULL;
+  location_changed = get_launcher_filename (self, &filename);
+
+  error = NULL;
+  if (!g_key_file_save_to_file (self->file, filename, &error))
+    {
+      if (interactive)
+        show_error_message (self, error->message);
+
+      g_error_free (error);
+      g_free (filename);
+
+      return FALSE;
+    }
+
+  if (location_changed)
+    g_settings_set_string (self->settings, "location", filename);
+
+  g_free (filename);
+
+  self->dirty = FALSE;
+
+  return TRUE;
+}
+
+static gboolean
+save_cb (gpointer user_data)
+{
+  GpLauncherProperties *self;
+
+  self = GP_LAUNCHER_PROPERTIES (user_data);
+  self->save_id = 0;
+
+  launcher_save (self, FALSE);
+
+  return G_SOURCE_REMOVE;
+}
+
+static void
+launcher_changed (GpLauncherProperties *self)
+{
+  self->dirty = TRUE;
+
+  gtk_dialog_set_response_sensitive (GTK_DIALOG (self),
+                                     GP_RESPONSE_REVERT,
+                                     TRUE);
+
+  if (self->save_id != 0)
+    g_source_remove (self->save_id);
+
+  self->save_id = g_timeout_add_seconds (2, save_cb, self);
+  g_source_set_name_by_id (self->save_id, "[gnome-panel] save_cb");
+}
+
+static void
+remove_locale_key (GKeyFile   *key_file,
+                   const char *key)
+{
+  char **keys;
+  size_t key_len;
+  int i;
+
+  keys = g_key_file_get_keys (key_file, G_KEY_FILE_DESKTOP_GROUP, NULL, NULL);
+  if (keys == NULL)
+    return;
+
+  key_len = strlen (key);
+
+  for (i = 0; keys[i] != NULL; i++)
+    {
+      size_t len;
+
+      if (strncmp (keys[i], key, key_len) != 0)
+        continue;
+
+      len = strlen (keys[i]);
+
+      if (len == key_len || keys[i][key_len] == '[')
+        {
+          g_key_file_remove_key (key_file,
+                                 G_KEY_FILE_DESKTOP_GROUP,
+                                 keys[i],
+                                 NULL);
+        }
+    }
+
+  g_strfreev (keys);
+}
+
+static void
+icon_changed_cb (GpEditor             *editor,
+                 GpLauncherProperties *self)
+{
+  const char *icon;
+
+  icon = gp_editor_get_icon (editor);
+
+  remove_locale_key (self->file, G_KEY_FILE_DESKTOP_KEY_ICON);
+
+  if (icon != NULL && *icon != '\0')
+    {
+      g_key_file_set_string (self->file,
+                             G_KEY_FILE_DESKTOP_GROUP,
+                             G_KEY_FILE_DESKTOP_KEY_ICON,
+                             icon);
+    }
+
+  launcher_changed (self);
+}
+
+static void
+type_changed_cb (GpEditor             *editor,
+                 GpLauncherProperties *self)
+{
+  GpEditorType type;
+  const char *type_key;
+  const char *command;
+
+  type = gp_editor_get_editor_type (editor);
+  command = gp_editor_get_command (editor);
+  type_key = NULL;
+
+  if (type == GP_EDITOR_TYPE_APPLICATION ||
+      type == GP_EDITOR_TYPE_TERMINAL_APPLICATION)
+    {
+      type_key = G_KEY_FILE_DESKTOP_TYPE_APPLICATION;
+    }
+  else if (type == GP_EDITOR_TYPE_DIRECTORY ||
+           type == GP_EDITOR_TYPE_FILE)
+    {
+      type_key = G_KEY_FILE_DESKTOP_TYPE_LINK;
+    }
+
+  g_key_file_set_string (self->file,
+                         G_KEY_FILE_DESKTOP_GROUP,
+                         G_KEY_FILE_DESKTOP_KEY_TYPE,
+                         type_key);
+
+  if (type == GP_EDITOR_TYPE_APPLICATION ||
+      type == GP_EDITOR_TYPE_TERMINAL_APPLICATION)
+    {
+      g_key_file_remove_key (self->file,
+                             G_KEY_FILE_DESKTOP_GROUP,
+                             G_KEY_FILE_DESKTOP_KEY_URL,
+                             NULL);
+
+      g_key_file_set_string (self->file,
+                             G_KEY_FILE_DESKTOP_GROUP,
+                             G_KEY_FILE_DESKTOP_KEY_EXEC,
+                             command);
+
+      if (type == GP_EDITOR_TYPE_TERMINAL_APPLICATION)
+        {
+          g_key_file_set_boolean (self->file,
+                                 G_KEY_FILE_DESKTOP_GROUP,
+                                 G_KEY_FILE_DESKTOP_KEY_TERMINAL,
+                                 TRUE);
+        }
+      else
+        {
+          g_key_file_remove_key (self->file,
+                                 G_KEY_FILE_DESKTOP_GROUP,
+                                 G_KEY_FILE_DESKTOP_KEY_TERMINAL,
+                                 NULL);
+        }
+    }
+  else if (type == GP_EDITOR_TYPE_DIRECTORY ||
+           type == GP_EDITOR_TYPE_FILE)
+    {
+      g_key_file_remove_key (self->file,
+                             G_KEY_FILE_DESKTOP_GROUP,
+                             G_KEY_FILE_DESKTOP_KEY_TERMINAL,
+                             NULL);
+
+      g_key_file_remove_key (self->file,
+                             G_KEY_FILE_DESKTOP_GROUP,
+                             G_KEY_FILE_DESKTOP_KEY_EXEC,
+                             NULL);
+
+      g_key_file_set_string (self->file,
+                             G_KEY_FILE_DESKTOP_GROUP,
+                             G_KEY_FILE_DESKTOP_KEY_URL,
+                             command);
+    }
+  else
+    {
+      g_assert_not_reached ();
+    }
+
+  launcher_changed (self);
+}
+
+static void
+name_changed_cb (GpEditor             *editor,
+                 GpLauncherProperties *self)
+{
+  const char *name;
+
+  name = gp_editor_get_name (editor);
+
+  remove_locale_key (self->file, "X-GNOME-FullName");
+  remove_locale_key (self->file, G_KEY_FILE_DESKTOP_KEY_NAME);
+
+  if (name != NULL && *name != '\0')
+    {
+      g_key_file_set_string (self->file,
+                             G_KEY_FILE_DESKTOP_GROUP,
+                             G_KEY_FILE_DESKTOP_KEY_NAME,
+                             name);
+    }
+
+  launcher_changed (self);
+}
+
+static void
+command_changed_cb (GpEditor             *editor,
+                    GpLauncherProperties *self)
+{
+  const char *command;
+  GpEditorType type;
+
+  command = gp_editor_get_command (editor);
+  type = gp_editor_get_editor_type (editor);
+
+  if (type == GP_EDITOR_TYPE_APPLICATION ||
+      type == GP_EDITOR_TYPE_TERMINAL_APPLICATION)
+    {
+      g_key_file_set_string (self->file,
+                             G_KEY_FILE_DESKTOP_GROUP,
+                             G_KEY_FILE_DESKTOP_KEY_EXEC,
+                             command);
+    }
+  else if (type == GP_EDITOR_TYPE_DIRECTORY ||
+           type == GP_EDITOR_TYPE_FILE)
+    {
+      g_key_file_set_string (self->file,
+                             G_KEY_FILE_DESKTOP_GROUP,
+                             G_KEY_FILE_DESKTOP_KEY_URL,
+                             command);
+    }
+  else
+    {
+      g_assert_not_reached ();
+    }
+
+  launcher_changed (self);
+}
+
+static void
+comment_changed_cb (GpEditor             *editor,
+                    GpLauncherProperties *self)
+{
+  const char *comment;
+
+  comment = gp_editor_get_comment (editor);
+
+  remove_locale_key (self->file, G_KEY_FILE_DESKTOP_KEY_COMMENT);
+
+  if (comment != NULL && *comment != '\0')
+    {
+      g_key_file_set_string (self->file,
+                             G_KEY_FILE_DESKTOP_GROUP,
+                             G_KEY_FILE_DESKTOP_KEY_COMMENT,
+                             comment);
+    }
+
+  launcher_changed (self);
+}
+
+static void
+fill_editor_from_file (GpLauncherProperties *self,
+                       GKeyFile             *key_file)
+{
+  char *icon;
+  char *type_string;
+  char *name;
+  char *command;
+  char *comment;
+  gboolean terminal;
+  GpEditorType type;
+
+  icon = NULL;
+  type_string = NULL;
+  name = NULL;
+  command = NULL;
+  comment = NULL;
+
+  if (!gp_launcher_read_from_key_file (key_file,
+                                       &icon,
+                                       &type_string,
+                                       &name,
+                                       &command,
+                                       &comment,
+                                       NULL))
+    return;
+
+  terminal = g_key_file_get_boolean (key_file,
+                                     G_KEY_FILE_DESKTOP_GROUP,
+                                     G_KEY_FILE_DESKTOP_KEY_TERMINAL,
+                                     NULL);
+
+  if (g_strcmp0 (type_string, G_KEY_FILE_DESKTOP_TYPE_APPLICATION) == 0)
+    {
+      if (terminal)
+        type = GP_EDITOR_TYPE_TERMINAL_APPLICATION;
+      else
+        type = GP_EDITOR_TYPE_APPLICATION;
+    }
+  else if (g_strcmp0 (type_string, G_KEY_FILE_DESKTOP_TYPE_LINK) == 0)
+    {
+      GFile *file;
+      char *path;
+
+      file = g_file_new_for_uri (command);
+      path = g_file_get_path (file);
+      g_object_unref (file);
+
+      if (file != NULL && g_file_test (path, G_FILE_TEST_IS_DIR))
+        type = GP_EDITOR_TYPE_DIRECTORY;
+      else
+        type = GP_EDITOR_TYPE_FILE;
+
+      g_free (path);
+    }
+  else
+    {
+      type = GP_EDITOR_TYPE_NONE;
+    }
+
+  gp_editor_set_icon (self->editor, icon);
+  gp_editor_set_editor_type (self->editor, type);
+  gp_editor_set_name (self->editor, name);
+  gp_editor_set_command (self->editor, command);
+  gp_editor_set_comment (self->editor, comment);
+
+  g_free (icon);
+  g_free (type_string);
+  g_free (name);
+  g_free (command);
+  g_free (comment);
+}
+
+static void
+response_cb (GtkWidget            *widget,
+             int                   response_id,
+             GpLauncherProperties *self)
+{
+  if (response_id == GTK_RESPONSE_CLOSE)
+    {
+      if (launcher_save (self, TRUE))
+        gtk_widget_destroy (widget);
+    }
+  else if (response_id == GP_RESPONSE_REVERT)
+    {
+      fill_editor_from_file (self, self->revert_file);
+      gtk_dialog_set_response_sensitive (GTK_DIALOG (self),
+                                         GP_RESPONSE_REVERT,
+                                         FALSE);
+    }
+  else if (response_id == GTK_RESPONSE_DELETE_EVENT)
+    {
+      fill_editor_from_file (self, self->revert_file);
+      launcher_save (self, FALSE);
+    }
+}
+
+static void
+gp_launcher_properties_constructed (GObject *object)
+{
+  GpLauncherProperties *self;
+  char *location;
+  GError *error;
+  GKeyFileFlags flags;
+
+  self = GP_LAUNCHER_PROPERTIES (object);
+
+  G_OBJECT_CLASS (gp_launcher_properties_parent_class)->constructed (object);
+
+  location = g_settings_get_string (self->settings, "location");
+  error = NULL;
+
+  flags = G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS;
+
+  self->file = g_key_file_new ();
+  self->revert_file = g_key_file_new ();
+
+  g_key_file_load_from_file (self->file, location, flags, &error);
+
+  if (error != NULL)
+    {
+      g_warning ("Failed to load key file “%s”: %s", location, error->message);
+      g_error_free (error);
+      g_free (location);
+
+      return;
+    }
+
+  g_key_file_load_from_file (self->revert_file, location, flags, NULL);
+  g_free (location);
+
+  fill_editor_from_file (self, self->file);
+
+  g_signal_connect (self->editor,
+                    "icon-changed",
+                    G_CALLBACK (icon_changed_cb),
+                    self);
+
+  g_signal_connect (self->editor,
+                    "type-changed",
+                    G_CALLBACK (type_changed_cb),
+                    self);
+
+  g_signal_connect (self->editor,
+                    "name-changed",
+                    G_CALLBACK (name_changed_cb),
+                    self);
+
+  g_signal_connect (self->editor,
+                    "command-changed",
+                    G_CALLBACK (command_changed_cb),
+                    self);
+
+  g_signal_connect (self->editor,
+                    "comment-changed",
+                    G_CALLBACK (comment_changed_cb),
+                    self);
+}
+
+static void
+gp_launcher_properties_dispose (GObject *object)
+{
+  GpLauncherProperties *self;
+
+  self = GP_LAUNCHER_PROPERTIES (object);
+
+  if (self->save_id != 0)
+    {
+      g_source_remove (self->save_id);
+      self->save_id = 0;
+    }
+
+  g_clear_object (&self->settings);
+
+  g_clear_pointer (&self->file, g_key_file_unref);
+  g_clear_pointer (&self->revert_file, g_key_file_unref);
+
+  G_OBJECT_CLASS (gp_launcher_properties_parent_class)->dispose (object);
+}
+
+static void
+gp_launcher_properties_set_property (GObject      *object,
+                                     guint         property_id,
+                                     const GValue *value,
+                                     GParamSpec   *pspec)
+{
+  GpLauncherProperties *self;
+
+  self = GP_LAUNCHER_PROPERTIES (object);
+
+  switch (property_id)
+    {
+      case PROP_SETTINGS:
+        g_assert (self->settings == NULL);
+        self->settings = g_value_dup_object (value);
+        break;
+
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+        break;
+    }
+}
+
+static void
+install_properties (GObjectClass *object_class)
+{
+  properties_properties[PROP_SETTINGS] =
+    g_param_spec_object ("settings",
+                         "settings",
+                         "settings",
+                         G_TYPE_SETTINGS,
+                         G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY |
+                         G_PARAM_STATIC_STRINGS);
+
+  g_object_class_install_properties (object_class,
+                                     LAST_PROP,
+                                     properties_properties);
+}
+
+static void
+gp_launcher_properties_class_init (GpLauncherPropertiesClass *self_class)
+{
+  GObjectClass *object_class;
+
+  object_class = G_OBJECT_CLASS (self_class);
+
+  object_class->constructed = gp_launcher_properties_constructed;
+  object_class->dispose = gp_launcher_properties_dispose;
+  object_class->set_property = gp_launcher_properties_set_property;
+
+  install_properties (object_class);
+}
+
+static void
+gp_launcher_properties_init (GpLauncherProperties *self)
+{
+  GtkWidget *content_area;
+  GtkWidget *editor;
+
+  content_area = gtk_dialog_get_content_area (GTK_DIALOG (self));
+  gtk_container_set_border_width (GTK_CONTAINER (content_area), 12);
+  gtk_box_set_spacing (GTK_BOX (content_area), 6);
+
+  editor = gp_editor_new (TRUE);
+  self->editor = GP_EDITOR (editor);
+
+  gtk_container_add (GTK_CONTAINER (content_area), editor);
+  gtk_widget_show (editor);
+
+  self->revert_button = gtk_dialog_add_button (GTK_DIALOG (self),
+                                               _("_Revert"),
+                                               GP_RESPONSE_REVERT);
+
+  gtk_dialog_set_response_sensitive (GTK_DIALOG (self),
+                                     GP_RESPONSE_REVERT,
+                                     FALSE);
+
+  gtk_dialog_add_button (GTK_DIALOG (self),
+                         _("_Close"),
+                         GTK_RESPONSE_CLOSE);
+
+  gtk_dialog_set_default_response (GTK_DIALOG (self), GTK_RESPONSE_CLOSE);
+
+  g_signal_connect (self, "response", G_CALLBACK (response_cb), self);
+}
+
+GtkWidget *
+gp_launcher_properties_new (GSettings *settings)
+{
+  return g_object_new (GP_TYPE_LAUNCHER_PROPERTIES,
+                       "title", _("Launcher Properties"),
+                       "settings", settings,
+                       NULL);
+}
diff --git a/modules/launcher/gp-launcher-properties.h b/modules/launcher/gp-launcher-properties.h
new file mode 100644
index 000000000..f95d3c02b
--- /dev/null
+++ b/modules/launcher/gp-launcher-properties.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2020 Alberts Muktupāvels
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GP_LAUNCHER_PROPERTIES_H
+#define GP_LAUNCHER_PROPERTIES_H
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define GP_TYPE_LAUNCHER_PROPERTIES (gp_launcher_properties_get_type ())
+G_DECLARE_FINAL_TYPE (GpLauncherProperties, gp_launcher_properties,
+                      GP, LAUNCHER_PROPERTIES, GtkDialog)
+
+GtkWidget *gp_launcher_properties_new (GSettings *settings);
+
+G_END_DECLS
+
+#endif
diff --git a/modules/launcher/gp-launcher-utils.c b/modules/launcher/gp-launcher-utils.c
new file mode 100644
index 000000000..484580332
--- /dev/null
+++ b/modules/launcher/gp-launcher-utils.c
@@ -0,0 +1,313 @@
+/*
+ * Copyright (C) 2020 Alberts Muktupāvels
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+#include "gp-launcher-utils.h"
+
+#include <glib/gi18n-lib.h>
+
+static void
+error_response_cb (GtkWidget *widget,
+                   int        response_id,
+                   gpointer   user_data)
+{
+  gtk_widget_destroy (widget);
+}
+
+gboolean
+gp_launcher_read_from_key_file (GKeyFile  *key_file,
+                                char     **icon,
+                                char     **type,
+                                char     **name,
+                                char     **command,
+                                char     **comment,
+                                char     **error)
+{
+  char *start_group;
+  char *type_string;
+
+  g_return_val_if_fail (key_file != NULL, FALSE);
+  g_return_val_if_fail (icon == NULL || *icon == NULL, FALSE);
+  g_return_val_if_fail (type == NULL || *type == NULL, FALSE);
+  g_return_val_if_fail (name == NULL || *name == NULL, FALSE);
+  g_return_val_if_fail (command == NULL || *command == NULL, FALSE);
+  g_return_val_if_fail (comment == NULL || *comment == NULL, FALSE);
+  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+  start_group = g_key_file_get_start_group (key_file);
+  if (start_group == NULL ||
+      g_strcmp0 (start_group, G_KEY_FILE_DESKTOP_GROUP) != 0)
+    {
+      if (error != NULL)
+        *error = g_strdup_printf (_("Launcher does not start with required “%s” group."),
+                                  G_KEY_FILE_DESKTOP_GROUP);
+
+      g_free (start_group);
+      return FALSE;
+    }
+
+  g_free (start_group);
+  type_string = g_key_file_get_string (key_file,
+                                       G_KEY_FILE_DESKTOP_GROUP,
+                                       G_KEY_FILE_DESKTOP_KEY_TYPE,
+                                       NULL);
+
+  if (type_string == NULL ||
+      (g_strcmp0 (type_string, G_KEY_FILE_DESKTOP_TYPE_APPLICATION) != 0 &&
+       g_strcmp0 (type_string, G_KEY_FILE_DESKTOP_TYPE_LINK) != 0))
+    {
+      if (error != NULL)
+        *error = g_strdup_printf (_("Launcher has invalid Type key value “%s”."),
+                                  type_string != NULL ? type_string : "(null)");
+
+      g_free (type_string);
+      return FALSE;
+    }
+
+  if (icon != NULL)
+    {
+      *icon = g_key_file_get_locale_string (key_file,
+                                            G_KEY_FILE_DESKTOP_GROUP,
+                                            G_KEY_FILE_DESKTOP_KEY_ICON,
+                                            NULL,
+                                            NULL);
+    }
+
+  if (type != NULL)
+    *type = g_strdup (type_string);
+
+  if (name != NULL)
+    {
+      *name = g_key_file_get_locale_string (key_file,
+                                            G_KEY_FILE_DESKTOP_GROUP,
+                                            "X-GNOME-FullName",
+                                            NULL,
+                                            NULL);
+
+      if (*name == NULL)
+        {
+          *name = g_key_file_get_locale_string (key_file,
+                                                G_KEY_FILE_DESKTOP_GROUP,
+                                                G_KEY_FILE_DESKTOP_KEY_NAME,
+                                                NULL,
+                                                NULL);
+        }
+    }
+
+  if (command != NULL)
+    {
+      if (g_strcmp0 (type_string, G_KEY_FILE_DESKTOP_TYPE_APPLICATION) == 0)
+        {
+          *command = g_key_file_get_string (key_file,
+                                            G_KEY_FILE_DESKTOP_GROUP,
+                                            G_KEY_FILE_DESKTOP_KEY_EXEC,
+                                            NULL);
+        }
+      else if (g_strcmp0 (type_string, G_KEY_FILE_DESKTOP_TYPE_LINK) == 0)
+        {
+          *command = g_key_file_get_string (key_file,
+                                            G_KEY_FILE_DESKTOP_GROUP,
+                                            G_KEY_FILE_DESKTOP_KEY_URL,
+                                            NULL);
+        }
+    }
+
+  if (comment != NULL)
+    {
+      *comment = g_key_file_get_locale_string (key_file,
+                                               G_KEY_FILE_DESKTOP_GROUP,
+                                               G_KEY_FILE_DESKTOP_KEY_COMMENT,
+                                               NULL,
+                                               NULL);
+    }
+
+  g_free (type_string);
+
+  return TRUE;
+}
+
+gboolean
+gp_launcher_validate (const char  *icon,
+                      const char  *type,
+                      const char  *name,
+                      const char  *command,
+                      const char  *comment,
+                      char       **error)
+{
+  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+  if (icon == NULL || *icon == '\0')
+    {
+      if (error != NULL)
+        *error = g_strdup (_("The icon of the launcher is not set."));
+
+      return FALSE;
+    }
+
+  if (type == NULL || *type == '\0')
+    {
+      if (error != NULL)
+        *error = g_strdup (_("The type of the launcher is not set."));
+
+      return FALSE;
+    }
+
+  if (g_strcmp0 (type, G_KEY_FILE_DESKTOP_TYPE_APPLICATION) != 0 &&
+      g_strcmp0 (type, G_KEY_FILE_DESKTOP_TYPE_LINK) != 0)
+    {
+      if (error != NULL)
+        *error = g_strdup_printf (_("The type of the launcher must be “%s” or “%s”."),
+                                  G_KEY_FILE_DESKTOP_TYPE_APPLICATION,
+                                  G_KEY_FILE_DESKTOP_TYPE_LINK);
+
+      return FALSE;
+    }
+
+  if (name == NULL || *name == '\0')
+    {
+      if (error != NULL)
+        *error = g_strdup (_("The name of the launcher is not set."));
+
+      return FALSE;
+    }
+
+  if (command == NULL || *command == '\0')
+    {
+      if (g_strcmp0 (type, G_KEY_FILE_DESKTOP_TYPE_APPLICATION) == 0)
+        {
+          if (error != NULL)
+            *error = g_strdup (_("The command of the launcher is not set."));
+        }
+      else if (g_strcmp0 (type, G_KEY_FILE_DESKTOP_TYPE_LINK) == 0)
+        {
+          if (error != NULL)
+            *error = g_strdup (_("The location of the launcher is not set."));
+        }
+
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+gboolean
+gp_launcher_validate_key_file (GKeyFile  *key_file,
+                               char     **error)
+{
+  char *icon;
+  char *type;
+  char *name;
+  char *command;
+  char *comment;
+  gboolean valid;
+
+  g_return_val_if_fail (key_file != NULL, FALSE);
+  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+  icon = NULL;
+  type = NULL;
+  name = NULL;
+  command = NULL;
+  comment = NULL;
+
+  if (!gp_launcher_read_from_key_file (key_file,
+                                       &icon,
+                                       &type,
+                                       &name,
+                                       &command,
+                                       &comment,
+                                       error))
+    return FALSE;
+
+  valid = gp_launcher_validate (icon, type, name, command, comment, error);
+
+  g_free (icon);
+  g_free (type);
+  g_free (name);
+  g_free (command);
+  g_free (comment);
+
+  return valid;
+}
+
+char *
+gp_launcher_get_launchers_dir (void)
+{
+  char *dir;
+
+  dir = g_build_filename (g_get_user_config_dir (),
+                          "gnome-panel",
+                          "launchers",
+                          NULL);
+
+  g_mkdir_with_parents (dir, 0700);
+
+  return dir;
+}
+
+char *
+gp_launcher_get_unique_filename (void)
+{
+  char *launchers_dir;
+  char *filename;
+
+  launchers_dir = gp_launcher_get_launchers_dir ();
+  filename = NULL;
+
+  do
+    {
+      char *uuid;
+      char *desktop;
+
+      g_free (filename);
+
+      uuid = g_uuid_string_random ();
+      desktop = g_strdup_printf ("%s.desktop", uuid);
+      g_free (uuid);
+
+      filename = g_build_filename (launchers_dir, desktop, NULL);
+      g_free (desktop);
+    }
+  while (g_file_test (filename, G_FILE_TEST_EXISTS));
+
+  g_free (launchers_dir);
+
+  return filename;
+}
+
+void
+gp_launcher_show_error_message (GtkWindow  *parent,
+                                const char *primary_text,
+                                const char *secondary_text)
+{
+  GtkWidget *dialog;
+
+  dialog = gtk_message_dialog_new (parent,
+                                   GTK_DIALOG_DESTROY_WITH_PARENT,
+                                   GTK_MESSAGE_ERROR,
+                                   GTK_BUTTONS_CLOSE,
+                                   "%s",
+                                   primary_text);
+
+  gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
+                                            "%s",
+                                            secondary_text);
+
+  g_signal_connect (dialog, "response", G_CALLBACK (error_response_cb), NULL);
+
+  gtk_window_present (GTK_WINDOW (dialog));
+}
diff --git a/modules/launcher/gp-launcher-utils.h b/modules/launcher/gp-launcher-utils.h
new file mode 100644
index 000000000..702e3d61e
--- /dev/null
+++ b/modules/launcher/gp-launcher-utils.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2020 Alberts Muktupāvels
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GP_LAUNCHER_UTILS_H
+#define GP_LAUNCHER_UTILS_H
+
+#include <glib.h>
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+gboolean  gp_launcher_read_from_key_file  (GKeyFile    *key_file,
+                                           char       **icon,
+                                           char       **type,
+                                           char       **name,
+                                           char       **command,
+                                           char       **comment,
+                                           char       **error);
+
+gboolean  gp_launcher_validate            (const char  *icon,
+                                           const char  *type,
+                                           const char  *name,
+                                           const char  *command,
+                                           const char  *comment,
+                                           char       **error);
+
+gboolean  gp_launcher_validate_key_file   (GKeyFile    *key_file,
+                                           char       **error);
+
+char     *gp_launcher_get_launchers_dir   (void);
+
+char     *gp_launcher_get_unique_filename (void);
+
+void      gp_launcher_show_error_message  (GtkWindow   *parent,
+                                           const char  *primary_text,
+                                           const char  *secondary_text);
+
+G_END_DECLS
+
+#endif
diff --git a/modules/launcher/launcher-menu.ui b/modules/launcher/launcher-menu.ui
new file mode 100644
index 000000000..d84bf05aa
--- /dev/null
+++ b/modules/launcher/launcher-menu.ui
@@ -0,0 +1,14 @@
+<interface>
+  <menu id="launcher-menu">
+    <section>
+      <item>
+        <attribute name="label" translatable="yes">_Launch</attribute>
+        <attribute name="action">launcher.launch</attribute>
+      </item>
+      <item>
+        <attribute name="label" translatable="yes">_Properties</attribute>
+        <attribute name="action">launcher.properties</attribute>
+      </item>
+    </section>
+  </menu>
+</interface>
diff --git a/modules/launcher/launcher.gresource.xml b/modules/launcher/launcher.gresource.xml
new file mode 100644
index 000000000..f5180a526
--- /dev/null
+++ b/modules/launcher/launcher.gresource.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<gresources>
+  <gresource prefix="/org/gnome/gnome-panel/modules/launcher">
+    <file compressed="true">custom-launcher-menu.ui</file>
+    <file compressed="true">gp-icon-name-chooser.ui</file>
+    <file compressed="true">launcher-menu.ui</file>
+  </gresource>
+</gresources>
diff --git a/modules/launcher/org.gnome.gnome-panel.applet.launcher.gschema.xml 
b/modules/launcher/org.gnome.gnome-panel.applet.launcher.gschema.xml
new file mode 100644
index 000000000..1222d00da
--- /dev/null
+++ b/modules/launcher/org.gnome.gnome-panel.applet.launcher.gschema.xml
@@ -0,0 +1,9 @@
+<schemalist gettext-domain="gnome-panel">
+  <schema id="org.gnome.gnome-panel.applet.launcher">
+    <key name="location" type="s">
+      <default>''</default>
+      <summary>Launcher location</summary>
+      <description>The location of the .desktop file describing the launcher.</description>
+    </key>
+  </schema>
+</schemalist>
diff --git a/po/POTFILES.in b/po/POTFILES.in
index 20f72e907..1daae1bd2 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -51,6 +51,15 @@ modules/fish/fish-applet.c
 modules/fish/fish-module.c
 modules/fish/fish-menu.ui
 modules/fish/fish.ui
+modules/launcher/custom-launcher-menu.ui
+modules/launcher/gp-editor.c
+modules/launcher/gp-icon-name-chooser.ui
+modules/launcher/gp-launcher-applet.c
+modules/launcher/gp-launcher-module.c
+modules/launcher/gp-launcher-properties.c
+modules/launcher/gp-launcher-utils.c
+modules/launcher/launcher-menu.ui
+modules/launcher/org.gnome.gnome-panel.applet.launcher.gschema.xml
 modules/menu/gp-bookmarks.c
 modules/menu/gp-lock-logout.c
 modules/menu/gp-menu-bar-applet.c


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]