[mirror_qemu.git] / include / ui / gtk.h

#ifndef UI_GTK_H
#define UI_GTK_H

/* Work around an -Wstrict-prototypes warning in GTK headers */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-prototypes"
#include <gtk/gtk.h>
#pragma GCC diagnostic pop

#include <gdk/gdkkeysyms.h>

#ifdef GDK_WINDOWING_X11
#include <gdk/gdkx.h>
#include <X11/XKBlib.h>
#endif

#ifdef GDK_WINDOWING_WAYLAND
#include <gdk/gdkwayland.h>
#endif

#include "ui/clipboard.h"
#include "ui/console.h"
#include "ui/kbd-state.h"
#if defined(CONFIG_OPENGL)
#include "ui/egl-helpers.h"
#include "ui/egl-context.h"
#endif
#ifdef CONFIG_VTE
#include "qemu/fifo8.h"
#endif

#define MAX_VCS 10

typedef struct GtkDisplayState GtkDisplayState;

typedef struct VirtualGfxConsole {
    GtkWidget *drawing_area;
    DisplayGLCtx dgc;
    DisplayChangeListener dcl;
    QKbdState *kbd;
    DisplaySurface *ds;
    pixman_image_t *convert;
    cairo_surface_t *surface;
    double scale_x;
    double scale_y;
#if defined(CONFIG_OPENGL)
    QemuGLShader *gls;
    EGLContext ectx;
    EGLSurface esurface;
    int glupdates;
    int x, y, w, h;
    egl_fb guest_fb;
    egl_fb win_fb;
    egl_fb cursor_fb;
    int cursor_x;
    int cursor_y;
    bool y0_top;
    bool scanout_mode;
    bool has_dmabuf;
#endif
} VirtualGfxConsole;

#if defined(CONFIG_VTE)
typedef struct VirtualVteConsole {
    GtkWidget *box;
    GtkWidget *scrollbar;
    GtkWidget *terminal;
    Chardev *chr;
    Fifo8 out_fifo;
    bool echo;
} VirtualVteConsole;
#endif

typedef enum VirtualConsoleType {
    GD_VC_GFX,
    GD_VC_VTE,
} VirtualConsoleType;

typedef struct VirtualConsole {
    GtkDisplayState *s;
    char *label;
    GtkWidget *window;
    GtkWidget *menu_item;
    GtkWidget *tab_item;
    GtkWidget *focus;
    VirtualConsoleType type;
    union {
        VirtualGfxConsole gfx;
#if defined(CONFIG_VTE)
        VirtualVteConsole vte;
#endif
    };
} VirtualConsole;

struct GtkDisplayState {
    GtkWidget *window;

    GtkWidget *menu_bar;

    GtkAccelGroup *accel_group;

    GtkWidget *machine_menu_item;
    GtkWidget *machine_menu;
    GtkWidget *pause_item;
    GtkWidget *reset_item;
    GtkWidget *powerdown_item;
    GtkWidget *quit_item;

    GtkWidget *view_menu_item;
    GtkWidget *view_menu;
    GtkWidget *full_screen_item;
    GtkWidget *copy_item;
    GtkWidget *zoom_in_item;
    GtkWidget *zoom_out_item;
    GtkWidget *zoom_fixed_item;
    GtkWidget *zoom_fit_item;
    GtkWidget *grab_item;
    GtkWidget *grab_on_hover_item;

    int nb_vcs;
    VirtualConsole vc[MAX_VCS];

    GtkWidget *show_tabs_item;
    GtkWidget *untabify_item;
    GtkWidget *show_menubar_item;

    GtkWidget *vbox;
    GtkWidget *notebook;
    int button_mask;
    gboolean last_set;
    int last_x;
    int last_y;
    int grab_x_root;
    int grab_y_root;
    VirtualConsole *kbd_owner;
    VirtualConsole *ptr_owner;

    gboolean full_screen;

    GdkCursor *null_cursor;
    Notifier mouse_mode_notifier;
    gboolean free_scale;

    bool external_pause_update;

    QemuClipboardPeer cbpeer;
    uint32_t cbpending[QEMU_CLIPBOARD_SELECTION__COUNT];
    GtkClipboard *gtkcb[QEMU_CLIPBOARD_SELECTION__COUNT];
    bool cbowner[QEMU_CLIPBOARD_SELECTION__COUNT];

    DisplayOptions *opts;
};

extern bool gtk_use_gl_area;

/* ui/gtk.c */
void gd_update_windowsize(VirtualConsole *vc);
void gd_update_monitor_refresh_rate(VirtualConsole *vc, GtkWidget *widget);
void gd_hw_gl_flushed(void *vc);

/* ui/gtk-egl.c */
void gd_egl_init(VirtualConsole *vc);
void gd_egl_draw(VirtualConsole *vc);
void gd_egl_update(DisplayChangeListener *dcl,
                   int x, int y, int w, int h);
