dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gimp/app/display/gimpimagewindow.c

2538 lines
87 KiB
C
Raw Normal View History

Add new toplevel window class GimpImageWindow This one will be the toplevel where GimpDisplayShells live in once they are no toplevels any longer.
2009-09-23 18:24:22 +08:00
/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* 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 3 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
Change the license URL from http://www.gnu.org/licenses/ to https://
2018-07-12 05:27:07 +08:00
* along with this program. If not, see <https://www.gnu.org/licenses/>.
Add new toplevel window class GimpImageWindow This one will be the toplevel where GimpDisplayShells live in once they are no toplevels any longer.
2009-09-23 18:24:22 +08:00
*/
#include "config.h"
app: make scale_{to_rectangle,fit_in,fill,shrink_wrap} rotation aware Use the (screen space) bounding box of the rectangle/canvas for these functions.
2016-07-17 04:53:12 +08:00
#include <math.h>
Add new toplevel window class GimpImageWindow This one will be the toplevel where GimpDisplayShells live in once they are no toplevels any longer.
2009-09-23 18:24:22 +08:00
#include <gegl.h>
#include <gtk/gtk.h>
Bug 575043 - GIMP ignores 'Maximized' windows hints on startup. Now the max parameter from Windows is taken into account and takes precedence over the saved session state if set. This can be applied either through the "run" property of a shortcut, or by command line: `start /max gimp-2.9.exe`. There is a start for min handling as well but I can clearly see the window being minimized and immediately re-raised. There must be a call later which deiconifies the window. This will have to be fixed.
2016-05-29 23:35:55 +08:00
#ifdef G_OS_WIN32
#include <windef.h>
#include <winbase.h>
#include <windows.h>
#endif
libgimbase: merge gimpparam.h into gimpparamspecs.h which means that it's now included normally via gimpbase.h and not any longer via gimpbasetypes.h which we only did out of lazyness. A *lot* of files in libgimp* and app/ now need to
2019-07-31 16:16:21 +08:00
#include "libgimpbase/gimpbase.h"
Move shrink_wrap() from the display to the window Also fix all callers. This clearly needs more cleanup.
2009-09-25 23:46:09 +08:00
#include "libgimpmath/gimpmath.h"
app: make sure GimpImageWindow notifies all its shells of monitor changes Call gimp_color_managed_profile_changed() on all newly added shells, and on all shells in GimpWindow::monitor_changed().
2014-03-14 05:34:16 +08:00
#include "libgimpcolor/gimpcolor.h"
Add new toplevel window class GimpImageWindow This one will be the toplevel where GimpDisplayShells live in once they are no toplevels any longer.
2009-09-23 18:24:22 +08:00
#include "libgimpwidgets/gimpwidgets.h"
#include "display-types.h"
app: Add GimpDockColumns to the left and right of a GimpImageWindow
2009-10-04 08:02:39 +08:00
#include "config/gimpguiconfig.h"
Use large image previews as tab widgets
2009-10-01 01:25:38 +08:00
#include "core/gimp.h"
app: Add GimpDockColumns to the left and right of a GimpImageWindow
2009-10-04 08:02:39 +08:00
#include "core/gimpcontext.h"
Move shrink_wrap() from the display to the window Also fix all callers. This clearly needs more cleanup.
2009-09-25 23:46:09 +08:00
#include "core/gimpimage.h"
Add gimp_statusbar_override/restore_window_title() Which sets/unsets the title of an iconified toplevel image window to the current progress message (if any). Use the new functions when the window is (de)iconified. Not exactly the high art of programming, but much better than the hacks in gimpdisplayshell-progress.c that are now removed.
2009-09-26 01:35:03 +08:00
#include "core/gimpprogress.h"
Bug 701090: allowing to reorder shell tabs by drag'n drop in single-window-mode.
2013-05-27 23:52:13 +08:00
#include "core/gimpcontainer.h"
Move shrink_wrap() from the display to the window Also fix all callers. This clearly needs more cleanup.
2009-09-25 23:46:09 +08:00
Move the fullscreen API from GimpDisplayShell to GimpImageWindow Also remove GimpDisplayShell's "window_state" member. Use gtk_widget_get_toplvel() to get to the GimpImageWindow when we need a display shell's fullscreen state.
2009-09-23 20:52:33 +08:00
#include "widgets/gimpactiongroup.h"
display: Hook pad controllers into GimpImageWindow We have everything in place to create GtkPadControllers converting events into actions as configured in settings, and the signaling to trigger the (re)generation of those as device, window or configuration changes appear. Only the last bit attaching those controllers to actually handle input was missing, now done in this commit. Since there may be multiple configured tablets and pads, we need to keep track of per-device controllers to handle the configuration for those. This mapping is kept in GimpImageWindow as the "main" toplevel (i.e. the one(s) typically considered "keyboard focus" and receiving pad events) and ensured to be kept up-to-date through the ::configure-pad signal.
2023-06-14 03:45:10 +08:00
#include "widgets/gimpdeviceinfo.h"
#include "widgets/gimpdevicemanager.h"
#include "widgets/gimpdevices.h"
Move more window managing code to GimpImageWindow Move the code that (de)iconifies the docks together with an empty image window from GimpDisplayShell to GimpImageWindow.
2009-09-23 21:05:00 +08:00
#include "widgets/gimpdialogfactory.h"
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
#include "widgets/gimpdock.h"
app: Make positioning of new dockables depend on window mode Add GimpWindowingStrategy with create_dockable_dialog() and use it in dialogs_create_dockable_cmd_callback(). There are two implementations: GimpSingleWindowStrategy and GimpMultiWindowStrategy. Depending on the window mode, we want new dockables to appear in different places when created. In single-window mode, they should appear inside the single image window. In multi-window mode, a new dock window is created.
2011-07-04 02:55:03 +08:00
#include "widgets/gimpdockbook.h"
app: Add GimpDockColumns to the left and right of a GimpImageWindow
2009-10-04 08:02:39 +08:00
#include "widgets/gimpdockcolumns.h"
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
#include "widgets/gimpdockcontainer.h"
Move the statusbar to GimpImageWindow As with the menubar, port some code properly, and add some horrible /* FIXME image window */ hacks to make it work.
2009-09-23 23:55:41 +08:00
#include "widgets/gimphelp-ids.h"
app: rename GimpMenu to GimpMenuBar. This is better in sync with GTK naming (GtkMenuBar), but especially, it will allow me to make a GimpMenu subclass of GtkMenu.
2023-02-23 18:59:29 +08:00
#include "widgets/gimpmenubar.h"
Add menubar_manager member and "menu-factory" construct-only property Create the menubar_manager when the construct property is set, assert for its presence in constructor(). Pass the newly required construct property to g_object_new() in gimp_display_shell_new().
2009-09-23 18:47:25 +08:00
#include "widgets/gimpmenufactory.h"
Move the window part of gimp_display_shell_empty() to GimpImageWindow
2009-09-25 07:56:30 +08:00
#include "widgets/gimpsessioninfo.h"
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
#include "widgets/gimpsessioninfo-aux.h"
#include "widgets/gimpsessionmanaged.h"
#include "widgets/gimpsessioninfo-dock.h"
app: Handle special case "Toolbox" in GimpSingleWindowStrategy The special case isn't pretty, but the current design can't handle it nicely. This is not the first special case for the toolbox.
2011-07-20 22:31:12 +08:00
#include "widgets/gimptoolbox.h"
Add menubar_manager member and "menu-factory" construct-only property Create the menubar_manager when the construct property is set, assert for its presence in constructor(). Pass the newly required construct property to g_object_new() in gimp_display_shell_new().
2009-09-23 18:47:25 +08:00
#include "widgets/gimpuimanager.h"
Use large image previews as tab widgets
2009-10-01 01:25:38 +08:00
#include "widgets/gimpview.h"
app: add a GimpColorConfig to GimpDisplayShell Use the shell's color config for color managing the display and various auxiliary widgets attached to it, like the notebook tab widget and navigation popup. The config is currently just a reference to the global prefs config, so no behavior changed.
2016-05-14 06:56:26 +08:00
#include "widgets/gimpviewrenderer.h"
app: make things behave more reasonable with multiple monitors There is now a preference option that determines whether windows should be opened on the same monitor as before. It should be disabled when the machine gets monitors plugged/unplugged dynamically ("laptop") and enabled when there is a static multi-monitor setup ("wokstation"). This is merely the current simplistic policy on top of the newly added underlying infrastructure: - pass integer monitor numbers around in all places where we already pass around a GdkScreen. Pass the "current" monitor to these changed APIs, where "current" is either the monitor where the action-triggering widget is, or if that is unavailable the monitor where the mouse is. - add gimp_widget_get_monitor() in order to easily get to the monitor, just like gtk_widget_get_screen(). - add screen and monitor parameters in some places that were missed before. - in sessionrc, save all window positions relative to the window's monitor, and save the monitor separately, if it's not the screen's primary monitor. - when restoring window positions, use the stored monitor when the new prefs options says so (use the screen's primary monitor if there is no stored monitor), otherwise use current monitor that is now passed around.
2014-05-02 09:01:23 +08:00
#include "widgets/gimpwidgets-utils.h"
Add menubar_manager member and "menu-factory" construct-only property Create the menubar_manager when the construct property is set, assert for its presence in constructor(). Pass the newly required construct property to g_object_new() in gimp_display_shell_new().
2009-09-23 18:47:25 +08:00
app: prevent multiple registrations of a same action. Pre-GIMP-3.0 code logics would re-allocate several GimpMenuFactory or GimpUIManager for no good reason. While it was still working with old GtkAction code, with our new GAction-based code, we were ending up overriding an action with a new version of the same action, while keeping reference to old actions. This made for discrepancies of the enabled or visible state of actions. The new code keeps singleton of some objects and references to already registered GimpUIManager or GimpActionGroups objects and make sure no actions with the same name are created twice.
2023-03-08 01:23:38 +08:00
#include "menus/menus.h"
Move more window managing code to GimpImageWindow Move the code that (de)iconifies the docks together with an empty image window from GimpDisplayShell to GimpImageWindow.
2009-09-23 21:05:00 +08:00
#include "gimpdisplay.h"
#include "gimpdisplay-foreach.h"
Add gimp_image_window_get_active_display() Should probably be refactored into something involving a GimpContext, but it's good enough as intermediate step.
2009-09-23 19:06:11 +08:00
#include "gimpdisplayshell.h"
Move updating the shell's appearance to the right window state event handler The shell's handler is going to go away, so move this call to the image window.
2009-09-25 19:58:25 +08:00
#include "gimpdisplayshell-appearance.h"
Move GtkWidget::delete_event() impl from the shell to the window Still has a FIXME but is in the right place now at least
2009-09-25 18:48:30 +08:00
#include "gimpdisplayshell-close.h"
Issue #3781 - Display artifacts on HiDPI when render cache is invalidated In GimpDisplayShell, scale the render cache by the window's scale factor, and render its content in device pixels, instead of scaled application pixels. When painting the cache to the screen, unscale the cairo context by the same factor, so that it's painted in the native resolution. Note that the various gimp_display_shell_render_foo() functions still speak in application pixels, and the scaling happens internally in gimp_display_shell_render(). Aside from rendering at native resolution on HiDPI, this also fixes an issue where grid-like display artifacts would appear when the render cache was not fully validated due to the non-native scaling.
2019-09-12 02:00:32 +08:00
#include "gimpdisplayshell-expose.h"
#include "gimpdisplayshell-render.h"
app: move gimp_display_shell_scale_changed() to gimpdisplayshell-scale.[ch] and rename it to gimp_display_shell_scale_update().
2016-01-06 01:48:22 +08:00
#include "gimpdisplayshell-scale.h"
Move shrink_wrap() from the display to the window Also fix all callers. This clearly needs more cleanup.
2009-09-25 23:46:09 +08:00
#include "gimpdisplayshell-scroll.h"
app: split tool event handling out into an own file it was simply getting too hairy in the callbacks.c file.
2011-02-23 12:21:06 +08:00
#include "gimpdisplayshell-tool-events.h"
Bug 602223 - Can't hide docks with Tab in single-window mode Add a "hide-docks" config and connect the Windows->Hide docks menu item to it. Also connect the image window to the config property so it can hide/show its docks when it needs to. Also add and use a utility function gimp_image_window_keep_canvas_pos() to ensure that the image in the window remains fixed when toggling visiblity of docks. One problem: When GimpDrawTool is active on the canvas, there is flicker. The end position is correct though. Also add regression testing for this fix to test-ui.c
2010-02-24 03:21:08 +08:00
#include "gimpdisplayshell-transform.h"
Add new toplevel window class GimpImageWindow This one will be the toplevel where GimpDisplayShells live in once they are no toplevels any longer.
2009-09-23 18:24:22 +08:00
#include "gimpimagewindow.h"
Move the statusbar to GimpImageWindow As with the menubar, port some code properly, and add some horrible /* FIXME image window */ hacks to make it work.
2009-09-23 23:55:41 +08:00
#include "gimpstatusbar.h"
Add new toplevel window class GimpImageWindow This one will be the toplevel where GimpDisplayShells live in once they are no toplevels any longer.
2009-09-23 18:24:22 +08:00
Add GtkWidget::window_state_event() implementation to GimpImageWindow Keep an own window_state member around and update it accordingly. Chain up in GimpDisplayShell's window_state_event() impl.
2009-09-23 19:40:52 +08:00
#include "gimp-log.h"
app: fix image-window UI-manager update while a projection is being rendered Set the priority of the image window's UI-manager update idle slightly higher than the projection idle priority, so that the image actions are updated during projection rendering.
2019-03-31 07:24:00 +08:00
#include "gimp-priorities.h"
Add new toplevel window class GimpImageWindow This one will be the toplevel where GimpDisplayShells live in once they are no toplevels any longer.
2009-09-23 18:24:22 +08:00
#include "gimp-intl.h"
app: some GimpImageWindow cleanup - implement GObject::constructed() instead of ::construct() - remove the display pause/resume idle hack because any tool drawing flickering is gone now by using cairo - some formatting cleanup - remove some unused local variables
2010-11-26 16:19:36 +08:00
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
#define GIMP_EMPTY_IMAGE_WINDOW_ENTRY_ID "gimp-empty-image-window"
#define GIMP_SINGLE_IMAGE_WINDOW_ENTRY_ID "gimp-single-image-window"
app: change serialization of the right docks width in SWM (again) Use "right-docks-width" and always a positive value instead of "right-docks-position" (as opponsed to "left-docks-width", that distinction is a GtkPaned implementation detail and does not belong into a config file). Parse all old values too. Also fix a glitch in the deserialization code which might fix bug #700147.
2013-05-13 06:00:57 +08:00
/* The width of the left and right dock areas */
#define GIMP_IMAGE_WINDOW_LEFT_DOCKS_WIDTH "left-docks-width"
#define GIMP_IMAGE_WINDOW_RIGHT_DOCKS_WIDTH "right-docks-width"
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
app: change serialization of the right docks width in SWM (again) Use "right-docks-width" and always a positive value instead of "right-docks-position" (as opponsed to "left-docks-width", that distinction is a GtkPaned implementation detail and does not belong into a config file). Parse all old values too. Also fix a glitch in the deserialization code which might fix bug #700147.
2013-05-13 06:00:57 +08:00
/* deprecated property: GtkPaned position of the right docks area */
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
#define GIMP_IMAGE_WINDOW_RIGHT_DOCKS_POS "right-docks-position"
app: Session manage empty- and single-image window separately Session manage empty- and single-image window separately. So when starting up, the default 2.6 UI is the same. But when enabling single-window mode, the image window will become much larger then the empty-image window. These conceptually different windows will then from that point be session managed separately: switching mode switches size of the image window.
2010-03-13 23:35:57 +08:00
app: Save the maximized state of the main window in the sessionrc file.
2012-04-04 08:59:37 +08:00
/* Whether the window's maximized or not */
#define GIMP_IMAGE_WINDOW_MAXIMIZED "maximized"
Add new toplevel window class GimpImageWindow This one will be the toplevel where GimpDisplayShells live in once they are no toplevels any longer.
2009-09-23 18:24:22 +08:00
Add menubar_manager member and "menu-factory" construct-only property Create the menubar_manager when the construct property is set, assert for its presence in constructor(). Pass the newly required construct property to g_object_new() in gimp_display_shell_new().
2009-09-23 18:47:25 +08:00
enum
{
PROP_0,
app: Add "gimp" property to GimpImageWindow
2009-10-26 04:44:23 +08:00
PROP_GIMP,
app: Cleanup GimpImageWindow and dependencies, only one dialog factory Cleanup GimpImageWindow and dependencies like GimpDisplay, there is only one dialog factory now.
2010-02-20 18:09:51 +08:00
PROP_DIALOG_FACTORY,
app: add screen and monitor to all display and image window constructors so they appear on the proper monitor as well.
2014-05-03 02:20:46 +08:00
PROP_INITIAL_MONITOR
Add menubar_manager member and "menu-factory" construct-only property Create the menubar_manager when the construct property is set, assert for its presence in constructor(). Pass the newly required construct property to g_object_new() in gimp_display_shell_new().
2009-09-23 18:47:25 +08:00
};
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
typedef struct _GimpImageWindowPrivate GimpImageWindowPrivate;
struct _GimpImageWindowPrivate
{
app: Add "gimp" property to GimpImageWindow
2009-10-26 04:44:23 +08:00
Gimp *gimp;
app: Cleanup GimpImageWindow and dependencies, only one dialog factory Cleanup GimpImageWindow and dependencies like GimpDisplay, there is only one dialog factory now.
2010-02-20 18:09:51 +08:00
GimpDialogFactory *dialog_factory;
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
GList *shells;
GimpDisplayShell *active_shell;
app: allow changing submenu's labels with gimp_menu_model_set_title(). Use this for the "View > Zoom" and "View > Flip & Rotate" submenus which used to display the zoom level and rotation angle. This regression is now fixed.
2023-04-17 21:24:26 +08:00
GimpMenuModel *menubar_model;
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
GtkWidget *main_vbox;
GtkWidget *menubar;
Add a central hbox for docks and display shells
2009-09-30 03:47:58 +08:00
GtkWidget *hbox;
app: Put docks in the image window in single-window mode in panes
2009-10-04 17:13:05 +08:00
GtkWidget *left_hpane;
app: Add GimpDockColumns to the left and right of a GimpImageWindow
2009-10-04 08:02:39 +08:00
GtkWidget *left_docks;
app: Put docks in the image window in single-window mode in panes
2009-10-04 17:13:05 +08:00
GtkWidget *right_hpane;
Add a notebook for the display shells
2009-09-30 03:57:57 +08:00
GtkWidget *notebook;
app: Add GimpDockColumns to the left and right of a GimpImageWindow
2009-10-04 08:02:39 +08:00
GtkWidget *right_docks;
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
display: Hook pad controllers into GimpImageWindow We have everything in place to create GtkPadControllers converting events into actions as configured in settings, and the signaling to trigger the (re)generation of those as device, window or configuration changes appear. Only the last bit attaching those controllers to actually handle input was missing, now done in this commit. Since there may be multiple configured tablets and pads, we need to keep track of per-device controllers to handle the configuration for those. This mapping is kept in GimpImageWindow as the "main" toplevel (i.e. the one(s) typically considered "keyboard focus" and receiving pad events) and ensured to be kept up-to-date through the ::configure-pad signal.
2023-06-14 03:45:10 +08:00
GHashTable *pad_controllers;
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
GdkWindowState window_state;
app: Session manage empty- and single-image window separately Session manage empty- and single-image window separately. So when starting up, the default 2.6 UI is the same. But when enabling single-window mode, the image window will become much larger then the empty-image window. These conceptually different windows will then from that point be session managed separately: switching mode switches size of the image window.
2010-03-13 23:35:57 +08:00
const gchar *entry_id;
app: add screen and monitor to all display and image window constructors so they appear on the proper monitor as well.
2014-05-03 02:20:46 +08:00
Port a lot of stuff from GdkScreen/monitor_number to GdkMonitor including some fixes for getting pointer coords, and needed API changes in libgimpwidgets.
2018-04-29 23:27:47 +08:00
GdkMonitor *initial_monitor;
app: make new images jump around much less Implement a mechanism to suspend/resume GimpImageWindow's "keep canvas pos" logic which is used to keep the image in place across widget changed such as show/hide rulers. gimp_display_shell_fill(): call suspend()/resume() around gimp_display_shell_appearance_update(), and center the image after calculating the initial scale factor, so the image jumping at least starts at the approximately right position.
2016-01-11 08:50:29 +08:00
Issue #3781 - Display artifacts on HiDPI when render cache is invalidated In GimpDisplayShell, scale the render cache by the window's scale factor, and render its content in device pixels, instead of scaled application pixels. When painting the cache to the screen, unscale the cairo context by the same factor, so that it's painted in the native resolution. Note that the various gimp_display_shell_render_foo() functions still speak in application pixels, and the scaling happens internally in gimp_display_shell_render(). Aside from rendering at native resolution on HiDPI, this also fixes an issue where grid-like display artifacts would appear when the render cache was not fully validated due to the non-native scaling.
2019-09-12 02:00:32 +08:00
gint scale_factor;
app: make new images jump around much less Implement a mechanism to suspend/resume GimpImageWindow's "keep canvas pos" logic which is used to keep the image in place across widget changed such as show/hide rulers. gimp_display_shell_fill(): call suspend()/resume() around gimp_display_shell_appearance_update(), and center the image after calculating the initial scale factor, so the image jumping at least starts at the approximately right position.
2016-01-11 08:50:29 +08:00
gint suspend_keep_pos;
app: defer image menu updates to an idle function In DEs which use a global menu, such as Unity, updating the menu can be expensive. This particularly affects canvas scaling and rotation, for which updating the menu synchronously causes notable lag.
2017-03-01 16:09:24 +08:00
gint update_ui_manager_idle_id;
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
};
Bug 602223 - Can't hide docks with Tab in single-window mode Add a "hide-docks" config and connect the Windows->Hide docks menu item to it. Also connect the image window to the config property so it can hide/show its docks when it needs to. Also add and use a utility function gimp_image_window_keep_canvas_pos() to ensure that the image in the window remains fixed when toggling visiblity of docks. One problem: When GimpDrawTool is active on the canvas, there is flicker. The end position is correct though. Also add regression testing for this fix to test-ui.c
2010-02-24 03:21:08 +08:00
typedef struct
{
app: make sure the image stays in place when showing/hiding docks also when it's rotated or flipped.
2015-11-14 07:05:23 +08:00
gint canvas_x;
gint canvas_y;
gint window_x;
gint window_y;
Bug 602223 - Can't hide docks with Tab in single-window mode Add a "hide-docks" config and connect the Windows->Hide docks menu item to it. Also connect the image window to the config property so it can hide/show its docks when it needs to. Also add and use a utility function gimp_image_window_keep_canvas_pos() to ensure that the image in the window remains fixed when toggling visiblity of docks. One problem: When GimpDrawTool is active on the canvas, there is flicker. The end position is correct though. Also add regression testing for this fix to test-ui.c
2010-02-24 03:21:08 +08:00
} PosCorrectionData;
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
#define GIMP_IMAGE_WINDOW_GET_PRIVATE(window) \
app, libgimp*, modules: don't use g_type_class_add_private() ... ... and G_TYPE_INSTANCE_GET_PRIVATE() g_type_class_add_private() and G_TYPE_INSTANCE_GET_PRIVATE() were deprecated in GLib 2.58. Instead, use G_DEFINE_[ABSTRACT_]TYPE_WITH_PRIVATE(), and G_ADD_PRIVATE[_DYNAMIC](), and the implictly-defined foo_get_instance_private() functions, all of which are available in the GLib versions we depend on. This commit only covers types registered using one of the G_DEFINE_FOO() macros (i.e., most types), but not types with a custom registration function, of which we still have a few -- GLib currently only provides a (non-deprecated) public API for adding a private struct using the G_DEFINE_FOO() macros. Note that this commit was 99% auto-generated (because I'm not *that* crazy :), so if there are any style mismatches... we'll have to live with them for now.
2018-09-19 00:09:39 +08:00
((GimpImageWindowPrivate *) gimp_image_window_get_instance_private ((GimpImageWindow *) (window)))
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
Add new toplevel window class GimpImageWindow This one will be the toplevel where GimpDisplayShells live in once they are no toplevels any longer.
2009-09-23 18:24:22 +08:00
/* local function prototypes */
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
static void gimp_image_window_dock_container_iface_init
(GimpDockContainerInterface
*iface);
static void gimp_image_window_session_managed_iface_init
(GimpSessionManagedInterface
*iface);
app: some GimpImageWindow cleanup - implement GObject::constructed() instead of ::construct() - remove the display pause/resume idle hack because any tool drawing flickering is gone now by using cairo - some formatting cleanup - remove some unused local variables
2010-11-26 16:19:36 +08:00
static void gimp_image_window_constructed (GObject *object);
app: disconnect from the dialog factory in dispose() instead of finalize()
2010-06-24 19:00:16 +08:00
static void gimp_image_window_dispose (GObject *object);
Reindent static prototypes
2009-09-25 19:43:54 +08:00
static void gimp_image_window_finalize (GObject *object);
static void gimp_image_window_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gimp_image_window_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static gboolean gimp_image_window_delete_event (GtkWidget *widget,
GdkEventAny *event);
static gboolean gimp_image_window_configure_event (GtkWidget *widget,
GdkEventConfigure *event);
static gboolean gimp_image_window_window_state_event (GtkWidget *widget,
GdkEventWindowState *event);
app: implement GtkWidget::style_updated() instead of style_set()
2010-12-23 06:34:47 +08:00
static void gimp_image_window_style_updated (GtkWidget *widget);
app: make sure GimpImageWindow notifies all its shells of monitor changes Call gimp_color_managed_profile_changed() on all newly added shells, and on all shells in GimpWindow::monitor_changed().
2014-03-14 05:34:16 +08:00
static void gimp_image_window_monitor_changed (GimpWindow *window,
Port a lot of stuff from GdkScreen/monitor_number to GdkMonitor including some fixes for getting pointer coords, and needed API changes in libgimpwidgets.
2018-04-29 23:27:47 +08:00
GdkMonitor *monitor);
app: make sure GimpImageWindow notifies all its shells of monitor changes Call gimp_color_managed_profile_changed() on all newly added shells, and on all shells in GimpWindow::monitor_changed().
2014-03-14 05:34:16 +08:00
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
static GList * gimp_image_window_get_docks (GimpDockContainer *dock_container);
app: add GimpDockContainer::get_dialog_factory() and use it where possible instead of gimp_dialog_factory_get_singleton(). Also reduce using this function in some other places.
2016-11-25 20:26:08 +08:00
static GimpDialogFactory *
gimp_image_window_dock_container_get_dialog_factory
(GimpDockContainer *dock_container);
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
static GimpUIManager *
gimp_image_window_dock_container_get_ui_manager
(GimpDockContainer *dock_container);
static void gimp_image_window_add_dock (GimpDockContainer *dock_container,
GimpDock *dock,
GimpSessionInfoDock *dock_info);
static GimpAlignmentType
gimp_image_window_get_dock_side (GimpDockContainer *dock_container,
GimpDock *dock);
static GList * gimp_image_window_get_aux_info (GimpSessionManaged *session_managed);
static void gimp_image_window_set_aux_info (GimpSessionManaged *session_managed,
GList *aux_info);
Reindent static prototypes
2009-09-25 19:43:54 +08:00
app: Update image window side docks visiblity from the image window Update image window side docks visiblity from the image window itself instead of from the ui configurer. The image window has a dependency to the config object anyway, so no need to complicate things.
2010-02-23 02:24:23 +08:00
static void gimp_image_window_config_notify (GimpImageWindow *window,
GParamSpec *pspec,
GimpGuiConfig *config);
app: Introduce image window session utility functions Introduce image window session utility functions gimp_image_window_session_clear() and gimp_image_window_session_apply().
2010-03-13 19:56:27 +08:00
static void gimp_image_window_session_clear (GimpImageWindow *window);
static void gimp_image_window_session_apply (GimpImageWindow *window,
app: make things behave more reasonable with multiple monitors There is now a preference option that determines whether windows should be opened on the same monitor as before. It should be disabled when the machine gets monitors plugged/unplugged dynamically ("laptop") and enabled when there is a static multi-monitor setup ("wokstation"). This is merely the current simplistic policy on top of the newly added underlying infrastructure: - pass integer monitor numbers around in all places where we already pass around a GdkScreen. Pass the "current" monitor to these changed APIs, where "current" is either the monitor where the action-triggering widget is, or if that is unavailable the monitor where the mouse is. - add gimp_widget_get_monitor() in order to easily get to the monitor, just like gtk_widget_get_screen(). - add screen and monitor parameters in some places that were missed before. - in sessionrc, save all window positions relative to the window's monitor, and save the monitor separately, if it's not the screen's primary monitor. - when restoring window positions, use the stored monitor when the new prefs options says so (use the screen's primary monitor if there is no stored monitor), otherwise use current monitor that is now passed around.
2014-05-02 09:01:23 +08:00
const gchar *entry_id,
Port a lot of stuff from GdkScreen/monitor_number to GdkMonitor including some fixes for getting pointer coords, and needed API changes in libgimpwidgets.
2018-04-29 23:27:47 +08:00
GdkMonitor *monitor);
app: Simplify GimpImageWindow session management Refactor session management with the "gimp-empty-image-window" in GimpImageWindow. In particular, only have one entry point to gimp_dialog_factory_add_foreign() and remove the is_empty instance struct member.
2010-03-13 19:41:06 +08:00
static void gimp_image_window_session_update (GimpImageWindow *window,
app: Don't unmaximize image window when switching tabs in swm It is when we apply session info to the image window we unmaximize, so don't apply session info to the image window when all we do is switching tabs in single-window mode.
2010-06-19 15:43:27 +08:00
GimpDisplay *new_display,
app: make things behave more reasonable with multiple monitors There is now a preference option that determines whether windows should be opened on the same monitor as before. It should be disabled when the machine gets monitors plugged/unplugged dynamically ("laptop") and enabled when there is a static multi-monitor setup ("wokstation"). This is merely the current simplistic policy on top of the newly added underlying infrastructure: - pass integer monitor numbers around in all places where we already pass around a GdkScreen. Pass the "current" monitor to these changed APIs, where "current" is either the monitor where the action-triggering widget is, or if that is unavailable the monitor where the mouse is. - add gimp_widget_get_monitor() in order to easily get to the monitor, just like gtk_widget_get_screen(). - add screen and monitor parameters in some places that were missed before. - in sessionrc, save all window positions relative to the window's monitor, and save the monitor separately, if it's not the screen's primary monitor. - when restoring window positions, use the stored monitor when the new prefs options says so (use the screen's primary monitor if there is no stored monitor), otherwise use current monitor that is now passed around.
2014-05-02 09:01:23 +08:00
const gchar *new_entry_id,
Port a lot of stuff from GdkScreen/monitor_number to GdkMonitor including some fixes for getting pointer coords, and needed API changes in libgimpwidgets.
2018-04-29 23:27:47 +08:00
GdkMonitor *monitor);
app: Session manage empty- and single-image window separately Session manage empty- and single-image window separately. So when starting up, the default 2.6 UI is the same. But when enabling single-window mode, the image window will become much larger then the empty-image window. These conceptually different windows will then from that point be session managed separately: switching mode switches size of the image window.
2010-03-13 23:35:57 +08:00
static const gchar *
gimp_image_window_config_to_entry_id (GimpGuiConfig *config);
Reindent static prototypes
2009-09-25 19:43:54 +08:00
static void gimp_image_window_show_tooltip (GimpUIManager *manager,
const gchar *tooltip,
GimpImageWindow *window);
static void gimp_image_window_hide_tooltip (GimpUIManager *manager,
GimpImageWindow *window);
app: defer image menu updates to an idle function In DEs which use a global menu, such as Unity, updating the menu can be expensive. This particularly affects canvas scaling and rotation, for which updating the menu synchronously causes notable lag.
2017-03-01 16:09:24 +08:00
static gboolean gimp_image_window_update_ui_manager_idle
(GimpImageWindow *window);
app: Update Windows->Toolbox menu entry depending on if toolbox exists Update Windows->Toolbox menu entry depending on if toolbox exists. If an existing toolbox will be raised, set "Toolbox". If it will create a new toolbox, set "New Toolbox". We need this special treatment since there can be only one toolbox, so "New Toolbox" will remove any toolbox docks from Recently Closed Docks. If we would just have "Toolbox" it could be misinterpreted as "get me the toolbox I just closed".
2010-03-07 19:24:26 +08:00
static void gimp_image_window_update_ui_manager (GimpImageWindow *window);
Move the statusbar to GimpImageWindow As with the menubar, port some code properly, and add some horrible /* FIXME image window */ hacks to make it work.
2009-09-23 23:55:41 +08:00
Bug 602223 - Can't hide docks with Tab in single-window mode Add a "hide-docks" config and connect the Windows->Hide docks menu item to it. Also connect the image window to the config property so it can hide/show its docks when it needs to. Also add and use a utility function gimp_image_window_keep_canvas_pos() to ensure that the image in the window remains fixed when toggling visiblity of docks. One problem: When GimpDrawTool is active on the canvas, there is flicker. The end position is correct though. Also add regression testing for this fix to test-ui.c
2010-02-24 03:21:08 +08:00
static void gimp_image_window_shell_size_allocate (GimpDisplayShell *shell,
GtkAllocation *allocation,
PosCorrectionData *data);
Move the remaining menubar signal connections from the shell to the window
2009-09-26 04:41:50 +08:00
static gboolean gimp_image_window_shell_events (GtkWidget *widget,
GdkEvent *event,
GimpImageWindow *window);
Merge the image window's active shell logic with the notebook's active page Add a GtkNotebook::switch_page() handler and move all shell switching code there. In gimp_image_window_set_active_shell(), simply set the right notebook page.
2009-09-30 04:14:10 +08:00
static void gimp_image_window_switch_page (GtkNotebook *notebook,
Fix the bulid after GtkNotebookPage got deprecated in gtk-2-22 In all GtkNotebook::switch_page() callbacks, simply replace GtkNotebookPage* by gpointer.
2010-07-16 21:24:25 +08:00
gpointer page,
Merge the image window's active shell logic with the notebook's active page Add a GtkNotebook::switch_page() handler and move all shell switching code there. In gimp_image_window_set_active_shell(), simply set the right notebook page.
2009-09-30 04:14:10 +08:00
gint page_num,
GimpImageWindow *window);
app: Connect to GtkNotebook::page-removed in GimpImageWindow We must disconnect from the last display shell when it is removed when rearranging the UI, so connect to GtkNotebook::page-removed in GimpImageWindow and do that.
2009-10-25 23:27:24 +08:00
static void gimp_image_window_page_removed (GtkNotebook *notebook,
app: gimp_image_window_page_removed() gets the widget, not page The first GtkNotebook::"page-removed" signal parameter is the GtkWidget that was removed, not a GtkNotebookPage. Correct function signature.
2010-01-06 21:44:24 +08:00
GtkWidget *widget,
app: Connect to GtkNotebook::page-removed in GimpImageWindow We must disconnect from the last display shell when it is removed when rearranging the UI, so connect to GtkNotebook::page-removed in GimpImageWindow and do that.
2009-10-25 23:27:24 +08:00
gint page_num,
GimpImageWindow *window);
Bug 701090: allowing to reorder shell tabs by drag'n drop in single-window-mode.
2013-05-27 23:52:13 +08:00
static void gimp_image_window_page_reordered (GtkNotebook *notebook,
GtkWidget *widget,
gint page_num,
GimpImageWindow *window);
app: Connect to GtkNotebook::page-removed in GimpImageWindow We must disconnect from the last display shell when it is removed when rearranging the UI, so connect to GtkNotebook::page-removed in GimpImageWindow and do that.
2009-10-25 23:27:24 +08:00
static void gimp_image_window_disconnect_from_active_shell
(GimpImageWindow *window);
Merge the image window's active shell logic with the notebook's active page Add a GtkNotebook::switch_page() handler and move all shell switching code there. In gimp_image_window_set_active_shell(), simply set the right notebook page.
2009-09-30 04:14:10 +08:00
Add notify callback for GimpDisplay's "image" property Will be used to do NIW things later.
2009-09-24 15:58:36 +08:00
static void gimp_image_window_image_notify (GimpDisplay *display,
const GParamSpec *pspec,
GimpImageWindow *window);
Add "title" and "status" properties to GimpSisplayShell Set the properties when updating title and status. In GimpImageWindow, connect to notifications of the properties to update window title and statusbar.
2009-09-24 01:33:36 +08:00
static void gimp_image_window_shell_scaled (GimpDisplayShell *shell,
GimpImageWindow *window);
app: add signal GimpDisplayShell::rotated and use it to update the menu
2013-04-21 09:15:22 +08:00
static void gimp_image_window_shell_rotated (GimpDisplayShell *shell,
GimpImageWindow *window);
Add "title" and "status" properties to GimpSisplayShell Set the properties when updating title and status. In GimpImageWindow, connect to notifications of the properties to update window title and statusbar.
2009-09-24 01:33:36 +08:00
static void gimp_image_window_shell_title_notify (GimpDisplayShell *shell,
const GParamSpec *pspec,
GimpImageWindow *window);
app: Add a close button to image window tabs It takes a bit more space, but it needs to be easy to close images.
2011-08-25 04:47:58 +08:00
static GtkWidget *
gimp_image_window_create_tab_label (GimpImageWindow *window,
GimpDisplayShell *shell);
Bug 747224 - Too easy to accidentially close an image tab Show the close button only on the active tab, so it's not accidentially hit when changing between images.
2015-04-04 02:28:57 +08:00
static void gimp_image_window_update_tab_labels (GimpImageWindow *window);
Add a GimpDisplayShell::scaled() handler to GimpImageWindow ...which is connected to the window's active display. Remove updating the window's menubar_manager from GimpDisplayShell's scaled() impl. Had to hack around a bit with the new API to set the window's active display because they are still the same widget.
2009-09-24 00:52:42 +08:00
display: Hook pad controllers into GimpImageWindow We have everything in place to create GtkPadControllers converting events into actions as configured in settings, and the signaling to trigger the (re)generation of those as device, window or configuration changes appear. Only the last bit attaching those controllers to actually handle input was missing, now done in this commit. Since there may be multiple configured tablets and pads, we need to keep track of per-device controllers to handle the configuration for those. This mapping is kept in GimpImageWindow as the "main" toplevel (i.e. the one(s) typically considered "keyboard focus" and receiving pad events) and ensured to be kept up-to-date through the ::configure-pad signal.
2023-06-14 03:45:10 +08:00
static void gimp_image_window_configure_pad (GimpImageWindow *window,
GimpDeviceInfo *info);
static void gimp_image_window_init_pad_foreach (GimpDeviceInfo *info,
GimpImageWindow *window);
Add new toplevel window class GimpImageWindow This one will be the toplevel where GimpDisplayShells live in once they are no toplevels any longer.
2009-09-23 18:24:22 +08:00
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
G_DEFINE_TYPE_WITH_CODE (GimpImageWindow, gimp_image_window, GIMP_TYPE_WINDOW,
app, libgimp*, modules: don't use g_type_class_add_private() ... ... and G_TYPE_INSTANCE_GET_PRIVATE() g_type_class_add_private() and G_TYPE_INSTANCE_GET_PRIVATE() were deprecated in GLib 2.58. Instead, use G_DEFINE_[ABSTRACT_]TYPE_WITH_PRIVATE(), and G_ADD_PRIVATE[_DYNAMIC](), and the implictly-defined foo_get_instance_private() functions, all of which are available in the GLib versions we depend on. This commit only covers types registered using one of the G_DEFINE_FOO() macros (i.e., most types), but not types with a custom registration function, of which we still have a few -- GLib currently only provides a (non-deprecated) public API for adding a private struct using the G_DEFINE_FOO() macros. Note that this commit was 99% auto-generated (because I'm not *that* crazy :), so if there are any style mismatches... we'll have to live with them for now.
2018-09-19 00:09:39 +08:00
G_ADD_PRIVATE (GimpImageWindow)
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
G_IMPLEMENT_INTERFACE (GIMP_TYPE_DOCK_CONTAINER,
gimp_image_window_dock_container_iface_init)
G_IMPLEMENT_INTERFACE (GIMP_TYPE_SESSION_MANAGED,
gimp_image_window_session_managed_iface_init))
Add new toplevel window class GimpImageWindow This one will be the toplevel where GimpDisplayShells live in once they are no toplevels any longer.
2009-09-23 18:24:22 +08:00
#define parent_class gimp_image_window_parent_class
static void
gimp_image_window_class_init (GimpImageWindowClass *klass)
{
app: make sure GimpImageWindow notifies all its shells of monitor changes Call gimp_color_managed_profile_changed() on all newly added shells, and on all shells in GimpWindow::monitor_changed().
2014-03-14 05:34:16 +08:00
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
GimpWindowClass *window_class = GIMP_WINDOW_CLASS (klass);
Add GtkWidget::window_state_event() implementation to GimpImageWindow Keep an own window_state member around and update it accordingly. Chain up in GimpDisplayShell's window_state_event() impl.
2009-09-23 19:40:52 +08:00
app: some GimpImageWindow cleanup - implement GObject::constructed() instead of ::construct() - remove the display pause/resume idle hack because any tool drawing flickering is gone now by using cairo - some formatting cleanup - remove some unused local variables
2010-11-26 16:19:36 +08:00
object_class->constructed = gimp_image_window_constructed;
app: disconnect from the dialog factory in dispose() instead of finalize()
2010-06-24 19:00:16 +08:00
object_class->dispose = gimp_image_window_dispose;
Add GtkWidget::window_state_event() implementation to GimpImageWindow Keep an own window_state member around and update it accordingly. Chain up in GimpDisplayShell's window_state_event() impl.
2009-09-23 19:40:52 +08:00
object_class->finalize = gimp_image_window_finalize;
object_class->set_property = gimp_image_window_set_property;
object_class->get_property = gimp_image_window_get_property;
Add new toplevel window class GimpImageWindow This one will be the toplevel where GimpDisplayShells live in once they are no toplevels any longer.
2009-09-23 18:24:22 +08:00
Move GtkWidget::delete_event() impl from the shell to the window Still has a FIXME but is in the right place now at least
2009-09-25 18:48:30 +08:00
widget_class->delete_event = gimp_image_window_delete_event;
Move GtkWidget::configure_event() impl from the shell to the window Still has a FIXME for later, but is in the right place now.
2009-09-25 19:41:23 +08:00
widget_class->configure_event = gimp_image_window_configure_event;
Reindent static prototypes
2009-09-25 19:43:54 +08:00
widget_class->window_state_event = gimp_image_window_window_state_event;
app: implement GtkWidget::style_updated() instead of style_set()
2010-12-23 06:34:47 +08:00
widget_class->style_updated = gimp_image_window_style_updated;
Add menubar_manager member and "menu-factory" construct-only property Create the menubar_manager when the construct property is set, assert for its presence in constructor(). Pass the newly required construct property to g_object_new() in gimp_display_shell_new().
2009-09-23 18:47:25 +08:00
app: make sure GimpImageWindow notifies all its shells of monitor changes Call gimp_color_managed_profile_changed() on all newly added shells, and on all shells in GimpWindow::monitor_changed().
2014-03-14 05:34:16 +08:00
window_class->monitor_changed = gimp_image_window_monitor_changed;
app: Add "gimp" property to GimpImageWindow
2009-10-26 04:44:23 +08:00
g_object_class_install_property (object_class, PROP_GIMP,
g_param_spec_object ("gimp",
NULL, NULL,
GIMP_TYPE_GIMP,
GIMP_PARAM_WRITABLE |
G_PARAM_CONSTRUCT_ONLY));
Move the rc style string for the fullscreen menubar to GimpImageWindow
2009-09-23 21:53:16 +08:00
app: Cleanup GimpImageWindow and dependencies, only one dialog factory Cleanup GimpImageWindow and dependencies like GimpDisplay, there is only one dialog factory now.
2010-02-20 18:09:51 +08:00
g_object_class_install_property (object_class, PROP_DIALOG_FACTORY,
g_param_spec_object ("dialog-factory",
app: Add "dock-factory" property to GimpImageWindow With the introduction of a single-window mode, not only dock windows needs to be able to create docks, the image window also needs to. So give it a "dock-factory" property.
2009-12-09 02:49:13 +08:00
NULL, NULL,
GIMP_TYPE_DIALOG_FACTORY,
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
Port a lot of stuff from GdkScreen/monitor_number to GdkMonitor including some fixes for getting pointer coords, and needed API changes in libgimpwidgets.
2018-04-29 23:27:47 +08:00
g_object_class_install_property (object_class, PROP_INITIAL_MONITOR,
g_param_spec_object ("initial-monitor",
app: add screen and monitor to all display and image window constructors so they appear on the proper monitor as well.
2014-05-03 02:20:46 +08:00
NULL, NULL,
Port a lot of stuff from GdkScreen/monitor_number to GdkMonitor including some fixes for getting pointer coords, and needed API changes in libgimpwidgets.
2018-04-29 23:27:47 +08:00
GDK_TYPE_MONITOR,
app: add screen and monitor to all display and image window constructors so they appear on the proper monitor as well.
2014-05-03 02:20:46 +08:00
GIMP_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY));
Add new toplevel window class GimpImageWindow This one will be the toplevel where GimpDisplayShells live in once they are no toplevels any longer.
2009-09-23 18:24:22 +08:00
}
static void
gimp_image_window_init (GimpImageWindow *window)
{
Bug 595708 - WM_WINDOW_ROLE should be unique Make the roles of toolbox, dock and image window unique by adding a serial number, resulting in e.g. gimp-dock-1.
2012-10-08 00:16:35 +08:00
static gint role_serial = 1;
gchar *role;
role = g_strdup_printf ("gimp-image-window-%d", role_serial++);
gtk_window_set_role (GTK_WINDOW (window), role);
g_free (role);
Set the window role and "resizable" on GimpImageWindow, not on the shell
2009-09-24 15:18:19 +08:00
gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
Add new toplevel window class GimpImageWindow This one will be the toplevel where GimpDisplayShells live in once they are no toplevels any longer.
2009-09-23 18:24:22 +08:00
}
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
static void
gimp_image_window_dock_container_iface_init (GimpDockContainerInterface *iface)
{
app: add GimpDockContainer::get_dialog_factory() and use it where possible instead of gimp_dialog_factory_get_singleton(). Also reduce using this function in some other places.
2016-11-25 20:26:08 +08:00
iface->get_docks = gimp_image_window_get_docks;
iface->get_dialog_factory = gimp_image_window_dock_container_get_dialog_factory;
iface->get_ui_manager = gimp_image_window_dock_container_get_ui_manager;
iface->add_dock = gimp_image_window_add_dock;
iface->get_dock_side = gimp_image_window_get_dock_side;
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
}
static void
gimp_image_window_session_managed_iface_init (GimpSessionManagedInterface *iface)
{
iface->get_aux_info = gimp_image_window_get_aux_info;
iface->set_aux_info = gimp_image_window_set_aux_info;
}
app: some GimpImageWindow cleanup - implement GObject::constructed() instead of ::construct() - remove the display pause/resume idle hack because any tool drawing flickering is gone now by using cairo - some formatting cleanup - remove some unused local variables
2010-11-26 16:19:36 +08:00
static void
gimp_image_window_constructed (GObject *object)
Add menubar_manager member and "menu-factory" construct-only property Create the menubar_manager when the construct property is set, assert for its presence in constructor(). Pass the newly required construct property to g_object_new() in gimp_display_shell_new().
2009-09-23 18:47:25 +08:00
{
app: some GimpImageWindow cleanup - implement GObject::constructed() instead of ::construct() - remove the display pause/resume idle hack because any tool drawing flickering is gone now by using cairo - some formatting cleanup - remove some unused local variables
2010-11-26 16:19:36 +08:00
GimpImageWindow *window = GIMP_IMAGE_WINDOW (object);
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
app: prevent multiple registrations of a same action. Pre-GIMP-3.0 code logics would re-allocate several GimpMenuFactory or GimpUIManager for no good reason. While it was still working with old GtkAction code, with our new GAction-based code, we were ending up overriding an action with a new version of the same action, while keeping reference to old actions. This made for discrepancies of the enabled or visible state of actions. The new code keeps singleton of some objects and references to already registered GimpUIManager or GimpActionGroups objects and make sure no actions with the same name are created twice.
2023-03-08 01:23:38 +08:00
GimpUIManager *menubar_manager;
app: Add GimpDockColumns to the left and right of a GimpImageWindow
2009-10-04 08:02:39 +08:00
GimpGuiConfig *config;
display: Hook pad controllers into GimpImageWindow We have everything in place to create GtkPadControllers converting events into actions as configured in settings, and the signaling to trigger the (re)generation of those as device, window or configuration changes appear. Only the last bit attaching those controllers to actually handle input was missing, now done in this commit. Since there may be multiple configured tablets and pads, we need to keep track of per-device controllers to handle the configuration for those. This mapping is kept in GimpImageWindow as the "main" toplevel (i.e. the one(s) typically considered "keyboard focus" and receiving pad events) and ensured to be kept up-to-date through the ::configure-pad signal.
2023-06-14 03:45:10 +08:00
GimpDeviceManager *device_manager;
app: using GtkApplication menubar with GIMP_GTK_MENUBAR environment variable. Testing the 2 code paths is otherwise extremely annoying. Let's just add an environment variable allowing us to run one or the other implementation if the variable is set.
2023-03-07 05:16:51 +08:00
gboolean use_gtk_menubar = TRUE;
app, menus: add an application menu for systems which wants this. In particular on macOS, we want to show some default common actions (see comments in !837) but gtk_application_prefers_app_menu() docs says that it will always return FALSE on this OS. So we ignore this call on macOS.
2023-04-05 06:46:35 +08:00
gboolean use_app_menu = TRUE;
Add menubar_manager member and "menu-factory" construct-only property Create the menubar_manager when the construct property is set, assert for its presence in constructor(). Pass the newly required construct property to g_object_new() in gimp_display_shell_new().
2009-09-23 18:47:25 +08:00
GimpImageWindow: Chain up from constructed https://bugzilla.gnome.org/show_bug.cgi?id=751507
2015-06-26 01:33:50 +08:00
G_OBJECT_CLASS (parent_class)->constructed (object);
app: replace all g_assert() by the newly added gimp_assert() which is just a #define to g_assert for now, but can now easily be turned into something that does some nicer debugging using our new stack trace infrastructure. This commit also reverts all constructed() functions to use assert again.
2018-02-12 05:23:10 +08:00
gimp_assert (GIMP_IS_GIMP (private->gimp));
gimp_assert (GIMP_IS_DIALOG_FACTORY (private->dialog_factory));
app: get rid of including menus/ stuff from widgets/ and other places Add GimpMenuFactory can always be found in a GimpDialogManager, use gimp_dialog_factory_get_menu_factory() where we have a dialog factory instead of accessing "global_menu_factory" or redundantly passing a menu factory around where we already pass around a dialog factory.
2016-11-24 02:16:36 +08:00
app: Update Windows->Toolbox menu entry depending on if toolbox exists Update Windows->Toolbox menu entry depending on if toolbox exists. If an existing toolbox will be raised, set "Toolbox". If it will create a new toolbox, set "New Toolbox". We need this special treatment since there can be only one toolbox, so "New Toolbox" will remove any toolbox docks from Recently Closed Docks. If we would just have "Toolbox" it could be misinterpreted as "get me the toolbox I just closed".
2010-03-07 19:24:26 +08:00
g_signal_connect_object (private->dialog_factory, "dock-window-added",
G_CALLBACK (gimp_image_window_update_ui_manager),
window, G_CONNECT_SWAPPED);
g_signal_connect_object (private->dialog_factory, "dock-window-removed",
G_CALLBACK (gimp_image_window_update_ui_manager),
window, G_CONNECT_SWAPPED);
app: prevent multiple registrations of a same action. Pre-GIMP-3.0 code logics would re-allocate several GimpMenuFactory or GimpUIManager for no good reason. While it was still working with old GtkAction code, with our new GAction-based code, we were ending up overriding an action with a new version of the same action, while keeping reference to old actions. This made for discrepancies of the enabled or visible state of actions. The new code keeps singleton of some objects and references to already registered GimpUIManager or GimpActionGroups objects and make sure no actions with the same name are created twice.
2023-03-08 01:23:38 +08:00
menubar_manager = menus_get_image_manager_singleton (private->gimp);
g_signal_connect (menubar_manager, "show-tooltip",
Move the statusbar to GimpImageWindow As with the menubar, port some code properly, and add some horrible /* FIXME image window */ hacks to make it work.
2009-09-23 23:55:41 +08:00
G_CALLBACK (gimp_image_window_show_tooltip),
window);
app: prevent multiple registrations of a same action. Pre-GIMP-3.0 code logics would re-allocate several GimpMenuFactory or GimpUIManager for no good reason. While it was still working with old GtkAction code, with our new GAction-based code, we were ending up overriding an action with a new version of the same action, while keeping reference to old actions. This made for discrepancies of the enabled or visible state of actions. The new code keeps singleton of some objects and references to already registered GimpUIManager or GimpActionGroups objects and make sure no actions with the same name are created twice.
2023-03-08 01:23:38 +08:00
g_signal_connect (menubar_manager, "hide-tooltip",
Move the statusbar to GimpImageWindow As with the menubar, port some code properly, and add some horrible /* FIXME image window */ hacks to make it work.
2009-09-23 23:55:41 +08:00
G_CALLBACK (gimp_image_window_hide_tooltip),
window);
app: simplify config access in GimpImageWindow We have a "gimp" member, no need to go via factory->context->gimp.
2013-07-20 21:25:33 +08:00
config = GIMP_GUI_CONFIG (private->gimp->config);
app: Add GimpDockColumns to the left and right of a GimpImageWindow
2009-10-04 08:02:39 +08:00
/* Create the window toplevel container */
app: use gtk_box_new()
2011-09-30 17:29:11 +08:00
private->main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
gtk_container_add (GTK_CONTAINER (window), private->main_vbox);
gtk_widget_show (private->main_vbox);
Keep the main_vbox around in the GimpImageWindow struct (temp hack)
2009-09-23 21:46:44 +08:00
app: Add GimpDockColumns to the left and right of a GimpImageWindow
2009-10-04 08:02:39 +08:00
/* Create the menubar */
app: allow changing submenu's labels with gimp_menu_model_set_title(). Use this for the "View > Zoom" and "View > Flip & Rotate" submenus which used to display the zoom level and rotation angle. This regression is now fixed.
2023-04-17 21:24:26 +08:00
private->menubar_model = gimp_ui_manager_get_model (menubar_manager,
"/image-menubar");
app, menus: very early prototype for a GimpMenu. This demonstrates a first version of our replacing menu, using GAction and GMenuModel. I had to make our own subclass of GtkMenu to process the model (from a .ui XML file) for the following reasons: * gtk_menu_new_from_model() doesn't support tooltips, which is a feature we use quite extensively in GIMP: with all our filters, being able to give a longer description is often useful; moreover we use tooltips to give hints about why a menu item is deactivated as well. Unfortunately it looks like GTK doesn't consider this lack as a problem and don't plan on adding tooltip support. See: https://gitlab.gnome.org/GNOME/gtk/-/issues/785 * I won't to avoid copying action's label and icons in the .ui file. This only duplicates strings and would be a source of issues each time we change action's strings (we'd have to do it in 2 places, which someone will inevitably forget). Now it still has various issues: * The syncing between actions and menu items need to be cleaned up. It's still in early demo code. * It uses directly some Gtk*Action code because GimpRadioAction and GimpToggleAction are not directly related right now (only through their parents). * gtk_application_set_menubar() might still be necessary on macOS as I think it's what enables the native menu system on this OS. It means that we'll have to edit the menu model to add back the labels (as this function does not extract these from the linked action since GAction has no label or icon concept). * Icons are not taken into account right now. * I'll have to verify if GimpAction with proxy work (but my guess is that right now, it won't). * Action's active state is not synced with menu item active state right now. * Various actions are inserted live, such as opened images, opened views, recently opened images, and so on. This needs to be implemented back. * Plug-ins need to be able to create their own menu item into this new menu. * For all these various reasons, I'm keeping the old menu around, for the sake of comparison, until the time the new one becomes feature-full. Part of this commit is inspired by !558 and obsoletes this MR.
2023-02-07 20:59:20 +08:00
app: using GtkApplication menubar with GIMP_GTK_MENUBAR environment variable. Testing the 2 code paths is otherwise extremely annoying. Let's just add an environment variable allowing us to run one or the other implementation if the variable is set.
2023-03-07 05:16:51 +08:00
#ifndef GDK_WINDOWING_QUARTZ
/* macOS has its native menubar system, which is implemented by
* gtk_application_set_menubar(). Unfortunately the GTK menubar feature
* doesn't support tooltips (though for macOS, having "native" application
* menus was deemed worth the feature loss).
* As a special-case, we allow testing the GTK menubar through setting the
* environment variable GIMP_GTK_MENUBAR on non-macOS platforms.
app, menus: very early prototype for a GimpMenu. This demonstrates a first version of our replacing menu, using GAction and GMenuModel. I had to make our own subclass of GtkMenu to process the model (from a .ui XML file) for the following reasons: * gtk_menu_new_from_model() doesn't support tooltips, which is a feature we use quite extensively in GIMP: with all our filters, being able to give a longer description is often useful; moreover we use tooltips to give hints about why a menu item is deactivated as well. Unfortunately it looks like GTK doesn't consider this lack as a problem and don't plan on adding tooltip support. See: https://gitlab.gnome.org/GNOME/gtk/-/issues/785 * I won't to avoid copying action's label and icons in the .ui file. This only duplicates strings and would be a source of issues each time we change action's strings (we'd have to do it in 2 places, which someone will inevitably forget). Now it still has various issues: * The syncing between actions and menu items need to be cleaned up. It's still in early demo code. * It uses directly some Gtk*Action code because GimpRadioAction and GimpToggleAction are not directly related right now (only through their parents). * gtk_application_set_menubar() might still be necessary on macOS as I think it's what enables the native menu system on this OS. It means that we'll have to edit the menu model to add back the labels (as this function does not extract these from the linked action since GAction has no label or icon concept). * Icons are not taken into account right now. * I'll have to verify if GimpAction with proxy work (but my guess is that right now, it won't). * Action's active state is not synced with menu item active state right now. * Various actions are inserted live, such as opened images, opened views, recently opened images, and so on. This needs to be implemented back. * Plug-ins need to be able to create their own menu item into this new menu. * For all these various reasons, I'm keeping the old menu around, for the sake of comparison, until the time the new one becomes feature-full. Part of this commit is inspired by !558 and obsoletes this MR.
2023-02-07 20:59:20 +08:00
*/
app: using GtkApplication menubar with GIMP_GTK_MENUBAR environment variable. Testing the 2 code paths is otherwise extremely annoying. Let's just add an environment variable allowing us to run one or the other implementation if the variable is set.
2023-03-07 05:16:51 +08:00
use_gtk_menubar = (g_getenv ("GIMP_GTK_MENUBAR") != NULL);
Move the menubar and the menubar_manager to GimpImageWindow Also move some of their related code and update other code to go via gtk_widget_get_toplevel(), but also add some horrid temp /* FIXME image window */ hacks.
2009-09-23 22:58:03 +08:00
#endif /* !GDK_WINDOWING_QUARTZ */
app: using GtkApplication menubar with GIMP_GTK_MENUBAR environment variable. Testing the 2 code paths is otherwise extremely annoying. Let's just add an environment variable allowing us to run one or the other implementation if the variable is set.
2023-03-07 05:16:51 +08:00
if (use_gtk_menubar)
{
gtk_application_set_menubar (GTK_APPLICATION (private->gimp->app),
app: allow changing submenu's labels with gimp_menu_model_set_title(). Use this for the "View > Zoom" and "View > Flip & Rotate" submenus which used to display the zoom level and rotation angle. This regression is now fixed.
2023-04-17 21:24:26 +08:00
G_MENU_MODEL (private->menubar_model));
app: using GtkApplication menubar with GIMP_GTK_MENUBAR environment variable. Testing the 2 code paths is otherwise extremely annoying. Let's just add an environment variable allowing us to run one or the other implementation if the variable is set.
2023-03-07 05:16:51 +08:00
}
else
{
app: allow changing submenu's labels with gimp_menu_model_set_title(). Use this for the "View > Zoom" and "View > Flip & Rotate" submenus which used to display the zoom level and rotation angle. This regression is now fixed.
2023-04-17 21:24:26 +08:00
private->menubar = gimp_menu_bar_new (private->menubar_model, menubar_manager);
app: using GtkApplication menubar with GIMP_GTK_MENUBAR environment variable. Testing the 2 code paths is otherwise extremely annoying. Let's just add an environment variable allowing us to run one or the other implementation if the variable is set.
2023-03-07 05:16:51 +08:00
/* make sure we can activate accels even if the menubar is invisible
* (see https://bugzilla.gnome.org/show_bug.cgi?id=137151)
*/
g_signal_connect (private->menubar, "can-activate-accel",
G_CALLBACK (gtk_true),
NULL);
/* active display callback */
g_signal_connect (private->menubar, "button-press-event",
G_CALLBACK (gimp_image_window_shell_events),
window);
g_signal_connect (private->menubar, "button-release-event",
G_CALLBACK (gimp_image_window_shell_events),
window);
g_signal_connect (private->menubar, "key-press-event",
G_CALLBACK (gimp_image_window_shell_events),
window);
Issue #7172: option to apply Client-Side decoration on image windows. This patch does the following things: - An option "Merge menu and title bar" (this is hopefully more understandable than calling it "Client-side decoration" or again "header bar") is added in Preferences > Image Windows. This option triggers the restart warning. Moreover when checked a small warning message will tell that in some cases, it may not work (there are feedbacks of people having 2 title bars when using GTK applications using CSD). - For the reason evoked above (sometimes 2 title bars) and also because the CSD concept seem really to divide people a lot (some love this as much as others hate this), this new option "custom-title-bar" on GimpGuiConfig is FALSE by default. - When the option is checked, the image windows will use a GTK header bar containing the menu, the window title (image name and information) as well as the usual minimize/maximize/close buttons per your OS conventions. - Since the header bar is set to be hidden when maximizing, if you checked "Show menubar" for the "Default Appearance in Fullscreen Mode" in Preferences > Image Windows > Appearance, the menu will be moved to its "old style" position, i.e. above the canvas. This makes the menu possibly visible (if relevant option is checked) even in fullscreen mode. - I tweaked the Default theme to show the header bar with minimal height, because I find GTK default theme's headerbar height unreasonably high (especially if the point of the header bar is to save screen space). I am unsure if this was the right move though, because maybe the default theme should not do such choices (maybe this should go in the Compact theme?).
2023-06-10 01:56:33 +08:00
if (config->custom_title_bar)
{
GtkWidget *headerbar;
headerbar = gtk_header_bar_new ();
gtk_window_set_titlebar (GTK_WINDOW (window), headerbar);
/* This is important to turn off space reservation for the subtitle
* (resulting in too high header bar).
*/
gtk_header_bar_set_has_subtitle (GTK_HEADER_BAR (headerbar), FALSE);
gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (headerbar), TRUE);
gtk_header_bar_pack_start (GTK_HEADER_BAR (headerbar), private->menubar);
gtk_widget_show (headerbar);
/* XXX There are competing propositions on how the title should be
* aligned. GTK is trying to center it (relatively to the window) as
* much as it can. But some people seem to thing it should be centered
* relatively to the remaining empty space after the menu.
* I am personally unsure so leaving GTK's defaults for now.
*/
}
else
{
gtk_box_pack_start (GTK_BOX (private->main_vbox),
private->menubar, FALSE, FALSE, 0);
}
app: using GtkApplication menubar with GIMP_GTK_MENUBAR environment variable. Testing the 2 code paths is otherwise extremely annoying. Let's just add an environment variable allowing us to run one or the other implementation if the variable is set.
2023-03-07 05:16:51 +08:00
}
app, menus: add an application menu for systems which wants this. In particular on macOS, we want to show some default common actions (see comments in !837) but gtk_application_prefers_app_menu() docs says that it will always return FALSE on this OS. So we ignore this call on macOS.
2023-04-05 06:46:35 +08:00
#ifndef GDK_WINDOWING_QUARTZ
/* Docs says that macOS always returns FALSE but we actually want to create
* our custom macOS menu.
*/
use_app_menu = gtk_application_prefers_app_menu (GTK_APPLICATION (private->gimp->app));
#endif /* !GDK_WINDOWING_QUARTZ */
if (use_app_menu)
{
GimpUIManager *app_menu_manager;
GimpMenuModel *app_menu_model;
app_menu_manager = gimp_menu_factory_get_manager (menus_get_global_menu_factory (private->gimp),
"<AppMenu>", private->gimp);
app_menu_model = gimp_ui_manager_get_model (app_menu_manager, "/app-menu");
gtk_application_set_app_menu (GTK_APPLICATION (private->gimp->app),
G_MENU_MODEL (app_menu_model));
}
app: Add GimpDockColumns to the left and right of a GimpImageWindow
2009-10-04 08:02:39 +08:00
/* Create the hbox that contains docks and images */
app: use gtk_box_new()
2011-09-30 17:29:11 +08:00
private->hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
Add a central hbox for docks and display shells
2009-09-30 03:47:58 +08:00
gtk_box_pack_start (GTK_BOX (private->main_vbox), private->hbox,
TRUE, TRUE, 0);
gtk_widget_show (private->hbox);
app: Put docks in the image window in single-window mode in panes
2009-10-04 17:13:05 +08:00
/* Create the left pane */
libgimpwidgets: add gtk_paned_new() to gimp3migration.[ch] and use it all over the place.
2011-10-02 20:29:40 +08:00
private->left_hpane = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
app: set all GtkPaned widgets to have wide handles the narrow handles' event areas did overlap with our own widgets close to the handle.
2018-05-09 18:51:31 +08:00
gtk_paned_set_wide_handle (GTK_PANED (private->left_hpane), TRUE);
app: Put docks in the image window in single-window mode in panes
2009-10-04 17:13:05 +08:00
gtk_box_pack_start (GTK_BOX (private->hbox), private->left_hpane,
TRUE, TRUE, 0);
gtk_widget_show (private->left_hpane);
app: Add GimpDockColumns to the left and right of a GimpImageWindow
2009-10-04 08:02:39 +08:00
/* Create the left dock columns widget */
app: Add gimp_dock_columns_new() and GimpContext property Add and use gimp_dock_columns_new() and add a GimpContext property to GimpDockColumns. Also move the widget construction from _init() to _constructor() in GimpDockWindow so we have a context object to pass to gimp_dock_columns_new().
2010-01-08 02:13:13 +08:00
private->left_docks =
app: Add "dialog-factory", "ui-manager" properties to GimpDockColumns Add "dialog-factory", "ui-manager" properties to GimpDockColumns and let GimpDock look for these before trying to look for a dock window which does not exist in single-window mode.
2010-01-08 02:18:03 +08:00
gimp_dock_columns_new (gimp_get_user_context (private->gimp),
app: Cleanup GimpImageWindow and dependencies, only one dialog factory Cleanup GimpImageWindow and dependencies like GimpDisplay, there is only one dialog factory now.
2010-02-20 18:09:51 +08:00
private->dialog_factory,
app: prevent multiple registrations of a same action. Pre-GIMP-3.0 code logics would re-allocate several GimpMenuFactory or GimpUIManager for no good reason. While it was still working with old GtkAction code, with our new GAction-based code, we were ending up overriding an action with a new version of the same action, while keeping reference to old actions. This made for discrepancies of the enabled or visible state of actions. The new code keeps singleton of some objects and references to already registered GimpUIManager or GimpActionGroups objects and make sure no actions with the same name are created twice.
2023-03-08 01:23:38 +08:00
menubar_manager);
app: Put docks in the image window in single-window mode in panes
2009-10-04 17:13:05 +08:00
gtk_paned_pack1 (GTK_PANED (private->left_hpane), private->left_docks,
Bug 692900 - Dragging left canvas border doesn't respect dock borders Don't allow the single window's docks to shrink smaller than their requisition, because that's horribly broken.
2013-02-07 06:27:37 +08:00
FALSE, FALSE);
app: Update image window side docks visiblity from the image window Update image window side docks visiblity from the image window itself instead of from the ui configurer. The image window has a dependency to the config object anyway, so no need to complicate things.
2010-02-23 02:24:23 +08:00
gtk_widget_set_visible (private->left_docks, config->single_window_mode);
app: Add GimpDockColumns to the left and right of a GimpImageWindow
2009-10-04 08:02:39 +08:00
app: Put docks in the image window in single-window mode in panes
2009-10-04 17:13:05 +08:00
/* Create the right pane */
libgimpwidgets: add gtk_paned_new() to gimp3migration.[ch] and use it all over the place.
2011-10-02 20:29:40 +08:00
private->right_hpane = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
app: set all GtkPaned widgets to have wide handles the narrow handles' event areas did overlap with our own widgets close to the handle.
2018-05-09 18:51:31 +08:00
gtk_paned_set_wide_handle (GTK_PANED (private->right_hpane), TRUE);
app: Put docks in the image window in single-window mode in panes
2009-10-04 17:13:05 +08:00
gtk_paned_pack2 (GTK_PANED (private->left_hpane), private->right_hpane,
TRUE, FALSE);
gtk_widget_show (private->right_hpane);
app: Add GimpDockColumns to the left and right of a GimpImageWindow
2009-10-04 08:02:39 +08:00
/* Create notebook that contains images */
Add a notebook for the display shells
2009-09-30 03:57:57 +08:00
private->notebook = gtk_notebook_new ();
Bug 639305 - Image tabs pushes toolbox to left Set the notebook to scrollable. Not a final fix, but enough to fix the immediate problem.
2011-03-01 07:56:23 +08:00
gtk_notebook_set_scrollable (GTK_NOTEBOOK (private->notebook), TRUE);
Add a notebook for the display shells
2009-09-30 03:57:57 +08:00
gtk_notebook_set_show_border (GTK_NOTEBOOK (private->notebook), FALSE);
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (private->notebook), FALSE);
Bug 667169 - Single window mode: allow tabs position setting.
2013-09-15 18:56:17 +08:00
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (private->notebook), GTK_POS_TOP);
app: Put docks in the image window in single-window mode in panes
2009-10-04 17:13:05 +08:00
gtk_paned_pack1 (GTK_PANED (private->right_hpane), private->notebook,
TRUE, TRUE);
Revert "Bug 794356 - Rulers always shown for subsequent image views" This reverts commit ea48b9f31ca3460611530b6a8297386d9acdaf92. Final revert of GTK+2 hack.
2018-05-02 07:27:53 +08:00
g_signal_connect (private->notebook, "switch-page",
G_CALLBACK (gimp_image_window_switch_page),
window);
app: Connect to GtkNotebook::page-removed in GimpImageWindow We must disconnect from the last display shell when it is removed when rearranging the UI, so connect to GtkNotebook::page-removed in GimpImageWindow and do that.
2009-10-25 23:27:24 +08:00
g_signal_connect (private->notebook, "page-removed",
G_CALLBACK (gimp_image_window_page_removed),
window);
Bug 701090: allowing to reorder shell tabs by drag'n drop in single-window-mode.
2013-05-27 23:52:13 +08:00
g_signal_connect (private->notebook, "page-reordered",
G_CALLBACK (gimp_image_window_page_reordered),
window);
app: Add GimpDockColumns to the left and right of a GimpImageWindow
2009-10-04 08:02:39 +08:00
gtk_widget_show (private->notebook);
Merge the image window's active shell logic with the notebook's active page Add a GtkNotebook::switch_page() handler and move all shell switching code there. In gimp_image_window_set_active_shell(), simply set the right notebook page.
2009-09-30 04:14:10 +08:00
app: Add GimpDockColumns to the left and right of a GimpImageWindow
2009-10-04 08:02:39 +08:00
/* Create the right dock columns widget */
app: Add gimp_dock_columns_new() and GimpContext property Add and use gimp_dock_columns_new() and add a GimpContext property to GimpDockColumns. Also move the widget construction from _init() to _constructor() in GimpDockWindow so we have a context object to pass to gimp_dock_columns_new().
2010-01-08 02:13:13 +08:00
private->right_docks =
app: Add "dialog-factory", "ui-manager" properties to GimpDockColumns Add "dialog-factory", "ui-manager" properties to GimpDockColumns and let GimpDock look for these before trying to look for a dock window which does not exist in single-window mode.
2010-01-08 02:18:03 +08:00
gimp_dock_columns_new (gimp_get_user_context (private->gimp),
app: Cleanup GimpImageWindow and dependencies, only one dialog factory Cleanup GimpImageWindow and dependencies like GimpDisplay, there is only one dialog factory now.
2010-02-20 18:09:51 +08:00
private->dialog_factory,
app: prevent multiple registrations of a same action. Pre-GIMP-3.0 code logics would re-allocate several GimpMenuFactory or GimpUIManager for no good reason. While it was still working with old GtkAction code, with our new GAction-based code, we were ending up overriding an action with a new version of the same action, while keeping reference to old actions. This made for discrepancies of the enabled or visible state of actions. The new code keeps singleton of some objects and references to already registered GimpUIManager or GimpActionGroups objects and make sure no actions with the same name are created twice.
2023-03-08 01:23:38 +08:00
menubar_manager);
app: Put docks in the image window in single-window mode in panes
2009-10-04 17:13:05 +08:00
gtk_paned_pack2 (GTK_PANED (private->right_hpane), private->right_docks,
Bug 692900 - Dragging left canvas border doesn't respect dock borders Don't allow the single window's docks to shrink smaller than their requisition, because that's horribly broken.
2013-02-07 06:27:37 +08:00
FALSE, FALSE);
app: Update image window side docks visiblity from the image window Update image window side docks visiblity from the image window itself instead of from the ui configurer. The image window has a dependency to the config object anyway, so no need to complicate things.
2010-02-23 02:24:23 +08:00
gtk_widget_set_visible (private->right_docks, config->single_window_mode);
app: Add GimpDockColumns to the left and right of a GimpImageWindow
2009-10-04 08:02:39 +08:00
app: Update image window side docks visiblity from the image window Update image window side docks visiblity from the image window itself instead of from the ui configurer. The image window has a dependency to the config object anyway, so no need to complicate things.
2010-02-23 02:24:23 +08:00
g_signal_connect_object (config, "notify::single-window-mode",
G_CALLBACK (gimp_image_window_config_notify),
window, G_CONNECT_SWAPPED);
app: Add option in the windows menu to hide the image tab bar. (cherry picked from commit 360aee10d8cc0de55072f78095e064f2e35bd5df)
2018-10-18 21:47:30 +08:00
g_signal_connect_object (config, "notify::show-tabs",
G_CALLBACK (gimp_image_window_config_notify),
window, G_CONNECT_SWAPPED);
Bug 602223 - Can't hide docks with Tab in single-window mode Add a "hide-docks" config and connect the Windows->Hide docks menu item to it. Also connect the image window to the config property so it can hide/show its docks when it needs to. Also add and use a utility function gimp_image_window_keep_canvas_pos() to ensure that the image in the window remains fixed when toggling visiblity of docks. One problem: When GimpDrawTool is active on the canvas, there is flicker. The end position is correct though. Also add regression testing for this fix to test-ui.c
2010-02-24 03:21:08 +08:00
g_signal_connect_object (config, "notify::hide-docks",
G_CALLBACK (gimp_image_window_config_notify),
window, G_CONNECT_SWAPPED);
Bug 667169 - Single window mode: allow tabs position setting.
2013-09-15 18:56:17 +08:00
g_signal_connect_object (config, "notify::tabs-position",
G_CALLBACK (gimp_image_window_config_notify),
window, G_CONNECT_SWAPPED);
app: Session manage empty- and single-image window separately Session manage empty- and single-image window separately. So when starting up, the default 2.6 UI is the same. But when enabling single-window mode, the image window will become much larger then the empty-image window. These conceptually different windows will then from that point be session managed separately: switching mode switches size of the image window.
2010-03-13 23:35:57 +08:00
app: Call gimp_image_window_session_update() early Call gimp_image_window_session_update() at the end of gimp_image_window_constructed() so that if GIMP is closed right after being started, the image window session info has the widget initialized (and also so that the correct size is setup initially).
2011-05-14 23:08:01 +08:00
gimp_image_window_session_update (window,
NULL /*new_display*/,
app: make things behave more reasonable with multiple monitors There is now a preference option that determines whether windows should be opened on the same monitor as before. It should be disabled when the machine gets monitors plugged/unplugged dynamically ("laptop") and enabled when there is a static multi-monitor setup ("wokstation"). This is merely the current simplistic policy on top of the newly added underlying infrastructure: - pass integer monitor numbers around in all places where we already pass around a GdkScreen. Pass the "current" monitor to these changed APIs, where "current" is either the monitor where the action-triggering widget is, or if that is unavailable the monitor where the mouse is. - add gimp_widget_get_monitor() in order to easily get to the monitor, just like gtk_widget_get_screen(). - add screen and monitor parameters in some places that were missed before. - in sessionrc, save all window positions relative to the window's monitor, and save the monitor separately, if it's not the screen's primary monitor. - when restoring window positions, use the stored monitor when the new prefs options says so (use the screen's primary monitor if there is no stored monitor), otherwise use current monitor that is now passed around.
2014-05-02 09:01:23 +08:00
gimp_image_window_config_to_entry_id (config),
app: add screen and monitor to all display and image window constructors so they appear on the proper monitor as well.
2014-05-03 02:20:46 +08:00
private->initial_monitor);
display: Hook pad controllers into GimpImageWindow We have everything in place to create GtkPadControllers converting events into actions as configured in settings, and the signaling to trigger the (re)generation of those as device, window or configuration changes appear. Only the last bit attaching those controllers to actually handle input was missing, now done in this commit. Since there may be multiple configured tablets and pads, we need to keep track of per-device controllers to handle the configuration for those. This mapping is kept in GimpImageWindow as the "main" toplevel (i.e. the one(s) typically considered "keyboard focus" and receiving pad events) and ensured to be kept up-to-date through the ::configure-pad signal.
2023-06-14 03:45:10 +08:00
private->pad_controllers =
g_hash_table_new_full (NULL, NULL, NULL, g_object_unref);
device_manager = gimp_devices_get_manager (private->gimp);
g_signal_connect_object (device_manager, "configure-pad",
G_CALLBACK (gimp_image_window_configure_pad),
window, G_CONNECT_SWAPPED);
gimp_container_foreach (GIMP_CONTAINER (device_manager),
(GFunc) gimp_image_window_init_pad_foreach,
window);
Add menubar_manager member and "menu-factory" construct-only property Create the menubar_manager when the construct property is set, assert for its presence in constructor(). Pass the newly required construct property to g_object_new() in gimp_display_shell_new().
2009-09-23 18:47:25 +08:00
}
app: disconnect from the dialog factory in dispose() instead of finalize()
2010-06-24 19:00:16 +08:00
static void
gimp_image_window_dispose (GObject *object)
{
app: some GimpImageWindow cleanup - implement GObject::constructed() instead of ::construct() - remove the display pause/resume idle hack because any tool drawing flickering is gone now by using cairo - some formatting cleanup - remove some unused local variables
2010-11-26 16:19:36 +08:00
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (object);
app: disconnect from the dialog factory in dispose() instead of finalize()
2010-06-24 19:00:16 +08:00
if (private->dialog_factory)
{
g_signal_handlers_disconnect_by_func (private->dialog_factory,
gimp_image_window_update_ui_manager,
app: some GimpImageWindow cleanup - implement GObject::constructed() instead of ::construct() - remove the display pause/resume idle hack because any tool drawing flickering is gone now by using cairo - some formatting cleanup - remove some unused local variables
2010-11-26 16:19:36 +08:00
object);
app: disconnect from the dialog factory in dispose() instead of finalize()
2010-06-24 19:00:16 +08:00
private->dialog_factory = NULL;
}
app: defer image menu updates to an idle function In DEs which use a global menu, such as Unity, updating the menu can be expensive. This particularly affects canvas scaling and rotation, for which updating the menu synchronously causes notable lag.
2017-03-01 16:09:24 +08:00
if (private->update_ui_manager_idle_id)
{
g_source_remove (private->update_ui_manager_idle_id);
private->update_ui_manager_idle_id = 0;
}
display: Hook pad controllers into GimpImageWindow We have everything in place to create GtkPadControllers converting events into actions as configured in settings, and the signaling to trigger the (re)generation of those as device, window or configuration changes appear. Only the last bit attaching those controllers to actually handle input was missing, now done in this commit. Since there may be multiple configured tablets and pads, we need to keep track of per-device controllers to handle the configuration for those. This mapping is kept in GimpImageWindow as the "main" toplevel (i.e. the one(s) typically considered "keyboard focus" and receiving pad events) and ensured to be kept up-to-date through the ::configure-pad signal.
2023-06-14 03:45:10 +08:00
g_clear_pointer (&private->pad_controllers, g_hash_table_unref);
app: allow changing submenu's labels with gimp_menu_model_set_title(). Use this for the "View > Zoom" and "View > Flip & Rotate" submenus which used to display the zoom level and rotation angle. This regression is now fixed.
2023-04-17 21:24:26 +08:00
g_clear_object (&private->menubar_model);
app: disconnect from the dialog factory in dispose() instead of finalize()
2010-06-24 19:00:16 +08:00
G_OBJECT_CLASS (parent_class)->dispose (object);
}
Add new toplevel window class GimpImageWindow This one will be the toplevel where GimpDisplayShells live in once they are no toplevels any longer.
2009-09-23 18:24:22 +08:00
static void
gimp_image_window_finalize (GObject *object)
{
app: some GimpImageWindow cleanup - implement GObject::constructed() instead of ::construct() - remove the display pause/resume idle hack because any tool drawing flickering is gone now by using cairo - some formatting cleanup - remove some unused local variables
2010-11-26 16:19:36 +08:00
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (object);
Add new toplevel window class GimpImageWindow This one will be the toplevel where GimpDisplayShells live in once they are no toplevels any longer.
2009-09-23 18:24:22 +08:00
app: private->shells might be a list with one element upon destroy; free it
2010-06-23 05:03:30 +08:00
if (private->shells)
{
g_list_free (private->shells);
private->shells = NULL;
}
Add new toplevel window class GimpImageWindow This one will be the toplevel where GimpDisplayShells live in once they are no toplevels any longer.
2009-09-23 18:24:22 +08:00
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gimp_image_window_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
GimpImageWindow *window = GIMP_IMAGE_WINDOW (object);
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
Add new toplevel window class GimpImageWindow This one will be the toplevel where GimpDisplayShells live in once they are no toplevels any longer.
2009-09-23 18:24:22 +08:00
switch (property_id)
{
app: Add "gimp" property to GimpImageWindow
2009-10-26 04:44:23 +08:00
case PROP_GIMP:
private->gimp = g_value_get_object (value);
break;
app: Cleanup GimpImageWindow and dependencies, only one dialog factory Cleanup GimpImageWindow and dependencies like GimpDisplay, there is only one dialog factory now.
2010-02-20 18:09:51 +08:00
case PROP_DIALOG_FACTORY:
private->dialog_factory = g_value_get_object (value);
app: Add "dock-factory" property to GimpImageWindow With the introduction of a single-window mode, not only dock windows needs to be able to create docks, the image window also needs to. So give it a "dock-factory" property.
2009-12-09 02:49:13 +08:00
break;
app: add screen and monitor to all display and image window constructors so they appear on the proper monitor as well.
2014-05-03 02:20:46 +08:00
case PROP_INITIAL_MONITOR:
Port a lot of stuff from GdkScreen/monitor_number to GdkMonitor including some fixes for getting pointer coords, and needed API changes in libgimpwidgets.
2018-04-29 23:27:47 +08:00
private->initial_monitor = g_value_get_object (value);
app: add screen and monitor to all display and image window constructors so they appear on the proper monitor as well.
2014-05-03 02:20:46 +08:00
break;
Add menubar_manager member and "menu-factory" construct-only property Create the menubar_manager when the construct property is set, assert for its presence in constructor(). Pass the newly required construct property to g_object_new() in gimp_display_shell_new().
2009-09-23 18:47:25 +08:00
Add new toplevel window class GimpImageWindow This one will be the toplevel where GimpDisplayShells live in once they are no toplevels any longer.
2009-09-23 18:24:22 +08:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_image_window_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
GimpImageWindow *window = GIMP_IMAGE_WINDOW (object);
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
Add new toplevel window class GimpImageWindow This one will be the toplevel where GimpDisplayShells live in once they are no toplevels any longer.
2009-09-23 18:24:22 +08:00
switch (property_id)
{
app: Add "gimp" property to GimpImageWindow
2009-10-26 04:44:23 +08:00
case PROP_GIMP:
g_value_set_object (value, private->gimp);
break;
app: Cleanup GimpImageWindow and dependencies, only one dialog factory Cleanup GimpImageWindow and dependencies like GimpDisplay, there is only one dialog factory now.
2010-02-20 18:09:51 +08:00
case PROP_DIALOG_FACTORY:
g_value_set_object (value, private->dialog_factory);
app: Add "dock-factory" property to GimpImageWindow With the introduction of a single-window mode, not only dock windows needs to be able to create docks, the image window also needs to. So give it a "dock-factory" property.
2009-12-09 02:49:13 +08:00
break;
app: add screen and monitor to all display and image window constructors so they appear on the proper monitor as well.
2014-05-03 02:20:46 +08:00
case PROP_INITIAL_MONITOR:
Port a lot of stuff from GdkScreen/monitor_number to GdkMonitor including some fixes for getting pointer coords, and needed API changes in libgimpwidgets.
2018-04-29 23:27:47 +08:00
g_value_set_object (value, private->initial_monitor);
app: add screen and monitor to all display and image window constructors so they appear on the proper monitor as well.
2014-05-03 02:20:46 +08:00
break;
Add "display-factory" construct-only property of type GimpDialogFactory
2009-09-25 07:31:08 +08:00
Add new toplevel window class GimpImageWindow This one will be the toplevel where GimpDisplayShells live in once they are no toplevels any longer.
2009-09-23 18:24:22 +08:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
Move GtkWidget::delete_event() impl from the shell to the window Still has a FIXME but is in the right place now at least
2009-09-25 18:48:30 +08:00
static gboolean
gimp_image_window_delete_event (GtkWidget *widget,
GdkEventAny *event)
{
Bug 664584: WM DELETE event in single window mode is synonym to file-quit. In multi-window mode, closing an image window is only meant to close the current image (unless this is the last empty window). In single window mode though, you are meaning to close the whole program. Thanks to Niels Martignène for the original patch.
2013-05-11 08:04:33 +08:00
GimpImageWindow *window = GIMP_IMAGE_WINDOW (widget);
GimpDisplayShell *shell = gimp_image_window_get_active_shell (window);
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
app: simplify config access in GimpImageWindow We have a "gimp" member, no need to go via factory->context->gimp.
2013-07-20 21:25:33 +08:00
GimpGuiConfig *config = GIMP_GUI_CONFIG (private->gimp->config);
Move GtkWidget::delete_event() impl from the shell to the window Still has a FIXME but is in the right place now at least
2009-09-25 18:48:30 +08:00
Bug 664584: WM DELETE event in single window mode is synonym to file-quit. In multi-window mode, closing an image window is only meant to close the current image (unless this is the last empty window). In single window mode though, you are meaning to close the whole program. Thanks to Niels Martignène for the original patch.
2013-05-11 08:04:33 +08:00
if (config->single_window_mode)
app: prevent multiple registrations of a same action. Pre-GIMP-3.0 code logics would re-allocate several GimpMenuFactory or GimpUIManager for no good reason. While it was still working with old GtkAction code, with our new GAction-based code, we were ending up overriding an action with a new version of the same action, while keeping reference to old actions. This made for discrepancies of the enabled or visible state of actions. The new code keeps singleton of some objects and references to already registered GimpUIManager or GimpActionGroups objects and make sure no actions with the same name are created twice.
2023-03-08 01:23:38 +08:00
gimp_ui_manager_activate_action (menus_get_image_manager_singleton (private->gimp),
Bug 664584: WM DELETE event in single window mode is synonym to file-quit. In multi-window mode, closing an image window is only meant to close the current image (unless this is the last empty window). In single window mode though, you are meaning to close the whole program. Thanks to Niels Martignène for the original patch.
2013-05-11 08:04:33 +08:00
"file", "file-quit");
else if (shell)
app: Handle gimp_image_window_get_active_shell() returning NULL When rearranging the UI it is pretty common that gimp_image_window_get_active_shell() returns NULL so check for that.
2009-10-25 22:24:44 +08:00
gimp_display_shell_close (shell, FALSE);
Move GtkWidget::delete_event() impl from the shell to the window Still has a FIXME but is in the right place now at least
2009-09-25 18:48:30 +08:00
return TRUE;
}
Move GtkWidget::configure_event() impl from the shell to the window Still has a FIXME for later, but is in the right place now.
2009-09-25 19:41:23 +08:00
static gboolean
gimp_image_window_configure_event (GtkWidget *widget,
GdkEventConfigure *event)
{
Issue #3781 - Display artifacts on HiDPI when render cache is invalidated In GimpDisplayShell, scale the render cache by the window's scale factor, and render its content in device pixels, instead of scaled application pixels. When painting the cache to the screen, unscale the cairo context by the same factor, so that it's painted in the native resolution. Note that the various gimp_display_shell_render_foo() functions still speak in application pixels, and the scaling happens internally in gimp_display_shell_render(). Aside from rendering at native resolution on HiDPI, this also fixes an issue where grid-like display artifacts would appear when the render cache was not fully validated due to the non-native scaling.
2019-09-12 02:00:32 +08:00
GimpImageWindow *window = GIMP_IMAGE_WINDOW (widget);
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
GtkAllocation allocation;
gint current_width;
gint current_height;
gint scale_factor;
Move GtkWidget::configure_event() impl from the shell to the window Still has a FIXME for later, but is in the right place now.
2009-09-25 19:41:23 +08:00
Build with GSEAL_ENABLE and #undef it where accessors are missing
2009-10-18 01:51:33 +08:00
gtk_widget_get_allocation (widget, &allocation);
Move GtkWidget::configure_event() impl from the shell to the window Still has a FIXME for later, but is in the right place now.
2009-09-25 19:41:23 +08:00
/* Grab the size before we run the parent implementation */
Build with GSEAL_ENABLE and #undef it where accessors are missing
2009-10-18 01:51:33 +08:00
current_width = allocation.width;
current_height = allocation.height;
Move GtkWidget::configure_event() impl from the shell to the window Still has a FIXME for later, but is in the right place now.
2009-09-25 19:41:23 +08:00
/* Run the parent implementation */
if (GTK_WIDGET_CLASS (parent_class)->configure_event)
GTK_WIDGET_CLASS (parent_class)->configure_event (widget, event);
/* If the window size has changed, make sure additoinal logic is run
* in the display shell's size-allocate
*/
if (event->width != current_width ||
event->height != current_height)
{
/* FIXME multiple shells */
Change GimpImageWindow API to speak in shells, not displays A widget container should keep around child widgets, not whatever objects that just have widgets.
2009-09-29 04:53:31 +08:00
GimpDisplayShell *shell = gimp_image_window_get_active_shell (window);
Move GtkWidget::configure_event() impl from the shell to the window Still has a FIXME for later, but is in the right place now.
2009-09-25 19:41:23 +08:00
app: Handle gimp_image_window_get_active_shell() returning NULL When rearranging the UI it is pretty common that gimp_image_window_get_active_shell() returns NULL so check for that.
2009-10-25 22:24:44 +08:00
if (shell && gimp_display_get_image (shell->display))
Change GimpImageWindow API to speak in shells, not displays A widget container should keep around child widgets, not whatever objects that just have widgets.
2009-09-29 04:53:31 +08:00
shell->size_allocate_from_configure_event = TRUE;
Move GtkWidget::configure_event() impl from the shell to the window Still has a FIXME for later, but is in the right place now.
2009-09-25 19:41:23 +08:00
}
Issue #3781 - Display artifacts on HiDPI when render cache is invalidated In GimpDisplayShell, scale the render cache by the window's scale factor, and render its content in device pixels, instead of scaled application pixels. When painting the cache to the screen, unscale the cairo context by the same factor, so that it's painted in the native resolution. Note that the various gimp_display_shell_render_foo() functions still speak in application pixels, and the scaling happens internally in gimp_display_shell_render(). Aside from rendering at native resolution on HiDPI, this also fixes an issue where grid-like display artifacts would appear when the render cache was not fully validated due to the non-native scaling.
2019-09-12 02:00:32 +08:00
scale_factor = gdk_window_get_scale_factor (gtk_widget_get_window (widget));
if (scale_factor != private->scale_factor)
{
GList *list;
private->scale_factor = scale_factor;
for (list = private->shells; list; list = g_list_next (list))
{
GimpDisplayShell *shell = list->data;
gimp_display_shell_render_set_scale (shell, scale_factor);
gimp_display_shell_expose_full (shell);
}
}
Move GtkWidget::configure_event() impl from the shell to the window Still has a FIXME for later, but is in the right place now.
2009-09-25 19:41:23 +08:00
return TRUE;
}
app: Hide CSD when going fullscreen By default, GTK keeps on showing client-side decorations when going fullscreen, as it might contain buttons or other functionality that would be lost. As such, we have to make sure we hide the titlebar. Getting to that titlebar to update its "visible" property needs a bit of effort, since it's an internal child of the GtkWindow that isn't exposed in any way, so we take a little detour using `gtk_container_forall()`.
2021-01-01 18:15:25 +08:00
static void
gimp_image_window_update_csd_on_fullscreen (GtkWidget *child,
gpointer user_data)
{
Issue #7172: option to apply Client-Side decoration on image windows. This patch does the following things: - An option "Merge menu and title bar" (this is hopefully more understandable than calling it "Client-side decoration" or again "header bar") is added in Preferences > Image Windows. This option triggers the restart warning. Moreover when checked a small warning message will tell that in some cases, it may not work (there are feedbacks of people having 2 title bars when using GTK applications using CSD). - For the reason evoked above (sometimes 2 title bars) and also because the CSD concept seem really to divide people a lot (some love this as much as others hate this), this new option "custom-title-bar" on GimpGuiConfig is FALSE by default. - When the option is checked, the image windows will use a GTK header bar containing the menu, the window title (image name and information) as well as the usual minimize/maximize/close buttons per your OS conventions. - Since the header bar is set to be hidden when maximizing, if you checked "Show menubar" for the "Default Appearance in Fullscreen Mode" in Preferences > Image Windows > Appearance, the menu will be moved to its "old style" position, i.e. above the canvas. This makes the menu possibly visible (if relevant option is checked) even in fullscreen mode. - I tweaked the Default theme to show the header bar with minimal height, because I find GTK default theme's headerbar height unreasonably high (especially if the point of the header bar is to save screen space). I am unsure if this was the right move though, because maybe the default theme should not do such choices (maybe this should go in the Compact theme?).
2023-06-10 01:56:33 +08:00
GimpImageWindow *window = GIMP_IMAGE_WINDOW (user_data);
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
gboolean fullscreen;
fullscreen = gimp_image_window_get_fullscreen (window);
app: Hide CSD when going fullscreen By default, GTK keeps on showing client-side decorations when going fullscreen, as it might contain buttons or other functionality that would be lost. As such, we have to make sure we hide the titlebar. Getting to that titlebar to update its "visible" property needs a bit of effort, since it's an internal child of the GtkWindow that isn't exposed in any way, so we take a little detour using `gtk_container_forall()`.
2021-01-01 18:15:25 +08:00
if (GTK_IS_HEADER_BAR (child))
Issue #7172: option to apply Client-Side decoration on image windows. This patch does the following things: - An option "Merge menu and title bar" (this is hopefully more understandable than calling it "Client-side decoration" or again "header bar") is added in Preferences > Image Windows. This option triggers the restart warning. Moreover when checked a small warning message will tell that in some cases, it may not work (there are feedbacks of people having 2 title bars when using GTK applications using CSD). - For the reason evoked above (sometimes 2 title bars) and also because the CSD concept seem really to divide people a lot (some love this as much as others hate this), this new option "custom-title-bar" on GimpGuiConfig is FALSE by default. - When the option is checked, the image windows will use a GTK header bar containing the menu, the window title (image name and information) as well as the usual minimize/maximize/close buttons per your OS conventions. - Since the header bar is set to be hidden when maximizing, if you checked "Show menubar" for the "Default Appearance in Fullscreen Mode" in Preferences > Image Windows > Appearance, the menu will be moved to its "old style" position, i.e. above the canvas. This makes the menu possibly visible (if relevant option is checked) even in fullscreen mode. - I tweaked the Default theme to show the header bar with minimal height, because I find GTK default theme's headerbar height unreasonably high (especially if the point of the header bar is to save screen space). I am unsure if this was the right move though, because maybe the default theme should not do such choices (maybe this should go in the Compact theme?).
2023-06-10 01:56:33 +08:00
{
gtk_widget_set_visible (child, !fullscreen);
/* When we manage the menubar ourselves (i.e. not when using the GTK
* menubar, e.g. on macOS), if the menubar was set to stay visible in
* fullscreen mode, we need to move it out of the header bar.
* Note that here we only move the menubar from one parent to another.
* This is not where we handle whether we make it visible or not.
*/
if (private->menubar)
{
GtkWidget *parent = gtk_widget_get_parent (private->menubar);
g_object_ref (private->menubar);
gtk_container_remove (GTK_CONTAINER (parent), private->menubar);
if (fullscreen)
{
gtk_box_pack_start (GTK_BOX (private->main_vbox),
private->menubar, FALSE, FALSE, 0);
gtk_box_reorder_child (GTK_BOX (private->main_vbox),
private->menubar, 0);
}
else
{
gtk_header_bar_pack_start (GTK_HEADER_BAR (child), private->menubar);
}
g_object_unref (private->menubar);
}
}
app: Hide CSD when going fullscreen By default, GTK keeps on showing client-side decorations when going fullscreen, as it might contain buttons or other functionality that would be lost. As such, we have to make sure we hide the titlebar. Getting to that titlebar to update its "visible" property needs a bit of effort, since it's an internal child of the GtkWindow that isn't exposed in any way, so we take a little detour using `gtk_container_forall()`.
2021-01-01 18:15:25 +08:00
}
Add GtkWidget::window_state_event() implementation to GimpImageWindow Keep an own window_state member around and update it accordingly. Chain up in GimpDisplayShell's window_state_event() impl.
2009-09-23 19:40:52 +08:00
static gboolean
Reindent static prototypes
2009-09-25 19:43:54 +08:00
gimp_image_window_window_state_event (GtkWidget *widget,
GdkEventWindowState *event)
Add GtkWidget::window_state_event() implementation to GimpImageWindow Keep an own window_state member around and update it accordingly. Chain up in GimpDisplayShell's window_state_event() impl.
2009-09-23 19:40:52 +08:00
{
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
GimpImageWindow *window = GIMP_IMAGE_WINDOW (widget);
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
GimpDisplayShell *shell = gimp_image_window_get_active_shell (window);
Add GtkWidget::window_state_event() implementation to GimpImageWindow Keep an own window_state member around and update it accordingly. Chain up in GimpDisplayShell's window_state_event() impl.
2009-09-23 19:40:52 +08:00
app: call parent's window_state_event() from GimpImageWindow Fixes #6883
2021-05-18 00:20:47 +08:00
/* Run the parent implementation */
if (GTK_WIDGET_CLASS (parent_class)->window_state_event)
GTK_WIDGET_CLASS (parent_class)->window_state_event (widget, event);
app: Handle gimp_image_window_get_active_shell() returning NULL When rearranging the UI it is pretty common that gimp_image_window_get_active_shell() returns NULL so check for that.
2009-10-25 22:24:44 +08:00
if (! shell)
return FALSE;
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
private->window_state = event->new_window_state;
Add GtkWidget::window_state_event() implementation to GimpImageWindow Keep an own window_state member around and update it accordingly. Chain up in GimpDisplayShell's window_state_event() impl.
2009-09-23 19:40:52 +08:00
Move the fullscreen API from GimpDisplayShell to GimpImageWindow Also remove GimpDisplayShell's "window_state" member. Use gtk_widget_get_toplvel() to get to the GimpImageWindow when we need a display shell's fullscreen state.
2009-09-23 20:52:33 +08:00
if (event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN)
{
Move updating the "view-fullscreen" actions to the proper place Update the actions in gimp_display_shell_appearance_update() and remove all action code from the window-state-event handlers.
2009-09-25 20:06:14 +08:00
gboolean fullscreen = gimp_image_window_get_fullscreen (window);
Move the fullscreen API from GimpDisplayShell to GimpImageWindow Also remove GimpDisplayShell's "window_state" member. Use gtk_widget_get_toplvel() to get to the GimpImageWindow when we need a display shell's fullscreen state.
2009-09-23 20:52:33 +08:00
GIMP_LOG (WM, "Image window '%s' [%p] set fullscreen %s",
gtk_window_get_title (GTK_WINDOW (widget)),
widget,
Bug 684785 - typo in log message Apply patch from Okano Takayoshi that fixes the typo.
2012-09-26 04:01:31 +08:00
fullscreen ? "TRUE" : "FALSE");
Move the fullscreen API from GimpDisplayShell to GimpImageWindow Also remove GimpDisplayShell's "window_state" member. Use gtk_widget_get_toplvel() to get to the GimpImageWindow when we need a display shell's fullscreen state.
2009-09-23 20:52:33 +08:00
app: fix image position when entering/leaving fullscreen mode Call the suspend()/resume() from the previous commit around gimp_display_shell_appearance_update() so the cancas is not repositioned for each individual widget configuration.
2016-01-11 08:55:14 +08:00
gimp_image_window_suspend_keep_pos (window);
Change GimpImageWindow API to speak in shells, not displays A widget container should keep around child widgets, not whatever objects that just have widgets.
2009-09-29 04:53:31 +08:00
gimp_display_shell_appearance_update (shell);
app: fix image position when entering/leaving fullscreen mode Call the suspend()/resume() from the previous commit around gimp_display_shell_appearance_update() so the cancas is not repositioned for each individual widget configuration.
2016-01-11 08:55:14 +08:00
gimp_image_window_resume_keep_pos (window);
app: Hide CSD when going fullscreen By default, GTK keeps on showing client-side decorations when going fullscreen, as it might contain buttons or other functionality that would be lost. As such, we have to make sure we hide the titlebar. Getting to that titlebar to update its "visible" property needs a bit of effort, since it's an internal child of the GtkWindow that isn't exposed in any way, so we take a little detour using `gtk_container_forall()`.
2021-01-01 18:15:25 +08:00
/* When using CSD (for example in Wayland), our title bar stays visible
* when going fullscreen by default. There is no getter for it and it's
* an internal child, so we use this workaround instead */
gtk_container_forall (GTK_CONTAINER (window),
gimp_image_window_update_csd_on_fullscreen,
Issue #7172: option to apply Client-Side decoration on image windows. This patch does the following things: - An option "Merge menu and title bar" (this is hopefully more understandable than calling it "Client-side decoration" or again "header bar") is added in Preferences > Image Windows. This option triggers the restart warning. Moreover when checked a small warning message will tell that in some cases, it may not work (there are feedbacks of people having 2 title bars when using GTK applications using CSD). - For the reason evoked above (sometimes 2 title bars) and also because the CSD concept seem really to divide people a lot (some love this as much as others hate this), this new option "custom-title-bar" on GimpGuiConfig is FALSE by default. - When the option is checked, the image windows will use a GTK header bar containing the menu, the window title (image name and information) as well as the usual minimize/maximize/close buttons per your OS conventions. - Since the header bar is set to be hidden when maximizing, if you checked "Show menubar" for the "Default Appearance in Fullscreen Mode" in Preferences > Image Windows > Appearance, the menu will be moved to its "old style" position, i.e. above the canvas. This makes the menu possibly visible (if relevant option is checked) even in fullscreen mode. - I tweaked the Default theme to show the header bar with minimal height, because I find GTK default theme's headerbar height unreasonably high (especially if the point of the header bar is to save screen space). I am unsure if this was the right move though, because maybe the default theme should not do such choices (maybe this should go in the Compact theme?).
2023-06-10 01:56:33 +08:00
window);
Move the fullscreen API from GimpDisplayShell to GimpImageWindow Also remove GimpDisplayShell's "window_state" member. Use gtk_widget_get_toplvel() to get to the GimpImageWindow when we need a display shell's fullscreen state.
2009-09-23 20:52:33 +08:00
}
if (event->changed_mask & GDK_WINDOW_STATE_ICONIFIED)
{
Move the statusbar back to GimpDisplayShell Keeping it in GimpImageWindow was a bad idea because - it wasted space - it produced evil code because - it conceptually didn't belong there
2009-10-04 21:31:38 +08:00
GimpStatusbar *statusbar = gimp_display_shell_get_statusbar (shell);
gboolean iconified = gimp_image_window_is_iconified (window);
Move the fullscreen API from GimpDisplayShell to GimpImageWindow Also remove GimpDisplayShell's "window_state" member. Use gtk_widget_get_toplvel() to get to the GimpImageWindow when we need a display shell's fullscreen state.
2009-09-23 20:52:33 +08:00
GIMP_LOG (WM, "Image window '%s' [%p] set %s",
gtk_window_get_title (GTK_WINDOW (widget)),
widget,
iconified ? "iconified" : "uniconified");
Move more window managing code to GimpImageWindow Move the code that (de)iconifies the docks together with an empty image window from GimpDisplayShell to GimpImageWindow.
2009-09-23 21:05:00 +08:00
if (iconified)
{
app: simplify config access in GimpImageWindow We have a "gimp" member, no need to go via factory->context->gimp.
2013-07-20 21:25:33 +08:00
if (gimp_displays_get_num_visible (private->gimp) == 0)
Move more window managing code to GimpImageWindow Move the code that (de)iconifies the docks together with an empty image window from GimpDisplayShell to GimpImageWindow.
2009-09-23 21:05:00 +08:00
{
GIMP_LOG (WM, "No displays visible any longer");
app: Store GimpDialogsState per dialog factory Get rid of the file-static variable 'dialogs_state' from gimpdialogfactory.c and move it into the GimpDialogFactory struct.
2010-03-01 01:48:16 +08:00
gimp_dialog_factory_hide_with_display (private->dialog_factory);
Move more window managing code to GimpImageWindow Move the code that (de)iconifies the docks together with an empty image window from GimpDisplayShell to GimpImageWindow.
2009-09-23 21:05:00 +08:00
}
}
else
{
app: Store GimpDialogsState per dialog factory Get rid of the file-static variable 'dialogs_state' from gimpdialogfactory.c and move it into the GimpDialogFactory struct.
2010-03-01 01:48:16 +08:00
gimp_dialog_factory_show_with_display (private->dialog_factory);
Move more window managing code to GimpImageWindow Move the code that (de)iconifies the docks together with an empty image window from GimpDisplayShell to GimpImageWindow.
2009-09-23 21:05:00 +08:00
}
Move the statusbar back to GimpDisplayShell Keeping it in GimpImageWindow was a bad idea because - it wasted space - it produced evil code because - it conceptually didn't belong there
2009-10-04 21:31:38 +08:00
if (gimp_progress_is_active (GIMP_PROGRESS (statusbar)))
Add gimp_statusbar_override/restore_window_title() Which sets/unsets the title of an iconified toplevel image window to the current progress message (if any). Use the new functions when the window is (de)iconified. Not exactly the high art of programming, but much better than the hacks in gimpdisplayshell-progress.c that are now removed.
2009-09-26 01:35:03 +08:00
{
if (iconified)
gimp_statusbar_override_window_title (statusbar);
else
gtk_window_set_title (GTK_WINDOW (window), shell->title);
}
Move the fullscreen API from GimpDisplayShell to GimpImageWindow Also remove GimpDisplayShell's "window_state" member. Use gtk_widget_get_toplvel() to get to the GimpImageWindow when we need a display shell's fullscreen state.
2009-09-23 20:52:33 +08:00
}
Add GtkWidget::window_state_event() implementation to GimpImageWindow Keep an own window_state member around and update it accordingly. Chain up in GimpDisplayShell's window_state_event() impl.
2009-09-23 19:40:52 +08:00
return FALSE;
}
Move the GtkWidget::style_set() handler to GimpImageWindow ...and remove it from GimpDisplayShell completely.
2009-09-24 00:13:08 +08:00
static void
app: implement GtkWidget::style_updated() instead of style_set()
2010-12-23 06:34:47 +08:00
gimp_image_window_style_updated (GtkWidget *widget)
Move the GtkWidget::style_set() handler to GimpImageWindow ...and remove it from GimpDisplayShell completely.
2009-09-24 00:13:08 +08:00
{
app: Handle gimp_image_window_get_active_shell() returning NULL When rearranging the UI it is pretty common that gimp_image_window_get_active_shell() returns NULL so check for that.
2009-10-25 22:24:44 +08:00
GimpImageWindow *window = GIMP_IMAGE_WINDOW (widget);
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
GimpDisplayShell *shell = gimp_image_window_get_active_shell (window);
GimpStatusbar *statusbar = NULL;
GtkRequisition requisition = { 0, };
GdkGeometry geometry = { 0, };
GdkWindowHints geometry_mask = 0;
Move the GtkWidget::style_set() handler to GimpImageWindow ...and remove it from GimpDisplayShell completely.
2009-09-24 00:13:08 +08:00
app: implement GtkWidget::style_updated() instead of style_set()
2010-12-23 06:34:47 +08:00
GTK_WIDGET_CLASS (parent_class)->style_updated (widget);
Move the GtkWidget::style_set() handler to GimpImageWindow ...and remove it from GimpDisplayShell completely.
2009-09-24 00:13:08 +08:00
app: Handle gimp_image_window_get_active_shell() returning NULL When rearranging the UI it is pretty common that gimp_image_window_get_active_shell() returns NULL so check for that.
2009-10-25 22:24:44 +08:00
if (! shell)
return;
statusbar = gimp_display_shell_get_statusbar (shell);
app: use gtk_widget_get_preferred_size() instead of size_request()
2010-10-19 18:11:59 +08:00
gtk_widget_get_preferred_size (GTK_WIDGET (statusbar), &requisition, NULL);
Move the GtkWidget::style_set() handler to GimpImageWindow ...and remove it from GimpDisplayShell completely.
2009-09-24 00:13:08 +08:00
geometry.min_height = 23;
geometry.min_width = requisition.width;
geometry.min_height += requisition.height;
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
if (private->menubar)
Move the GtkWidget::style_set() handler to GimpImageWindow ...and remove it from GimpDisplayShell completely.
2009-09-24 00:13:08 +08:00
{
app: use gtk_widget_get_preferred_size() instead of size_request()
2010-10-19 18:11:59 +08:00
gtk_widget_get_preferred_size (private->menubar, &requisition, NULL);
Move the GtkWidget::style_set() handler to GimpImageWindow ...and remove it from GimpDisplayShell completely.
2009-09-24 00:13:08 +08:00
geometry.min_height += requisition.height;
}
geometry_mask = GDK_HINT_MIN_SIZE;
/* Only set user pos on the empty display because it gets a pos
* set by gimp. All other displays should be placed by the window
Change a bazillion URLs to https:// Including all user-visible link and links called from code, like the help pages.
2018-07-14 20:13:22 +08:00
* manager. See https://bugzilla.gnome.org/show_bug.cgi?id=559580
Move the GtkWidget::style_set() handler to GimpImageWindow ...and remove it from GimpDisplayShell completely.
2009-09-24 00:13:08 +08:00
*/
Use gimp_display_get_image() instead of display->image
2009-10-07 01:20:44 +08:00
if (! gimp_display_get_image (shell->display))
Move the GtkWidget::style_set() handler to GimpImageWindow ...and remove it from GimpDisplayShell completely.
2009-09-24 00:13:08 +08:00
geometry_mask |= GDK_HINT_USER_POS;
gtk_window_set_geometry_hints (GTK_WINDOW (widget), NULL,
&geometry, geometry_mask);
gimp_dialog_factory_set_has_min_size (GTK_WINDOW (widget), TRUE);
}
app: make sure GimpImageWindow notifies all its shells of monitor changes Call gimp_color_managed_profile_changed() on all newly added shells, and on all shells in GimpWindow::monitor_changed().
2014-03-14 05:34:16 +08:00
static void
gimp_image_window_monitor_changed (GimpWindow *window,
Port a lot of stuff from GdkScreen/monitor_number to GdkMonitor including some fixes for getting pointer coords, and needed API changes in libgimpwidgets.
2018-04-29 23:27:47 +08:00
GdkMonitor *monitor)
app: make sure GimpImageWindow notifies all its shells of monitor changes Call gimp_color_managed_profile_changed() on all newly added shells, and on all shells in GimpWindow::monitor_changed().
2014-03-14 05:34:16 +08:00
{
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
GList *list;
for (list = private->shells; list; list = g_list_next (list))
{
app: update GimpDisplayShell's monitor resolution when changing monitors so the image size adapts when dot-for-dot is off.
2014-05-03 23:16:54 +08:00
/* hack, this should live here, and screen_changed call
* monitor_changed
*/
g_signal_emit_by_name (list->data, "screen-changed",
gtk_widget_get_screen (list->data));
/* make it fetch the new monitor's resolution */
app: move gimp_display_shell_scale_changed() to gimpdisplayshell-scale.[ch] and rename it to gimp_display_shell_scale_update().
2016-01-06 01:48:22 +08:00
gimp_display_shell_scale_update (GIMP_DISPLAY_SHELL (list->data));
app: update GimpDisplayShell's monitor resolution when changing monitors so the image size adapts when dot-for-dot is off.
2014-05-03 23:16:54 +08:00
app: make sure GimpImageWindow notifies all its shells of monitor changes Call gimp_color_managed_profile_changed() on all newly added shells, and on all shells in GimpWindow::monitor_changed().
2014-03-14 05:34:16 +08:00
/* make it fetch the right monitor profile */
gimp_color_managed_profile_changed (GIMP_COLOR_MANAGED (list->data));
}
}
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
static GList *
gimp_image_window_get_docks (GimpDockContainer *dock_container)
{
GimpImageWindowPrivate *private;
GList *iter;
GList *all_docks = NULL;
g_return_val_if_fail (GIMP_IS_IMAGE_WINDOW (dock_container), FALSE);
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (dock_container);
for (iter = gimp_dock_columns_get_docks (GIMP_DOCK_COLUMNS (private->left_docks));
iter;
iter = g_list_next (iter))
{
all_docks = g_list_append (all_docks, GIMP_DOCK (iter->data));
}
for (iter = gimp_dock_columns_get_docks (GIMP_DOCK_COLUMNS (private->right_docks));
iter;
iter = g_list_next (iter))
{
all_docks = g_list_append (all_docks, GIMP_DOCK (iter->data));
}
return all_docks;
}
app: add GimpDockContainer::get_dialog_factory() and use it where possible instead of gimp_dialog_factory_get_singleton(). Also reduce using this function in some other places.
2016-11-25 20:26:08 +08:00
static GimpDialogFactory *
gimp_image_window_dock_container_get_dialog_factory (GimpDockContainer *dock_container)
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
{
app: add GimpDockContainer::get_dialog_factory() and use it where possible instead of gimp_dialog_factory_get_singleton(). Also reduce using this function in some other places.
2016-11-25 20:26:08 +08:00
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (dock_container);
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
app: add GimpDockContainer::get_dialog_factory() and use it where possible instead of gimp_dialog_factory_get_singleton(). Also reduce using this function in some other places.
2016-11-25 20:26:08 +08:00
return private->dialog_factory;
}
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
app: add GimpDockContainer::get_dialog_factory() and use it where possible instead of gimp_dialog_factory_get_singleton(). Also reduce using this function in some other places.
2016-11-25 20:26:08 +08:00
static GimpUIManager *
gimp_image_window_dock_container_get_ui_manager (GimpDockContainer *dock_container)
{
GimpImageWindow *window = GIMP_IMAGE_WINDOW (dock_container);
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
app: prevent multiple registrations of a same action. Pre-GIMP-3.0 code logics would re-allocate several GimpMenuFactory or GimpUIManager for no good reason. While it was still working with old GtkAction code, with our new GAction-based code, we were ending up overriding an action with a new version of the same action, while keeping reference to old actions. This made for discrepancies of the enabled or visible state of actions. The new code keeps singleton of some objects and references to already registered GimpUIManager or GimpActionGroups objects and make sure no actions with the same name are created twice.
2023-03-08 01:23:38 +08:00
return menus_get_image_manager_singleton (GIMP_IMAGE_WINDOW_GET_PRIVATE (window)->gimp);
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
}
void
gimp_image_window_add_dock (GimpDockContainer *dock_container,
GimpDock *dock,
GimpSessionInfoDock *dock_info)
{
app: Update appearance after adding dock Since gimp_display_shell_appearance_update() depends on docks being present, call it in gimp_image_window_add_dock(). Otherwise the resize handle will be present when starting in single-window mode.
2011-06-06 21:50:32 +08:00
GimpImageWindow *window;
GimpDisplayShell *active_shell;
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
GimpImageWindowPrivate *private;
g_return_if_fail (GIMP_IS_IMAGE_WINDOW (dock_container));
app: Update appearance after adding dock Since gimp_display_shell_appearance_update() depends on docks being present, call it in gimp_image_window_add_dock(). Otherwise the resize handle will be present when starting in single-window mode.
2011-06-06 21:50:32 +08:00
window = GIMP_IMAGE_WINDOW (dock_container);
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
if (dock_info->side == GIMP_ALIGN_LEFT)
{
gimp_dock_columns_add_dock (GIMP_DOCK_COLUMNS (private->left_docks),
dock,
-1 /*index*/);
}
else
{
gimp_dock_columns_add_dock (GIMP_DOCK_COLUMNS (private->right_docks),
dock,
-1 /*index*/);
}
app: Update appearance after adding dock Since gimp_display_shell_appearance_update() depends on docks being present, call it in gimp_image_window_add_dock(). Otherwise the resize handle will be present when starting in single-window mode.
2011-06-06 21:50:32 +08:00
active_shell = gimp_image_window_get_active_shell (window);
if (active_shell)
gimp_display_shell_appearance_update (active_shell);
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
}
static GimpAlignmentType
gimp_image_window_get_dock_side (GimpDockContainer *dock_container,
GimpDock *dock)
{
GimpAlignmentType side = -1;
GimpImageWindowPrivate *private;
GList *iter;
g_return_val_if_fail (GIMP_IS_IMAGE_WINDOW (dock_container), FALSE);
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (dock_container);
for (iter = gimp_dock_columns_get_docks (GIMP_DOCK_COLUMNS (private->left_docks));
iter && side == -1;
iter = g_list_next (iter))
{
GimpDock *dock_iter = GIMP_DOCK (iter->data);
if (dock_iter == dock)
side = GIMP_ALIGN_LEFT;
}
for (iter = gimp_dock_columns_get_docks (GIMP_DOCK_COLUMNS (private->right_docks));
iter && side == -1;
iter = g_list_next (iter))
{
GimpDock *dock_iter = GIMP_DOCK (iter->data);
if (dock_iter == dock)
side = GIMP_ALIGN_RIGHT;
}
return side;
}
static GList *
gimp_image_window_get_aux_info (GimpSessionManaged *session_managed)
{
GList *aux_info = NULL;
GimpImageWindowPrivate *private;
GimpGuiConfig *config;
g_return_val_if_fail (GIMP_IS_IMAGE_WINDOW (session_managed), NULL);
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (session_managed);
app: simplify config access in GimpImageWindow We have a "gimp" member, no need to go via factory->context->gimp.
2013-07-20 21:25:33 +08:00
config = GIMP_GUI_CONFIG (private->gimp->config);
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
if (config->single_window_mode)
{
GimpSessionInfoAux *aux;
Bug 694665 - SWM should distribute remaining space to main frame Save the "right-docks-position" as negative value in pixels from the right window border. Change the image window restoring code to interpret negative values like that, but keep the meaning of positive values for compatibility with existing sessionrc files.
2013-02-28 06:46:00 +08:00
GtkAllocation allocation;
app: Save the maximized state of the main window in the sessionrc file.
2012-04-04 08:59:37 +08:00
gchar widthbuf[128];
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
g_snprintf (widthbuf, sizeof (widthbuf), "%d",
gtk_paned_get_position (GTK_PANED (private->left_hpane)));
app: change serialization of the right docks width in SWM (again) Use "right-docks-width" and always a positive value instead of "right-docks-position" (as opponsed to "left-docks-width", that distinction is a GtkPaned implementation detail and does not belong into a config file). Parse all old values too. Also fix a glitch in the deserialization code which might fix bug #700147.
2013-05-13 06:00:57 +08:00
aux = gimp_session_info_aux_new (GIMP_IMAGE_WINDOW_LEFT_DOCKS_WIDTH,
widthbuf);
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
aux_info = g_list_append (aux_info, aux);
Bug 694665 - SWM should distribute remaining space to main frame Save the "right-docks-position" as negative value in pixels from the right window border. Change the image window restoring code to interpret negative values like that, but keep the meaning of positive values for compatibility with existing sessionrc files.
2013-02-28 06:46:00 +08:00
gtk_widget_get_allocation (private->right_hpane, &allocation);
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
g_snprintf (widthbuf, sizeof (widthbuf), "%d",
app: change serialization of the right docks width in SWM (again) Use "right-docks-width" and always a positive value instead of "right-docks-position" (as opponsed to "left-docks-width", that distinction is a GtkPaned implementation detail and does not belong into a config file). Parse all old values too. Also fix a glitch in the deserialization code which might fix bug #700147.
2013-05-13 06:00:57 +08:00
allocation.width -
gtk_paned_get_position (GTK_PANED (private->right_hpane)));
aux = gimp_session_info_aux_new (GIMP_IMAGE_WINDOW_RIGHT_DOCKS_WIDTH,
widthbuf);
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
aux_info = g_list_append (aux_info, aux);
app: Save the maximized state of the main window in the sessionrc file.
2012-04-04 08:59:37 +08:00
aux = gimp_session_info_aux_new (GIMP_IMAGE_WINDOW_MAXIMIZED,
gimp_image_window_is_maximized (GIMP_IMAGE_WINDOW (session_managed)) ?
"yes" : "no");
aux_info = g_list_append (aux_info, aux);
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
}
return aux_info;
}
static void
app: change serialization of the right docks width in SWM (again) Use "right-docks-width" and always a positive value instead of "right-docks-position" (as opponsed to "left-docks-width", that distinction is a GtkPaned implementation detail and does not belong into a config file). Parse all old values too. Also fix a glitch in the deserialization code which might fix bug #700147.
2013-05-13 06:00:57 +08:00
gimp_image_window_set_right_docks_width (GtkPaned *paned,
GtkAllocation *allocation,
void *data)
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
{
app: change serialization of the right docks width in SWM (again) Use "right-docks-width" and always a positive value instead of "right-docks-position" (as opponsed to "left-docks-width", that distinction is a GtkPaned implementation detail and does not belong into a config file). Parse all old values too. Also fix a glitch in the deserialization code which might fix bug #700147.
2013-05-13 06:00:57 +08:00
gint width = GPOINTER_TO_INT (data);
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
g_return_if_fail (GTK_IS_PANED (paned));
app: change serialization of the right docks width in SWM (again) Use "right-docks-width" and always a positive value instead of "right-docks-position" (as opponsed to "left-docks-width", that distinction is a GtkPaned implementation detail and does not belong into a config file). Parse all old values too. Also fix a glitch in the deserialization code which might fix bug #700147.
2013-05-13 06:00:57 +08:00
if (width > 0)
gtk_paned_set_position (paned, allocation->width - width);
Bug 694665 - SWM should distribute remaining space to main frame Save the "right-docks-position" as negative value in pixels from the right window border. Change the image window restoring code to interpret negative values like that, but keep the meaning of positive values for compatibility with existing sessionrc files.
2013-02-28 06:46:00 +08:00
else
app: change serialization of the right docks width in SWM (again) Use "right-docks-width" and always a positive value instead of "right-docks-position" (as opponsed to "left-docks-width", that distinction is a GtkPaned implementation detail and does not belong into a config file). Parse all old values too. Also fix a glitch in the deserialization code which might fix bug #700147.
2013-05-13 06:00:57 +08:00
gtk_paned_set_position (paned, - width);
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
g_signal_handlers_disconnect_by_func (paned,
app: change serialization of the right docks width in SWM (again) Use "right-docks-width" and always a positive value instead of "right-docks-position" (as opponsed to "left-docks-width", that distinction is a GtkPaned implementation detail and does not belong into a config file). Parse all old values too. Also fix a glitch in the deserialization code which might fix bug #700147.
2013-05-13 06:00:57 +08:00
gimp_image_window_set_right_docks_width,
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
data);
}
static void
gimp_image_window_set_aux_info (GimpSessionManaged *session_managed,
GList *aux_info)
{
GimpImageWindowPrivate *private;
GList *iter;
app: change serialization of the right docks width in SWM (again) Use "right-docks-width" and always a positive value instead of "right-docks-position" (as opponsed to "left-docks-width", that distinction is a GtkPaned implementation detail and does not belong into a config file). Parse all old values too. Also fix a glitch in the deserialization code which might fix bug #700147.
2013-05-13 06:00:57 +08:00
gint left_docks_width = G_MININT;
gint right_docks_width = G_MININT;
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
gboolean wait_with_right_docks = FALSE;
app: Save the maximized state of the main window in the sessionrc file.
2012-04-04 08:59:37 +08:00
gboolean maximized = FALSE;
Bug 575043 - GIMP ignores 'Maximized' windows hints on startup. Now the max parameter from Windows is taken into account and takes precedence over the saved session state if set. This can be applied either through the "run" property of a shortcut, or by command line: `start /max gimp-2.9.exe`. There is a start for min handling as well but I can clearly see the window being minimized and immediately re-raised. There must be a call later which deiconifies the window. This will have to be fixed.
2016-05-29 23:35:55 +08:00
#ifdef G_OS_WIN32
Use GetStartupInfoW ()
2022-12-30 23:55:22 +08:00
STARTUPINFOW StartupInfo;
Bug 575043 - GIMP ignores 'Maximized' windows hints on startup. Now the max parameter from Windows is taken into account and takes precedence over the saved session state if set. This can be applied either through the "run" property of a shortcut, or by command line: `start /max gimp-2.9.exe`. There is a start for min handling as well but I can clearly see the window being minimized and immediately re-raised. There must be a call later which deiconifies the window. This will have to be fixed.
2016-05-29 23:35:55 +08:00
Use GetStartupInfoW ()
2022-12-30 23:55:22 +08:00
GetStartupInfoW (&StartupInfo);
Bug 575043 - GIMP ignores 'Maximized' windows hints on startup. Now the max parameter from Windows is taken into account and takes precedence over the saved session state if set. This can be applied either through the "run" property of a shortcut, or by command line: `start /max gimp-2.9.exe`. There is a start for min handling as well but I can clearly see the window being minimized and immediately re-raised. There must be a call later which deiconifies the window. This will have to be fixed.
2016-05-29 23:35:55 +08:00
#endif
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
g_return_if_fail (GIMP_IS_IMAGE_WINDOW (session_managed));
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (session_managed);
for (iter = aux_info; iter; iter = g_list_next (iter))
{
GimpSessionInfoAux *aux = iter->data;
gint *width = NULL;
if (! strcmp (aux->name, GIMP_IMAGE_WINDOW_LEFT_DOCKS_WIDTH))
width = &left_docks_width;
app: change serialization of the right docks width in SWM (again) Use "right-docks-width" and always a positive value instead of "right-docks-position" (as opponsed to "left-docks-width", that distinction is a GtkPaned implementation detail and does not belong into a config file). Parse all old values too. Also fix a glitch in the deserialization code which might fix bug #700147.
2013-05-13 06:00:57 +08:00
else if (! strcmp (aux->name, GIMP_IMAGE_WINDOW_RIGHT_DOCKS_WIDTH))
width = &right_docks_width;
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
else if (! strcmp (aux->name, GIMP_IMAGE_WINDOW_RIGHT_DOCKS_POS))
app: change serialization of the right docks width in SWM (again) Use "right-docks-width" and always a positive value instead of "right-docks-position" (as opponsed to "left-docks-width", that distinction is a GtkPaned implementation detail and does not belong into a config file). Parse all old values too. Also fix a glitch in the deserialization code which might fix bug #700147.
2013-05-13 06:00:57 +08:00
width = &right_docks_width;
app: Save the maximized state of the main window in the sessionrc file.
2012-04-04 08:59:37 +08:00
else if (! strcmp (aux->name, GIMP_IMAGE_WINDOW_MAXIMIZED))
if (! g_ascii_strcasecmp (aux->value, "yes"))
maximized = TRUE;
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
if (width)
sscanf (aux->value, "%d", width);
app: change serialization of the right docks width in SWM (again) Use "right-docks-width" and always a positive value instead of "right-docks-position" (as opponsed to "left-docks-width", that distinction is a GtkPaned implementation detail and does not belong into a config file). Parse all old values too. Also fix a glitch in the deserialization code which might fix bug #700147.
2013-05-13 06:00:57 +08:00
/* compat handling for right docks */
if (! strcmp (aux->name, GIMP_IMAGE_WINDOW_RIGHT_DOCKS_POS))
{
/* negate the value because negative docks pos means docks width,
* also use the negativenes of a real docks pos as condition below.
*/
*width = - *width;
}
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
}
app: change serialization of the right docks width in SWM (again) Use "right-docks-width" and always a positive value instead of "right-docks-position" (as opponsed to "left-docks-width", that distinction is a GtkPaned implementation detail and does not belong into a config file). Parse all old values too. Also fix a glitch in the deserialization code which might fix bug #700147.
2013-05-13 06:00:57 +08:00
if (left_docks_width != G_MININT &&
gtk_paned_get_position (GTK_PANED (private->left_hpane)) !=
left_docks_width)
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
{
gtk_paned_set_position (GTK_PANED (private->left_hpane), left_docks_width);
/* We can't set the position of the right docks, because it will
* be undesirably adjusted when its get a new size
* allocation. We must wait until after the size allocation.
*/
wait_with_right_docks = TRUE;
}
app: change serialization of the right docks width in SWM (again) Use "right-docks-width" and always a positive value instead of "right-docks-position" (as opponsed to "left-docks-width", that distinction is a GtkPaned implementation detail and does not belong into a config file). Parse all old values too. Also fix a glitch in the deserialization code which might fix bug #700147.
2013-05-13 06:00:57 +08:00
if (right_docks_width != G_MININT &&
gtk_paned_get_position (GTK_PANED (private->right_hpane)) !=
right_docks_width)
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
{
app: change serialization of the right docks width in SWM (again) Use "right-docks-width" and always a positive value instead of "right-docks-position" (as opponsed to "left-docks-width", that distinction is a GtkPaned implementation detail and does not belong into a config file). Parse all old values too. Also fix a glitch in the deserialization code which might fix bug #700147.
2013-05-13 06:00:57 +08:00
if (wait_with_right_docks || right_docks_width > 0)
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
{
app: change serialization of the right docks width in SWM (again) Use "right-docks-width" and always a positive value instead of "right-docks-position" (as opponsed to "left-docks-width", that distinction is a GtkPaned implementation detail and does not belong into a config file). Parse all old values too. Also fix a glitch in the deserialization code which might fix bug #700147.
2013-05-13 06:00:57 +08:00
/* We must wait for a size allocation before we can set the
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
* position
*/
g_signal_connect_data (private->right_hpane, "size-allocate",
app: change serialization of the right docks width in SWM (again) Use "right-docks-width" and always a positive value instead of "right-docks-position" (as opponsed to "left-docks-width", that distinction is a GtkPaned implementation detail and does not belong into a config file). Parse all old values too. Also fix a glitch in the deserialization code which might fix bug #700147.
2013-05-13 06:00:57 +08:00
G_CALLBACK (gimp_image_window_set_right_docks_width),
GINT_TO_POINTER (right_docks_width), NULL,
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
G_CONNECT_AFTER);
}
else
{
/* We can set the position directly, because we didn't
app: change serialization of the right docks width in SWM (again) Use "right-docks-width" and always a positive value instead of "right-docks-position" (as opponsed to "left-docks-width", that distinction is a GtkPaned implementation detail and does not belong into a config file). Parse all old values too. Also fix a glitch in the deserialization code which might fix bug #700147.
2013-05-13 06:00:57 +08:00
* change the left hpane position, and we got the old compat
* dock pos property.
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
*/
gtk_paned_set_position (GTK_PANED (private->right_hpane),
app: change serialization of the right docks width in SWM (again) Use "right-docks-width" and always a positive value instead of "right-docks-position" (as opponsed to "left-docks-width", that distinction is a GtkPaned implementation detail and does not belong into a config file). Parse all old values too. Also fix a glitch in the deserialization code which might fix bug #700147.
2013-05-13 06:00:57 +08:00
- right_docks_width);
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
}
}
app: Save the maximized state of the main window in the sessionrc file.
2012-04-04 08:59:37 +08:00
Bug 575043 - GIMP ignores 'Maximized' windows hints on startup. Now the max parameter from Windows is taken into account and takes precedence over the saved session state if set. This can be applied either through the "run" property of a shortcut, or by command line: `start /max gimp-2.9.exe`. There is a start for min handling as well but I can clearly see the window being minimized and immediately re-raised. There must be a call later which deiconifies the window. This will have to be fixed.
2016-05-29 23:35:55 +08:00
#ifdef G_OS_WIN32
/* On Windows, user can provide startup hints to have a program
* maximized/minimized on startup. This can be done through command
* line: `start /max gimp-2.9.exe` or with the shortcut's "run"
* property.
* When such a hint is given, we should follow it and bypass the
* session's information.
*/
if (StartupInfo.wShowWindow == SW_SHOWMAXIMIZED)
app: Save the maximized state of the main window in the sessionrc file.
2012-04-04 08:59:37 +08:00
gtk_window_maximize (GTK_WINDOW (session_managed));
Bug 575043 - GIMP ignores 'Maximized' windows hints on startup. Now the max parameter from Windows is taken into account and takes precedence over the saved session state if set. This can be applied either through the "run" property of a shortcut, or by command line: `start /max gimp-2.9.exe`. There is a start for min handling as well but I can clearly see the window being minimized and immediately re-raised. There must be a call later which deiconifies the window. This will have to be fixed.
2016-05-29 23:35:55 +08:00
else if (StartupInfo.wShowWindow == SW_SHOWMINIMIZED ||
StartupInfo.wShowWindow == SW_SHOWMINNOACTIVE ||
StartupInfo.wShowWindow == SW_MINIMIZE)
gtk_window_iconify (GTK_WINDOW (session_managed));
app: Save the maximized state of the main window in the sessionrc file.
2012-04-04 08:59:37 +08:00
else
Bug 575043 - GIMP ignores 'Maximized' windows hints on startup. Now the max parameter from Windows is taken into account and takes precedence over the saved session state if set. This can be applied either through the "run" property of a shortcut, or by command line: `start /max gimp-2.9.exe`. There is a start for min handling as well but I can clearly see the window being minimized and immediately re-raised. There must be a call later which deiconifies the window. This will have to be fixed.
2016-05-29 23:35:55 +08:00
/* Another show property not relevant to min/max.
* Defaults is: SW_SHOWNORMAL
*/
#endif
if (maximized)
gtk_window_maximize (GTK_WINDOW (session_managed));
else
gtk_window_unmaximize (GTK_WINDOW (session_managed));
Bug 603848 - Single-window mode is not properly session managed yet Make GimpImageWindow implement GimpDockContainer and GimpSessionManaged so that GIMP can be started in single-window mode.
2011-06-01 05:49:24 +08:00
}
Add gimp_image_window_get_active_display() Should probably be refactored into something involving a GimpContext, but it's good enough as intermediate step.
2009-09-23 19:06:11 +08:00
/* public functions */
app: Add gimp_image_window_new/destroy() Add gimp_image_window_new/destroy() so we have a central place where the Gimp::image_windows list is managed.
2009-10-26 05:02:38 +08:00
GimpImageWindow *
gimp_image_window_new (Gimp *gimp,
GimpImage *image,
app: add screen and monitor to all display and image window constructors so they appear on the proper monitor as well.
2014-05-03 02:20:46 +08:00
GimpDialogFactory *dialog_factory,
Port a lot of stuff from GdkScreen/monitor_number to GdkMonitor including some fixes for getting pointer coords, and needed API changes in libgimpwidgets.
2018-04-29 23:27:47 +08:00
GdkMonitor *monitor)
app: Add gimp_image_window_new/destroy() Add gimp_image_window_new/destroy() so we have a central place where the Gimp::image_windows list is managed.
2009-10-26 05:02:38 +08:00
{
app: make sure image windows end up on the intended monitor In gimp_image_window_new(), place the window on the right monitor manually if we are not in single-window-mode. In gimp_image_window_switch_page(), make sure we don't use an unrealized new window's monitor for updating the session info, because the monitor of an unrealized window is always where the pointer is.
2014-05-03 15:38:50 +08:00
GimpImageWindow *window;
GimpImageWindowPrivate *private;
app: Add gimp_image_window_new/destroy() Add gimp_image_window_new/destroy() so we have a central place where the Gimp::image_windows list is managed.
2009-10-26 05:02:38 +08:00
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
app: make sure image windows end up on the intended monitor In gimp_image_window_new(), place the window on the right monitor manually if we are not in single-window-mode. In gimp_image_window_switch_page(), make sure we don't use an unrealized new window's monitor for updating the session info, because the monitor of an unrealized window is always where the pointer is.
2014-05-03 15:38:50 +08:00
g_return_val_if_fail (image == NULL || GIMP_IS_IMAGE (image), NULL);
app: Cleanup GimpImageWindow and dependencies, only one dialog factory Cleanup GimpImageWindow and dependencies like GimpDisplay, there is only one dialog factory now.
2010-02-20 18:09:51 +08:00
g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (dialog_factory), NULL);
Port a lot of stuff from GdkScreen/monitor_number to GdkMonitor including some fixes for getting pointer coords, and needed API changes in libgimpwidgets.
2018-04-29 23:27:47 +08:00
g_return_val_if_fail (GDK_IS_MONITOR (monitor), NULL);
app: Add gimp_image_window_new/destroy() Add gimp_image_window_new/destroy() so we have a central place where the Gimp::image_windows list is managed.
2009-10-26 05:02:38 +08:00
window = g_object_new (GIMP_TYPE_IMAGE_WINDOW,
"gimp", gimp,
app: Cleanup GimpImageWindow and dependencies, only one dialog factory Cleanup GimpImageWindow and dependencies like GimpDisplay, there is only one dialog factory now.
2010-02-20 18:09:51 +08:00
"dialog-factory", dialog_factory,
app: add screen and monitor to all display and image window constructors so they appear on the proper monitor as well.
2014-05-03 02:20:46 +08:00
"initial-monitor", monitor,
app: initial work on moving to GtkApplication. Reviewer's message (Jehan): This was a work-in-progress by Niels, which we only keep in this state because Lukas worked over it. I have rebased and fix-amended many broken part of this commit, because various things had been changed in these areas of code since this commit was initially written.
2021-12-20 01:09:28 +08:00
"application", g_application_get_default (),
app: Add gimp_image_window_new/destroy() Add gimp_image_window_new/destroy() so we have a central place where the Gimp::image_windows list is managed.
2009-10-26 05:02:38 +08:00
/* The window position will be overridden by the
* dialog factory, it is only really used on first
* startup.
*/
image ? NULL : "window-position",
GTK_WIN_POS_CENTER,
NULL);
app: make sure image windows end up on the intended monitor In gimp_image_window_new(), place the window on the right monitor manually if we are not in single-window-mode. In gimp_image_window_switch_page(), make sure we don't use an unrealized new window's monitor for updating the session info, because the monitor of an unrealized window is always where the pointer is.
2014-05-03 15:38:50 +08:00
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
Bug 703736: when switching from multi to single window mode, tab order is lost.
2013-07-07 12:47:37 +08:00
gimp->image_windows = g_list_append (gimp->image_windows, window);
app: Add gimp_image_window_new/destroy() Add gimp_image_window_new/destroy() so we have a central place where the Gimp::image_windows list is managed.
2009-10-26 05:02:38 +08:00
app: make sure image windows end up on the intended monitor In gimp_image_window_new(), place the window on the right monitor manually if we are not in single-window-mode. In gimp_image_window_switch_page(), make sure we don't use an unrealized new window's monitor for updating the session info, because the monitor of an unrealized window is always where the pointer is.
2014-05-03 15:38:50 +08:00
if (! GIMP_GUI_CONFIG (private->gimp->config)->single_window_mode)
{
app: don't use gtk_window_parse_geometry() in GimpImageWindow
2018-05-22 18:33:23 +08:00
GdkMonitor *pointer_monitor = gimp_get_monitor_at_pointer ();
app: make sure image windows end up on the intended monitor In gimp_image_window_new(), place the window on the right monitor manually if we are not in single-window-mode. In gimp_image_window_switch_page(), make sure we don't use an unrealized new window's monitor for updating the session info, because the monitor of an unrealized window is always where the pointer is.
2014-05-03 15:38:50 +08:00
/* If we are supposed to go to a monitor other than where the
* pointer is, place the window on that monitor manually,
* otherwise simply let the window manager place the window on
* the poiner's monitor.
*/
Port a lot of stuff from GdkScreen/monitor_number to GdkMonitor including some fixes for getting pointer coords, and needed API changes in libgimpwidgets.
2018-04-29 23:27:47 +08:00
if (pointer_monitor != monitor)
app: make sure image windows end up on the intended monitor In gimp_image_window_new(), place the window on the right monitor manually if we are not in single-window-mode. In gimp_image_window_switch_page(), make sure we don't use an unrealized new window's monitor for updating the session info, because the monitor of an unrealized window is always where the pointer is.
2014-05-03 15:38:50 +08:00
{
GdkRectangle rect;
Port a lot of stuff from GdkScreen/monitor_number to GdkMonitor including some fixes for getting pointer coords, and needed API changes in libgimpwidgets.
2018-04-29 23:27:47 +08:00
gdk_monitor_get_workarea (monitor, &rect);
app: make sure image windows end up on the intended monitor In gimp_image_window_new(), place the window on the right monitor manually if we are not in single-window-mode. In gimp_image_window_switch_page(), make sure we don't use an unrealized new window's monitor for updating the session info, because the monitor of an unrealized window is always where the pointer is.
2014-05-03 15:38:50 +08:00
app: don't use gtk_window_parse_geometry() in GimpImageWindow
2018-05-22 18:33:23 +08:00
gtk_window_move (GTK_WINDOW (window),
rect.x + 300, rect.y + 30);
gtk_window_set_geometry_hints (GTK_WINDOW (window),
NULL, NULL, GDK_HINT_USER_POS);
app: make sure image windows end up on the intended monitor In gimp_image_window_new(), place the window on the right monitor manually if we are not in single-window-mode. In gimp_image_window_switch_page(), make sure we don't use an unrealized new window's monitor for updating the session info, because the monitor of an unrealized window is always where the pointer is.
2014-05-03 15:38:50 +08:00
}
}
app: Add gimp_image_window_new/destroy() Add gimp_image_window_new/destroy() so we have a central place where the Gimp::image_windows list is managed.
2009-10-26 05:02:38 +08:00
return window;
}
void
gimp_image_window_destroy (GimpImageWindow *window)
{
GimpImageWindowPrivate *private;
g_return_if_fail (GIMP_IS_IMAGE_WINDOW (window));
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
private->gimp->image_windows = g_list_remove (private->gimp->image_windows,
window);
gtk_widget_destroy (GTK_WIDGET (window));
}
app: Add GimpDockColumns to the left and right of a GimpImageWindow
2009-10-04 08:02:39 +08:00
GimpDockColumns *
gimp_image_window_get_left_docks (GimpImageWindow *window)
{
GimpImageWindowPrivate *private;
g_return_val_if_fail (GIMP_IS_IMAGE_WINDOW (window), FALSE);
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
return GIMP_DOCK_COLUMNS (private->left_docks);
}
GimpDockColumns *
gimp_image_window_get_right_docks (GimpImageWindow *window)
{
GimpImageWindowPrivate *private;
g_return_val_if_fail (GIMP_IS_IMAGE_WINDOW (window), FALSE);
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
return GIMP_DOCK_COLUMNS (private->right_docks);
}
Add gimp_image_window_add_display() and use it This API is most likely not final, but enables adding the vbox of shell widgets to the image window's vbox *after* the shell constructor returns. Seems to work nicely :-)
2009-09-26 00:35:58 +08:00
void
Change GimpImageWindow API to speak in shells, not displays A widget container should keep around child widgets, not whatever objects that just have widgets.
2009-09-29 04:53:31 +08:00
gimp_image_window_add_shell (GimpImageWindow *window,
GimpDisplayShell *shell)
Add gimp_image_window_add_display() and use it This API is most likely not final, but enables adding the vbox of shell widgets to the image window's vbox *after* the shell constructor returns. Seems to work nicely :-)
2009-09-26 00:35:58 +08:00
{
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
GimpImageWindowPrivate *private;
app: Add a close button to image window tabs It takes a bit more space, but it needs to be easy to close images.
2011-08-25 04:47:58 +08:00
GtkWidget *tab_label;
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
Add gimp_image_window_add_display() and use it This API is most likely not final, but enables adding the vbox of shell widgets to the image window's vbox *after* the shell constructor returns. Seems to work nicely :-)
2009-09-26 00:35:58 +08:00
g_return_if_fail (GIMP_IS_IMAGE_WINDOW (window));
Change GimpImageWindow API to speak in shells, not displays A widget container should keep around child widgets, not whatever objects that just have widgets.
2009-09-29 04:53:31 +08:00
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
g_return_if_fail (g_list_find (private->shells, shell) == NULL);
Add gimp_image_window_add_display() and use it This API is most likely not final, but enables adding the vbox of shell widgets to the image window's vbox *after* the shell constructor returns. Seems to work nicely :-)
2009-09-26 00:35:58 +08:00
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
private->shells = g_list_append (private->shells, shell);
Add gimp_image_window_add_display() and use it This API is most likely not final, but enables adding the vbox of shell widgets to the image window's vbox *after* the shell constructor returns. Seems to work nicely :-)
2009-09-26 00:35:58 +08:00
app: Add a close button to image window tabs It takes a bit more space, but it needs to be easy to close images.
2011-08-25 04:47:58 +08:00
tab_label = gimp_image_window_create_tab_label (window, shell);
Use large image previews as tab widgets
2009-10-01 01:25:38 +08:00
Add a notebook for the display shells
2009-09-30 03:57:57 +08:00
gtk_notebook_append_page (GTK_NOTEBOOK (private->notebook),
app: Add a close button to image window tabs It takes a bit more space, but it needs to be easy to close images.
2011-08-25 04:47:58 +08:00
GTK_WIDGET (shell), tab_label);
Bug 701090: allowing to reorder shell tabs by drag'n drop in single-window-mode.
2013-05-27 23:52:13 +08:00
gtk_notebook_set_tab_reorderable (GTK_NOTEBOOK (private->notebook),
GTK_WIDGET (shell), TRUE);
Make GimpImageWindow handle the empty display correctly Keep around a boolean state "is_empty" and update it when adding and removing shells, and when the image of any shell changes. Do empty display voodoo only when the "is_empty" state changes.
2009-10-02 01:41:37 +08:00
Derive GimpDisplayShell from GtkVBox instead of GimpImageWindow ...and pack the widget into a separately created GimpImageWindow.
2009-09-30 02:56:14 +08:00
gtk_widget_show (GTK_WIDGET (shell));
app: make sure GimpImageWindow notifies all its shells of monitor changes Call gimp_color_managed_profile_changed() on all newly added shells, and on all shells in GimpWindow::monitor_changed().
2014-03-14 05:34:16 +08:00
/* make it fetch the right monitor profile */
gimp_color_managed_profile_changed (GIMP_COLOR_MANAGED (shell));
Add gimp_image_window_add_display() and use it This API is most likely not final, but enables adding the vbox of shell widgets to the image window's vbox *after* the shell constructor returns. Seems to work nicely :-)
2009-09-26 00:35:58 +08:00
}
app: Add gimp_image_window_get_shell()
2009-10-26 04:57:14 +08:00
GimpDisplayShell *
gimp_image_window_get_shell (GimpImageWindow *window,
gint index)
{
GimpImageWindowPrivate *private;
g_return_val_if_fail (GIMP_IS_IMAGE_WINDOW (window), NULL);
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
return g_list_nth_data (private->shells, index);
}
Add some more shell management API to GimpImageWindow - gimp_image_window_remove_shell() - gimp_image_window_get_n_shells()
2009-09-30 04:59:48 +08:00
void
gimp_image_window_remove_shell (GimpImageWindow *window,
GimpDisplayShell *shell)
{
GimpImageWindowPrivate *private;
g_return_if_fail (GIMP_IS_IMAGE_WINDOW (window));
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
g_return_if_fail (g_list_find (private->shells, shell) != NULL);
private->shells = g_list_remove (private->shells, shell);
gtk_container_remove (GTK_CONTAINER (private->notebook),
GTK_WIDGET (shell));
}
gint
gimp_image_window_get_n_shells (GimpImageWindow *window)
{
GimpImageWindowPrivate *private;
g_return_val_if_fail (GIMP_IS_IMAGE_WINDOW (window), 0);
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
return g_list_length (private->shells);
}
Keep around an "active_display" member in GimpImageWindow And add gimp_image_window_set_active_display(). Call the new function when creating a shell. Will all be done by the means of a GimpContext later, but is a step to get rid of FIXME hacks.
2009-09-24 00:22:50 +08:00
void
Change GimpImageWindow API to speak in shells, not displays A widget container should keep around child widgets, not whatever objects that just have widgets.
2009-09-29 04:53:31 +08:00
gimp_image_window_set_active_shell (GimpImageWindow *window,
GimpDisplayShell *shell)
Keep around an "active_display" member in GimpImageWindow And add gimp_image_window_set_active_display(). Call the new function when creating a shell. Will all be done by the means of a GimpContext later, but is a step to get rid of FIXME hacks.
2009-09-24 00:22:50 +08:00
{
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
GimpImageWindowPrivate *private;
Merge the image window's active shell logic with the notebook's active page Add a GtkNotebook::switch_page() handler and move all shell switching code there. In gimp_image_window_set_active_shell(), simply set the right notebook page.
2009-09-30 04:14:10 +08:00
gint page_num;
Add a GimpDisplayShell::scaled() handler to GimpImageWindow ...which is connected to the window's active display. Remove updating the window's menubar_manager from GimpDisplayShell's scaled() impl. Had to hack around a bit with the new API to set the window's active display because they are still the same widget.
2009-09-24 00:52:42 +08:00
Keep around an "active_display" member in GimpImageWindow And add gimp_image_window_set_active_display(). Call the new function when creating a shell. Will all be done by the means of a GimpContext later, but is a step to get rid of FIXME hacks.
2009-09-24 00:22:50 +08:00
g_return_if_fail (GIMP_IS_IMAGE_WINDOW (window));
Change GimpImageWindow API to speak in shells, not displays A widget container should keep around child widgets, not whatever objects that just have widgets.
2009-09-29 04:53:31 +08:00
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
Keep around an "active_display" member in GimpImageWindow And add gimp_image_window_set_active_display(). Call the new function when creating a shell. Will all be done by the means of a GimpContext later, but is a step to get rid of FIXME hacks.
2009-09-24 00:22:50 +08:00
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
Merge the image window's active shell logic with the notebook's active page Add a GtkNotebook::switch_page() handler and move all shell switching code there. In gimp_image_window_set_active_shell(), simply set the right notebook page.
2009-09-30 04:14:10 +08:00
g_return_if_fail (g_list_find (private->shells, shell));
Change GimpImageWindow API to speak in shells, not displays A widget container should keep around child widgets, not whatever objects that just have widgets.
2009-09-29 04:53:31 +08:00
Merge the image window's active shell logic with the notebook's active page Add a GtkNotebook::switch_page() handler and move all shell switching code there. In gimp_image_window_set_active_shell(), simply set the right notebook page.
2009-09-30 04:14:10 +08:00
page_num = gtk_notebook_page_num (GTK_NOTEBOOK (private->notebook),
GTK_WIDGET (shell));
Add notify callback for GimpDisplay's "image" property Will be used to do NIW things later.
2009-09-24 15:58:36 +08:00
Merge the image window's active shell logic with the notebook's active page Add a GtkNotebook::switch_page() handler and move all shell switching code there. In gimp_image_window_set_active_shell(), simply set the right notebook page.
2009-09-30 04:14:10 +08:00
gtk_notebook_set_current_page (GTK_NOTEBOOK (private->notebook), page_num);
Keep around an "active_display" member in GimpImageWindow And add gimp_image_window_set_active_display(). Call the new function when creating a shell. Will all be done by the means of a GimpContext later, but is a step to get rid of FIXME hacks.
2009-09-24 00:22:50 +08:00
}
Change GimpImageWindow API to speak in shells, not displays A widget container should keep around child widgets, not whatever objects that just have widgets.
2009-09-29 04:53:31 +08:00
GimpDisplayShell *
gimp_image_window_get_active_shell (GimpImageWindow *window)
Add gimp_image_window_get_active_display() Should probably be refactored into something involving a GimpContext, but it's good enough as intermediate step.
2009-09-23 19:06:11 +08:00
{
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
GimpImageWindowPrivate *private;
Add gimp_image_window_get_active_display() Should probably be refactored into something involving a GimpContext, but it's good enough as intermediate step.
2009-09-23 19:06:11 +08:00
g_return_val_if_fail (GIMP_IS_IMAGE_WINDOW (window), NULL);
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
return private->active_shell;
Add gimp_image_window_get_active_display() Should probably be refactored into something involving a GimpContext, but it's good enough as intermediate step.
2009-09-23 19:06:11 +08:00
}
Move the fullscreen API from GimpDisplayShell to GimpImageWindow Also remove GimpDisplayShell's "window_state" member. Use gtk_widget_get_toplvel() to get to the GimpImageWindow when we need a display shell's fullscreen state.
2009-09-23 20:52:33 +08:00
app: allow changing submenu's labels with gimp_menu_model_set_title(). Use this for the "View > Zoom" and "View > Flip & Rotate" submenus which used to display the zoom level and rotation angle. This regression is now fixed.
2023-04-17 21:24:26 +08:00
GimpMenuModel *
gimp_image_window_get_menubar_model (GimpImageWindow *window)
{
GimpImageWindowPrivate *private;
g_return_val_if_fail (GIMP_IS_IMAGE_WINDOW (window), NULL);
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
return private->menubar_model;
}
Move the fullscreen API from GimpDisplayShell to GimpImageWindow Also remove GimpDisplayShell's "window_state" member. Use gtk_widget_get_toplvel() to get to the GimpImageWindow when we need a display shell's fullscreen state.
2009-09-23 20:52:33 +08:00
void
gimp_image_window_set_fullscreen (GimpImageWindow *window,
gboolean fullscreen)
{
g_return_if_fail (GIMP_IS_IMAGE_WINDOW (window));
if (fullscreen != gimp_image_window_get_fullscreen (window))
{
if (fullscreen)
gtk_window_fullscreen (GTK_WINDOW (window));
else
gtk_window_unfullscreen (GTK_WINDOW (window));
}
}
gboolean
gimp_image_window_get_fullscreen (GimpImageWindow *window)
{
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
GimpImageWindowPrivate *private;
g_return_val_if_fail (GIMP_IS_IMAGE_WINDOW (window), FALSE);
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
return (private->window_state & GDK_WINDOW_STATE_FULLSCREEN) != 0;
}
void
gimp_image_window_set_show_menubar (GimpImageWindow *window,
gboolean show)
{
GimpImageWindowPrivate *private;
g_return_if_fail (GIMP_IS_IMAGE_WINDOW (window));
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
app: don't use image_window->menubar if it's NULL
2011-09-17 05:23:01 +08:00
if (private->menubar)
gtk_widget_set_visible (private->menubar, show);
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
}
gboolean
gimp_image_window_get_show_menubar (GimpImageWindow *window)
{
GimpImageWindowPrivate *private;
g_return_val_if_fail (GIMP_IS_IMAGE_WINDOW (window), FALSE);
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
app: don't use image_window->menubar if it's NULL
2011-09-17 05:23:01 +08:00
if (private->menubar)
return gtk_widget_get_visible (private->menubar);
return FALSE;
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
}
Add gimp_image_window_is_iconified() and use it in GimpImageWindow
2009-09-26 01:04:10 +08:00
gboolean
gimp_image_window_is_iconified (GimpImageWindow *window)
{
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
GimpImageWindowPrivate *private;
Add gimp_image_window_is_iconified() and use it in GimpImageWindow
2009-09-26 01:04:10 +08:00
g_return_val_if_fail (GIMP_IS_IMAGE_WINDOW (window), FALSE);
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
return (private->window_state & GDK_WINDOW_STATE_ICONIFIED) != 0;
Add gimp_image_window_is_iconified() and use it in GimpImageWindow
2009-09-26 01:04:10 +08:00
}
app: Save the maximized state of the main window in the sessionrc file.
2012-04-04 08:59:37 +08:00
gboolean
gimp_image_window_is_maximized (GimpImageWindow *window)
{
GimpImageWindowPrivate *private;
g_return_val_if_fail (GIMP_IS_IMAGE_WINDOW (window), FALSE);
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
return (private->window_state & GDK_WINDOW_STATE_MAXIMIZED) != 0;
}
app: Handle special case "Toolbox" in GimpSingleWindowStrategy The special case isn't pretty, but the current design can't handle it nicely. This is not the first special case for the toolbox.
2011-07-20 22:31:12 +08:00
/**
* gimp_image_window_has_toolbox:
* @window:
*
* Returns: %TRUE if the image window contains a GimpToolbox.
**/
gboolean
gimp_image_window_has_toolbox (GimpImageWindow *window)
{
GimpImageWindowPrivate *private;
GList *iter = NULL;
g_return_val_if_fail (GIMP_IS_IMAGE_WINDOW (window), FALSE);
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
for (iter = gimp_dock_columns_get_docks (GIMP_DOCK_COLUMNS (private->left_docks));
iter;
iter = g_list_next (iter))
{
if (GIMP_IS_TOOLBOX (iter->data))
return TRUE;
}
for (iter = gimp_dock_columns_get_docks (GIMP_DOCK_COLUMNS (private->right_docks));
iter;
iter = g_list_next (iter))
{
if (GIMP_IS_TOOLBOX (iter->data))
return TRUE;
}
return FALSE;
}
Move shrink_wrap() from the display to the window Also fix all callers. This clearly needs more cleanup.
2009-09-25 23:46:09 +08:00
void
gimp_image_window_shrink_wrap (GimpImageWindow *window,
gboolean grow_only)
{
app/libgimp*: remove stuff found by -Wunused-but-set-variable
2011-05-02 05:23:19 +08:00
GimpDisplayShell *active_shell;
GtkWidget *widget;
GtkAllocation allocation;
Port a lot of stuff from GdkScreen/monitor_number to GdkMonitor including some fixes for getting pointer coords, and needed API changes in libgimpwidgets.
2018-04-29 23:27:47 +08:00
GdkMonitor *monitor;
app/libgimp*: remove stuff found by -Wunused-but-set-variable
2011-05-02 05:23:19 +08:00
GdkRectangle rect;
gint disp_width, disp_height;
app: improve display scroll/zoom-related behavior in "show all" mode In "show all" mode, the image is thought to be "infinite"; this commit improves the overall scrolling/zooming behavior in this mode according to this assumption. In cases where a specific image size is needed (e.g., for the scrollbar bounds, fit-image-in-window, etc.), the image's full bounding box is used; however, in cases where a center point is needed (e.g., for the zoomed-out scrollbar bounds, center-image-in-window), the canvas center, rather than the bounding-box center, is still used.
2019-09-04 21:11:54 +08:00
gint width, height;
app/libgimp*: remove stuff found by -Wunused-but-set-variable
2011-05-02 05:23:19 +08:00
gint max_auto_width, max_auto_height;
gint border_width, border_height;
gboolean resize = FALSE;
Move shrink_wrap() from the display to the window Also fix all callers. This clearly needs more cleanup.
2009-09-25 23:46:09 +08:00
g_return_if_fail (GIMP_IS_IMAGE_WINDOW (window));
Use accessors from GTK+ 2.20 instead of using sealed members directly
2010-04-20 01:21:07 +08:00
if (! gtk_widget_get_realized (GTK_WIDGET (window)))
Move shrink_wrap() from the display to the window Also fix all callers. This clearly needs more cleanup.
2009-09-25 23:46:09 +08:00
return;
/* FIXME this so needs cleanup and shell/window separation */
Change GimpImageWindow API to speak in shells, not displays A widget container should keep around child widgets, not whatever objects that just have widgets.
2009-09-29 04:53:31 +08:00
active_shell = gimp_image_window_get_active_shell (window);
Move shrink_wrap() from the display to the window Also fix all callers. This clearly needs more cleanup.
2009-09-25 23:46:09 +08:00
app: Handle gimp_image_window_get_active_shell() returning NULL When rearranging the UI it is pretty common that gimp_image_window_get_active_shell() returns NULL so check for that.
2009-10-25 22:24:44 +08:00
if (!active_shell)
return;
Port a lot of stuff from GdkScreen/monitor_number to GdkMonitor including some fixes for getting pointer coords, and needed API changes in libgimpwidgets.
2018-04-29 23:27:47 +08:00
widget = GTK_WIDGET (window);
monitor = gimp_widget_get_monitor (widget);
Move shrink_wrap() from the display to the window Also fix all callers. This clearly needs more cleanup.
2009-09-25 23:46:09 +08:00
Build with GSEAL_ENABLE and #undef it where accessors are missing
2009-10-18 01:51:33 +08:00
gtk_widget_get_allocation (widget, &allocation);
Port a lot of stuff from GdkScreen/monitor_number to GdkMonitor including some fixes for getting pointer coords, and needed API changes in libgimpwidgets.
2018-04-29 23:27:47 +08:00
gdk_monitor_get_workarea (monitor, &rect);
Move shrink_wrap() from the display to the window Also fix all callers. This clearly needs more cleanup.
2009-09-25 23:46:09 +08:00
app: behave as if "show all" is disabled in scroll/zoom actions when keeping padding
2019-09-15 21:22:06 +08:00
if (! gimp_display_shell_get_infinite_canvas (active_shell))
{
gimp_display_shell_scale_get_image_size (active_shell,
&width, &height);
}
else
{
gimp_display_shell_scale_get_image_bounding_box (active_shell,
NULL, NULL,
&width, &height);
}
Move shrink_wrap() from the display to the window Also fix all callers. This clearly needs more cleanup.
2009-09-25 23:46:09 +08:00
disp_width = active_shell->disp_width;
disp_height = active_shell->disp_height;
/* As long as the disp_width/disp_height is larger than 1 we
* can reliably depend on it to calculate the
* border_width/border_height because that means there is enough
* room in the top-level for the canvas as well as the rulers and
* scrollbars. If it is 1 or smaller it is likely that the rulers
* and scrollbars are overlapping each other and thus we cannot use
* the normal approach to border size, so special case that.
*/
if (disp_width > 1 || !active_shell->vsb)
Build with GSEAL_ENABLE and #undef it where accessors are missing
2009-10-18 01:51:33 +08:00
{
border_width = allocation.width - disp_width;
}
Move shrink_wrap() from the display to the window Also fix all callers. This clearly needs more cleanup.
2009-09-25 23:46:09 +08:00
else
Build with GSEAL_ENABLE and #undef it where accessors are missing
2009-10-18 01:51:33 +08:00
{
GtkAllocation vsb_allocation;
gtk_widget_get_allocation (active_shell->vsb, &vsb_allocation);
border_width = allocation.width - disp_width + vsb_allocation.width;
}
Move shrink_wrap() from the display to the window Also fix all callers. This clearly needs more cleanup.
2009-09-25 23:46:09 +08:00
if (disp_height > 1 || !active_shell->hsb)
Build with GSEAL_ENABLE and #undef it where accessors are missing
2009-10-18 01:51:33 +08:00
{
border_height = allocation.height - disp_height;
}
Move shrink_wrap() from the display to the window Also fix all callers. This clearly needs more cleanup.
2009-09-25 23:46:09 +08:00
else
Build with GSEAL_ENABLE and #undef it where accessors are missing
2009-10-18 01:51:33 +08:00
{
GtkAllocation hsb_allocation;
gtk_widget_get_allocation (active_shell->hsb, &hsb_allocation);
border_height = allocation.height - disp_height + hsb_allocation.height;
}
Move shrink_wrap() from the display to the window Also fix all callers. This clearly needs more cleanup.
2009-09-25 23:46:09 +08:00
max_auto_width = (rect.width - border_width) * 0.75;
max_auto_height = (rect.height - border_height) * 0.75;
/* If one of the display dimensions has changed and one of the
* dimensions fits inside the screen
*/
if (((width + border_width) < rect.width ||
(height + border_height) < rect.height) &&
(width != disp_width ||
height != disp_height))
{
width = ((width + border_width) < rect.width) ? width : max_auto_width;
height = ((height + border_height) < rect.height) ? height : max_auto_height;
resize = TRUE;
}
/* If the projected dimension is greater than current, but less than
* 3/4 of the screen size, expand automagically
*/
else if ((width > disp_width ||
height > disp_height) &&
(disp_width < max_auto_width ||
disp_height < max_auto_height))
{
width = MIN (max_auto_width, width);
height = MIN (max_auto_height, height);
resize = TRUE;
}
if (resize)
{
Move the statusbar back to GimpDisplayShell Keeping it in GimpImageWindow was a bad idea because - it wasted space - it produced evil code because - it conceptually didn't belong there
2009-10-04 21:31:38 +08:00
GimpStatusbar *statusbar = gimp_display_shell_get_statusbar (active_shell);
Build with GSEAL_ENABLE and #undef it where accessors are missing
2009-10-18 01:51:33 +08:00
gint statusbar_width;
gtk_widget_get_size_request (GTK_WIDGET (statusbar),
&statusbar_width, NULL);
Move the statusbar back to GimpDisplayShell Keeping it in GimpImageWindow was a bad idea because - it wasted space - it produced evil code because - it conceptually didn't belong there
2009-10-04 21:31:38 +08:00
Build with GSEAL_ENABLE and #undef it where accessors are missing
2009-10-18 01:51:33 +08:00
if (width < statusbar_width)
width = statusbar_width;
Move shrink_wrap() from the display to the window Also fix all callers. This clearly needs more cleanup.
2009-09-25 23:46:09 +08:00
width = width + border_width;
height = height + border_height;
if (grow_only)
{
Build with GSEAL_ENABLE and #undef it where accessors are missing
2009-10-18 01:51:33 +08:00
if (width < allocation.width)
width = allocation.width;
Move shrink_wrap() from the display to the window Also fix all callers. This clearly needs more cleanup.
2009-09-25 23:46:09 +08:00
Build with GSEAL_ENABLE and #undef it where accessors are missing
2009-10-18 01:51:33 +08:00
if (height < allocation.height)
height = allocation.height;
Move shrink_wrap() from the display to the window Also fix all callers. This clearly needs more cleanup.
2009-09-25 23:46:09 +08:00
}
gtk_window_resize (GTK_WINDOW (window), width, height);
}
/* A wrap always means that we should center the image too. If the
* window changes size another center will be done in
* GimpDisplayShell::configure_event().
*/
/* FIXME multiple shells */
app: improve display scroll/zoom-related behavior in "show all" mode In "show all" mode, the image is thought to be "infinite"; this commit improves the overall scrolling/zooming behavior in this mode according to this assumption. In cases where a specific image size is needed (e.g., for the scrollbar bounds, fit-image-in-window, etc.), the image's full bounding box is used; however, in cases where a center point is needed (e.g., for the zoomed-out scrollbar bounds, center-image-in-window), the canvas center, rather than the bounding-box center, is still used.
2019-09-04 21:11:54 +08:00
gimp_display_shell_scroll_center_content (active_shell, TRUE, TRUE);
Move shrink_wrap() from the display to the window Also fix all callers. This clearly needs more cleanup.
2009-09-25 23:46:09 +08:00
}
app: Make positioning of new dockables depend on window mode Add GimpWindowingStrategy with create_dockable_dialog() and use it in dialogs_create_dockable_cmd_callback(). There are two implementations: GimpSingleWindowStrategy and GimpMultiWindowStrategy. Depending on the window mode, we want new dockables to appear in different places when created. In single-window mode, they should appear inside the single image window. In multi-window mode, a new dock window is created.
2011-07-04 02:55:03 +08:00
static GtkWidget *
gimp_image_window_get_first_dockbook (GimpDockColumns *columns)
{
GList *dock_iter;
app: some formatting cleanup in GimpImageWindow
2014-03-14 05:37:37 +08:00
app: Make positioning of new dockables depend on window mode Add GimpWindowingStrategy with create_dockable_dialog() and use it in dialogs_create_dockable_cmd_callback(). There are two implementations: GimpSingleWindowStrategy and GimpMultiWindowStrategy. Depending on the window mode, we want new dockables to appear in different places when created. In single-window mode, they should appear inside the single image window. In multi-window mode, a new dock window is created.
2011-07-04 02:55:03 +08:00
for (dock_iter = gimp_dock_columns_get_docks (columns);
dock_iter;
dock_iter = g_list_next (dock_iter))
{
GimpDock *dock = GIMP_DOCK (dock_iter->data);
GList *dockbooks = gimp_dock_get_dockbooks (dock);
if (dockbooks)
return GTK_WIDGET (dockbooks->data);
}
return NULL;
}
/**
* gimp_image_window_get_default_dockbook:
* @window:
*
* Gets the default dockbook, which is the dockbook in which new
* dockables should be put in single-window mode.
*
Add (nullable) if applicable Basically this commit makes sure that all return values that are marked as "Returns:" also have a `(nullable)` annotation if it is mentioned on the same line that NULL can also be returned. This will prevent a few problems in GObject-introspection.
2019-08-03 06:36:59 +08:00
* Returns: (nullable): The default dockbook for new dockables, or %NULL if no
Bug 794996 - Misc. typo fixes in comments in app/ Found via `codespell -q 3 --skip="./po*"`
2018-03-25 04:49:01 +08:00
* dockbook were available.
app: Make positioning of new dockables depend on window mode Add GimpWindowingStrategy with create_dockable_dialog() and use it in dialogs_create_dockable_cmd_callback(). There are two implementations: GimpSingleWindowStrategy and GimpMultiWindowStrategy. Depending on the window mode, we want new dockables to appear in different places when created. In single-window mode, they should appear inside the single image window. In multi-window mode, a new dock window is created.
2011-07-04 02:55:03 +08:00
**/
GtkWidget *
gimp_image_window_get_default_dockbook (GimpImageWindow *window)
{
GimpImageWindowPrivate *private;
GimpDockColumns *dock_columns;
GtkWidget *dockbook = NULL;
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
/* First try the first dockbook in the right docks */
dock_columns = GIMP_DOCK_COLUMNS (private->right_docks);
dockbook = gimp_image_window_get_first_dockbook (dock_columns);
/* Then the left docks */
if (! dockbook)
{
dock_columns = GIMP_DOCK_COLUMNS (private->left_docks);
dockbook = gimp_image_window_get_first_dockbook (dock_columns);
}
return dockbook;
}
app: Keep canvas position on all display shell widgets Don't use gimp_image_window_keep_canvas_pos() only for docks, use it for all widgets in the display shell: the rulers, the menu bar, the statusbar and the scrollbars. It is not really necessary for the two latter ones because they are below and/or to the right of the canvas, but we include them for completeness. Plus, they might get moved around some day...
2010-02-28 22:22:17 +08:00
/**
* gimp_image_window_keep_canvas_pos:
* @window:
*
Bug 703787 - Crash during switch from multi to single window mode Shells can now travel from one window to another. Canvas position code should therefore not keep track of the image window for a specific shell but must use whatever is the current window for this shell (even though it may be a different one before and after the size-allocate). This also partly fixes some positioning issue during mode switch.
2013-07-08 21:21:03 +08:00
* Stores the coordinates of the current image canvas origin relatively
* its GtkWindow; and on the first size-allocate sets the offsets in
* the shell so that the image origin remains the same (even on another
* GtkWindow).
app: Keep canvas position on all display shell widgets Don't use gimp_image_window_keep_canvas_pos() only for docks, use it for all widgets in the display shell: the rulers, the menu bar, the statusbar and the scrollbars. It is not really necessary for the two latter ones because they are below and/or to the right of the canvas, but we include them for completeness. Plus, they might get moved around some day...
2010-02-28 22:22:17 +08:00
*
Bug 703787 - Crash during switch from multi to single window mode Shells can now travel from one window to another. Canvas position code should therefore not keep track of the image window for a specific shell but must use whatever is the current window for this shell (even though it may be a different one before and after the size-allocate). This also partly fixes some positioning issue during mode switch.
2013-07-08 21:21:03 +08:00
* Example use case: The user hides docks attached to the side of image
app: Keep canvas position on all display shell widgets Don't use gimp_image_window_keep_canvas_pos() only for docks, use it for all widgets in the display shell: the rulers, the menu bar, the statusbar and the scrollbars. It is not really necessary for the two latter ones because they are below and/or to the right of the canvas, but we include them for completeness. Plus, they might get moved around some day...
2010-02-28 22:22:17 +08:00
* windows. You want the image to remain fixed on the screen though,
* so you use this function to keep the image fixed after the docks
* have been hidden.
**/
void
gimp_image_window_keep_canvas_pos (GimpImageWindow *window)
{
app: make new images jump around much less Implement a mechanism to suspend/resume GimpImageWindow's "keep canvas pos" logic which is used to keep the image in place across widget changed such as show/hide rulers. gimp_display_shell_fill(): call suspend()/resume() around gimp_display_shell_appearance_update(), and center the image after calculating the initial scale factor, so the image jumping at least starts at the approximately right position.
2016-01-11 08:50:29 +08:00
GimpImageWindowPrivate *private;
GimpDisplayShell *shell;
gint canvas_x;
gint canvas_y;
gint window_x;
gint window_y;
g_return_if_fail (GIMP_IS_IMAGE_WINDOW (window));
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
if (private->suspend_keep_pos > 0)
return;
shell = gimp_image_window_get_active_shell (window);
app: Keep canvas position on all display shell widgets Don't use gimp_image_window_keep_canvas_pos() only for docks, use it for all widgets in the display shell: the rulers, the menu bar, the statusbar and the scrollbars. It is not really necessary for the two latter ones because they are below and/or to the right of the canvas, but we include them for completeness. Plus, they might get moved around some day...
2010-02-28 22:22:17 +08:00
app: make sure the image stays in place when showing/hiding docks also when it's rotated or flipped.
2015-11-14 07:05:23 +08:00
gimp_display_shell_transform_xy (shell, 0.0, 0.0, &canvas_x, &canvas_y);
Bug 630069 - In single-window mode, canvas badly positioned in all successive tabs The problem is that gimp_image_window_keep_canvas_pos() connects a signal handler too early, with data not yet valid, the handler is executed after the canvas position is computed correctly and so invalid data overrides the valid. Checks the return value of gtk_widget_translate_coordinates() to avoid connecting handlers when their execution is considered harmful.
2011-03-09 14:30:15 +08:00
if (gtk_widget_translate_coordinates (GTK_WIDGET (shell->canvas),
GTK_WIDGET (window),
app: make sure the image stays in place when showing/hiding docks also when it's rotated or flipped.
2015-11-14 07:05:23 +08:00
canvas_x, canvas_y,
&window_x, &window_y))
Bug 630069 - In single-window mode, canvas badly positioned in all successive tabs The problem is that gimp_image_window_keep_canvas_pos() connects a signal handler too early, with data not yet valid, the handler is executed after the canvas position is computed correctly and so invalid data overrides the valid. Checks the return value of gtk_widget_translate_coordinates() to avoid connecting handlers when their execution is considered harmful.
2011-03-09 14:30:15 +08:00
{
PosCorrectionData *data = g_new0 (PosCorrectionData, 1);
app: make sure the image stays in place when showing/hiding docks also when it's rotated or flipped.
2015-11-14 07:05:23 +08:00
data->canvas_x = canvas_x;
data->canvas_y = canvas_y;
data->window_x = window_x;
data->window_y = window_y;
Bug 630069 - In single-window mode, canvas badly positioned in all successive tabs The problem is that gimp_image_window_keep_canvas_pos() connects a signal handler too early, with data not yet valid, the handler is executed after the canvas position is computed correctly and so invalid data overrides the valid. Checks the return value of gtk_widget_translate_coordinates() to avoid connecting handlers when their execution is considered harmful.
2011-03-09 14:30:15 +08:00
g_signal_connect_data (shell, "size-allocate",
G_CALLBACK (gimp_image_window_shell_size_allocate),
data, (GClosureNotify) g_free,
G_CONNECT_AFTER);
Issue #5813: Hidden rulers in GIMP 2.99 still take the same place.
2020-11-29 19:39:57 +08:00
/*
* XXX Asking a resize should not be necessary and should happen
* automatically with the translate coordinates. And it does, but
* sometimes only after some further event (like clicking on shell
* widgets). Until such event happens, the shell look broken, for
* instance with rulers and canvas overlapping and misaligned
* ruler values.
* So I queue a resize explicitly to force the correct shell
* visualization immediately.
* See also #5813.
*/
gtk_widget_queue_resize (GTK_WIDGET (shell));
Bug 630069 - In single-window mode, canvas badly positioned in all successive tabs The problem is that gimp_image_window_keep_canvas_pos() connects a signal handler too early, with data not yet valid, the handler is executed after the canvas position is computed correctly and so invalid data overrides the valid. Checks the return value of gtk_widget_translate_coordinates() to avoid connecting handlers when their execution is considered harmful.
2011-03-09 14:30:15 +08:00
}
app: Keep canvas position on all display shell widgets Don't use gimp_image_window_keep_canvas_pos() only for docks, use it for all widgets in the display shell: the rulers, the menu bar, the statusbar and the scrollbars. It is not really necessary for the two latter ones because they are below and/or to the right of the canvas, but we include them for completeness. Plus, they might get moved around some day...
2010-02-28 22:22:17 +08:00
}
app: make new images jump around much less Implement a mechanism to suspend/resume GimpImageWindow's "keep canvas pos" logic which is used to keep the image in place across widget changed such as show/hide rulers. gimp_display_shell_fill(): call suspend()/resume() around gimp_display_shell_appearance_update(), and center the image after calculating the initial scale factor, so the image jumping at least starts at the approximately right position.
2016-01-11 08:50:29 +08:00
void
gimp_image_window_suspend_keep_pos (GimpImageWindow *window)
{
GimpImageWindowPrivate *private;
g_return_if_fail (GIMP_IS_IMAGE_WINDOW (window));
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
private->suspend_keep_pos++;
}
void
gimp_image_window_resume_keep_pos (GimpImageWindow *window)
{
GimpImageWindowPrivate *private;
g_return_if_fail (GIMP_IS_IMAGE_WINDOW (window));
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
g_return_if_fail (private->suspend_keep_pos > 0);
private->suspend_keep_pos--;
}
Move the statusbar to GimpImageWindow As with the menubar, port some code properly, and add some horrible /* FIXME image window */ hacks to make it work.
2009-09-23 23:55:41 +08:00
Bug 675436 - Tabs always present when docks shown and absent when docks hidden The main change is that even with only 1 image in single window mode, there is now a tab. Also whatever the number of images when you hide docks with Tab, no tabs are shown.
2013-07-03 18:44:53 +08:00
/**
* gimp_image_window_update_tabs:
* @window: the Image Window to update.
*
* Holds the logics of whether shell tabs are to be shown or not in the
* Image Window @window. This function should be called after every
* change to @window where one might expect tab visibility to change.
*
* No direct call to gtk_notebook_set_show_tabs() should ever be made.
* If we change the logics of tab hiding, we should only change this
* procedure instead.
**/
void
Bug 747224 - Too easy to accidentially close an image tab Show the close button only on the active tab, so it's not accidentially hit when changing between images.
2015-04-04 02:28:57 +08:00
gimp_image_window_update_tabs (GimpImageWindow *window)
Bug 675436 - Tabs always present when docks shown and absent when docks hidden The main change is that even with only 1 image in single window mode, there is now a tab. Also whatever the number of images when you hide docks with Tab, no tabs are shown.
2013-07-03 18:44:53 +08:00
{
GimpImageWindowPrivate *private;
GimpGuiConfig *config;
Bug 667169 - Single window mode: allow tabs position setting.
2013-09-15 18:56:17 +08:00
GtkPositionType position;
Bug 675436 - Tabs always present when docks shown and absent when docks hidden The main change is that even with only 1 image in single window mode, there is now a tab. Also whatever the number of images when you hide docks with Tab, no tabs are shown.
2013-07-03 18:44:53 +08:00
g_return_if_fail (GIMP_IS_IMAGE_WINDOW (window));
private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
config = GIMP_GUI_CONFIG (private->gimp->config);
Bug 667169 - Single window mode: allow tabs position setting.
2013-09-15 18:56:17 +08:00
/* Tab visibility. */
Bug 675436 - Tabs always present when docks shown and absent when docks hidden The main change is that even with only 1 image in single window mode, there is now a tab. Also whatever the number of images when you hide docks with Tab, no tabs are shown.
2013-07-03 18:44:53 +08:00
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (private->notebook),
config->single_window_mode &&
app: Add option in the windows menu to hide the image tab bar. (cherry picked from commit 360aee10d8cc0de55072f78095e064f2e35bd5df)
2018-10-18 21:47:30 +08:00
config->show_tabs &&
Bug 675436 - Tabs always present when docks shown and absent when docks hidden The main change is that even with only 1 image in single window mode, there is now a tab. Also whatever the number of images when you hide docks with Tab, no tabs are shown.
2013-07-03 18:44:53 +08:00
! config->hide_docks &&
((private->active_shell &&
private->active_shell->display &&
gimp_display_get_image (private->active_shell->display)) ||
g_list_length (private->shells) > 1));
Bug 667169 - Single window mode: allow tabs position setting.
2013-09-15 18:56:17 +08:00
/* Tab position. */
switch (config->tabs_position)
{
case GIMP_POSITION_TOP:
position = GTK_POS_TOP;
break;
case GIMP_POSITION_BOTTOM:
position = GTK_POS_BOTTOM;
break;
case GIMP_POSITION_LEFT:
position = GTK_POS_LEFT;
break;
case GIMP_POSITION_RIGHT:
position = GTK_POS_RIGHT;
break;
default:
/* If we have any strange value, just reset to default. */
position = GTK_POS_TOP;
break;
}
Bug 747224 - Too easy to accidentially close an image tab Show the close button only on the active tab, so it's not accidentially hit when changing between images.
2015-04-04 02:28:57 +08:00
Bug 667169 - Single window mode: allow tabs position setting.
2013-09-15 18:56:17 +08:00
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (private->notebook), position);
Bug 675436 - Tabs always present when docks shown and absent when docks hidden The main change is that even with only 1 image in single window mode, there is now a tab. Also whatever the number of images when you hide docks with Tab, no tabs are shown.
2013-07-03 18:44:53 +08:00
}
Bug 747224 - Too easy to accidentially close an image tab Show the close button only on the active tab, so it's not accidentially hit when changing between images.
2015-04-04 02:28:57 +08:00
Move the statusbar to GimpImageWindow As with the menubar, port some code properly, and add some horrible /* FIXME image window */ hacks to make it work.
2009-09-23 23:55:41 +08:00
/* private functions */
static void
gimp_image_window_show_tooltip (GimpUIManager *manager,
const gchar *tooltip,
GimpImageWindow *window)
{
Move the statusbar back to GimpDisplayShell Keeping it in GimpImageWindow was a bad idea because - it wasted space - it produced evil code because - it conceptually didn't belong there
2009-10-04 21:31:38 +08:00
GimpDisplayShell *shell = gimp_image_window_get_active_shell (window);
app: Handle gimp_image_window_get_active_shell() returning NULL When rearranging the UI it is pretty common that gimp_image_window_get_active_shell() returns NULL so check for that.
2009-10-25 22:24:44 +08:00
GimpStatusbar *statusbar = NULL;
if (! shell)
return;
statusbar = gimp_display_shell_get_statusbar (shell);
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
Move the statusbar back to GimpDisplayShell Keeping it in GimpImageWindow was a bad idea because - it wasted space - it produced evil code because - it conceptually didn't belong there
2009-10-04 21:31:38 +08:00
gimp_statusbar_push (statusbar, "menu-tooltip",
Move the statusbar to GimpImageWindow As with the menubar, port some code properly, and add some horrible /* FIXME image window */ hacks to make it work.
2009-09-23 23:55:41 +08:00
NULL, "%s", tooltip);
}
app: Update image window side docks visiblity from the image window Update image window side docks visiblity from the image window itself instead of from the ui configurer. The image window has a dependency to the config object anyway, so no need to complicate things.
2010-02-23 02:24:23 +08:00
static void
gimp_image_window_config_notify (GimpImageWindow *window,
GParamSpec *pspec,
GimpGuiConfig *config)
{
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
app: Session manage empty- and single-image window separately Session manage empty- and single-image window separately. So when starting up, the default 2.6 UI is the same. But when enabling single-window mode, the image window will become much larger then the empty-image window. These conceptually different windows will then from that point be session managed separately: switching mode switches size of the image window.
2010-03-13 23:35:57 +08:00
/* Dock column visibility */
Bug 602223 - Can't hide docks with Tab in single-window mode Add a "hide-docks" config and connect the Windows->Hide docks menu item to it. Also connect the image window to the config property so it can hide/show its docks when it needs to. Also add and use a utility function gimp_image_window_keep_canvas_pos() to ensure that the image in the window remains fixed when toggling visiblity of docks. One problem: When GimpDrawTool is active on the canvas, there is flicker. The end position is correct though. Also add regression testing for this fix to test-ui.c
2010-02-24 03:21:08 +08:00
if (strcmp (pspec->name, "single-window-mode") == 0 ||
Bug 667169 - Single window mode: allow tabs position setting.
2013-09-15 18:56:17 +08:00
strcmp (pspec->name, "hide-docks") == 0 ||
app: Add option in the windows menu to hide the image tab bar. (cherry picked from commit 360aee10d8cc0de55072f78095e064f2e35bd5df)
2018-10-18 21:47:30 +08:00
strcmp (pspec->name, "show-tabs") == 0 ||
Bug 667169 - Single window mode: allow tabs position setting.
2013-09-15 18:56:17 +08:00
strcmp (pspec->name, "tabs-position") == 0)
app: Update image window side docks visiblity from the image window Update image window side docks visiblity from the image window itself instead of from the ui configurer. The image window has a dependency to the config object anyway, so no need to complicate things.
2010-02-23 02:24:23 +08:00
{
Bug 667169 - Single window mode: allow tabs position setting.
2013-09-15 18:56:17 +08:00
if (strcmp (pspec->name, "single-window-mode") == 0 ||
strcmp (pspec->name, "hide-docks") == 0)
{
gboolean show_docks = (config->single_window_mode &&
! config->hide_docks);
gimp_image_window_keep_canvas_pos (window);
gtk_widget_set_visible (private->left_docks, show_docks);
gtk_widget_set_visible (private->right_docks, show_docks);
Bug 567333 - Using tab to toggle docked "utility windows" does not... ...bring focus back to GIMP image window When showing docks in multi-window-mode, try to set the keyboard focus back to the active display because it might have been stolen by a dock.
2014-10-30 06:30:45 +08:00
/* If docks are being shown, and we are in multi-window-mode,
* and this is the window of the active display, try to set
* the keyboard focus to this window because it might have
* been stolen by a dock. See bug #567333.
*/
if (strcmp (pspec->name, "hide-docks") == 0 &&
! config->single_window_mode &&
! config->hide_docks)
{
GimpDisplayShell *shell;
GimpContext *user_context;
shell = gimp_image_window_get_active_shell (window);
user_context = gimp_get_user_context (private->gimp);
if (gimp_context_get_display (user_context) == shell->display)
{
GdkWindow *w = gtk_widget_get_window (GTK_WIDGET (window));
if (w)
gdk_window_focus (w, gtk_get_current_event_time ());
}
}
Bug 667169 - Single window mode: allow tabs position setting.
2013-09-15 18:56:17 +08:00
}
Bug 602223 - Can't hide docks with Tab in single-window mode Add a "hide-docks" config and connect the Windows->Hide docks menu item to it. Also connect the image window to the config property so it can hide/show its docks when it needs to. Also add and use a utility function gimp_image_window_keep_canvas_pos() to ensure that the image in the window remains fixed when toggling visiblity of docks. One problem: When GimpDrawTool is active on the canvas, there is flicker. The end position is correct though. Also add regression testing for this fix to test-ui.c
2010-02-24 03:21:08 +08:00
Bug 675436 - Tabs always present when docks shown and absent when docks hidden The main change is that even with only 1 image in single window mode, there is now a tab. Also whatever the number of images when you hide docks with Tab, no tabs are shown.
2013-07-03 18:44:53 +08:00
gimp_image_window_update_tabs (window);
app: Update image window side docks visiblity from the image window Update image window side docks visiblity from the image window itself instead of from the ui configurer. The image window has a dependency to the config object anyway, so no need to complicate things.
2010-02-23 02:24:23 +08:00
}
app: Session manage empty- and single-image window separately Session manage empty- and single-image window separately. So when starting up, the default 2.6 UI is the same. But when enabling single-window mode, the image window will become much larger then the empty-image window. These conceptually different windows will then from that point be session managed separately: switching mode switches size of the image window.
2010-03-13 23:35:57 +08:00
/* Session management */
if (strcmp (pspec->name, "single-window-mode") == 0)
{
Bug 650348 - Window unmaximizes when a document is closed Refactor GimpImageWindow session management. As far as session management goes, there are four states and four transitions that are interesting. The states are: State Window mode Images opened ------------------------------------------ s1 swm 0 s2 swm >0 s3 mwm 0 s4 mwm >0 The transitions are: Transition Description ------------------------------------------- t1 Enter single-window mode (swm) t2 Enter multi-window mwm (mwm) t3 Open an image t4 Close an image When thinking of it like this, it is pretty easy to see when to call gimp_image_window_session_clear() and when to call gimp_image_window_session_apply(). So kill gimp_image_window_set_entry_id() and handle all transitions in gimp_image_window_session_update().
2011-08-10 02:23:51 +08:00
gimp_image_window_session_update (window,
NULL /*new_display*/,
app: make things behave more reasonable with multiple monitors There is now a preference option that determines whether windows should be opened on the same monitor as before. It should be disabled when the machine gets monitors plugged/unplugged dynamically ("laptop") and enabled when there is a static multi-monitor setup ("wokstation"). This is merely the current simplistic policy on top of the newly added underlying infrastructure: - pass integer monitor numbers around in all places where we already pass around a GdkScreen. Pass the "current" monitor to these changed APIs, where "current" is either the monitor where the action-triggering widget is, or if that is unavailable the monitor where the mouse is. - add gimp_widget_get_monitor() in order to easily get to the monitor, just like gtk_widget_get_screen(). - add screen and monitor parameters in some places that were missed before. - in sessionrc, save all window positions relative to the window's monitor, and save the monitor separately, if it's not the screen's primary monitor. - when restoring window positions, use the stored monitor when the new prefs options says so (use the screen's primary monitor if there is no stored monitor), otherwise use current monitor that is now passed around.
2014-05-02 09:01:23 +08:00
gimp_image_window_config_to_entry_id (config),
gimp_widget_get_monitor (GTK_WIDGET (window)));
app: Session manage empty- and single-image window separately Session manage empty- and single-image window separately. So when starting up, the default 2.6 UI is the same. But when enabling single-window mode, the image window will become much larger then the empty-image window. These conceptually different windows will then from that point be session managed separately: switching mode switches size of the image window.
2010-03-13 23:35:57 +08:00
}
app: Update image window side docks visiblity from the image window Update image window side docks visiblity from the image window itself instead of from the ui configurer. The image window has a dependency to the config object anyway, so no need to complicate things.
2010-02-23 02:24:23 +08:00
}
Move the statusbar to GimpImageWindow As with the menubar, port some code properly, and add some horrible /* FIXME image window */ hacks to make it work.
2009-09-23 23:55:41 +08:00
static void
gimp_image_window_hide_tooltip (GimpUIManager *manager,
GimpImageWindow *window)
{
Move the statusbar back to GimpDisplayShell Keeping it in GimpImageWindow was a bad idea because - it wasted space - it produced evil code because - it conceptually didn't belong there
2009-10-04 21:31:38 +08:00
GimpDisplayShell *shell = gimp_image_window_get_active_shell (window);
app: Handle gimp_image_window_get_active_shell() returning NULL When rearranging the UI it is pretty common that gimp_image_window_get_active_shell() returns NULL so check for that.
2009-10-25 22:24:44 +08:00
GimpStatusbar *statusbar = NULL;
if (! shell)
return;
statusbar = gimp_display_shell_get_statusbar (shell);
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
Move the statusbar back to GimpDisplayShell Keeping it in GimpImageWindow was a bad idea because - it wasted space - it produced evil code because - it conceptually didn't belong there
2009-10-04 21:31:38 +08:00
gimp_statusbar_pop (statusbar, "menu-tooltip");
Move the statusbar to GimpImageWindow As with the menubar, port some code properly, and add some horrible /* FIXME image window */ hacks to make it work.
2009-09-23 23:55:41 +08:00
}
app: defer image menu updates to an idle function In DEs which use a global menu, such as Unity, updating the menu can be expensive. This particularly affects canvas scaling and rotation, for which updating the menu synchronously causes notable lag.
2017-03-01 16:09:24 +08:00
static gboolean
gimp_image_window_update_ui_manager_idle (GimpImageWindow *window)
app: Update Windows->Toolbox menu entry depending on if toolbox exists Update Windows->Toolbox menu entry depending on if toolbox exists. If an existing toolbox will be raised, set "Toolbox". If it will create a new toolbox, set "New Toolbox". We need this special treatment since there can be only one toolbox, so "New Toolbox" will remove any toolbox docks from Recently Closed Docks. If we would just have "Toolbox" it could be misinterpreted as "get me the toolbox I just closed".
2010-03-07 19:24:26 +08:00
{
Issue #10441: encoding conversion popup when changing from SWM to MWM.
2024-08-26 19:31:54 +08:00
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
GimpImage *active_image = NULL;
GimpContext *context;
app: Update Windows->Toolbox menu entry depending on if toolbox exists Update Windows->Toolbox menu entry depending on if toolbox exists. If an existing toolbox will be raised, set "Toolbox". If it will create a new toolbox, set "New Toolbox". We need this special treatment since there can be only one toolbox, so "New Toolbox" will remove any toolbox docks from Recently Closed Docks. If we would just have "Toolbox" it could be misinterpreted as "get me the toolbox I just closed".
2010-03-07 19:24:26 +08:00
app: replace all g_assert() by the newly added gimp_assert() which is just a #define to g_assert for now, but can now easily be turned into something that does some nicer debugging using our new stack trace infrastructure. This commit also reverts all constructed() functions to use assert again.
2018-02-12 05:23:10 +08:00
gimp_assert (private->active_shell != NULL);
app: defer image menu updates to an idle function In DEs which use a global menu, such as Unity, updating the menu can be expensive. This particularly affects canvas scaling and rotation, for which updating the menu synchronously causes notable lag.
2017-03-01 16:09:24 +08:00
Issue #10441: encoding conversion popup when changing from SWM to MWM.
2024-08-26 19:31:54 +08:00
context = gimp_get_user_context (private->active_shell->display->gimp);
if (context)
active_image = gimp_context_get_image (context);
/* Since we are running idle, it is possible this runs after the
* active display switched, and therefore we may call the wrong
* actions for an image. See #10441.
*/
if ((active_image &&
(! private->active_shell->display || ! gimp_display_get_image (private->active_shell->display))) ||
active_image != gimp_display_get_image (private->active_shell->display))
{
private->update_ui_manager_idle_id = 0;
return G_SOURCE_REMOVE;
}
app: prevent multiple registrations of a same action. Pre-GIMP-3.0 code logics would re-allocate several GimpMenuFactory or GimpUIManager for no good reason. While it was still working with old GtkAction code, with our new GAction-based code, we were ending up overriding an action with a new version of the same action, while keeping reference to old actions. This made for discrepancies of the enabled or visible state of actions. The new code keeps singleton of some objects and references to already registered GimpUIManager or GimpActionGroups objects and make sure no actions with the same name are created twice.
2023-03-08 01:23:38 +08:00
gimp_ui_manager_update (menus_get_image_manager_singleton (private->active_shell->display->gimp),
app: some GimpImageWindow cleanup - implement GObject::constructed() instead of ::construct() - remove the display pause/resume idle hack because any tool drawing flickering is gone now by using cairo - some formatting cleanup - remove some unused local variables
2010-11-26 16:19:36 +08:00
private->active_shell->display);
app: defer image menu updates to an idle function In DEs which use a global menu, such as Unity, updating the menu can be expensive. This particularly affects canvas scaling and rotation, for which updating the menu synchronously causes notable lag.
2017-03-01 16:09:24 +08:00
private->update_ui_manager_idle_id = 0;
return G_SOURCE_REMOVE;
}
static void
gimp_image_window_update_ui_manager (GimpImageWindow *window)
{
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
if (! private->update_ui_manager_idle_id)
{
private->update_ui_manager_idle_id =
app: fix image-window UI-manager update while a projection is being rendered Set the priority of the image window's UI-manager update idle slightly higher than the projection idle priority, so that the image actions are updated during projection rendering.
2019-03-31 07:24:00 +08:00
g_idle_add_full (GIMP_PRIORITY_IMAGE_WINDOW_UPDATE_UI_MANAGER_IDLE,
(GSourceFunc) gimp_image_window_update_ui_manager_idle,
window,
NULL);
app: defer image menu updates to an idle function In DEs which use a global menu, such as Unity, updating the menu can be expensive. This particularly affects canvas scaling and rotation, for which updating the menu synchronously causes notable lag.
2017-03-01 16:09:24 +08:00
}
app: Pause tool drawing while hiding docks in single-window mode Freeze the active tool until the UI has stabilized. If it draws while we hide widgets there will be flicker. See bug 602223.
2010-02-26 04:37:02 +08:00
}
Bug 602223 - Can't hide docks with Tab in single-window mode Add a "hide-docks" config and connect the Windows->Hide docks menu item to it. Also connect the image window to the config property so it can hide/show its docks when it needs to. Also add and use a utility function gimp_image_window_keep_canvas_pos() to ensure that the image in the window remains fixed when toggling visiblity of docks. One problem: When GimpDrawTool is active on the canvas, there is flicker. The end position is correct though. Also add regression testing for this fix to test-ui.c
2010-02-24 03:21:08 +08:00
static void
gimp_image_window_shell_size_allocate (GimpDisplayShell *shell,
app: some GimpImageWindow cleanup - implement GObject::constructed() instead of ::construct() - remove the display pause/resume idle hack because any tool drawing flickering is gone now by using cairo - some formatting cleanup - remove some unused local variables
2010-11-26 16:19:36 +08:00
GtkAllocation *allocation,
PosCorrectionData *data)
Bug 602223 - Can't hide docks with Tab in single-window mode Add a "hide-docks" config and connect the Windows->Hide docks menu item to it. Also connect the image window to the config property so it can hide/show its docks when it needs to. Also add and use a utility function gimp_image_window_keep_canvas_pos() to ensure that the image in the window remains fixed when toggling visiblity of docks. One problem: When GimpDrawTool is active on the canvas, there is flicker. The end position is correct though. Also add regression testing for this fix to test-ui.c
2010-02-24 03:21:08 +08:00
{
app: make sure the image stays in place when showing/hiding docks also when it's rotated or flipped.
2015-11-14 07:05:23 +08:00
GimpImageWindow *window = gimp_display_shell_get_window (shell);
gint new_window_x;
gint new_window_y;
if (gtk_widget_translate_coordinates (GTK_WIDGET (shell->canvas),
GTK_WIDGET (window),
data->canvas_x, data->canvas_y,
&new_window_x, &new_window_y))
Bug 703787 - Crash during switch from multi to single window mode Shells can now travel from one window to another. Canvas position code should therefore not keep track of the image window for a specific shell but must use whatever is the current window for this shell (even though it may be a different one before and after the size-allocate). This also partly fixes some positioning issue during mode switch.
2013-07-08 21:21:03 +08:00
{
app: make new images jump around much less Implement a mechanism to suspend/resume GimpImageWindow's "keep canvas pos" logic which is used to keep the image in place across widget changed such as show/hide rulers. gimp_display_shell_fill(): call suspend()/resume() around gimp_display_shell_appearance_update(), and center the image after calculating the initial scale factor, so the image jumping at least starts at the approximately right position.
2016-01-11 08:50:29 +08:00
gint off_x = new_window_x - data->window_x;
gint off_y = new_window_y - data->window_y;
if (off_x || off_y)
gimp_display_shell_scroll (shell, off_x, off_y);
Bug 703787 - Crash during switch from multi to single window mode Shells can now travel from one window to another. Canvas position code should therefore not keep track of the image window for a specific shell but must use whatever is the current window for this shell (even though it may be a different one before and after the size-allocate). This also partly fixes some positioning issue during mode switch.
2013-07-08 21:21:03 +08:00
}
Bug 602223 - Can't hide docks with Tab in single-window mode Add a "hide-docks" config and connect the Windows->Hide docks menu item to it. Also connect the image window to the config property so it can hide/show its docks when it needs to. Also add and use a utility function gimp_image_window_keep_canvas_pos() to ensure that the image in the window remains fixed when toggling visiblity of docks. One problem: When GimpDrawTool is active on the canvas, there is flicker. The end position is correct though. Also add regression testing for this fix to test-ui.c
2010-02-24 03:21:08 +08:00
g_signal_handlers_disconnect_by_func (shell,
gimp_image_window_shell_size_allocate,
data);
}
Move the remaining menubar signal connections from the shell to the window
2009-09-26 04:41:50 +08:00
static gboolean
gimp_image_window_shell_events (GtkWidget *widget,
GdkEvent *event,
GimpImageWindow *window)
{
Change GimpImageWindow API to speak in shells, not displays A widget container should keep around child widgets, not whatever objects that just have widgets.
2009-09-29 04:53:31 +08:00
GimpDisplayShell *shell = gimp_image_window_get_active_shell (window);
Move the remaining menubar signal connections from the shell to the window
2009-09-26 04:41:50 +08:00
app: Handle gimp_image_window_get_active_shell() returning NULL When rearranging the UI it is pretty common that gimp_image_window_get_active_shell() returns NULL so check for that.
2009-10-25 22:24:44 +08:00
if (! shell)
return FALSE;
Change GimpImageWindow API to speak in shells, not displays A widget container should keep around child widgets, not whatever objects that just have widgets.
2009-09-29 04:53:31 +08:00
return gimp_display_shell_events (widget, event, shell);
Move the remaining menubar signal connections from the shell to the window
2009-09-26 04:41:50 +08:00
}
Merge the image window's active shell logic with the notebook's active page Add a GtkNotebook::switch_page() handler and move all shell switching code there. In gimp_image_window_set_active_shell(), simply set the right notebook page.
2009-09-30 04:14:10 +08:00
static void
gimp_image_window_switch_page (GtkNotebook *notebook,
Fix the bulid after GtkNotebookPage got deprecated in gtk-2-22 In all GtkNotebook::switch_page() callbacks, simply replace GtkNotebookPage* by gpointer.
2010-07-16 21:24:25 +08:00
gpointer page,
Merge the image window's active shell logic with the notebook's active page Add a GtkNotebook::switch_page() handler and move all shell switching code there. In gimp_image_window_set_active_shell(), simply set the right notebook page.
2009-09-30 04:14:10 +08:00
gint page_num,
GimpImageWindow *window)
{
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
GimpDisplayShell *shell;
GimpDisplay *active_display;
shell = GIMP_DISPLAY_SHELL (gtk_notebook_get_nth_page (notebook, page_num));
if (shell == private->active_shell)
return;
app: Connect to GtkNotebook::page-removed in GimpImageWindow We must disconnect from the last display shell when it is removed when rearranging the UI, so connect to GtkNotebook::page-removed in GimpImageWindow and do that.
2009-10-25 23:27:24 +08:00
gimp_image_window_disconnect_from_active_shell (window);
Merge the image window's active shell logic with the notebook's active page Add a GtkNotebook::switch_page() handler and move all shell switching code there. In gimp_image_window_set_active_shell(), simply set the right notebook page.
2009-09-30 04:14:10 +08:00
app: Fix menubar suddently stopping to work when toggling window modes The image window must not disconnect from the active shell when any page is removed, only when the active page is removed. This fixes the bug with this step-by-step: 1. Start GIMP with a clean gimpdir 2. Create two windows 3. Enable single-window mode 4. Disable single-window mode 5. Try to execute a menu action, e.g. Select -> Invert, on both images Expected result: It works Actual result: It won't work in the image window that was reused and thus once had two notebook pages, since it disconnected from page 1 when page 2 was removed. Also add some debug output.
2010-01-06 21:49:13 +08:00
GIMP_LOG (WM, "GimpImageWindow %p, private->active_shell = %p; \n",
window, shell);
Merge the image window's active shell logic with the notebook's active page Add a GtkNotebook::switch_page() handler and move all shell switching code there. In gimp_image_window_set_active_shell(), simply set the right notebook page.
2009-09-30 04:14:10 +08:00
private->active_shell = shell;
Bug 675549 - image region does not have focus unless clicked on We cannot simply randomy move the focus from e.g. a text entry back to the canvas. Instead introduce global handling of "Escape" and a "primary_focus_widget" that is always set the the image window's active canvas. When Escape is pressed, move the focus to that primary focus widget, or beep if it is already there. Text widgets still get the key events before that logic and can consume the Escape.
2013-04-09 21:41:20 +08:00
gimp_window_set_primary_focus_widget (GIMP_WINDOW (window),
shell->canvas);
Merge the image window's active shell logic with the notebook's active page Add a GtkNotebook::switch_page() handler and move all shell switching code there. In gimp_image_window_set_active_shell(), simply set the right notebook page.
2009-09-30 04:14:10 +08:00
active_display = private->active_shell->display;
g_signal_connect (active_display, "notify::image",
G_CALLBACK (gimp_image_window_image_notify),
window);
g_signal_connect (private->active_shell, "scaled",
G_CALLBACK (gimp_image_window_shell_scaled),
window);
app: add signal GimpDisplayShell::rotated and use it to update the menu
2013-04-21 09:15:22 +08:00
g_signal_connect (private->active_shell, "rotated",
G_CALLBACK (gimp_image_window_shell_rotated),
window);
Remove "gimp-" prefix from the shell's "icon" and "title" properties The prefix was needed because GtkWindow also has "icon" and "title" properties.
2009-09-30 04:20:12 +08:00
g_signal_connect (private->active_shell, "notify::title",
Merge the image window's active shell logic with the notebook's active page Add a GtkNotebook::switch_page() handler and move all shell switching code there. In gimp_image_window_set_active_shell(), simply set the right notebook page.
2009-09-30 04:14:10 +08:00
G_CALLBACK (gimp_image_window_shell_title_notify),
window);
Update the window title and icon when switching between shells
2009-10-06 16:56:46 +08:00
gtk_window_set_title (GTK_WINDOW (window), shell->title);
Merge the image window's active shell logic with the notebook's active page Add a GtkNotebook::switch_page() handler and move all shell switching code there. In gimp_image_window_set_active_shell(), simply set the right notebook page.
2009-09-30 04:14:10 +08:00
gimp_display_shell_appearance_update (private->active_shell);
app: make sure image windows end up on the intended monitor In gimp_image_window_new(), place the window on the right monitor manually if we are not in single-window-mode. In gimp_image_window_switch_page(), make sure we don't use an unrealized new window's monitor for updating the session info, because the monitor of an unrealized window is always where the pointer is.
2014-05-03 15:38:50 +08:00
if (gtk_widget_get_window (GTK_WIDGET (window)))
{
/* we are fully initialized, use the window's current monitor
*/
gimp_image_window_session_update (window,
active_display,
NULL /*new_entry_id*/,
gimp_widget_get_monitor (GTK_WIDGET (window)));
}
else
{
/* we are in construction, use the initial monitor; calling
* gimp_widget_get_monitor() would get us the monitor where the
* pointer is
*/
gimp_image_window_session_update (window,
active_display,
NULL /*new_entry_id*/,
private->initial_monitor);
}
Merge the image window's active shell logic with the notebook's active page Add a GtkNotebook::switch_page() handler and move all shell switching code there. In gimp_image_window_set_active_shell(), simply set the right notebook page.
2009-09-30 04:14:10 +08:00
Bug 676522 - Changing tabs in single-window-mode should switch the active image Change the active image when switching tabs in single-window-mode.
2012-05-23 07:25:22 +08:00
gimp_context_set_display (gimp_get_user_context (private->gimp),
active_display);
app: defer image menu updates to an idle function In DEs which use a global menu, such as Unity, updating the menu can be expensive. This particularly affects canvas scaling and rotation, for which updating the menu synchronously causes notable lag.
2017-03-01 16:09:24 +08:00
gimp_image_window_update_ui_manager (window);
Bug 747224 - Too easy to accidentially close an image tab Show the close button only on the active tab, so it's not accidentially hit when changing between images.
2015-04-04 02:28:57 +08:00
gimp_image_window_update_tab_labels (window);
Merge the image window's active shell logic with the notebook's active page Add a GtkNotebook::switch_page() handler and move all shell switching code there. In gimp_image_window_set_active_shell(), simply set the right notebook page.
2009-09-30 04:14:10 +08:00
}
app: Connect to GtkNotebook::page-removed in GimpImageWindow We must disconnect from the last display shell when it is removed when rearranging the UI, so connect to GtkNotebook::page-removed in GimpImageWindow and do that.
2009-10-25 23:27:24 +08:00
static void
gimp_image_window_page_removed (GtkNotebook *notebook,
app: gimp_image_window_page_removed() gets the widget, not page The first GtkNotebook::"page-removed" signal parameter is the GtkWidget that was removed, not a GtkNotebookPage. Correct function signature.
2010-01-06 21:44:24 +08:00
GtkWidget *widget,
app: Connect to GtkNotebook::page-removed in GimpImageWindow We must disconnect from the last display shell when it is removed when rearranging the UI, so connect to GtkNotebook::page-removed in GimpImageWindow and do that.
2009-10-25 23:27:24 +08:00
gint page_num,
GimpImageWindow *window)
{
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
app: Fix menubar suddently stopping to work when toggling window modes The image window must not disconnect from the active shell when any page is removed, only when the active page is removed. This fixes the bug with this step-by-step: 1. Start GIMP with a clean gimpdir 2. Create two windows 3. Enable single-window mode 4. Disable single-window mode 5. Try to execute a menu action, e.g. Select -> Invert, on both images Expected result: It works Actual result: It won't work in the image window that was reused and thus once had two notebook pages, since it disconnected from page 1 when page 2 was removed. Also add some debug output.
2010-01-06 21:49:13 +08:00
if (GTK_WIDGET (private->active_shell) == widget)
{
GIMP_LOG (WM, "GimpImageWindow %p, private->active_shell = %p; \n",
window, NULL);
gimp_image_window_disconnect_from_active_shell (window);
private->active_shell = NULL;
}
app: Connect to GtkNotebook::page-removed in GimpImageWindow We must disconnect from the last display shell when it is removed when rearranging the UI, so connect to GtkNotebook::page-removed in GimpImageWindow and do that.
2009-10-25 23:27:24 +08:00
}
Bug 701090: allowing to reorder shell tabs by drag'n drop in single-window-mode.
2013-05-27 23:52:13 +08:00
static void
gimp_image_window_page_reordered (GtkNotebook *notebook,
GtkWidget *widget,
gint page_num,
GimpImageWindow *window)
{
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
GimpContainer *displays = private->gimp->displays;
app: some formatting cleanup in GimpImageWindow
2014-03-14 05:37:37 +08:00
gint index = g_list_index (private->shells, widget);
Bug 701090: reorder the shells too when tabs are reordered. This allows to not lose the tab order after we come back from multi-window mode.
2013-07-07 21:36:49 +08:00
if (index != page_num)
app: some formatting cleanup in GimpImageWindow
2014-03-14 05:37:37 +08:00
{
Bug 701090: reorder the shells too when tabs are reordered. This allows to not lose the tab order after we come back from multi-window mode.
2013-07-07 21:36:49 +08:00
private->shells = g_list_remove (private->shells, widget);
private->shells = g_list_insert (private->shells, widget, page_num);
app: some formatting cleanup in GimpImageWindow
2014-03-14 05:37:37 +08:00
}
Bug 701090: reorder the shells too when tabs are reordered. This allows to not lose the tab order after we come back from multi-window mode.
2013-07-07 21:36:49 +08:00
Bug 701090: allowing to reorder shell tabs by drag'n drop in single-window-mode.
2013-05-27 23:52:13 +08:00
/* We need to reorder the displays as well in order to update the
app: some formatting cleanup in GimpImageWindow
2014-03-14 05:37:37 +08:00
* numbered accelerators (alt-1, alt-2, etc.).
*/
gimp_container_reorder (displays,
GIMP_OBJECT (GIMP_DISPLAY_SHELL (widget)->display),
page_num);
Bug 701090: reorder the shells too when tabs are reordered. This allows to not lose the tab order after we come back from multi-window mode.
2013-07-07 21:36:49 +08:00
gtk_notebook_reorder_child (notebook, widget, page_num);
Bug 701090: allowing to reorder shell tabs by drag'n drop in single-window-mode.
2013-05-27 23:52:13 +08:00
}
app: Connect to GtkNotebook::page-removed in GimpImageWindow We must disconnect from the last display shell when it is removed when rearranging the UI, so connect to GtkNotebook::page-removed in GimpImageWindow and do that.
2009-10-25 23:27:24 +08:00
static void
gimp_image_window_disconnect_from_active_shell (GimpImageWindow *window)
{
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
GimpDisplay *active_display = NULL;
if (! private->active_shell)
return;
active_display = private->active_shell->display;
app: move code from GtkObject::destroy() to GObject::dispose()
2010-09-27 04:35:49 +08:00
if (active_display)
g_signal_handlers_disconnect_by_func (active_display,
gimp_image_window_image_notify,
window);
app: Connect to GtkNotebook::page-removed in GimpImageWindow We must disconnect from the last display shell when it is removed when rearranging the UI, so connect to GtkNotebook::page-removed in GimpImageWindow and do that.
2009-10-25 23:27:24 +08:00
g_signal_handlers_disconnect_by_func (private->active_shell,
gimp_image_window_shell_scaled,
window);
app: add signal GimpDisplayShell::rotated and use it to update the menu
2013-04-21 09:15:22 +08:00
g_signal_handlers_disconnect_by_func (private->active_shell,
gimp_image_window_shell_rotated,
window);
app: Connect to GtkNotebook::page-removed in GimpImageWindow We must disconnect from the last display shell when it is removed when rearranging the UI, so connect to GtkNotebook::page-removed in GimpImageWindow and do that.
2009-10-25 23:27:24 +08:00
g_signal_handlers_disconnect_by_func (private->active_shell,
gimp_image_window_shell_title_notify,
window);
app: prevent multiple registrations of a same action. Pre-GIMP-3.0 code logics would re-allocate several GimpMenuFactory or GimpUIManager for no good reason. While it was still working with old GtkAction code, with our new GAction-based code, we were ending up overriding an action with a new version of the same action, while keeping reference to old actions. This made for discrepancies of the enabled or visible state of actions. The new code keeps singleton of some objects and references to already registered GimpUIManager or GimpActionGroups objects and make sure no actions with the same name are created twice.
2023-03-08 01:23:38 +08:00
gimp_image_window_hide_tooltip (menus_get_image_manager_singleton (private->gimp), window);
app: defer image menu updates to an idle function In DEs which use a global menu, such as Unity, updating the menu can be expensive. This particularly affects canvas scaling and rotation, for which updating the menu synchronously causes notable lag.
2017-03-01 16:09:24 +08:00
if (private->update_ui_manager_idle_id)
{
g_source_remove (private->update_ui_manager_idle_id);
private->update_ui_manager_idle_id = 0;
}
app: Connect to GtkNotebook::page-removed in GimpImageWindow We must disconnect from the last display shell when it is removed when rearranging the UI, so connect to GtkNotebook::page-removed in GimpImageWindow and do that.
2009-10-25 23:27:24 +08:00
}
Add notify callback for GimpDisplay's "image" property Will be used to do NIW things later.
2009-09-24 15:58:36 +08:00
static void
gimp_image_window_image_notify (GimpDisplay *display,
const GParamSpec *pspec,
GimpImageWindow *window)
{
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
app: Add a close button to image window tabs It takes a bit more space, but it needs to be easy to close images.
2011-08-25 04:47:58 +08:00
GtkWidget *tab_label;
GList *children;
Use large image previews as tab widgets
2009-10-01 01:25:38 +08:00
GtkWidget *view;
Move all GimpImageWindow members to a private struct Add accessor functions for publically available members and visibility functions for menubar and statusbar.
2009-09-30 03:44:43 +08:00
app: Don't unmaximize image window when switching tabs in swm It is when we apply session info to the image window we unmaximize, so don't apply session info to the image window when all we do is switching tabs in single-window mode.
2010-06-19 15:43:27 +08:00
gimp_image_window_session_update (window,
display,
app: make things behave more reasonable with multiple monitors There is now a preference option that determines whether windows should be opened on the same monitor as before. It should be disabled when the machine gets monitors plugged/unplugged dynamically ("laptop") and enabled when there is a static multi-monitor setup ("wokstation"). This is merely the current simplistic policy on top of the newly added underlying infrastructure: - pass integer monitor numbers around in all places where we already pass around a GdkScreen. Pass the "current" monitor to these changed APIs, where "current" is either the monitor where the action-triggering widget is, or if that is unavailable the monitor where the mouse is. - add gimp_widget_get_monitor() in order to easily get to the monitor, just like gtk_widget_get_screen(). - add screen and monitor parameters in some places that were missed before. - in sessionrc, save all window positions relative to the window's monitor, and save the monitor separately, if it's not the screen's primary monitor. - when restoring window positions, use the stored monitor when the new prefs options says so (use the screen's primary monitor if there is no stored monitor), otherwise use current monitor that is now passed around.
2014-05-02 09:01:23 +08:00
NULL /*new_entry_id*/,
gimp_widget_get_monitor (GTK_WIDGET (window)));
app: Simplify GimpImageWindow session management Refactor session management with the "gimp-empty-image-window" in GimpImageWindow. In particular, only have one entry point to gimp_dialog_factory_add_foreign() and remove the is_empty instance struct member.
2010-03-13 19:41:06 +08:00
app: Add a close button to image window tabs It takes a bit more space, but it needs to be easy to close images.
2011-08-25 04:47:58 +08:00
tab_label = gtk_notebook_get_tab_label (GTK_NOTEBOOK (private->notebook),
GTK_WIDGET (gimp_display_get_shell (display)));
children = gtk_container_get_children (GTK_CONTAINER (tab_label));
view = GTK_WIDGET (children->data);
g_list_free (children);
app: Simplify GimpImageWindow session management Refactor session management with the "gimp-empty-image-window" in GimpImageWindow. In particular, only have one entry point to gimp_dialog_factory_add_foreign() and remove the is_empty instance struct member.
2010-03-13 19:41:06 +08:00
gimp_view_set_viewable (GIMP_VIEW (view),
GIMP_VIEWABLE (gimp_display_get_image (display)));
app: defer image menu updates to an idle function In DEs which use a global menu, such as Unity, updating the menu can be expensive. This particularly affects canvas scaling and rotation, for which updating the menu synchronously causes notable lag.
2017-03-01 16:09:24 +08:00
gimp_image_window_update_ui_manager (window);
app: Simplify GimpImageWindow session management Refactor session management with the "gimp-empty-image-window" in GimpImageWindow. In particular, only have one entry point to gimp_dialog_factory_add_foreign() and remove the is_empty instance struct member.
2010-03-13 19:41:06 +08:00
}
app: Introduce image window session utility functions Introduce image window session utility functions gimp_image_window_session_clear() and gimp_image_window_session_apply().
2010-03-13 19:56:27 +08:00
static void
gimp_image_window_session_clear (GimpImageWindow *window)
{
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
GtkWidget *widget = GTK_WIDGET (window);
if (gimp_dialog_factory_from_widget (widget, NULL))
gimp_dialog_factory_remove_dialog (private->dialog_factory,
widget);
}
static void
gimp_image_window_session_apply (GimpImageWindow *window,
app: make things behave more reasonable with multiple monitors There is now a preference option that determines whether windows should be opened on the same monitor as before. It should be disabled when the machine gets monitors plugged/unplugged dynamically ("laptop") and enabled when there is a static multi-monitor setup ("wokstation"). This is merely the current simplistic policy on top of the newly added underlying infrastructure: - pass integer monitor numbers around in all places where we already pass around a GdkScreen. Pass the "current" monitor to these changed APIs, where "current" is either the monitor where the action-triggering widget is, or if that is unavailable the monitor where the mouse is. - add gimp_widget_get_monitor() in order to easily get to the monitor, just like gtk_widget_get_screen(). - add screen and monitor parameters in some places that were missed before. - in sessionrc, save all window positions relative to the window's monitor, and save the monitor separately, if it's not the screen's primary monitor. - when restoring window positions, use the stored monitor when the new prefs options says so (use the screen's primary monitor if there is no stored monitor), otherwise use current monitor that is now passed around.
2014-05-02 09:01:23 +08:00
const gchar *entry_id,
Port a lot of stuff from GdkScreen/monitor_number to GdkMonitor including some fixes for getting pointer coords, and needed API changes in libgimpwidgets.
2018-04-29 23:27:47 +08:00
GdkMonitor *monitor)
app: Introduce image window session utility functions Introduce image window session utility functions gimp_image_window_session_clear() and gimp_image_window_session_apply().
2010-03-13 19:56:27 +08:00
{
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
GimpSessionInfo *session_info = NULL;
gint width = -1;
gint height = -1;
gtk_window_unfullscreen (GTK_WINDOW (window));
/* get the NIW size before adding the display to the dialog
* factory so the window's current size doesn't affect the
* stored session info entry.
*/
session_info =
gimp_dialog_factory_find_session_info (private->dialog_factory, entry_id);
if (session_info)
{
width = gimp_session_info_get_width (session_info);
height = gimp_session_info_get_height (session_info);
}
else
{
GtkAllocation allocation;
gtk_widget_get_allocation (GTK_WIDGET (window), &allocation);
width = allocation.width;
height = allocation.height;
}
gimp_dialog_factory_add_foreign (private->dialog_factory,
entry_id,
app: make things behave more reasonable with multiple monitors There is now a preference option that determines whether windows should be opened on the same monitor as before. It should be disabled when the machine gets monitors plugged/unplugged dynamically ("laptop") and enabled when there is a static multi-monitor setup ("wokstation"). This is merely the current simplistic policy on top of the newly added underlying infrastructure: - pass integer monitor numbers around in all places where we already pass around a GdkScreen. Pass the "current" monitor to these changed APIs, where "current" is either the monitor where the action-triggering widget is, or if that is unavailable the monitor where the mouse is. - add gimp_widget_get_monitor() in order to easily get to the monitor, just like gtk_widget_get_screen(). - add screen and monitor parameters in some places that were missed before. - in sessionrc, save all window positions relative to the window's monitor, and save the monitor separately, if it's not the screen's primary monitor. - when restoring window positions, use the stored monitor when the new prefs options says so (use the screen's primary monitor if there is no stored monitor), otherwise use current monitor that is now passed around.
2014-05-02 09:01:23 +08:00
GTK_WIDGET (window),
monitor);
app: Introduce image window session utility functions Introduce image window session utility functions gimp_image_window_session_clear() and gimp_image_window_session_apply().
2010-03-13 19:56:27 +08:00
gtk_window_unmaximize (GTK_WINDOW (window));
gtk_window_resize (GTK_WINDOW (window), width, height);
}
app: Simplify GimpImageWindow session management Refactor session management with the "gimp-empty-image-window" in GimpImageWindow. In particular, only have one entry point to gimp_dialog_factory_add_foreign() and remove the is_empty instance struct member.
2010-03-13 19:41:06 +08:00
static void
gimp_image_window_session_update (GimpImageWindow *window,
app: Don't unmaximize image window when switching tabs in swm It is when we apply session info to the image window we unmaximize, so don't apply session info to the image window when all we do is switching tabs in single-window mode.
2010-06-19 15:43:27 +08:00
GimpDisplay *new_display,
app: make things behave more reasonable with multiple monitors There is now a preference option that determines whether windows should be opened on the same monitor as before. It should be disabled when the machine gets monitors plugged/unplugged dynamically ("laptop") and enabled when there is a static multi-monitor setup ("wokstation"). This is merely the current simplistic policy on top of the newly added underlying infrastructure: - pass integer monitor numbers around in all places where we already pass around a GdkScreen. Pass the "current" monitor to these changed APIs, where "current" is either the monitor where the action-triggering widget is, or if that is unavailable the monitor where the mouse is. - add gimp_widget_get_monitor() in order to easily get to the monitor, just like gtk_widget_get_screen(). - add screen and monitor parameters in some places that were missed before. - in sessionrc, save all window positions relative to the window's monitor, and save the monitor separately, if it's not the screen's primary monitor. - when restoring window positions, use the stored monitor when the new prefs options says so (use the screen's primary monitor if there is no stored monitor), otherwise use current monitor that is now passed around.
2014-05-02 09:01:23 +08:00
const gchar *new_entry_id,
Port a lot of stuff from GdkScreen/monitor_number to GdkMonitor including some fixes for getting pointer coords, and needed API changes in libgimpwidgets.
2018-04-29 23:27:47 +08:00
GdkMonitor *monitor)
app: Simplify GimpImageWindow session management Refactor session management with the "gimp-empty-image-window" in GimpImageWindow. In particular, only have one entry point to gimp_dialog_factory_add_foreign() and remove the is_empty instance struct member.
2010-03-13 19:41:06 +08:00
{
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
Bug 650348 - Window unmaximizes when a document is closed Refactor GimpImageWindow session management. As far as session management goes, there are four states and four transitions that are interesting. The states are: State Window mode Images opened ------------------------------------------ s1 swm 0 s2 swm >0 s3 mwm 0 s4 mwm >0 The transitions are: Transition Description ------------------------------------------- t1 Enter single-window mode (swm) t2 Enter multi-window mwm (mwm) t3 Open an image t4 Close an image When thinking of it like this, it is pretty easy to see when to call gimp_image_window_session_clear() and when to call gimp_image_window_session_apply(). So kill gimp_image_window_set_entry_id() and handle all transitions in gimp_image_window_session_update().
2011-08-10 02:23:51 +08:00
/* Handle changes to the entry id */
if (new_entry_id)
{
if (! private->entry_id)
{
/* We're initializing. If we're in single-window mode, this
* will be the only window, so start to session manage
* it. If we're in multi-window mode, we will find out if we
* should session manage ourselves when we get a display
*/
if (strcmp (new_entry_id, GIMP_SINGLE_IMAGE_WINDOW_ENTRY_ID) == 0)
{
Port a lot of stuff from GdkScreen/monitor_number to GdkMonitor including some fixes for getting pointer coords, and needed API changes in libgimpwidgets.
2018-04-29 23:27:47 +08:00
gimp_image_window_session_apply (window, new_entry_id, monitor);
Bug 650348 - Window unmaximizes when a document is closed Refactor GimpImageWindow session management. As far as session management goes, there are four states and four transitions that are interesting. The states are: State Window mode Images opened ------------------------------------------ s1 swm 0 s2 swm >0 s3 mwm 0 s4 mwm >0 The transitions are: Transition Description ------------------------------------------- t1 Enter single-window mode (swm) t2 Enter multi-window mwm (mwm) t3 Open an image t4 Close an image When thinking of it like this, it is pretty easy to see when to call gimp_image_window_session_clear() and when to call gimp_image_window_session_apply(). So kill gimp_image_window_set_entry_id() and handle all transitions in gimp_image_window_session_update().
2011-08-10 02:23:51 +08:00
}
}
else if (strcmp (private->entry_id, new_entry_id) != 0)
{
/* The entry id changed, immediately and always stop session
* managing the old entry
*/
gimp_image_window_session_clear (window);
if (strcmp (new_entry_id, GIMP_EMPTY_IMAGE_WINDOW_ENTRY_ID) == 0)
{
/* If there is only one imageless display, we shall
* become the empty image window
*/
if (private->active_shell &&
private->active_shell->display &&
! gimp_display_get_image (private->active_shell->display) &&
g_list_length (private->shells) <= 1)
{
app: make things behave more reasonable with multiple monitors There is now a preference option that determines whether windows should be opened on the same monitor as before. It should be disabled when the machine gets monitors plugged/unplugged dynamically ("laptop") and enabled when there is a static multi-monitor setup ("wokstation"). This is merely the current simplistic policy on top of the newly added underlying infrastructure: - pass integer monitor numbers around in all places where we already pass around a GdkScreen. Pass the "current" monitor to these changed APIs, where "current" is either the monitor where the action-triggering widget is, or if that is unavailable the monitor where the mouse is. - add gimp_widget_get_monitor() in order to easily get to the monitor, just like gtk_widget_get_screen(). - add screen and monitor parameters in some places that were missed before. - in sessionrc, save all window positions relative to the window's monitor, and save the monitor separately, if it's not the screen's primary monitor. - when restoring window positions, use the stored monitor when the new prefs options says so (use the screen's primary monitor if there is no stored monitor), otherwise use current monitor that is now passed around.
2014-05-02 09:01:23 +08:00
gimp_image_window_session_apply (window, new_entry_id,
Port a lot of stuff from GdkScreen/monitor_number to GdkMonitor including some fixes for getting pointer coords, and needed API changes in libgimpwidgets.
2018-04-29 23:27:47 +08:00
monitor);
Bug 650348 - Window unmaximizes when a document is closed Refactor GimpImageWindow session management. As far as session management goes, there are four states and four transitions that are interesting. The states are: State Window mode Images opened ------------------------------------------ s1 swm 0 s2 swm >0 s3 mwm 0 s4 mwm >0 The transitions are: Transition Description ------------------------------------------- t1 Enter single-window mode (swm) t2 Enter multi-window mwm (mwm) t3 Open an image t4 Close an image When thinking of it like this, it is pretty easy to see when to call gimp_image_window_session_clear() and when to call gimp_image_window_session_apply(). So kill gimp_image_window_set_entry_id() and handle all transitions in gimp_image_window_session_update().
2011-08-10 02:23:51 +08:00
}
}
else if (strcmp (new_entry_id, GIMP_SINGLE_IMAGE_WINDOW_ENTRY_ID) == 0)
{
/* As soon as we become the single image window, we
* shall session manage ourself until single-window mode
* is exited
*/
app: make things behave more reasonable with multiple monitors There is now a preference option that determines whether windows should be opened on the same monitor as before. It should be disabled when the machine gets monitors plugged/unplugged dynamically ("laptop") and enabled when there is a static multi-monitor setup ("wokstation"). This is merely the current simplistic policy on top of the newly added underlying infrastructure: - pass integer monitor numbers around in all places where we already pass around a GdkScreen. Pass the "current" monitor to these changed APIs, where "current" is either the monitor where the action-triggering widget is, or if that is unavailable the monitor where the mouse is. - add gimp_widget_get_monitor() in order to easily get to the monitor, just like gtk_widget_get_screen(). - add screen and monitor parameters in some places that were missed before. - in sessionrc, save all window positions relative to the window's monitor, and save the monitor separately, if it's not the screen's primary monitor. - when restoring window positions, use the stored monitor when the new prefs options says so (use the screen's primary monitor if there is no stored monitor), otherwise use current monitor that is now passed around.
2014-05-02 09:01:23 +08:00
gimp_image_window_session_apply (window, new_entry_id,
Port a lot of stuff from GdkScreen/monitor_number to GdkMonitor including some fixes for getting pointer coords, and needed API changes in libgimpwidgets.
2018-04-29 23:27:47 +08:00
monitor);
Bug 650348 - Window unmaximizes when a document is closed Refactor GimpImageWindow session management. As far as session management goes, there are four states and four transitions that are interesting. The states are: State Window mode Images opened ------------------------------------------ s1 swm 0 s2 swm >0 s3 mwm 0 s4 mwm >0 The transitions are: Transition Description ------------------------------------------- t1 Enter single-window mode (swm) t2 Enter multi-window mwm (mwm) t3 Open an image t4 Close an image When thinking of it like this, it is pretty easy to see when to call gimp_image_window_session_clear() and when to call gimp_image_window_session_apply(). So kill gimp_image_window_set_entry_id() and handle all transitions in gimp_image_window_session_update().
2011-08-10 02:23:51 +08:00
}
}
private->entry_id = new_entry_id;
}
app: Session manage empty- and single-image window separately Session manage empty- and single-image window separately. So when starting up, the default 2.6 UI is the same. But when enabling single-window mode, the image window will become much larger then the empty-image window. These conceptually different windows will then from that point be session managed separately: switching mode switches size of the image window.
2010-03-13 23:35:57 +08:00
Bug 650348 - Window unmaximizes when a document is closed Refactor GimpImageWindow session management. As far as session management goes, there are four states and four transitions that are interesting. The states are: State Window mode Images opened ------------------------------------------ s1 swm 0 s2 swm >0 s3 mwm 0 s4 mwm >0 The transitions are: Transition Description ------------------------------------------- t1 Enter single-window mode (swm) t2 Enter multi-window mwm (mwm) t3 Open an image t4 Close an image When thinking of it like this, it is pretty easy to see when to call gimp_image_window_session_clear() and when to call gimp_image_window_session_apply(). So kill gimp_image_window_set_entry_id() and handle all transitions in gimp_image_window_session_update().
2011-08-10 02:23:51 +08:00
/* Handle changes to the displays. When in single-window mode, we
* just keep session managing the single image window. We only need
* to care about the multi-window mode case here
*/
if (new_display &&
strcmp (private->entry_id, GIMP_EMPTY_IMAGE_WINDOW_ENTRY_ID) == 0)
Add notify callback for GimpDisplay's "image" property Will be used to do NIW things later.
2009-09-24 15:58:36 +08:00
{
Bug 650348 - Window unmaximizes when a document is closed Refactor GimpImageWindow session management. As far as session management goes, there are four states and four transitions that are interesting. The states are: State Window mode Images opened ------------------------------------------ s1 swm 0 s2 swm >0 s3 mwm 0 s4 mwm >0 The transitions are: Transition Description ------------------------------------------- t1 Enter single-window mode (swm) t2 Enter multi-window mwm (mwm) t3 Open an image t4 Close an image When thinking of it like this, it is pretty easy to see when to call gimp_image_window_session_clear() and when to call gimp_image_window_session_apply(). So kill gimp_image_window_set_entry_id() and handle all transitions in gimp_image_window_session_update().
2011-08-10 02:23:51 +08:00
if (gimp_display_get_image (new_display))
app: Session manage empty- and single-image window separately Session manage empty- and single-image window separately. So when starting up, the default 2.6 UI is the same. But when enabling single-window mode, the image window will become much larger then the empty-image window. These conceptually different windows will then from that point be session managed separately: switching mode switches size of the image window.
2010-03-13 23:35:57 +08:00
{
/* As soon as we have an image we should not affect the size of the
* empty image window
*/
gimp_image_window_session_clear (window);
}
Bug 650348 - Window unmaximizes when a document is closed Refactor GimpImageWindow session management. As far as session management goes, there are four states and four transitions that are interesting. The states are: State Window mode Images opened ------------------------------------------ s1 swm 0 s2 swm >0 s3 mwm 0 s4 mwm >0 The transitions are: Transition Description ------------------------------------------- t1 Enter single-window mode (swm) t2 Enter multi-window mwm (mwm) t3 Open an image t4 Close an image When thinking of it like this, it is pretty easy to see when to call gimp_image_window_session_clear() and when to call gimp_image_window_session_apply(). So kill gimp_image_window_set_entry_id() and handle all transitions in gimp_image_window_session_update().
2011-08-10 02:23:51 +08:00
else if (! gimp_display_get_image (new_display) &&
app: Session manage empty- and single-image window separately Session manage empty- and single-image window separately. So when starting up, the default 2.6 UI is the same. But when enabling single-window mode, the image window will become much larger then the empty-image window. These conceptually different windows will then from that point be session managed separately: switching mode switches size of the image window.
2010-03-13 23:35:57 +08:00
g_list_length (private->shells) <= 1)
{
/* As soon as we have no image (and no other shells that may
* contain images) we should become the empty image window
*/
app: make things behave more reasonable with multiple monitors There is now a preference option that determines whether windows should be opened on the same monitor as before. It should be disabled when the machine gets monitors plugged/unplugged dynamically ("laptop") and enabled when there is a static multi-monitor setup ("wokstation"). This is merely the current simplistic policy on top of the newly added underlying infrastructure: - pass integer monitor numbers around in all places where we already pass around a GdkScreen. Pass the "current" monitor to these changed APIs, where "current" is either the monitor where the action-triggering widget is, or if that is unavailable the monitor where the mouse is. - add gimp_widget_get_monitor() in order to easily get to the monitor, just like gtk_widget_get_screen(). - add screen and monitor parameters in some places that were missed before. - in sessionrc, save all window positions relative to the window's monitor, and save the monitor separately, if it's not the screen's primary monitor. - when restoring window positions, use the stored monitor when the new prefs options says so (use the screen's primary monitor if there is no stored monitor), otherwise use current monitor that is now passed around.
2014-05-02 09:01:23 +08:00
gimp_image_window_session_apply (window, private->entry_id,
Port a lot of stuff from GdkScreen/monitor_number to GdkMonitor including some fixes for getting pointer coords, and needed API changes in libgimpwidgets.
2018-04-29 23:27:47 +08:00
monitor);
app: Session manage empty- and single-image window separately Session manage empty- and single-image window separately. So when starting up, the default 2.6 UI is the same. But when enabling single-window mode, the image window will become much larger then the empty-image window. These conceptually different windows will then from that point be session managed separately: switching mode switches size of the image window.
2010-03-13 23:35:57 +08:00
}
Add notify callback for GimpDisplay's "image" property Will be used to do NIW things later.
2009-09-24 15:58:36 +08:00
}
app: Session manage empty- and single-image window separately Session manage empty- and single-image window separately. So when starting up, the default 2.6 UI is the same. But when enabling single-window mode, the image window will become much larger then the empty-image window. These conceptually different windows will then from that point be session managed separately: switching mode switches size of the image window.
2010-03-13 23:35:57 +08:00
}
static const gchar *
gimp_image_window_config_to_entry_id (GimpGuiConfig *config)
{
return (config->single_window_mode ?
GIMP_SINGLE_IMAGE_WINDOW_ENTRY_ID :
GIMP_EMPTY_IMAGE_WINDOW_ENTRY_ID);
}
Add a GimpDisplayShell::scaled() handler to GimpImageWindow ...which is connected to the window's active display. Remove updating the window's menubar_manager from GimpDisplayShell's scaled() impl. Had to hack around a bit with the new API to set the window's active display because they are still the same widget.
2009-09-24 00:52:42 +08:00
static void
gimp_image_window_shell_scaled (GimpDisplayShell *shell,
GimpImageWindow *window)
{
/* update the <Image>/View/Zoom menu */
app: defer image menu updates to an idle function In DEs which use a global menu, such as Unity, updating the menu can be expensive. This particularly affects canvas scaling and rotation, for which updating the menu synchronously causes notable lag.
2017-03-01 16:09:24 +08:00
gimp_image_window_update_ui_manager (window);
Add a GimpDisplayShell::scaled() handler to GimpImageWindow ...which is connected to the window's active display. Remove updating the window's menubar_manager from GimpDisplayShell's scaled() impl. Had to hack around a bit with the new API to set the window's active display because they are still the same widget.
2009-09-24 00:52:42 +08:00
}
Add "title" and "status" properties to GimpSisplayShell Set the properties when updating title and status. In GimpImageWindow, connect to notifications of the properties to update window title and statusbar.
2009-09-24 01:33:36 +08:00
app: add signal GimpDisplayShell::rotated and use it to update the menu
2013-04-21 09:15:22 +08:00
static void
gimp_image_window_shell_rotated (GimpDisplayShell *shell,
GimpImageWindow *window)
{
/* update the <Image>/View/Rotate menu */
app: defer image menu updates to an idle function In DEs which use a global menu, such as Unity, updating the menu can be expensive. This particularly affects canvas scaling and rotation, for which updating the menu synchronously causes notable lag.
2017-03-01 16:09:24 +08:00
gimp_image_window_update_ui_manager (window);
app: add signal GimpDisplayShell::rotated and use it to update the menu
2013-04-21 09:15:22 +08:00
}
Add "title" and "status" properties to GimpSisplayShell Set the properties when updating title and status. In GimpImageWindow, connect to notifications of the properties to update window title and statusbar.
2009-09-24 01:33:36 +08:00
static void
gimp_image_window_shell_title_notify (GimpDisplayShell *shell,
const GParamSpec *pspec,
GimpImageWindow *window)
{
gtk_window_set_title (GTK_WINDOW (window), shell->title);
}
app: Add a close button to image window tabs It takes a bit more space, but it needs to be easy to close images.
2011-08-25 04:47:58 +08:00
static void
gimp_image_window_shell_close_button_callback (GimpDisplayShell *shell)
{
if (shell)
gimp_display_shell_close (shell, FALSE);
}
static GtkWidget *
gimp_image_window_create_tab_label (GimpImageWindow *window,
GimpDisplayShell *shell)
{
GtkWidget *hbox;
GtkWidget *view;
GimpImage *image;
GtkWidget *button;
app: use a smaller icon for the image tabs' close button Also make sure the visibility of the icon doesn't depend on GTK+ settings by packing it manually.
2011-09-15 15:04:38 +08:00
GtkWidget *gtk_image;
app: Add a close button to image window tabs It takes a bit more space, but it needs to be easy to close images.
2011-08-25 04:47:58 +08:00
app: use gtk_box_new()
2011-09-30 17:29:11 +08:00
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
app: Add a close button to image window tabs It takes a bit more space, but it needs to be easy to close images.
2011-08-25 04:47:58 +08:00
gtk_widget_show (hbox);
view = gimp_view_new_by_types (gimp_get_user_context (shell->display->gimp),
GIMP_TYPE_VIEW, GIMP_TYPE_IMAGE,
GIMP_VIEW_SIZE_LARGE, 0, FALSE);
Bug 679256 - SWM image tabs must have a minimum width Set all tabs to the same width so very narrow images' tabs stay clickable.
2012-07-10 04:53:17 +08:00
gtk_widget_set_size_request (view, GIMP_VIEW_SIZE_LARGE, -1);
app: add a GimpColorConfig to GimpDisplayShell Use the shell's color config for color managing the display and various auxiliary widgets attached to it, like the notebook tab widget and navigation popup. The config is currently just a reference to the global prefs config, so no behavior changed.
2016-05-14 06:56:26 +08:00
gimp_view_renderer_set_color_config (GIMP_VIEW (view)->renderer,
gimp_display_shell_get_color_config (shell));
app: Add a close button to image window tabs It takes a bit more space, but it needs to be easy to close images.
2011-08-25 04:47:58 +08:00
gtk_box_pack_start (GTK_BOX (hbox), view, FALSE, FALSE, 0);
gtk_widget_show (view);
image = gimp_display_get_image (shell->display);
if (image)
gimp_view_set_viewable (GIMP_VIEW (view), GIMP_VIEWABLE (image));
button = gtk_button_new ();
app: use a smaller icon for the image tabs' close button Also make sure the visibility of the icon doesn't depend on GTK+ settings by packing it manually.
2011-09-15 15:04:38 +08:00
gtk_widget_set_can_focus (button, FALSE);
app: Add a close button to image window tabs It takes a bit more space, but it needs to be easy to close images.
2011-08-25 04:47:58 +08:00
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
app: use a smaller icon for the image tabs' close button Also make sure the visibility of the icon doesn't depend on GTK+ settings by packing it manually.
2011-09-15 15:04:38 +08:00
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
Deprecate stock items for good and change all icon defines to GIMP_ICON_* Try to sort all GIMP_ICON_* defines into FDO categories like in https://specifications.freedesktop.org/icon-naming-spec/latest/ar01s04.html Add defines for all icons we override, rename some icons to their FDO standard names, and mark the ones we duplicate with a comment so we don't forget to rename those to standard names in 3.0.
2017-03-05 23:01:59 +08:00
gtk_image = gtk_image_new_from_icon_name (GIMP_ICON_CLOSE,
app: port most of app's GUI from stock IDs to icon names There is still quite some stock ID rendering around, stay tuned...
2014-05-07 21:30:38 +08:00
GTK_ICON_SIZE_MENU);
app: use a smaller icon for the image tabs' close button Also make sure the visibility of the icon doesn't depend on GTK+ settings by packing it manually.
2011-09-15 15:04:38 +08:00
gtk_container_add (GTK_CONTAINER (button), gtk_image);
gtk_widget_show (gtk_image);
app: Add a close button to image window tabs It takes a bit more space, but it needs to be easy to close images.
2011-08-25 04:47:58 +08:00
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gimp_image_window_shell_close_button_callback),
shell);
Bug 747224 - Too easy to accidentially close an image tab Show the close button only on the active tab, so it's not accidentially hit when changing between images.
2015-04-04 02:28:57 +08:00
g_object_set_data (G_OBJECT (hbox), "close-button", button);
app: Add a close button to image window tabs It takes a bit more space, but it needs to be easy to close images.
2011-08-25 04:47:58 +08:00
return hbox;
}
Bug 747224 - Too easy to accidentially close an image tab Show the close button only on the active tab, so it's not accidentially hit when changing between images.
2015-04-04 02:28:57 +08:00
static void
gimp_image_window_update_tab_labels (GimpImageWindow *window)
{
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
GList *children;
GList *list;
children = gtk_container_get_children (GTK_CONTAINER (private->notebook));
for (list = children; list; list = g_list_next (list))
{
GtkWidget *shell = list->data;
GtkWidget *tab_widget;
GtkWidget *close_button;
tab_widget = gtk_notebook_get_tab_label (GTK_NOTEBOOK (private->notebook),
shell);
close_button = g_object_get_data (G_OBJECT (tab_widget), "close-button");
if (gimp_context_get_display (gimp_get_user_context (private->gimp)) ==
GIMP_DISPLAY_SHELL (shell)->display)
{
gtk_widget_show (close_button);
}
else
{
gtk_widget_hide (close_button);
}
}
g_list_free (children);
}
display: Hook pad controllers into GimpImageWindow We have everything in place to create GtkPadControllers converting events into actions as configured in settings, and the signaling to trigger the (re)generation of those as device, window or configuration changes appear. Only the last bit attaching those controllers to actually handle input was missing, now done in this commit. Since there may be multiple configured tablets and pads, we need to keep track of per-device controllers to handle the configuration for those. This mapping is kept in GimpImageWindow as the "main" toplevel (i.e. the one(s) typically considered "keyboard focus" and receiving pad events) and ensured to be kept up-to-date through the ::configure-pad signal.
2023-06-14 03:45:10 +08:00
static void
gimp_image_window_configure_pad (GimpImageWindow *window,
GimpDeviceInfo *info)
{
GimpImageWindowPrivate *private = GIMP_IMAGE_WINDOW_GET_PRIVATE (window);
GtkPadController *controller;
g_hash_table_remove (private->pad_controllers, info);
if (gimp_device_info_get_device (info, NULL) != NULL)
{
controller =
gimp_device_info_create_pad_controller (info, GIMP_WINDOW (window));
if (controller)
g_hash_table_insert (private->pad_controllers, info, controller);
}
}
static void
gimp_image_window_init_pad_foreach (GimpDeviceInfo *info,
GimpImageWindow *window)
{
if (gimp_device_info_get_device (info, NULL) == NULL)
return;
if (gimp_device_info_get_source (info) != GDK_SOURCE_TABLET_PAD)
return;
gimp_image_window_configure_pad (window, info);
}