2000-07-23 01:18:34 +00:00
|
|
|
/* GDK - The GIMP Drawing Kit
|
|
|
|
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
|
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Library General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library 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
|
|
|
|
* Library General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Library General Public
|
2012-02-27 13:01:10 +00:00
|
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
2000-07-23 01:18:34 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Modified by the GTK+ Team and others 1997-1999. See the AUTHORS
|
|
|
|
* file for a list of people on the GTK+ Team. See the ChangeLog
|
|
|
|
* files for a list of changes. These files are distributed with
|
2015-04-29 07:31:08 +00:00
|
|
|
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
|
2000-07-23 01:18:34 +00:00
|
|
|
*/
|
|
|
|
|
2018-03-20 10:40:08 +00:00
|
|
|
#ifndef __GDK_SURFACE_WIN32_H__
|
|
|
|
#define __GDK_SURFACE_WIN32_H__
|
2000-07-23 01:18:34 +00:00
|
|
|
|
2011-01-02 10:51:25 +00:00
|
|
|
#include "gdk/win32/gdkprivate-win32.h"
|
2018-03-29 23:40:32 +00:00
|
|
|
#include "gdk/win32/gdkwin32cursor.h"
|
2018-03-20 10:46:11 +00:00
|
|
|
#include "gdk/gdksurfaceimpl.h"
|
2011-01-02 10:51:25 +00:00
|
|
|
#include "gdk/gdkcursor.h"
|
2000-07-23 01:18:34 +00:00
|
|
|
|
2011-01-02 10:51:25 +00:00
|
|
|
#include <windows.h>
|
2000-07-23 01:18:34 +00:00
|
|
|
|
2011-01-02 10:51:25 +00:00
|
|
|
G_BEGIN_DECLS
|
2000-07-23 01:18:34 +00:00
|
|
|
|
|
|
|
/* Window implementation for Win32
|
|
|
|
*/
|
|
|
|
|
2018-03-20 10:40:08 +00:00
|
|
|
typedef struct _GdkSurfaceImplWin32 GdkSurfaceImplWin32;
|
|
|
|
typedef struct _GdkSurfaceImplWin32Class GdkSurfaceImplWin32Class;
|
2000-07-23 01:18:34 +00:00
|
|
|
|
2018-03-20 10:40:08 +00:00
|
|
|
#define GDK_TYPE_SURFACE_IMPL_WIN32 (_gdk_surface_impl_win32_get_type ())
|
|
|
|
#define GDK_SURFACE_IMPL_WIN32(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_SURFACE_IMPL_WIN32, GdkSurfaceImplWin32))
|
|
|
|
#define GDK_SURFACE_IMPL_WIN32_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_SURFACE_IMPL_WIN32, GdkSurfaceImplWin32Class))
|
|
|
|
#define GDK_IS_SURFACE_IMPL_WIN32(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_SURFACE_IMPL_WIN32))
|
|
|
|
#define GDK_IS_SURFACE_IMPL_WIN32_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_SURFACE_IMPL_WIN32))
|
|
|
|
#define GDK_SURFACE_IMPL_WIN32_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_SURFACE_IMPL_WIN32, GdkSurfaceImplWin32Class))
|
2000-07-23 01:18:34 +00:00
|
|
|
|
2016-03-08 02:33:47 +00:00
|
|
|
enum _GdkWin32AeroSnapCombo
|
|
|
|
{
|
|
|
|
GDK_WIN32_AEROSNAP_COMBO_NOTHING = 0,
|
|
|
|
GDK_WIN32_AEROSNAP_COMBO_UP,
|
|
|
|
GDK_WIN32_AEROSNAP_COMBO_DOWN,
|
|
|
|
GDK_WIN32_AEROSNAP_COMBO_LEFT,
|
|
|
|
GDK_WIN32_AEROSNAP_COMBO_RIGHT,
|
|
|
|
/* Same order as non-shift variants. We use it to do things like:
|
|
|
|
* AEROSNAP_UP + 4 = AEROSNAP_SHIFTUP
|
|
|
|
*/
|
|
|
|
GDK_WIN32_AEROSNAP_COMBO_SHIFTUP,
|
|
|
|
GDK_WIN32_AEROSNAP_COMBO_SHIFTDOWN,
|
|
|
|
GDK_WIN32_AEROSNAP_COMBO_SHIFTLEFT,
|
|
|
|
GDK_WIN32_AEROSNAP_COMBO_SHIFTRIGHT
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef enum _GdkWin32AeroSnapCombo GdkWin32AeroSnapCombo;
|
|
|
|
|
|
|
|
enum _GdkWin32AeroSnapState
|
|
|
|
{
|
|
|
|
GDK_WIN32_AEROSNAP_STATE_UNDETERMINED = 0,
|
|
|
|
GDK_WIN32_AEROSNAP_STATE_HALFLEFT,
|
|
|
|
GDK_WIN32_AEROSNAP_STATE_HALFRIGHT,
|
|
|
|
GDK_WIN32_AEROSNAP_STATE_FULLUP,
|
2016-03-08 05:03:29 +00:00
|
|
|
/* Maximize state is only used by edge-snap */
|
|
|
|
GDK_WIN32_AEROSNAP_STATE_MAXIMIZE
|
2016-03-08 02:33:47 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
typedef enum _GdkWin32AeroSnapState GdkWin32AeroSnapState;
|
|
|
|
|
|
|
|
struct _GdkRectangleDouble
|
|
|
|
{
|
|
|
|
gdouble x;
|
|
|
|
gdouble y;
|
|
|
|
gdouble width;
|
|
|
|
gdouble height;
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct _GdkRectangleDouble GdkRectangleDouble;
|
|
|
|
|
2016-02-06 12:06:41 +00:00
|
|
|
enum _GdkW32WindowDragOp
|
|
|
|
{
|
|
|
|
GDK_WIN32_DRAGOP_NONE = 0,
|
|
|
|
GDK_WIN32_DRAGOP_RESIZE,
|
|
|
|
GDK_WIN32_DRAGOP_MOVE,
|
|
|
|
GDK_WIN32_DRAGOP_COUNT
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef enum _GdkW32WindowDragOp GdkW32WindowDragOp;
|
|
|
|
|
|
|
|
struct _GdkW32DragMoveResizeContext
|
|
|
|
{
|
2016-03-12 16:26:19 +00:00
|
|
|
/* The window that is being moved/resized */
|
2018-03-20 10:40:08 +00:00
|
|
|
GdkSurface *window;
|
2016-03-12 16:26:19 +00:00
|
|
|
|
2016-02-06 12:06:41 +00:00
|
|
|
/* The kind of drag-operation going on. */
|
|
|
|
GdkW32WindowDragOp op;
|
|
|
|
|
|
|
|
/* The edge that was grabbed for resizing. Not used for moving. */
|
2018-03-20 10:40:08 +00:00
|
|
|
GdkSurfaceEdge edge;
|
2016-02-06 12:06:41 +00:00
|
|
|
|
2016-02-27 00:10:12 +00:00
|
|
|
/* The device used to initiate the op.
|
|
|
|
* We grab it at the beginning and ungrab it at the end.
|
|
|
|
*/
|
2016-02-06 12:06:41 +00:00
|
|
|
GdkDevice *device;
|
|
|
|
|
2016-02-27 00:10:12 +00:00
|
|
|
/* The button pressed down to initiate the op.
|
|
|
|
* The op will be canceled only when *this* button
|
|
|
|
* is released.
|
|
|
|
*/
|
2016-02-06 12:06:41 +00:00
|
|
|
gint button;
|
|
|
|
|
|
|
|
/* Initial cursor position when the operation began.
|
|
|
|
* Current cursor position is subtracted from it to find how far
|
|
|
|
* to move window border(s).
|
|
|
|
*/
|
|
|
|
gint start_root_x;
|
|
|
|
gint start_root_y;
|
|
|
|
|
|
|
|
/* Initial window rectangle (position and size).
|
|
|
|
* The window is resized/moved relative to this (see start_root_*).
|
|
|
|
*/
|
|
|
|
RECT start_rect;
|
|
|
|
|
|
|
|
/* Not used */
|
|
|
|
guint32 timestamp;
|
|
|
|
|
|
|
|
/* TRUE if during the next redraw we should call SetWindowPos() to push
|
|
|
|
* the window size and poistion to the native window.
|
|
|
|
*/
|
|
|
|
gboolean native_move_resize_pending;
|
2016-02-27 00:10:12 +00:00
|
|
|
|
|
|
|
/* The cursor we should use while the operation is running. */
|
|
|
|
GdkCursor *cursor;
|
2016-03-08 05:03:29 +00:00
|
|
|
|
|
|
|
/* This window looks like an outline and is drawn under the window
|
|
|
|
* that is being dragged. It indicates the shape the dragged window
|
|
|
|
* will take if released at a particular point.
|
2016-03-12 16:26:19 +00:00
|
|
|
* Indicator window size always matches the target indicator shape,
|
|
|
|
* the the actual indicator drawn on it might not, depending on
|
|
|
|
* how much time elapsed since the animation started.
|
2016-03-08 05:03:29 +00:00
|
|
|
*/
|
|
|
|
HWND shape_indicator;
|
|
|
|
|
2016-03-12 16:26:19 +00:00
|
|
|
/* Used to draw the indicator */
|
|
|
|
cairo_surface_t *indicator_surface;
|
|
|
|
gint indicator_surface_width;
|
|
|
|
gint indicator_surface_height;
|
|
|
|
|
|
|
|
/* Size/position of shape_indicator */
|
|
|
|
GdkRectangle indicator_window_rect;
|
|
|
|
|
|
|
|
/* Indicator will animate to occupy this rectangle */
|
|
|
|
GdkRectangle indicator_target;
|
|
|
|
|
|
|
|
/* Indicator will start animating from this rectangle */
|
|
|
|
GdkRectangle indicator_start;
|
|
|
|
|
|
|
|
/* Timestamp of the animation start */
|
|
|
|
gint64 indicator_start_time;
|
|
|
|
|
|
|
|
/* Timer that drives the animation */
|
|
|
|
guint timer;
|
|
|
|
|
|
|
|
/* A special timestamp, if we want to draw not how
|
|
|
|
* the animation should look *now*, but how it should
|
|
|
|
* look at arbitrary moment of time.
|
|
|
|
* Set to 0 to tell GDK to use current time.
|
|
|
|
*/
|
|
|
|
gint64 draw_timestamp;
|
|
|
|
|
2016-03-08 05:03:29 +00:00
|
|
|
/* Indicates that a transformation was revealed:
|
|
|
|
*
|
|
|
|
* For drag-resize: If it's FALSE,
|
|
|
|
* then the pointer have not yet hit a trigger that triggers fullup.
|
|
|
|
* If TRUE, then the pointer did hit a trigger that triggers fullup
|
|
|
|
* at some point during this drag op.
|
|
|
|
* This is used to prevent drag-resize from triggering
|
|
|
|
* a transformation when first approaching a trigger of the work area -
|
|
|
|
* one must drag it all the way to the very trigger to trigger; afterwards
|
|
|
|
* a transformation will start triggering at some distance from the trigger
|
|
|
|
* for as long as the op is still running. This is how AeroSnap works.
|
|
|
|
*
|
|
|
|
* For drag-move: If it's FALSE,
|
|
|
|
* then the pointer have not yet hit a trigger, even if it is
|
|
|
|
* already within a edge region.
|
|
|
|
* If it's TRUE, then the pointer did hit a trigger within an
|
|
|
|
* edge region, and have not yet left an edge region
|
|
|
|
* (passing from one edge region into another doesn't count).
|
|
|
|
*/
|
|
|
|
gboolean revealed;
|
|
|
|
|
|
|
|
/* Arrays of GdkRectangle pairs, describing the areas of the virtual
|
|
|
|
* desktop that trigger various AeroSnap window transofrmations
|
|
|
|
* Coordinates are GDK screen coordinates.
|
|
|
|
*/
|
|
|
|
GArray *halfleft_regions;
|
|
|
|
GArray *halfright_regions;
|
|
|
|
GArray *maximize_regions;
|
|
|
|
GArray *fullup_regions;
|
|
|
|
|
|
|
|
/* Current pointer position will result in this kind of snapping,
|
|
|
|
* if the drag op is finished.
|
|
|
|
*/
|
|
|
|
GdkWin32AeroSnapState current_snap;
|
2016-02-06 12:06:41 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct _GdkW32DragMoveResizeContext GdkW32DragMoveResizeContext;
|
|
|
|
|
GDK W32: Adapt to GdkDrop and GdkDragContext changes
* Remove clipdrop->dnd_target_state, it's not used anymore
* Remove non-functioning _gdk_dropfiles_store(), store dropfiles
list in GdkWin32Drop instead
* Fix multiple comment typos
* Fix _gdk_win32_get_clipboard_format_name_as_interned_mimetype() to
leave names that look like mime/types alone
* Refactor _gdk_win32_add_w32format_to_pairs() to populate
GdkContentFormatsBuilder directly, instead of making a GList
* Rename context -> drag (still using GdkDragContext type,
but [almost?] all variables and comments say "drag" now)
* Rename GdkDropContext -> GdkDrop
* Rename some parameter names for clarity
* Rewrite local protocol to look more like OLE2 protocol
instead of mirroring the structure of the X11 API.
* Add handle_events field to GdkWin32DragContext,
to shut off event handling (temporary fix until GTK is patched up)
* Remove _gdk_win32_drag_context_find() - the drag object is stored
in GdkDrop instead. Use _gdk_win32_find_drag_for_dest_surface()
to get it initially.
* Remove target_ctx_for_window, droptarget context is stored
in the surface instead.
* Call gdk_drag_context_set_cursor() just like wayland backend does
(slightly broken for now)
* Clean up the action choosing code (filter source actions by using
keyboard state, pass that to GTK, get all actions supported by GTK in
response, match them up with filtered source actions, return the
result, falling back to COPY in case of multiple actions)
* Check drag_win32->protocol instead of the use_ole2_dnd variable where
possible
* Remove protocol checks from functions that are only used by the local
protocol
* Use event state to manufacture the keyboard state for WM_MOUSEMOVE
* Change function names printed by GDK_NOTE to name the actual
functions, not their theoretical generic GDK stack ancestors
* Consistently use drag_win32 and drop_win32 variables instead of a mix
of that and win32_drag/win32_drop
* Return FALSE from button handler to ensure that GTK gets the button
event to break implicit grab
* Emit leave event on failed idroptarget_drop() calls
2018-06-05 23:03:51 +00:00
|
|
|
/* defined in gdkdrop-win32.c */
|
|
|
|
typedef struct _drop_target_context drop_target_context;
|
|
|
|
|
2018-03-20 10:40:08 +00:00
|
|
|
struct _GdkSurfaceImplWin32
|
2000-07-23 01:18:34 +00:00
|
|
|
{
|
2018-03-20 10:40:08 +00:00
|
|
|
GdkSurfaceImpl parent_instance;
|
2011-01-02 10:51:25 +00:00
|
|
|
|
2018-03-20 10:40:08 +00:00
|
|
|
GdkSurface *wrapper;
|
2011-01-02 10:51:25 +00:00
|
|
|
HANDLE handle;
|
2000-07-23 01:18:34 +00:00
|
|
|
|
2003-12-14 01:06:56 +00:00
|
|
|
HICON hicon_big;
|
|
|
|
HICON hicon_small;
|
2000-07-23 01:18:34 +00:00
|
|
|
|
2018-03-29 23:40:32 +00:00
|
|
|
/* The cursor that GDK set for this window via GdkDevice */
|
|
|
|
GdkWin32HCursor *cursor;
|
|
|
|
|
2016-07-24 14:26:06 +00:00
|
|
|
/* When VK_PACKET sends us a leading surrogate, it's stashed here.
|
|
|
|
* Later, when another VK_PACKET sends a tailing surrogate, we make up
|
|
|
|
* a full unicode character from them, or discard the leading surrogate,
|
|
|
|
* if the next key is not a tailing surrogate.
|
|
|
|
*/
|
|
|
|
wchar_t leading_surrogate_keydown;
|
|
|
|
wchar_t leading_surrogate_keyup;
|
|
|
|
|
2000-07-23 01:18:34 +00:00
|
|
|
/* Window size hints */
|
|
|
|
gint hint_flags;
|
2003-08-02 02:05:12 +00:00
|
|
|
GdkGeometry hints;
|
2000-07-23 01:18:34 +00:00
|
|
|
|
GDK W32: Adapt to GdkDrop and GdkDragContext changes
* Remove clipdrop->dnd_target_state, it's not used anymore
* Remove non-functioning _gdk_dropfiles_store(), store dropfiles
list in GdkWin32Drop instead
* Fix multiple comment typos
* Fix _gdk_win32_get_clipboard_format_name_as_interned_mimetype() to
leave names that look like mime/types alone
* Refactor _gdk_win32_add_w32format_to_pairs() to populate
GdkContentFormatsBuilder directly, instead of making a GList
* Rename context -> drag (still using GdkDragContext type,
but [almost?] all variables and comments say "drag" now)
* Rename GdkDropContext -> GdkDrop
* Rename some parameter names for clarity
* Rewrite local protocol to look more like OLE2 protocol
instead of mirroring the structure of the X11 API.
* Add handle_events field to GdkWin32DragContext,
to shut off event handling (temporary fix until GTK is patched up)
* Remove _gdk_win32_drag_context_find() - the drag object is stored
in GdkDrop instead. Use _gdk_win32_find_drag_for_dest_surface()
to get it initially.
* Remove target_ctx_for_window, droptarget context is stored
in the surface instead.
* Call gdk_drag_context_set_cursor() just like wayland backend does
(slightly broken for now)
* Clean up the action choosing code (filter source actions by using
keyboard state, pass that to GTK, get all actions supported by GTK in
response, match them up with filtered source actions, return the
result, falling back to COPY in case of multiple actions)
* Check drag_win32->protocol instead of the use_ole2_dnd variable where
possible
* Remove protocol checks from functions that are only used by the local
protocol
* Use event state to manufacture the keyboard state for WM_MOUSEMOVE
* Change function names printed by GDK_NOTE to name the actual
functions, not their theoretical generic GDK stack ancestors
* Consistently use drag_win32 and drop_win32 variables instead of a mix
of that and win32_drag/win32_drop
* Return FALSE from button handler to ensure that GTK gets the button
event to break implicit grab
* Emit leave event on failed idroptarget_drop() calls
2018-06-05 23:03:51 +00:00
|
|
|
/* Non-NULL for any window that is registered as a drop target.
|
|
|
|
* For OLE2 protocol only.
|
|
|
|
*/
|
|
|
|
drop_target_context *drop_target;
|
|
|
|
/* Temporarily holds the GdkDrop currently associated with this window.
|
|
|
|
* For LOCAL protocol only.
|
|
|
|
*/
|
|
|
|
GdkDrop *drop;
|
|
|
|
|
2018-03-20 10:40:08 +00:00
|
|
|
GdkSurfaceTypeHint type_hint;
|
2005-11-09 02:13:35 +00:00
|
|
|
|
2018-03-20 10:40:08 +00:00
|
|
|
GdkSurface *transient_owner;
|
2007-10-18 00:31:22 +00:00
|
|
|
GSList *transient_children;
|
|
|
|
gint num_transients;
|
|
|
|
gboolean changing_state;
|
2009-02-14 18:23:54 +00:00
|
|
|
|
2011-10-27 14:09:42 +00:00
|
|
|
gint initial_x;
|
|
|
|
gint initial_y;
|
|
|
|
|
2016-03-15 10:15:14 +00:00
|
|
|
/* left/right/top/bottom width of the shadow/resize-grip around the window */
|
|
|
|
RECT margins;
|
|
|
|
|
|
|
|
/* left+right and top+bottom from @margins */
|
|
|
|
gint margins_x;
|
|
|
|
gint margins_y;
|
|
|
|
|
2016-03-15 10:17:45 +00:00
|
|
|
/* Set to TRUE when GTK tells us that margins are 0 everywhere.
|
|
|
|
* We don't actually set margins to 0, we just set this bit.
|
|
|
|
*/
|
|
|
|
guint zero_margins : 1;
|
2009-02-14 18:23:54 +00:00
|
|
|
guint no_bg : 1;
|
2011-10-27 08:42:07 +00:00
|
|
|
guint inhibit_configure : 1;
|
2011-01-02 10:51:25 +00:00
|
|
|
|
2016-02-23 09:20:55 +00:00
|
|
|
/* Set to TRUE if window is using true layered mode adjustments
|
|
|
|
* via UpdateLayeredWindow().
|
|
|
|
* Layered windows that get SetLayeredWindowAttributes() called
|
|
|
|
* on them are not true layered windows.
|
|
|
|
*/
|
|
|
|
guint layered : 1;
|
|
|
|
|
2016-03-18 04:51:52 +00:00
|
|
|
/* If TRUE, the @temp_styles is set to the styles that were temporarily
|
|
|
|
* added to this window.
|
|
|
|
*/
|
|
|
|
guint have_temp_styles : 1;
|
|
|
|
|
2016-12-11 16:26:34 +00:00
|
|
|
/* If TRUE, the window is in the process of being maximized.
|
2018-03-20 10:40:08 +00:00
|
|
|
* This is set by WM_SYSCOMMAND and by gdk_win32_surface_maximize (),
|
2016-12-11 16:26:34 +00:00
|
|
|
* and is unset when WM_WINDOWPOSCHANGING is handled.
|
|
|
|
*/
|
|
|
|
guint maximizing : 1;
|
|
|
|
|
2016-02-23 09:20:55 +00:00
|
|
|
/* GDK does not keep window contents around, it just draws new
|
|
|
|
* stuff over the window where changes occurred.
|
|
|
|
* cache_surface retains old window contents, because
|
|
|
|
* UpdateLayeredWindow() doesn't do partial redraws.
|
|
|
|
*/
|
|
|
|
cairo_surface_t *cache_surface;
|
|
|
|
|
|
|
|
/* Unlike window-backed surfaces, DIB-backed surface
|
|
|
|
* does not provide a way to query its size,
|
|
|
|
* so we have to remember it ourselves.
|
|
|
|
*/
|
|
|
|
gint dib_width;
|
|
|
|
gint dib_height;
|
|
|
|
|
|
|
|
/* If the client wants uniformly-transparent window,
|
|
|
|
* we remember the opacity value here and apply it
|
|
|
|
* during UpdateLayredWindow() call, for layered windows.
|
|
|
|
*/
|
|
|
|
gdouble layered_opacity;
|
|
|
|
|
2011-01-02 10:51:25 +00:00
|
|
|
HDC hdc;
|
|
|
|
int hdc_count;
|
|
|
|
HBITMAP saved_dc_bitmap; /* Original bitmap for dc */
|
2016-02-06 12:06:41 +00:00
|
|
|
|
|
|
|
GdkW32DragMoveResizeContext drag_move_resize_context;
|
2016-02-23 09:20:55 +00:00
|
|
|
|
2016-03-08 02:33:47 +00:00
|
|
|
/* Remembers where the window was snapped.
|
|
|
|
* Some snap operations change their meaning if
|
|
|
|
* the window is already snapped.
|
|
|
|
*/
|
|
|
|
GdkWin32AeroSnapState snap_state;
|
|
|
|
|
|
|
|
/* Remembers window position before it was snapped.
|
|
|
|
* This is used to unsnap it.
|
|
|
|
* Position and size are percentages of the workarea
|
|
|
|
* of the monitor on which the window was before it was snapped.
|
|
|
|
*/
|
|
|
|
GdkRectangleDouble *snap_stash;
|
|
|
|
|
2016-03-08 03:17:09 +00:00
|
|
|
/* Also remember the same position, but in absolute form. */
|
|
|
|
GdkRectangle *snap_stash_int;
|
|
|
|
|
2018-03-20 10:40:08 +00:00
|
|
|
/* Decorations set by gdk_surface_set_decorations() or NULL if unset */
|
2016-02-23 09:20:55 +00:00
|
|
|
GdkWMDecoration* decorations;
|
2016-03-05 03:34:16 +00:00
|
|
|
|
|
|
|
/* No. of windows to force layered windows off */
|
|
|
|
guint suppress_layered;
|
2016-03-18 04:51:52 +00:00
|
|
|
|
|
|
|
/* Temporary styles that this window got for the purpose of
|
|
|
|
* handling WM_SYSMENU.
|
|
|
|
* They are removed at the first opportunity (usually WM_INITMENU).
|
|
|
|
*/
|
|
|
|
LONG_PTR temp_styles;
|
GDK-Win32/4.0: Enable HiDPI support for Windows
This enables HiDPI support for GTK+ on Windows, so that the
fonts and window look better on HiDPI displays. Notes for the current
work:
-The DPI awareness enabling can be disabled if and only if an application
manifest is not embedded in the app to enable DPI awareness AND a user
compatibility setting is not set to limit DPI awareness for the app, via
the envvar GDK_WIN32_DISABLE_HIDPI. The app manifest/user setting for
DPI awareness will always win against the envvar, and so the HiDPI items
will be always setup in such scenarios, unless DPI awareness is disabled.
-Both automatic detection for the scaling factor and setting the scale
factor using the GDK_SCALE envvar are supported, where the envvar takes
precedence, which will therefore disable automatic scaling when
resolution changes.
-We now default to a per-system DPI awareness model, which means that we
do not handle WM_DPICHANGED, unless one sets the
GDK_WIN32_PER_MONITOR_HIDPI envvar, where notes for it are in the
following point.
-Automatic scaling during WM_DISPLAYCHANGE is handled (DPI setting change of
current monitor) is now supported. WM_DPICHANGED is handled as well,
except that the window positioning during the change of scaling still
needs to be refined, a change in GDK itself may be required for this.
-I am unable to test the wintab items because I don't have such devices
around.
https://bugzilla.gnome.org/show_bug.cgi?id=768081
2016-06-27 05:16:43 +00:00
|
|
|
|
|
|
|
/* scale of window on HiDPI */
|
2018-03-20 11:05:26 +00:00
|
|
|
gint surface_scale;
|
GDK-Win32/4.0: Enable HiDPI support for Windows
This enables HiDPI support for GTK+ on Windows, so that the
fonts and window look better on HiDPI displays. Notes for the current
work:
-The DPI awareness enabling can be disabled if and only if an application
manifest is not embedded in the app to enable DPI awareness AND a user
compatibility setting is not set to limit DPI awareness for the app, via
the envvar GDK_WIN32_DISABLE_HIDPI. The app manifest/user setting for
DPI awareness will always win against the envvar, and so the HiDPI items
will be always setup in such scenarios, unless DPI awareness is disabled.
-Both automatic detection for the scaling factor and setting the scale
factor using the GDK_SCALE envvar are supported, where the envvar takes
precedence, which will therefore disable automatic scaling when
resolution changes.
-We now default to a per-system DPI awareness model, which means that we
do not handle WM_DPICHANGED, unless one sets the
GDK_WIN32_PER_MONITOR_HIDPI envvar, where notes for it are in the
following point.
-Automatic scaling during WM_DISPLAYCHANGE is handled (DPI setting change of
current monitor) is now supported. WM_DPICHANGED is handled as well,
except that the window positioning during the change of scaling still
needs to be refined, a change in GDK itself may be required for this.
-I am unable to test the wintab items because I don't have such devices
around.
https://bugzilla.gnome.org/show_bug.cgi?id=768081
2016-06-27 05:16:43 +00:00
|
|
|
gint unscaled_width;
|
|
|
|
gint unscaled_height;
|
2000-07-23 01:18:34 +00:00
|
|
|
};
|
2015-04-29 07:31:08 +00:00
|
|
|
|
2018-03-20 10:40:08 +00:00
|
|
|
struct _GdkSurfaceImplWin32Class
|
2000-07-23 01:18:34 +00:00
|
|
|
{
|
2018-03-20 10:40:08 +00:00
|
|
|
GdkSurfaceImplClass parent_class;
|
2000-07-23 01:18:34 +00:00
|
|
|
};
|
|
|
|
|
2018-03-20 10:40:08 +00:00
|
|
|
GType _gdk_surface_impl_win32_get_type (void);
|
2000-07-23 01:18:34 +00:00
|
|
|
|
2018-03-20 10:40:08 +00:00
|
|
|
void _gdk_win32_surface_tmp_unset_bg (GdkSurface *window,
|
2018-03-21 08:06:31 +00:00
|
|
|
gboolean recurse);
|
2018-03-20 10:40:08 +00:00
|
|
|
void _gdk_win32_surface_tmp_reset_bg (GdkSurface *window,
|
2018-03-21 08:06:31 +00:00
|
|
|
gboolean recurse);
|
2009-02-24 15:52:32 +00:00
|
|
|
|
2018-03-20 10:40:08 +00:00
|
|
|
void _gdk_win32_surface_tmp_unset_parent_bg (GdkSurface *window);
|
|
|
|
void _gdk_win32_surface_tmp_reset_parent_bg (GdkSurface *window);
|
2009-02-24 15:52:32 +00:00
|
|
|
|
2018-03-20 10:40:08 +00:00
|
|
|
void _gdk_win32_surface_update_style_bits (GdkSurface *window);
|
2016-03-08 05:00:49 +00:00
|
|
|
|
2018-03-20 10:40:08 +00:00
|
|
|
gint _gdk_win32_surface_get_scale_factor (GdkSurface *window);
|
GDK-Win32/4.0: Enable HiDPI support for Windows
This enables HiDPI support for GTK+ on Windows, so that the
fonts and window look better on HiDPI displays. Notes for the current
work:
-The DPI awareness enabling can be disabled if and only if an application
manifest is not embedded in the app to enable DPI awareness AND a user
compatibility setting is not set to limit DPI awareness for the app, via
the envvar GDK_WIN32_DISABLE_HIDPI. The app manifest/user setting for
DPI awareness will always win against the envvar, and so the HiDPI items
will be always setup in such scenarios, unless DPI awareness is disabled.
-Both automatic detection for the scaling factor and setting the scale
factor using the GDK_SCALE envvar are supported, where the envvar takes
precedence, which will therefore disable automatic scaling when
resolution changes.
-We now default to a per-system DPI awareness model, which means that we
do not handle WM_DPICHANGED, unless one sets the
GDK_WIN32_PER_MONITOR_HIDPI envvar, where notes for it are in the
following point.
-Automatic scaling during WM_DISPLAYCHANGE is handled (DPI setting change of
current monitor) is now supported. WM_DPICHANGED is handled as well,
except that the window positioning during the change of scaling still
needs to be refined, a change in GDK itself may be required for this.
-I am unable to test the wintab items because I don't have such devices
around.
https://bugzilla.gnome.org/show_bug.cgi?id=768081
2016-06-27 05:16:43 +00:00
|
|
|
|
2018-04-24 15:14:23 +00:00
|
|
|
void _gdk_win32_get_window_client_area_rect (GdkSurface *window,
|
|
|
|
gint scale,
|
|
|
|
RECT *rect);
|
|
|
|
void _gdk_win32_update_layered_window_from_cache (GdkSurface *window,
|
|
|
|
RECT *client_rect,
|
|
|
|
gboolean do_move,
|
|
|
|
gboolean do_resize,
|
|
|
|
gboolean do_paint);
|
|
|
|
|
|
|
|
|
2019-04-01 06:44:53 +00:00
|
|
|
void
|
|
|
|
gdk_win32_surface_get_queued_window_rect (GdkSurface *surface,
|
|
|
|
gint scale,
|
|
|
|
RECT *return_window_rect);
|
|
|
|
|
|
|
|
void
|
|
|
|
gdk_win32_surface_apply_queued_move_resize (GdkSurface *surface,
|
|
|
|
RECT window_rect);
|
|
|
|
|
2005-06-12 05:32:25 +00:00
|
|
|
G_END_DECLS
|
2000-07-23 01:18:34 +00:00
|
|
|
|
2018-03-20 10:40:08 +00:00
|
|
|
#endif /* __GDK_SURFACE_WIN32_H__ */
|