void gd_egl_refresh(DisplayChangeListener *dcl);
void gd_egl_switch(DisplayChangeListener *dcl,
                   DisplaySurface *surface);
QEMUGLContext gd_egl_create_context(DisplayGLCtx *dgc,
                                    QEMUGLParams *params);
void gd_egl_scanout_disable(DisplayChangeListener *dcl);
void gd_egl_scanout_texture(DisplayChangeListener *dcl,
                            uint32_t backing_id,
                            bool backing_y_0_top,
                            uint32_t backing_width,
                            uint32_t backing_height,
                            uint32_t x, uint32_t y,
                            uint32_t w, uint32_t h,
                            void *d3d_tex2d);
void gd_egl_scanout_dmabuf(DisplayChangeListener *dcl,
                           QemuDmaBuf *dmabuf);
void gd_egl_cursor_dmabuf(DisplayChangeListener *dcl,
                          QemuDmaBuf *dmabuf, bool have_hot,
                          uint32_t hot_x, uint32_t hot_y);
void gd_egl_cursor_position(DisplayChangeListener *dcl,
                            uint32_t pos_x, uint32_t pos_y);
void gd_egl_flush(DisplayChangeListener *dcl,
                  uint32_t x, uint32_t y, uint32_t w, uint32_t h);
void gd_egl_scanout_flush(DisplayChangeListener *dcl,
                          uint32_t x, uint32_t y, uint32_t w, uint32_t h);
void gtk_egl_init(DisplayGLMode mode);
int gd_egl_make_current(DisplayGLCtx *dgc,
                        QEMUGLContext ctx);

/* ui/gtk-gl-area.c */
void gd_gl_area_init(VirtualConsole *vc);
void gd_gl_area_draw(VirtualConsole *vc);
void gd_gl_area_update(DisplayChangeListener *dcl,
                       int x, int y, int w, int h);
void gd_gl_area_refresh(DisplayChangeListener *dcl);
void gd_gl_area_switch(DisplayChangeListener *dcl,
                       DisplaySurface *surface);
QEMUGLContext gd_gl_area_create_context(DisplayGLCtx *dgc,
                                        QEMUGLParams *params);
void gd_gl_area_destroy_context(DisplayGLCtx *dgc,
                                QEMUGLContext ctx);
void gd_gl_area_scanout_dmabuf(DisplayChangeListener *dcl,
                               QemuDmaBuf *dmabuf);
void gd_gl_area_scanout_texture(DisplayChangeListener *dcl,
                                uint32_t backing_id,
                                bool backing_y_0_top,
                                uint32_t backing_width,
                                uint32_t backing_height,
                                uint32_t x, uint32_t y,
                                uint32_t w, uint32_t h,
                                void *d3d_tex2d);
void gd_gl_area_scanout_disable(DisplayChangeListener *dcl);
void gd_gl_area_scanout_flush(DisplayChangeListener *dcl,
                              uint32_t x, uint32_t y, uint32_t w, uint32_t h);
void gtk_gl_area_init(void);
int gd_gl_area_make_current(DisplayGLCtx *dgc,
                            QEMUGLContext ctx);

/* gtk-clipboard.c */
void gd_clipboard_init(GtkDisplayState *gd);

#endif /* UI_GTK_H */
Commit	Line	Data
dc7ff344 GH	1	#ifndef UI_GTK_H
	2	#define UI_GTK_H
	3
dc7ff344 GH	4	/* Work around an -Wstrict-prototypes warning in GTK headers */
	5	#pragma GCC diagnostic push
	6	#pragma GCC diagnostic ignored "-Wstrict-prototypes"
dc7ff344	7	#include <gtk/gtk.h>
dc7ff344	8	#pragma GCC diagnostic pop
dc7ff344 GH	9
	10	#include <gdk/gdkkeysyms.h>
	11
	12	#ifdef GDK_WINDOWING_X11
	13	#include <gdk/gdkx.h>
	14	#include <X11/XKBlib.h>
	15	#endif
	16
a8ffb372 DB	17	#ifdef GDK_WINDOWING_WAYLAND
	18	#include <gdk/gdkwayland.h>
	19	#endif
	20
d11ebe2c	21	#include "ui/clipboard.h"
5f692f57	22	#include "ui/console.h"
0c0d4273	23	#include "ui/kbd-state.h"
97edf3bd GH	24	#if defined(CONFIG_OPENGL)
97edf3bd GH	25	#include "ui/egl-helpers.h"
4782aeb7	26	#include "ui/egl-context.h"
97edf3bd	27	#endif
584af1f1 VR	28	#ifdef CONFIG_VTE
	29	#include "qemu/fifo8.h"
	30	#endif
