• 一个小应用

    一个小应用

    当使用GtkApplication，main主函数非常简单。我们仅仅调用了g_application_run() 并给出一个应用范例。

    1. #include <gtk/gtk.h>
    2. #include <exampleapp.h>
    4. int
    5. main (int argc, char *argv[])
    6. {
    7.   return g_application_run (G_APPLICATION (example_app_new ()), argc, argv);
    8. }

    所有的应用程序逻辑都在GtkApplicaton的子类中。我们的范例还没有任何有趣的功能。它所做的只是当它没有传递参数而被激活时打开一个窗口，在传递了参数被激活时打开给定的文件。

    为了处理这两种情况，我们重载了activate()vfunc，当应用程序被加载没有命令行参数时它被调用，当应用程序被加载并带有命令行参数时，调用open()vfunc。

    想知道更多关于GApplication入口知识，请查看GIO文档。

    1. #include <gtk/gtk.h>
    3. #include "exampleapp.h"
    4. #include "exampleappwin.h"
    6. struct _ExampleApp
    7. {
    8.   GtkApplication parent;
    9. };
    11. struct _ExampleAppClass
    12. {
    13.   GtkApplicationClass parent_class;
    14. };
    16. G_DEFINE_TYPE(ExampleApp, example_app, GTK_TYPE_APPLICATION);
    18. static void
    19. example_app_init (ExampleApp *app)
    20. {
    21. }
    23. static void
    24. example_app_activate (GApplication *app)
    25. {
    26.   ExampleAppWindow *win;
    28.   win = example_app_window_new (EXAMPLE_APP (app));
    29.   gtk_window_present (GTK_WINDOW (win));
    30. }
    32. static void
    33. example_app_open (GApplication  *app,
    34.                   GFile        **files,
    35.                   gint           n_files,
    36.                   const gchar   *hint)
    37. {
    38.   GList *windows;
    39.   ExampleAppWindow *win;
    40.   int i;
    42.   windows = gtk_application_get_windows (GTK_APPLICATION (app));
    43.   if (windows)
    44.     win = EXAMPLE_APP_WINDOW (windows->data);
    45.   else
    46.     win = example_app_window_new (EXAMPLE_APP (app));
    48.   for (i = 0; i < n_files; i++)
    49.     example_app_window_open (win, files[i]);
    51.   gtk_window_present (GTK_WINDOW (win));
    52. }
    54. static void
    55. example_app_class_init (ExampleAppClass *class)
    56. {
    57.   G_APPLICATION_CLASS (class)->activate = example_app_activate;
    58.   G_APPLICATION_CLASS (class)->open = example_app_open;
    59. }
    61. ExampleApp *
    62. example_app_new (void)
    63. {
    64.   return g_object_new (EXAMPLE_APP_TYPE,
    65.                        "application-id", "org.gtk.exampleapp",
    66.                        "flags", G_APPLICATION_HANDLES_OPEN,
    67.                        NULL);
    68. }

    应用程序中另一个受GTK+支持的重要的类是GtkApplicationWindow。它通常也是子类。我们的子类不做任何事，因此我们只得到一个空的窗口。

    1. #include "exampleapp.h"
    2. #include "exampleappwin.h"
    3. #include <gtk/gtk.h>
    5. struct _ExampleAppWindow
    6. {
    7.   GtkApplicationWindow parent;
    8. };
    10. struct _ExampleAppWindowClass
    11. {
    12.   GtkApplicationWindowClass parent_class;
    13. };
    15. G_DEFINE_TYPE(ExampleAppWindow, example_app_window, GTK_TYPE_APPLICATION_WINDOW);
    17. static void
    18. example_app_window_init (ExampleAppWindow *app)
    19. {
    20. }
    22. static void
    23. example_app_window_class_init (ExampleAppWindowClass *class)
    24. {
    25. }
    27. ExampleAppWindow *
    28. example_app_window_new (ExampleApp *app)
    29. {
    30.   return g_object_new (EXAMPLE_APP_WINDOW_TYPE, "application", app, NULL);
    31. }
    33. void
    34. example_app_window_open (ExampleAppWindow *win,
    35.                          GFile            *file)
    36. {
    37. }

    作为我们应用程序初始化中的一部分，我们创建一个图标和一个桌面文件。

    exampleapp.png

    1. [Desktop Entry]
    2. Type=Application
    3. Name=Example
    4. Icon=exampleapp
    5. StartupNotify=true
    6. Exec=@bindir@/exampleapp

    注意 @bindir@需要被实际的二进制文件路径替代，这样桌面文件才能使用。

    这就是目前我们实现的:

    getting-started-app1.png

    至今我们的程序并没那么瞩目，但是它已经在会话总线上出现，它有单个实例，而且它接受文件作为命令行参数。