std::unique_ptr<PlatformDisplay> PlatformDisplay::createPlatformDisplay()
{
#if PLATFORM(GTK)
#if defined(GTK_API_VERSION_2)
return std::make_unique<PlatformDisplayX11>(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()));
#else
GdkDisplay* display = gdk_display_manager_get_default_display(gdk_display_manager_get());
#if PLATFORM(X11)
if (GDK_IS_X11_DISPLAY(display))
return std::make_unique<PlatformDisplayX11>(GDK_DISPLAY_XDISPLAY(display));
#endif
#if PLATFORM(WAYLAND)
if (GDK_IS_WAYLAND_DISPLAY(display))
return std::make_unique<PlatformDisplayWayland>(gdk_wayland_display_get_wl_display(display));
#endif
#endif
#elif PLATFORM(EFL) && defined(HAVE_ECORE_X)
return std::make_unique<PlatformDisplayX11>(static_cast<Display*>(ecore_x_display_get()));
#elif PLATFORM(WIN)
return std::make_unique<PlatformDisplayWin>();
#endif
#if PLATFORM(X11)
return std::make_unique<PlatformDisplayX11>();
#endif
ASSERT_NOT_REACHED();
return nullptr;
}
/**
* gdk_atom_intern_static_string:
* @atom_name: a static string
*
* Finds or creates an atom corresponding to a given string.
*
* Note that this function is identical to gdk_atom_intern() except
* that if a new #GdkAtom is created the string itself is used rather
* than a copy. This saves memory, but can only be used if the string
* will <emphasis>always</emphasis> exist. It can be used with statically
* allocated strings in the main program, but not with statically
* allocated memory in dynamically loaded modules, if you expect to
* ever unload the module again (e.g. do not use this function in
* GTK+ theme engines).
*
* Returns: (transfer none): the atom corresponding to @atom_name
*
* Since: 2.10
*/
GdkAtom
gdk_atom_intern_static_string (const gchar *atom_name)
{
GdkDisplayManager *manager = gdk_display_manager_get ();
return GDK_DISPLAY_MANAGER_GET_CLASS (manager)->atom_intern (manager, atom_name, FALSE);
}
static void
test_unset_display (void)
{
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR))
{
GdkDisplayManager *manager;
g_unsetenv ("DISPLAY");
g_assert (!gdk_init_check (NULL, NULL));
manager = gdk_display_manager_get ();
g_assert (manager != NULL);
g_assert (gdk_display_manager_get_default_display (manager) == NULL);
exit (0);
}
g_test_trap_assert_passed ();
if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR))
{
g_unsetenv ("DISPLAY");
gdk_init (NULL, NULL);
exit (0);
}
g_test_trap_assert_failed ();
g_test_trap_assert_stderr ("*cannot open display*");
}
/* Cleans up when the toplevel is destroyed; we remove the
* connections we use to track currently open displays, then
* free the ChangeDisplayInfo structure.
*/
static void
destroy_info (ChangeDisplayInfo *info)
{
GdkDisplayManager *manager = gdk_display_manager_get ();
GSList *displays = gdk_display_manager_list_displays (manager);
GSList *tmp_list;
g_signal_handlers_disconnect_by_func (manager,
display_opened_cb,
info);
for (tmp_list = displays; tmp_list; tmp_list = tmp_list->next)
g_signal_handlers_disconnect_by_func (tmp_list->data,
display_closed_cb,
info);
g_slist_free (tmp_list);
g_object_unref (info->size_group);
g_object_unref (info->display_model);
g_object_unref (info->screen_model);
if (info->current_display)
g_object_unref (info->current_display);
if (info->current_screen)
g_object_unref (info->current_screen);
g_free (info);
}
/**
* gdk_atom_name:
* @atom: a #GdkAtom.
*
* Determines the string corresponding to an atom.
*
* Returns: a newly-allocated string containing the string
* corresponding to @atom. When you are done with the
* return value, you should free it using g_free().
*/
gchar *
gdk_atom_name (GdkAtom atom)
{
GdkDisplayManager *manager = gdk_display_manager_get ();
return GDK_DISPLAY_MANAGER_GET_CLASS (manager)->get_atom_name (manager, atom);
}
void
window_menu_setup (GimpUIManager *manager,
const gchar *group_name,
const gchar *ui_path)
{
GdkDisplayManager *disp_manager = gdk_display_manager_get ();
GSList *displays;
GSList *list;
g_return_if_fail (GIMP_IS_UI_MANAGER (manager));
g_return_if_fail (ui_path != NULL);
g_object_set_data_full (G_OBJECT (manager), "move-to-screen-group-name",
g_strdup (group_name),
(GDestroyNotify) g_free);
g_object_set_data_full (G_OBJECT (manager), "move-to-screen-ui-path",
g_strdup (ui_path),
(GDestroyNotify) g_free);
displays = gdk_display_manager_list_displays (disp_manager);
/* present displays in the order in which they were opened */
displays = g_slist_reverse (displays);
for (list = displays; list; list = g_slist_next (list))
{
window_menu_display_opened (disp_manager, list->data, manager);
}
g_slist_free (displays);
g_signal_connect_object (disp_manager, "display-opened",
G_CALLBACK (window_menu_display_opened),
G_OBJECT (manager), 0);
}
void
window_actions_setup (GimpActionGroup *group,
const gchar *move_to_screen_help_id)
{
GdkDisplayManager *manager = gdk_display_manager_get ();
GSList *displays;
GSList *list;
g_object_set_data_full (G_OBJECT (group), "move-to-screen-help-id",
g_strdup (move_to_screen_help_id),
(GDestroyNotify) g_free);
displays = gdk_display_manager_list_displays (manager);
/* present displays in the order in which they were opened */
displays = g_slist_reverse (displays);
for (list = displays; list; list = g_slist_next (list))
{
window_actions_display_opened (manager, list->data, group);
}
g_slist_free (displays);
g_signal_connect_object (manager, "display-opened",
G_CALLBACK (window_actions_display_opened),
G_OBJECT (group), 0);
}
/**
* gdk_keyval_name:
* @keyval: a key value
*
* Converts a key value into a symbolic name.
*
* The names are the same as those in the
* <filename><gdk/gdkkeysyms.h></filename> header file
* but without the leading "GDK_KEY_".
*
* Return value: (transfer none): a string containing the name of the key,
* or %NULL if @keyval is not a valid key. The string should not be
* modified.
*/
gchar *
gdk_keyval_name (guint keyval)
{
GdkDisplayManager *manager = gdk_display_manager_get ();
return GDK_DISPLAY_MANAGER_GET_CLASS (manager)->get_keyval_name (manager,
keyval);
}
/**
* gdk_keyval_from_name:
* @keyval_name: a key name
*
* Converts a key name to a key value.
*
* The names are the same as those in the
* <filename><gdk/gdkkeysyms.h></filename> header file
* but without the leading "GDK_KEY_".
*
* Returns: the corresponding key value, or %GDK_KEY_VoidSymbol
* if the key name is not a valid key
*/
guint
gdk_keyval_from_name (const gchar *keyval_name)
{
GdkDisplayManager *manager = gdk_display_manager_get ();
return GDK_DISPLAY_MANAGER_GET_CLASS (manager)->lookup_keyval (manager,
keyval_name);
}
/**
* gdk_atom_intern:
* @atom_name: a string.
* @only_if_exists: if %TRUE, GDK is allowed to not create a new atom, but
* just return %GDK_NONE if the requested atom doesn't already
* exists. Currently, the flag is ignored, since checking the
* existance of an atom is as expensive as creating it.
*
* Finds or creates an atom corresponding to a given string.
*
* Returns: (transfer none): the atom corresponding to @atom_name.
*/
GdkAtom
gdk_atom_intern (const gchar *atom_name,
gboolean only_if_exists)
{
GdkDisplayManager *manager = gdk_display_manager_get ();
return GDK_DISPLAY_MANAGER_GET_CLASS (manager)->atom_intern (manager, atom_name, TRUE);
}
static OwnPtr<WidgetBackingStore> createBackingStoreForGTK(GtkWidget* widget, const IntSize& size, float deviceScaleFactor)
{
#if PLATFORM(X11) && defined(GDK_WINDOWING_X11)
GdkDisplay* display = gdk_display_manager_get_default_display(gdk_display_manager_get());
if (GDK_IS_X11_DISPLAY(display))
return WebCore::WidgetBackingStoreGtkX11::create(widget, size, deviceScaleFactor);
#endif
return WebCore::WidgetBackingStoreCairo::create(widget, size, deviceScaleFactor);
}
/**
* gdk_keyval_convert_case:
* @symbol: a keyval
* @lower: (out): return location for lowercase version of @symbol
* @upper: (out): return location for uppercase version of @symbol
*
* Obtains the upper- and lower-case versions of the keyval @symbol.
* Examples of keyvals are #GDK_KEY_a, #GDK_KEY_Enter, #GDK_KEY_F1, etc.
*/
void
gdk_keyval_convert_case (guint symbol,
guint *lower,
guint *upper)
{
GdkDisplayManager *manager = gdk_display_manager_get ();
GDK_DISPLAY_MANAGER_GET_CLASS (manager)->keyval_convert_case (manager, symbol, lower, upper);
}
static PassOwnPtr<WidgetBackingStore> createBackingStore(GtkWidget* widget, const IntSize& size)
{
#ifdef GDK_WINDOWING_X11
GdkDisplay* display = gdk_display_manager_get_default_display(gdk_display_manager_get());
if (GDK_IS_X11_DISPLAY(display))
return WebCore::WidgetBackingStoreGtkX11::create(widget, size);
#endif
return WebCore::WidgetBackingStoreCairo::create(widget, size);
}
void
window_actions_update (GimpActionGroup *group,
GtkWidget *window)
{
const gchar *group_name;
gint show_menu = FALSE;
gchar *name;
group_name = gtk_action_group_get_name (GTK_ACTION_GROUP (group));
#define SET_ACTIVE(action,active) \
gimp_action_group_set_action_active (group, action, (active) != 0)
#define SET_VISIBLE(action,active) \
gimp_action_group_set_action_visible (group, action, (active) != 0)
if (GTK_IS_WINDOW (window))
{
GdkDisplay *display;
GdkScreen *screen;
gchar *screen_name;
display = gtk_widget_get_display (window);
show_menu = (gdk_display_get_n_screens (display) > 1);
#ifdef GIMP_UNSTABLE
show_menu = TRUE;
#endif
if (! show_menu)
{
GdkDisplayManager *manager = gdk_display_manager_get ();
GSList *displays;
displays = gdk_display_manager_list_displays (manager);
show_menu = (displays->next != NULL);
g_slist_free (displays);
}
screen = gtk_widget_get_screen (window);
screen_name = gdk_screen_make_display_name (screen);
name = g_strdup_printf ("%s-move-to-screen-%s", group_name, screen_name);
g_free (screen_name);
SET_ACTIVE (name, TRUE);
g_free (name);
}
name = g_strdup_printf ("%s-move-to-screen-menu", group_name);
SET_VISIBLE (name, show_menu);
g_free (name);
#undef SET_ACTIVE
#undef SET_VISIBLE
}
/* Adds all currently open displays to our list of displays,
* and set up a signal connection so that we'll be notified
* when displays are opened in the future as well.
*/
static void
initialize_displays (ChangeDisplayInfo *info)
{
GdkDisplayManager *manager = gdk_display_manager_get ();
GSList *displays = gdk_display_manager_list_displays (manager);
GSList *tmp_list;
for (tmp_list = displays; tmp_list; tmp_list = tmp_list->next)
add_display (info, tmp_list->data);
g_slist_free (tmp_list);
g_signal_connect (manager, "display-opened",
G_CALLBACK (display_opened_cb), info);
}
GdkDisplay *
gdk_display_open (const gchar *display_name)
{
GDK_NOTE (MISC, g_print ("gdk_display_open: %s\n", (display_name ? display_name : "NULL")));
if (display_name == NULL ||
g_ascii_strcasecmp (display_name,
gdk_display_get_name (_gdk_display)) == 0)
{
if (_gdk_display != NULL)
{
GDK_NOTE (MISC, g_print ("... return _gdk_display\n"));
return _gdk_display;
}
}
else
{
GDK_NOTE (MISC, g_print ("... return NULL\n"));
return NULL;
}
_gdk_display = g_object_new (GDK_TYPE_DISPLAY, NULL);
_gdk_screen = g_object_new (GDK_TYPE_SCREEN, NULL);
_gdk_monitor_init ();
_gdk_visual_init ();
gdk_screen_set_default_colormap (_gdk_screen,
gdk_screen_get_system_colormap (_gdk_screen));
_gdk_windowing_window_init ();
_gdk_windowing_image_init ();
_gdk_events_init ();
_gdk_input_init (_gdk_display);
_gdk_dnd_init ();
/* Precalculate display name */
(void) gdk_display_get_name (_gdk_display);
g_signal_emit_by_name (gdk_display_manager_get (),
"display_opened", _gdk_display);
GDK_NOTE (MISC, g_print ("... _gdk_display now set up\n"));
return _gdk_display;
}
/* X error handler. Keep the name the same because people are used to
* breaking on it in the debugger.
*/
static int
gdk_x_error (Display *xdisplay,
XErrorEvent *error)
{
if (error->error_code)
{
GdkDisplay *error_display;
GdkDisplayManager *manager;
GSList *displays;
/* Figure out which GdkDisplay if any got the error. */
error_display = NULL;
manager = gdk_display_manager_get ();
displays = gdk_display_manager_list_displays (manager);
while (displays != NULL)
{
GdkX11Display *gdk_display = displays->data;
if (xdisplay == gdk_display->xdisplay)
{
error_display = GDK_DISPLAY (gdk_display);
g_slist_free (displays);
displays = NULL;
}
else
{
displays = g_slist_delete_link (displays, displays);
}
}
if (error_display == NULL)
{
/* Error on an X display not opened by GDK. Ignore. */
return 0;
}
else
{
_gdk_x11_display_error_event (error_display, error);
}
}
return 0;
}
std::unique_ptr<PlatformDisplay> PlatformDisplay::createPlatformDisplay()
{
#if PLATFORM(GTK)
#if defined(GTK_API_VERSION_2)
return std::make_unique<PlatformDisplayX11>(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()));
#else
GdkDisplay* display = gdk_display_manager_get_default_display(gdk_display_manager_get());
#if PLATFORM(X11)
if (GDK_IS_X11_DISPLAY(display))
return std::make_unique<PlatformDisplayX11>(GDK_DISPLAY_XDISPLAY(display));
#endif
#if PLATFORM(WAYLAND)
if (GDK_IS_WAYLAND_DISPLAY(display))
return std::make_unique<PlatformDisplayWayland>(gdk_wayland_display_get_wl_display(display));
#endif
#endif
#elif PLATFORM(EFL) && defined(HAVE_ECORE_X)
return std::make_unique<PlatformDisplayX11>(static_cast<Display*>(ecore_x_display_get()));
#elif PLATFORM(WIN)
return std::make_unique<PlatformDisplayWin>();
#endif
#if PLATFORM(WAYLAND)
if (auto platformDisplay = PlatformDisplayWayland::create())
return platformDisplay;
#endif
#if PLATFORM(X11)
if (auto platformDisplay = PlatformDisplayX11::create())
return platformDisplay;
#endif
// If at this point we still don't have a display, just create a fake display with no native.
#if PLATFORM(WAYLAND)
return std::make_unique<PlatformDisplayWayland>(nullptr);
#endif
#if PLATFORM(X11)
return std::make_unique<PlatformDisplayX11>(nullptr);
#endif
ASSERT_NOT_REACHED();
return nullptr;
}
static GdkDisplay *
display_open_if_needed (const gchar *name)
{
GSList *displays;
GSList *l;
GdkDisplay *display = NULL;
displays = gdk_display_manager_list_displays (gdk_display_manager_get ());
for (l = displays; l != NULL; l = l->next)
{
if (strcmp (gdk_display_get_name ((GdkDisplay *) l->data), name) == 0)
{
display = l->data;
break;
}
}
g_slist_free (displays);
return display != NULL ? display : gdk_display_open (name);
}
static void
gdk_wayland_display_dispose (GObject *object)
{
GdkDisplayWayland *display_wayland = GDK_DISPLAY_WAYLAND (object);
_gdk_wayland_display_manager_remove_display (gdk_display_manager_get (),
GDK_DISPLAY (display_wayland));
g_list_foreach (display_wayland->input_devices,
(GFunc) g_object_run_dispose, NULL);
_gdk_screen_close (display_wayland->screen);
if (display_wayland->event_source)
{
g_source_destroy (display_wayland->event_source);
g_source_unref (display_wayland->event_source);
display_wayland->event_source = NULL;
}
eglTerminate(display_wayland->egl_display);
G_OBJECT_CLASS (_gdk_display_wayland_parent_class)->dispose (object);
}
static void
gtk_clipboard_store_all (void)
{
GtkClipboard *clipboard;
GSList *displays, *list;
displays = gdk_display_manager_list_displays (gdk_display_manager_get ());
list = displays;
while (list)
{
GdkDisplay *display = static_cast<GdkDisplay *>(list->data);
clipboard = gtk_clipboard_get_for_display (display, GDK_SELECTION_CLIPBOARD);
if (clipboard)
gtk_clipboard_store (clipboard);
list = list->next;
}
g_slist_free (displays);
}
GdkDisplay *
gdk_display_open (const gchar *display_name)
{
if (gdk_display == NULL || _gdk_display != NULL)
return NULL; /* single display only */
_gdk_display = g_object_new (GDK_TYPE_DISPLAY, NULL);
_gdk_screen = g_object_new (GDK_TYPE_SCREEN, NULL);
_gdk_visual_init ();
gdk_screen_set_default_colormap (_gdk_screen,
gdk_screen_get_system_colormap (_gdk_screen));
_gdk_windowing_window_init ();
_gdk_windowing_image_init ();
_gdk_events_init ();
_gdk_input_init ();
_gdk_dnd_init ();
g_signal_emit_by_name (gdk_display_manager_get (),
"display_opened", _gdk_display);
return _gdk_display;
}
GdkDisplay *
_gdk_wayland_display_open (const gchar *display_name)
{
struct wl_display *wl_display;
GdkDisplay *display;
GdkDisplayWayland *display_wayland;
wl_display = wl_display_connect(display_name);
if (!wl_display)
return NULL;
display = g_object_new (GDK_TYPE_DISPLAY_WAYLAND, NULL);
display_wayland = GDK_DISPLAY_WAYLAND (display);
display_wayland->wl_display = wl_display;
display_wayland->screen = _gdk_wayland_screen_new (display);
display->device_manager = _gdk_wayland_device_manager_new (display);
/* Set up listener so we'll catch all events. */
wl_display_add_global_listener(display_wayland->wl_display,
gdk_display_handle_global, display_wayland);
gdk_display_init_egl(display);
display_wayland->event_source =
_gdk_wayland_display_event_source_new (display);
gdk_input_init (display);
g_signal_emit_by_name (display, "opened");
g_signal_emit_by_name (gdk_display_manager_get(), "display_opened", display);
return display;
}
/**
* gdk_display_get_default:
*
* Gets the default #GdkDisplay. This is a convenience
* function for
* <literal>gdk_display_manager_get_default_display (gdk_display_manager_get ())</literal>.
*
* Returns: (transfer none): a #GdkDisplay, or %NULL if there is no default
* display.
*
* Since: 2.2
*/
GdkDisplay *
gdk_display_get_default (void)
{
return gdk_display_manager_get_default_display (gdk_display_manager_get ());
}
GdkDisplay *
gdk_display_open (const gchar *display_name)
{
HMODULE user32;
if (_gdk_display != NULL)
return NULL; /* single display only */
_gdk_display = g_object_new (GDK_TYPE_DISPLAY, NULL);
_gdk_screen = g_object_new (GDK_TYPE_SCREEN, NULL);
#ifdef HAVE_MONITOR_INFO
user32 = GetModuleHandle ("USER32.dll");
g_assert (user32 != NULL);
p_EnumDisplayMonitors = (t_EnumDisplayMonitors) GetProcAddress (user32, "EnumDisplayMonitors");
p_GetMonitorInfoA = (t_GetMonitorInfoA) GetProcAddress (user32, "GetMonitorInfoA");
if (p_EnumDisplayMonitors != NULL && p_GetMonitorInfoA != NULL)
{
gint i, index;
_gdk_num_monitors = 0;
(*p_EnumDisplayMonitors) (NULL, NULL, count_monitor, (LPARAM) &_gdk_num_monitors);
_gdk_monitors = g_new (GdkRectangle, _gdk_num_monitors);
index = 0;
(*p_EnumDisplayMonitors) (NULL, NULL, enum_monitor, (LPARAM) &index);
#if 1
_gdk_offset_x = G_MININT;
_gdk_offset_y = G_MININT;
/* Calculate offset */
for (i = 0; i < _gdk_num_monitors; i++)
{
_gdk_offset_x = MAX (_gdk_offset_x, -_gdk_monitors[i].x);
_gdk_offset_y = MAX (_gdk_offset_y, -_gdk_monitors[i].y);
}
GDK_NOTE (MISC, g_print ("Multi-monitor offset: (%d,%d)\n",
_gdk_offset_x, _gdk_offset_y));
/* Translate monitor coords into GDK coordinate space */
for (i = 0; i < _gdk_num_monitors; i++)
{
_gdk_monitors[i].x += _gdk_offset_x;
_gdk_monitors[i].y += _gdk_offset_y;
GDK_NOTE (MISC, g_print ("Monitor %d: %dx%d@+%d+%d\n",
i, _gdk_monitors[i].width,
_gdk_monitors[i].height,
_gdk_monitors[i].x, _gdk_monitors[i].y));
}
#endif
}
else
#endif /* HAVE_MONITOR_INFO */
{
RECT rect;
_gdk_num_monitors = 1;
_gdk_monitors = g_new (GdkRectangle, 1);
SystemParametersInfo (SPI_GETWORKAREA, 0, &rect, 0);
_gdk_monitors[0].x = rect.left;
_gdk_monitors[0].y = rect.top;
_gdk_monitors[0].width = rect.right - rect.left;
_gdk_monitors[0].height = rect.bottom - rect.top;
_gdk_offset_x = 0;
_gdk_offset_y = 0;
}
_gdk_visual_init ();
gdk_screen_set_default_colormap (_gdk_screen,
gdk_screen_get_system_colormap (_gdk_screen));
_gdk_windowing_window_init ();
_gdk_windowing_image_init ();
_gdk_events_init ();
_gdk_input_init (_gdk_display);
_gdk_dnd_init ();
g_signal_emit_by_name (gdk_display_manager_get (),
"display_opened", _gdk_display);
return _gdk_display;
}
static VALUE
rg_s_get(G_GNUC_UNUSED VALUE self)
{
return GOBJ2RVAL(gdk_display_manager_get());
}
int
main (int argc, char const **argv)
{
gboolean opened_workbook = FALSE;
gboolean with_gui;
GOIOContext *ioc;
WorkbookView *wbv;
GSList *wbcgs_to_kill = NULL;
GOCmdContext *cc;
#ifdef G_OS_WIN32
gboolean has_console;
#endif
/* No code before here, we need to init threads */
argv = gnm_pre_parse_init (argc, argv);
/*
* Attempt to disable Ubuntu's funky, non-working scroll
* bars. This needs to be done before gtk starts loading
* modules. Note: the following call will not replace
* an existing setting, so you can run with =1 if you like.
*/
g_setenv ("LIBOVERLAY_SCROLLBAR", "0", FALSE);
#ifdef G_OS_WIN32
has_console = FALSE;
{
typedef BOOL (CALLBACK* LPFNATTACHCONSOLE)(DWORD);
LPFNATTACHCONSOLE MyAttachConsole;
HMODULE hmod;
if ((hmod = GetModuleHandle("kernel32.dll"))) {
MyAttachConsole = (LPFNATTACHCONSOLE) GetProcAddress(hmod, "AttachConsole");
if (MyAttachConsole && MyAttachConsole(ATTACH_PARENT_PROCESS)) {
freopen("CONOUT$", "w", stdout);
freopen("CONOUT$", "w", stderr);
dup2(fileno(stdout), 1);
dup2(fileno(stderr), 2);
has_console = TRUE;
}
}
}
#endif
gnumeric_arg_parse (argc, (char **)argv);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
bind_textdomain_codeset (GETTEXT_PACKAGE "-functions", "UTF-8");
with_gui = !func_def_file && !func_state_file && !split_funcdocs;
if (with_gui) {
gnm_session_init (argv[0]);
}
gnm_init ();
/* These are useful for the build process only. */
if (func_state_file)
return gnm_dump_func_defs (func_state_file, 0);
if (func_def_file)
return gnm_dump_func_defs (func_def_file, 1);
if (split_funcdocs)
return gnm_dump_func_defs (NULL, 2);
if (ext_refs_file)
return gnm_dump_func_defs (ext_refs_file, 4);
if (with_gui) {
go_component_set_default_command_context (cc = cmd_context_stderr_new ());
g_object_unref (cc);
cc = g_object_new (GNM_TYPE_IO_CONTEXT_GTK,
"show-splash", !gnumeric_no_splash,
"show-warnings", !gnumeric_no_warnings,
NULL);
ioc = GO_IO_CONTEXT (g_object_ref (cc));
handle_paint_events ();
pathetic_qt_workaround ();
} else {
/* TODO: Make this inconsistency go away */
cc = cmd_context_stderr_new ();
ioc = go_io_context_new (cc);
go_component_set_default_command_context (cc);
}
/* Keep in sync with .desktop file */
g_set_application_name (_("Gnumeric Spreadsheet"));
gnm_plugins_init (GO_CMD_CONTEXT (ioc));
if (startup_files) {
int i;
for (i = 0; startup_files [i]; i++)
;
go_io_context_set_num_files (ioc, i);
for (i = 0;
startup_files [i] && !initial_workbook_open_complete;
i++) {
char *uri = go_shell_arg_to_uri (startup_files[i]);
if (uri == NULL) {
g_warning ("Ignoring invalid URI.");
continue;
}
go_io_context_processing_file (ioc, uri);
wbv = workbook_view_new_from_uri (uri, NULL, ioc, NULL);
g_free (uri);
if (go_io_error_occurred (ioc) ||
go_io_warning_occurred (ioc)) {
go_io_error_display (ioc);
go_io_error_clear (ioc);
}
if (wbv != NULL) {
WBCGtk *wbcg;
workbook_update_history (wb_view_get_workbook (wbv), GNM_FILE_SAVE_AS_STYLE_SAVE);
wbcg = wbc_gtk_new (wbv, NULL, NULL, geometry);
geometry = NULL;
sheet_update (wb_view_cur_sheet (wbv));
opened_workbook = TRUE;
gnm_io_context_gtk_set_transient_for (GNM_IO_CONTEXT_GTK (ioc),
wbcg_toplevel (wbcg));
if (immediate_exit_flag)
wbcgs_to_kill = g_slist_prepend (wbcgs_to_kill,
wbcg);
}
/* cheesy attempt to keep the ui from freezing during
load */
handle_paint_events ();
if (gnm_io_context_gtk_get_interrupted (GNM_IO_CONTEXT_GTK (ioc)))
break; /* Don't load any more workbooks */
}
}
g_object_unref (cc);
cc = NULL;
/* FIXME: Maybe we should quit here if we were asked to open
files and failed to do so. */
/* If we were intentionally short circuited exit now */
if (!initial_workbook_open_complete) {
initial_workbook_open_complete = TRUE;
if (!opened_workbook) {
gint n_of_sheets = gnm_conf_get_core_workbook_n_sheet ();
wbc_gtk_new (NULL,
workbook_new_with_sheets (n_of_sheets),
NULL, geometry);
}
if (immediate_exit_flag) {
GSList *l;
for (l = wbcgs_to_kill; l; l = l->next)
g_idle_add ((GSourceFunc)cb_kill_wbcg, l->data);
}
g_signal_connect (gnm_app_get_app (),
"workbook_removed",
G_CALLBACK (cb_workbook_removed),
NULL);
gnm_io_context_gtk_discharge_splash (GNM_IO_CONTEXT_GTK (ioc));
g_object_unref (ioc);
g_idle_add ((GSourceFunc)pathetic_qt_workaround, NULL);
gtk_main ();
} else {
g_object_unref (ioc);
g_slist_foreach (wbcgs_to_kill, (GFunc)cb_kill_wbcg, NULL);
}
g_slist_free (wbcgs_to_kill);
gnumeric_arg_shutdown ();
store_plugin_state ();
gnm_shutdown ();
#if defined(G_OS_WIN32)
if (has_console) {
close(1);
close(2);
FreeConsole();
}
#endif
gnm_pre_parse_shutdown ();
go_component_set_default_command_context (NULL);
/*
* This helps finding leaks. We might want it in developent
* only.
*/
if (with_gui && gnm_debug_flag ("close-displays")) {
GSList *displays;
gdk_flush();
while (g_main_context_iteration (NULL, FALSE))
;/* nothing */
displays = gdk_display_manager_list_displays
(gdk_display_manager_get ());
g_slist_foreach (displays, (GFunc)gdk_display_close, NULL);
g_slist_free (displays);
}
return 0;
}
static void
gdk_display_real_opened (GdkDisplay *display)
{
_gdk_display_manager_add_display (gdk_display_manager_get (), display);
}
/* Main entry point for gdk in 2.6 args are parsed
*/
GdkDisplay *
gdk_display_open (const gchar *display_name)
{
IDirectFB *directfb;
IDirectFBDisplayLayer *layer;
IDirectFBInputDevice *keyboard;
DFBResult ret;
if (_gdk_display)
{
return GDK_DISPLAY_OBJECT (_gdk_display); /* single display only */
}
ret = DirectFBInit (NULL, NULL);
if (ret != DFB_OK)
{
DirectFBError ("gdk_display_open: DirectFBInit", ret);
return NULL;
}
ret = DirectFBCreate (&directfb);
if (ret != DFB_OK)
{
DirectFBError ("gdk_display_open: DirectFBCreate", ret);
return NULL;
}
_gdk_display = g_object_new (GDK_TYPE_DISPLAY_DFB, NULL);
_gdk_display->directfb = directfb;
ret = directfb->GetDisplayLayer (directfb, DLID_PRIMARY, &layer);
if (ret != DFB_OK)
{
DirectFBError ("gdk_display_open: GetDisplayLayer", ret);
directfb->Release (directfb);
_gdk_display->directfb = NULL;
return NULL;
}
ret = directfb->GetInputDevice (directfb, DIDID_KEYBOARD, &keyboard);
if (ret != DFB_OK)
{
DirectFBError ("gdk_display_open: GetInputDevice", ret);
directfb->Release (directfb);
_gdk_display->directfb = NULL;
return NULL;
}
_gdk_display->layer = layer;
_gdk_display->keyboard = keyboard;
_gdk_directfb_keyboard_init ();
_gdk_screen = g_object_new (GDK_TYPE_SCREEN, NULL);
_gdk_visual_init ();
_gdk_windowing_window_init (_gdk_screen);
gdk_screen_set_default_colormap (_gdk_screen,
gdk_screen_get_system_colormap (_gdk_screen));
_gdk_windowing_image_init ();
_gdk_events_init ();
_gdk_input_init ();
_gdk_dnd_init ();
layer->EnableCursor (layer, 1);
g_signal_emit_by_name (gdk_display_manager_get (),
"display_opened", _gdk_display);
return GDK_DISPLAY_OBJECT (_gdk_display);
}