97edf3bd	31
5f692f57 GH	32	#define MAX_VCS 10
5f692f57 GH	33
dc7ff344 GH	34	typedef struct GtkDisplayState GtkDisplayState;
	35
	36	typedef struct VirtualGfxConsole {
	37	GtkWidget *drawing_area;
5e79d516	38	DisplayGLCtx dgc;
dc7ff344	39	DisplayChangeListener dcl;
0c0d4273	40	QKbdState *kbd;
dc7ff344 GH	41	DisplaySurface *ds;
	42	pixman_image_t *convert;
	43	cairo_surface_t *surface;
	44	double scale_x;
	45	double scale_y;
97edf3bd	46	#if defined(CONFIG_OPENGL)
46e19e14	47	QemuGLShader *gls;
97edf3bd GH	48	EGLContext ectx;
	49	EGLSurface esurface;
	50	int glupdates;
4782aeb7	51	int x, y, w, h;
a4f113fd GH	52	egl_fb guest_fb;
a4f113fd GH	53	egl_fb win_fb;
f1bd3132 GH	54	egl_fb cursor_fb;
	55	int cursor_x;
	56	int cursor_y;
4782aeb7 GH	57	bool y0_top;
4782aeb7 GH	58	bool scanout_mode;
52a37e20	59	bool has_dmabuf;
97edf3bd	60	#endif
dc7ff344 GH	61	} VirtualGfxConsole;
	62
	63	#if defined(CONFIG_VTE)
	64	typedef struct VirtualVteConsole {
	65	GtkWidget *box;
	66	GtkWidget *scrollbar;
	67	GtkWidget *terminal;
0ec7b3e7	68	Chardev *chr;
584af1f1	69	Fifo8 out_fifo;
fba958c6	70	bool echo;
dc7ff344 GH	71	} VirtualVteConsole;
	72	#endif
	73
	74	typedef enum VirtualConsoleType {
	75	GD_VC_GFX,
	76	GD_VC_VTE,
	77	} VirtualConsoleType;
	78
	79	typedef struct VirtualConsole {
	80	GtkDisplayState *s;
	81	char *label;
	82	GtkWidget *window;
	83	GtkWidget *menu_item;
	84	GtkWidget *tab_item;
	85	GtkWidget *focus;
	86	VirtualConsoleType type;
	87	union {
	88	VirtualGfxConsole gfx;
	89	#if defined(CONFIG_VTE)
	90	VirtualVteConsole vte;
	91	#endif
	92	};
	93	} VirtualConsole;
	94
5f692f57 GH	95	struct GtkDisplayState {
	96	GtkWidget *window;
	97
	98	GtkWidget *menu_bar;
	99
	100	GtkAccelGroup *accel_group;
	101
	102	GtkWidget *machine_menu_item;
	103	GtkWidget *machine_menu;
	104	GtkWidget *pause_item;
	105	GtkWidget *reset_item;
	106	GtkWidget *powerdown_item;
	107	GtkWidget *quit_item;
	108
	109	GtkWidget *view_menu_item;
	110	GtkWidget *view_menu;
	111	GtkWidget *full_screen_item;
	112	GtkWidget *copy_item;
	113	GtkWidget *zoom_in_item;
	114	GtkWidget *zoom_out_item;
	115	GtkWidget *zoom_fixed_item;
	116	GtkWidget *zoom_fit_item;
	117	GtkWidget *grab_item;
	118	GtkWidget *grab_on_hover_item;
	119
	120	int nb_vcs;
	121	VirtualConsole vc[MAX_VCS];
	122
	123	GtkWidget *show_tabs_item;
	124	GtkWidget *untabify_item;
	125	GtkWidget *show_menubar_item;
	126
	127	GtkWidget *vbox;
	128	GtkWidget *notebook;
	129	int button_mask;
	130	gboolean last_set;
	131	int last_x;
	132	int last_y;
	133	int grab_x_root;
	134	int grab_y_root;
	135	VirtualConsole *kbd_owner;
	136	VirtualConsole *ptr_owner;
	137
	138	gboolean full_screen;
	139
	140	GdkCursor *null_cursor;
	141	Notifier mouse_mode_notifier;
	142	gboolean free_scale;
	143
	144	bool external_pause_update;
	145
d11ebe2c	146	QemuClipboardPeer cbpeer;
d11ebe2c GH	147	uint32_t cbpending[QEMU_CLIPBOARD_SELECTION__COUNT];
	148	GtkClipboard *gtkcb[QEMU_CLIPBOARD_SELECTION__COUNT];
	149	bool cbowner[QEMU_CLIPBOARD_SELECTION__COUNT];
	150
5f692f57 GH	151	DisplayOptions *opts;
	152	};
	153
11c82b58 GH	154	extern bool gtk_use_gl_area;
11c82b58 GH	155
97edf3bd GH	156	/* ui/gtk.c */
97edf3bd GH	157	void gd_update_windowsize(VirtualConsole *vc);
aeffd071	158	void gd_update_monitor_refresh_rate(VirtualConsole vc, GtkWidget widget);
65b847d2	159	void gd_hw_gl_flushed(void *vc);
97edf3bd GH	160
	161	/* ui/gtk-egl.c */
	162	void gd_egl_init(VirtualConsole *vc);
	163	void gd_egl_draw(VirtualConsole *vc);
	164	void gd_egl_update(DisplayChangeListener *dcl,
	165	int x, int y, int w, int h);
	166	void gd_egl_refresh(DisplayChangeListener *dcl);
	167	void gd_egl_switch(DisplayChangeListener *dcl,
	168	DisplaySurface *surface);
5e79d516	169	QEMUGLContext gd_egl_create_context(DisplayGLCtx *dgc,
4782aeb7	170	QEMUGLParams *params);
543a7a16	171	void gd_egl_scanout_disable(DisplayChangeListener *dcl);
f4c36bda GH	172	void gd_egl_scanout_texture(DisplayChangeListener *dcl,
	173	uint32_t backing_id,
	174	bool backing_y_0_top,
	175	uint32_t backing_width,
	176	uint32_t backing_height,
	177	uint32_t x, uint32_t y,
bf41ab61 MAL	178	uint32_t w, uint32_t h,
bf41ab61 MAL	179	void *d3d_tex2d);
70763fea GH	180	void gd_egl_scanout_dmabuf(DisplayChangeListener *dcl,
70763fea GH	181	QemuDmaBuf *dmabuf);
f1bd3132 GH	182	void gd_egl_cursor_dmabuf(DisplayChangeListener *dcl,
	183	QemuDmaBuf *dmabuf, bool have_hot,
	184	uint32_t hot_x, uint32_t hot_y);
	185	void gd_egl_cursor_position(DisplayChangeListener *dcl,
	186	uint32_t pos_x, uint32_t pos_y);
ab971f8a VK	187	void gd_egl_flush(DisplayChangeListener *dcl,
ab971f8a VK	188	uint32_t x, uint32_t y, uint32_t w, uint32_t h);
4782aeb7 GH	189	void gd_egl_scanout_flush(DisplayChangeListener *dcl,
4782aeb7 GH	190	uint32_t x, uint32_t y, uint32_t w, uint32_t h);
54d208ff	191	void gtk_egl_init(DisplayGLMode mode);
5e79d516	192	int gd_egl_make_current(DisplayGLCtx *dgc,
4782aeb7	193	QEMUGLContext ctx);
97edf3bd	194
925a0400 GH	195	/* ui/gtk-gl-area.c */
	196	void gd_gl_area_init(VirtualConsole *vc);
	197	void gd_gl_area_draw(VirtualConsole *vc);
	198	void gd_gl_area_update(DisplayChangeListener *dcl,
	199	int x, int y, int w, int h);
	200	void gd_gl_area_refresh(DisplayChangeListener *dcl);
	201	void gd_gl_area_switch(DisplayChangeListener *dcl,
	202	DisplaySurface *surface);
5e79d516	203	QEMUGLContext gd_gl_area_create_context(DisplayGLCtx *dgc,
925a0400	204	QEMUGLParams *params);
5e79d516	205	void gd_gl_area_destroy_context(DisplayGLCtx *dgc,
925a0400	206	QEMUGLContext ctx);
2606519b MAL	207	void gd_gl_area_scanout_dmabuf(DisplayChangeListener *dcl,
2606519b MAL	208	QemuDmaBuf *dmabuf);
f4c36bda GH	209	void gd_gl_area_scanout_texture(DisplayChangeListener *dcl,
	210	uint32_t backing_id,
	211	bool backing_y_0_top,
	212	uint32_t backing_width,
	213	uint32_t backing_height,
	214	uint32_t x, uint32_t y,
bf41ab61 MAL	215	uint32_t w, uint32_t h,
bf41ab61 MAL	216	void *d3d_tex2d);
568b12fc	217	void gd_gl_area_scanout_disable(DisplayChangeListener *dcl);
925a0400 GH	218	void gd_gl_area_scanout_flush(DisplayChangeListener *dcl,
	219	uint32_t x, uint32_t y, uint32_t w, uint32_t h);
	220	void gtk_gl_area_init(void);
5e79d516	221	int gd_gl_area_make_current(DisplayGLCtx *dgc,
925a0400 GH	222	QEMUGLContext ctx);
925a0400 GH	223
d11ebe2c GH	224	/* gtk-clipboard.c */
	225	void gd_clipboard_init(GtkDisplayState *gd);
	226
dc7ff344	227	#endif /* UI_GTK_H */