mirror of
https://github.com/kovidgoyal/kitty.git
synced 2026-11-20 15:12:37 +00:00
Timers are dispatched outside the main loop tick, so state changed by them was not rendered while the OS window was otherwise idle, only catching up when some other event woke the loop. For example, a custom tab bar refreshed from add_timer, or actions mapped to mouse clicks, which are dispatched from a timer after click_interval. Request a tick after every Python timer callback, after dispatching pending clicks and when marking the tab bar dirty. Closes #10878
2317 lines
86 KiB
C
2317 lines
86 KiB
C
/*
|
|
* state.c
|
|
* Copyright (C) 2017 Kovid Goyal <kovid at kovidgoyal.net>
|
|
*
|
|
* Distributed under terms of the GPL3 license.
|
|
*/
|
|
|
|
#include "cleanup.h"
|
|
#include "dnd.h"
|
|
#include "options/to-c-generated.h"
|
|
#include <math.h>
|
|
#include <sys/mman.h>
|
|
|
|
GlobalState global_state = {{0}};
|
|
|
|
#define REMOVER(array, qid, count, destroy, capacity) \
|
|
{ \
|
|
for (size_t i = 0; i < count; i++) { \
|
|
if (array[i].id == qid) { \
|
|
destroy(array + i); \
|
|
zero_at_i(array, i); \
|
|
remove_i_from_array(array, i, count); \
|
|
break; \
|
|
} \
|
|
} \
|
|
}
|
|
|
|
#define WITH_OS_WINDOW(os_window_id) \
|
|
for (size_t o = 0; o < global_state.num_os_windows; o++) { \
|
|
OSWindow *os_window = global_state.os_windows + o; \
|
|
if (os_window->id == os_window_id) {
|
|
#define END_WITH_OS_WINDOW \
|
|
break; \
|
|
} \
|
|
}
|
|
|
|
#define WITH_TAB(os_window_id, tab_id) \
|
|
for (size_t o = 0, tab_found = 0; o < global_state.num_os_windows && !tab_found; o++) { \
|
|
OSWindow *osw = global_state.os_windows + o; \
|
|
if (osw->id == os_window_id) { \
|
|
for (size_t t = 0; t < osw->num_tabs; t++) { \
|
|
if (osw->tabs[t].id == tab_id) { \
|
|
Tab *tab = osw->tabs + t;
|
|
#define END_WITH_TAB \
|
|
tab_found = 1; \
|
|
break; \
|
|
} \
|
|
} \
|
|
} \
|
|
}
|
|
|
|
#define WITH_WINDOW(os_window_id, tab_id, window_id) \
|
|
for (size_t o = 0, window_found = 0; o < global_state.num_os_windows && !window_found; o++) { \
|
|
OSWindow *osw = global_state.os_windows + o; \
|
|
if (osw->id == os_window_id) { \
|
|
for (size_t t = 0; t < osw->num_tabs && !window_found; t++) { \
|
|
if (osw->tabs[t].id == tab_id) { \
|
|
Tab *tab = osw->tabs + t; \
|
|
for (size_t w = 0; w < tab->num_windows; w++) { \
|
|
if (tab->windows[w].id == window_id) { \
|
|
Window *window = tab->windows + w;
|
|
#define END_WITH_WINDOW \
|
|
window_found = 1; \
|
|
break; \
|
|
} \
|
|
} \
|
|
} \
|
|
} \
|
|
} \
|
|
}
|
|
|
|
|
|
#define WITH_OS_WINDOW_REFS \
|
|
id_type cb_window_id = 0, focused_window_id = 0; \
|
|
if (global_state.callback_os_window) cb_window_id = global_state.callback_os_window->id;
|
|
|
|
#define END_WITH_OS_WINDOW_REFS \
|
|
if (cb_window_id || focused_window_id) { \
|
|
global_state.callback_os_window = NULL; \
|
|
for (size_t wn = 0; wn < global_state.num_os_windows; wn++) { \
|
|
OSWindow *wp = global_state.os_windows + wn; \
|
|
if (wp->id == cb_window_id && cb_window_id) global_state.callback_os_window = wp; \
|
|
} \
|
|
}
|
|
|
|
static double
|
|
dpi_for_os_window(const OSWindow *os_window) {
|
|
double dpi = (os_window->fonts_data->logical_dpi_x + os_window->fonts_data->logical_dpi_y) / 2.;
|
|
if (dpi == 0) dpi = (global_state.default_dpi.x + global_state.default_dpi.y) / 2.;
|
|
return dpi;
|
|
}
|
|
|
|
static double
|
|
dpi_for_os_window_id(id_type os_window_id) {
|
|
double dpi = 0;
|
|
if (os_window_id) {
|
|
WITH_OS_WINDOW(os_window_id)
|
|
dpi = dpi_for_os_window(os_window);
|
|
END_WITH_OS_WINDOW
|
|
}
|
|
if (dpi == 0) { dpi = (global_state.default_dpi.x + global_state.default_dpi.y) / 2.; }
|
|
return dpi;
|
|
}
|
|
|
|
static long
|
|
pt_to_px_for_os_window(double pt, const OSWindow *w) {
|
|
const double dpi = dpi_for_os_window(w);
|
|
return ((long)round((pt * (dpi / 72.0))));
|
|
}
|
|
|
|
static long
|
|
pt_to_px(double pt, id_type os_window_id) {
|
|
const double dpi = dpi_for_os_window_id(os_window_id);
|
|
return ((long)round((pt * (dpi / 72.0))));
|
|
}
|
|
|
|
|
|
OSWindow *
|
|
current_os_window(void) {
|
|
if (global_state.callback_os_window) return global_state.callback_os_window;
|
|
for (size_t i = 0; i < global_state.num_os_windows; i++) {
|
|
if (global_state.os_windows[i].is_focused) return global_state.os_windows + i;
|
|
}
|
|
return global_state.os_windows;
|
|
}
|
|
|
|
static id_type
|
|
last_focused_os_window_id(void) {
|
|
id_type ans = 0, max_fc_count = 0;
|
|
for (size_t i = 0; i < global_state.num_os_windows; i++) {
|
|
OSWindow *w = &global_state.os_windows[i];
|
|
if (w->last_focused_counter > max_fc_count) {
|
|
ans = w->id;
|
|
max_fc_count = w->last_focused_counter;
|
|
}
|
|
}
|
|
return ans;
|
|
}
|
|
|
|
static id_type
|
|
current_focused_os_window_id(void) {
|
|
for (size_t i = 0; i < global_state.num_os_windows; i++) {
|
|
OSWindow *w = &global_state.os_windows[i];
|
|
if (w->is_focused) { return w->id; }
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
OSWindow *
|
|
os_window_for_id(id_type os_window_id) {
|
|
for (size_t i = 0; i < global_state.num_os_windows; i++) {
|
|
OSWindow *w = global_state.os_windows + i;
|
|
if (w->id == os_window_id) return w;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
OSWindow *
|
|
os_window_for_kitty_window(id_type kitty_window_id) {
|
|
for (size_t i = 0; i < global_state.num_os_windows; i++) {
|
|
OSWindow *w = global_state.os_windows + i;
|
|
for (size_t t = 0; t < w->num_tabs; t++) {
|
|
Tab *tab = w->tabs + t;
|
|
for (size_t c = 0; c < tab->num_windows; c++) {
|
|
if (tab->windows[c].id == kitty_window_id) return w;
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
Window *
|
|
window_for_window_id(id_type kitty_window_id) {
|
|
for (size_t i = 0; i < global_state.num_os_windows; i++) {
|
|
OSWindow *w = global_state.os_windows + i;
|
|
for (size_t t = 0; t < w->num_tabs; t++) {
|
|
Tab *tab = w->tabs + t;
|
|
for (size_t c = 0; c < tab->num_windows; c++) {
|
|
if (tab->windows[c].id == kitty_window_id) return tab->windows + c;
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void
|
|
update_os_window_visibility_reports(OSWindow *os_window) {
|
|
const bool os_window_is_visible = is_os_window_potentially_visible(os_window);
|
|
for (size_t t = 0; t < os_window->num_tabs; t++) {
|
|
Tab *tab = os_window->tabs + t;
|
|
for (size_t w = 0; w < tab->num_windows; w++) {
|
|
Window *window = tab->windows + w;
|
|
if (window->render_data.screen) {
|
|
screen_visibility_changed(window->render_data.screen, os_window_is_visible && t == os_window->active_tab && window->visible);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
free_bgimage_bitmap(BackgroundImage *bgimage) {
|
|
if (!bgimage->bitmap) return;
|
|
if (bgimage->mmap_size) {
|
|
if (munmap(bgimage->bitmap, bgimage->mmap_size) != 0) log_error("Failed to unmap BackgroundImage with error: %s", strerror(errno));
|
|
} else free(bgimage->bitmap);
|
|
bgimage->bitmap = NULL;
|
|
bgimage->mmap_size = 0;
|
|
}
|
|
|
|
static bool
|
|
send_bgimage_to_gpu(BackgroundImageLayout layout, BackgroundImage *bgimage) {
|
|
RepeatStrategy r = REPEAT_DEFAULT;
|
|
switch (layout) {
|
|
case SCALED:
|
|
case CLAMPED:
|
|
case CENTER_CLAMPED:
|
|
case CENTER_SCALED: r = REPEAT_CLAMP; break;
|
|
case MIRRORED: r = REPEAT_MIRROR; break;
|
|
case TILING: r = REPEAT_DEFAULT; break;
|
|
}
|
|
bgimage->texture_id = 0;
|
|
size_t delta = bgimage->mmap_size ? bgimage->mmap_size - ((size_t)4) * bgimage->width * bgimage->height : 0;
|
|
send_image_to_gpu(&bgimage->texture_id, bgimage->bitmap + delta, bgimage->width, bgimage->height, false, true, OPT(background_image_linear), r);
|
|
free_bgimage_bitmap(bgimage);
|
|
return bgimage->texture_id > 0;
|
|
}
|
|
|
|
static void
|
|
free_bgimage(BackgroundImage **bgimage, bool release_texture) {
|
|
if (*bgimage && (*bgimage)->refcnt) {
|
|
(*bgimage)->refcnt--;
|
|
if ((*bgimage)->refcnt == 0) {
|
|
free_bgimage_bitmap(*bgimage);
|
|
if (release_texture) free_texture(&(*bgimage)->texture_id);
|
|
free(*bgimage);
|
|
}
|
|
}
|
|
*bgimage = NULL;
|
|
}
|
|
|
|
static void
|
|
free_global_background_images(bool release_texture) {
|
|
if (global_state.background_images.images) {
|
|
for (size_t i = 0; i < global_state.background_images.count; i++) free_bgimage(&global_state.background_images.images[i], release_texture);
|
|
free(global_state.background_images.images);
|
|
global_state.background_images.images = NULL;
|
|
}
|
|
zero_at_ptr(&global_state.background_images);
|
|
}
|
|
|
|
static void
|
|
ensure_background_images_generation(bool release_texture) {
|
|
if (global_state.background_images.generation == OPT(background_images).generation) return;
|
|
free_global_background_images(release_texture);
|
|
global_state.background_images.generation = OPT(background_images).generation;
|
|
global_state.background_images.entries_attempted = 0;
|
|
if (OPT(background_images).count) {
|
|
global_state.background_images.images = calloc(OPT(background_images).count, sizeof(global_state.background_images.images[0]));
|
|
if (!global_state.background_images.images) fatal("Out of memory");
|
|
}
|
|
}
|
|
|
|
static unsigned bg_image_id_counter = 0;
|
|
|
|
static BackgroundImage *
|
|
global_background_image(size_t idx) {
|
|
ensure_background_images_generation(true);
|
|
while (global_state.background_images.count <= idx && global_state.background_images.entries_attempted < OPT(background_images).count) {
|
|
size_t j = global_state.background_images.entries_attempted++;
|
|
BackgroundImage *img = calloc(1, sizeof(BackgroundImage));
|
|
if (!img) fatal("Out of memory");
|
|
if (image_path_to_bitmap(OPT(background_images).paths[j], &img->bitmap, &img->width, &img->height, &img->mmap_size)) {
|
|
if (send_bgimage_to_gpu(OPT(background_image_layout), img)) {
|
|
img->refcnt++;
|
|
img->id = ++bg_image_id_counter;
|
|
global_state.background_images.images[global_state.background_images.count++] = img;
|
|
} else free(img);
|
|
} else free(img);
|
|
}
|
|
return global_state.background_images.count > idx ? global_state.background_images.images[idx] : NULL;
|
|
}
|
|
|
|
BackgroundImage *
|
|
background_image_for_os_window(OSWindow *w) {
|
|
if (w->background_image.no_image) return NULL;
|
|
if (w->background_image.override) return w->background_image.override;
|
|
BackgroundImage *ans = NULL;
|
|
if (w->background_image.global_bg_images_idx && (ans = global_background_image(w->background_image.global_bg_images_idx))) return ans;
|
|
return global_background_image(0);
|
|
}
|
|
|
|
static size_t
|
|
increment_bg_image_idx(size_t idx, int delta) {
|
|
if (delta == 0) return idx;
|
|
if (delta > 0) {
|
|
size_t new_idx = idx + delta;
|
|
return global_background_image(new_idx) ? new_idx : 0;
|
|
}
|
|
if ((unsigned)abs(delta) <= idx) return idx + delta;
|
|
// wrap to last image, which means we need to load all
|
|
if (OPT(background_images).count > 0) global_background_image(OPT(background_images).count - 1);
|
|
return global_state.background_images.count ? global_state.background_images.count - 1 : 0;
|
|
}
|
|
|
|
OSWindow *
|
|
add_os_window(void) {
|
|
WITH_OS_WINDOW_REFS
|
|
ensure_space_for(&global_state, os_windows, OSWindow, global_state.num_os_windows + 1, capacity, 1, true);
|
|
OSWindow *ans = global_state.os_windows + global_state.num_os_windows++;
|
|
zero_at_ptr(ans);
|
|
ans->id = ++global_state.os_window_id_counter;
|
|
ans->tab_bar_render_data.vao_idx = create_cell_vao();
|
|
ans->background_opacity.alpha = OPT(background_opacity);
|
|
ans->created_at = monotonic();
|
|
init_shader_animation_state(ans);
|
|
END_WITH_OS_WINDOW_REFS
|
|
return ans;
|
|
}
|
|
|
|
static id_type
|
|
add_tab(id_type os_window_id) {
|
|
WITH_OS_WINDOW(os_window_id)
|
|
make_os_window_context_current(os_window);
|
|
ensure_space_for(os_window, tabs, Tab, os_window->num_tabs + 1, capacity, 1, true);
|
|
zero_at_i(os_window->tabs, os_window->num_tabs);
|
|
os_window->tabs[os_window->num_tabs].id = ++global_state.tab_id_counter;
|
|
os_window->tabs[os_window->num_tabs].border_rects.vao_idx = create_border_vao();
|
|
return os_window->tabs[os_window->num_tabs++].id;
|
|
END_WITH_OS_WINDOW
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
create_gpu_resources_for_window(Window *w) {
|
|
w->render_data.vao_idx = create_cell_vao();
|
|
w->window_title_render_data.vao_idx = create_cell_vao();
|
|
}
|
|
|
|
static void
|
|
release_gpu_resources_for_window(Window *w) {
|
|
if (w->render_data.vao_idx > -1) free_vao(w->render_data.vao_idx);
|
|
w->render_data.vao_idx = -1;
|
|
if (w->window_title_render_data.vao_idx > -1) free_vao(w->window_title_render_data.vao_idx);
|
|
w->window_title_render_data.vao_idx = -1;
|
|
Py_CLEAR(w->window_title_render_data.screen);
|
|
}
|
|
|
|
static bool
|
|
set_window_logo(Window *w, const char *path, const ImageAnchorPosition pos, float alpha, bool is_default, char *png_data, size_t png_data_size) {
|
|
bool ok = false;
|
|
if (path && path[0]) {
|
|
window_logo_id_t wl = find_or_create_window_logo(global_state.all_window_logos, path, png_data, png_data_size);
|
|
if (wl) {
|
|
if (w->window_logo.id) decref_window_logo(global_state.all_window_logos, w->window_logo.id);
|
|
w->window_logo.id = wl;
|
|
w->window_logo.position = pos;
|
|
w->window_logo.alpha = alpha;
|
|
ok = true;
|
|
}
|
|
} else {
|
|
if (w->window_logo.id) {
|
|
decref_window_logo(global_state.all_window_logos, w->window_logo.id);
|
|
w->window_logo.id = 0;
|
|
}
|
|
ok = true;
|
|
}
|
|
w->window_logo.using_default = is_default;
|
|
if (ok && w->render_data.screen) w->render_data.screen->is_dirty = true;
|
|
return ok;
|
|
}
|
|
|
|
static void
|
|
initialize_window(Window *w, PyObject *title, bool init_gpu_resources) {
|
|
w->id = ++global_state.window_id_counter;
|
|
w->visible = true;
|
|
w->title = title;
|
|
Py_XINCREF(title);
|
|
w->scrollbar.is_hovering = false;
|
|
if (!set_window_logo(w, OPT(default_window_logo), OPT(window_logo_position), OPT(window_logo_alpha), true, NULL, 0)) {
|
|
log_error("Failed to load default window logo: %s", OPT(default_window_logo));
|
|
if (PyErr_Occurred()) PyErr_Print();
|
|
}
|
|
if (init_gpu_resources) create_gpu_resources_for_window(w);
|
|
else {
|
|
// Mock windows have no graphics context. Neither VAO may be deleted when
|
|
// the mock window is destroyed by the mouse regression tests.
|
|
w->render_data.vao_idx = w->window_title_render_data.vao_idx = -1;
|
|
}
|
|
}
|
|
|
|
static id_type
|
|
add_window(id_type os_window_id, id_type tab_id, PyObject *title) {
|
|
WITH_TAB(os_window_id, tab_id);
|
|
ensure_space_for(tab, windows, Window, tab->num_windows + 1, capacity, 1, true);
|
|
make_os_window_context_current(osw);
|
|
zero_at_i(tab->windows, tab->num_windows);
|
|
initialize_window(tab->windows + tab->num_windows, title, true);
|
|
return tab->windows[tab->num_windows++].id;
|
|
END_WITH_TAB;
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
update_window_title(id_type os_window_id, id_type tab_id, id_type window_id, PyObject *title) {
|
|
WITH_WINDOW(os_window_id, tab_id, window_id)
|
|
Py_CLEAR(window->title);
|
|
if (title) window->title = Py_NewRef(title);
|
|
END_WITH_WINDOW;
|
|
}
|
|
|
|
void
|
|
set_os_window_title_from_window(Window *w, OSWindow *os_window) {
|
|
if (os_window->disallow_title_changes || os_window->title_is_overriden) return;
|
|
if (w->title && w->title != os_window->window_title) {
|
|
Py_CLEAR(os_window->window_title);
|
|
os_window->window_title = Py_NewRef(w->title);
|
|
set_os_window_title(os_window, PyUnicode_AsUTF8(w->title));
|
|
}
|
|
}
|
|
|
|
void
|
|
update_os_window_title(OSWindow *os_window) {
|
|
if (os_window->num_tabs) {
|
|
Tab *tab = os_window->tabs + os_window->active_tab;
|
|
if (tab->num_windows) {
|
|
Window *w = tab->windows + tab->active_window;
|
|
set_os_window_title_from_window(w, os_window);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
destroy_window(Window *w) {
|
|
drop_free_data(w);
|
|
drag_free_offer(w, true);
|
|
free(w->pending_clicks.clicks);
|
|
zero_at_ptr(&w->pending_clicks);
|
|
free_buffered_keys(w);
|
|
Py_CLEAR(w->render_data.screen);
|
|
Py_CLEAR(w->title);
|
|
Py_CLEAR(w->title_bar_data.last_drawn_title_object_id);
|
|
free(w->title_bar_data.buf);
|
|
w->title_bar_data.buf = NULL;
|
|
Py_CLEAR(w->url_target_bar_data.last_drawn_title_object_id);
|
|
free(w->url_target_bar_data.buf);
|
|
w->url_target_bar_data.buf = NULL;
|
|
release_gpu_resources_for_window(w);
|
|
if (w->window_logo.id) {
|
|
decref_window_logo(global_state.all_window_logos, w->window_logo.id);
|
|
w->window_logo.id = 0;
|
|
}
|
|
}
|
|
|
|
static void
|
|
remove_window_inner(Tab *tab, id_type id) {
|
|
id_type active_window_id = 0;
|
|
if (tab->active_window < tab->num_windows) active_window_id = tab->windows[tab->active_window].id;
|
|
REMOVER(tab->windows, id, tab->num_windows, destroy_window, tab->capacity);
|
|
if (active_window_id) {
|
|
for (unsigned int w = 0; w < tab->num_windows; w++) {
|
|
if (tab->windows[w].id == active_window_id) {
|
|
tab->active_window = w;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if (tab->active_window >= tab->num_windows) tab->active_window = 0;
|
|
}
|
|
|
|
static void
|
|
remove_window(id_type os_window_id, id_type tab_id, id_type id) {
|
|
WITH_TAB(os_window_id, tab_id);
|
|
make_os_window_context_current(osw);
|
|
remove_window_inner(tab, id);
|
|
END_WITH_TAB;
|
|
}
|
|
|
|
typedef struct {
|
|
unsigned int num_windows, capacity;
|
|
Window *windows;
|
|
} DetachedWindows;
|
|
|
|
static DetachedWindows detached_windows = {0};
|
|
|
|
|
|
static void
|
|
add_detached_window(Window *w) {
|
|
ensure_space_for(&detached_windows, windows, Window, detached_windows.num_windows + 1, capacity, 8, true);
|
|
memcpy(detached_windows.windows + detached_windows.num_windows++, w, sizeof(Window));
|
|
}
|
|
|
|
static void
|
|
detach_window(id_type os_window_id, id_type tab_id, id_type id) {
|
|
WITH_TAB(os_window_id, tab_id);
|
|
for (size_t i = 0; i < tab->num_windows; i++) {
|
|
if (tab->windows[i].id == id) {
|
|
make_os_window_context_current(osw);
|
|
release_gpu_resources_for_window(&tab->windows[i]);
|
|
add_detached_window(tab->windows + i);
|
|
zero_at_i(tab->windows, i);
|
|
remove_i_from_array(tab->windows, i, tab->num_windows);
|
|
if (tab->active_window >= tab->num_windows) tab->active_window = tab->num_windows ? tab->num_windows - 1 : 0;
|
|
break;
|
|
}
|
|
}
|
|
END_WITH_TAB;
|
|
}
|
|
|
|
|
|
static bool
|
|
move_window_to_tab(id_type os_window_id, id_type src_tab_id, id_type dest_tab_id, id_type id) {
|
|
// Move a window between two tabs of the same OS window. Unlike detach_window() and
|
|
// attach_window() this keeps the GPU resources of the window, as both tabs share the
|
|
// OpenGL context of the OS window.
|
|
OSWindow *osw = os_window_for_id(os_window_id);
|
|
if (!osw || src_tab_id == dest_tab_id) return false;
|
|
Tab *src = NULL, *dest = NULL;
|
|
for (size_t t = 0; t < osw->num_tabs; t++) {
|
|
if (osw->tabs[t].id == src_tab_id) src = osw->tabs + t;
|
|
else if (osw->tabs[t].id == dest_tab_id) dest = osw->tabs + t;
|
|
}
|
|
if (!src || !dest) return false;
|
|
for (size_t i = 0; i < src->num_windows; i++) {
|
|
if (src->windows[i].id == id) {
|
|
ensure_space_for(dest, windows, Window, dest->num_windows + 1, capacity, 1, true);
|
|
memcpy(dest->windows + dest->num_windows++, src->windows + i, sizeof(Window));
|
|
zero_at_i(src->windows, i);
|
|
remove_i_from_array(src->windows, i, src->num_windows);
|
|
if (src->active_window > i) src->active_window--;
|
|
else if (src->active_window >= src->num_windows) src->active_window = src->num_windows ? src->num_windows - 1 : 0;
|
|
osw->needs_render = true;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void
|
|
resize_screen(OSWindow *os_window, Screen *screen, bool has_graphics) {
|
|
if (screen) {
|
|
screen->cell_size.width = os_window->fonts_data->fcm.cell_width;
|
|
screen->cell_size.height = os_window->fonts_data->fcm.cell_height;
|
|
screen_dirty_sprite_positions(screen);
|
|
if (has_graphics) screen_rescale_images(screen);
|
|
}
|
|
}
|
|
|
|
static void
|
|
attach_window(id_type os_window_id, id_type tab_id, id_type id) {
|
|
WITH_TAB(os_window_id, tab_id);
|
|
for (size_t i = 0; i < detached_windows.num_windows; i++) {
|
|
if (detached_windows.windows[i].id == id) {
|
|
ensure_space_for(tab, windows, Window, tab->num_windows + 1, capacity, 1, true);
|
|
Window *w = tab->windows + tab->num_windows++;
|
|
memcpy(w, detached_windows.windows + i, sizeof(Window));
|
|
zero_at_i(detached_windows.windows, i);
|
|
remove_i_from_array(detached_windows.windows, i, detached_windows.num_windows);
|
|
make_os_window_context_current(osw);
|
|
create_gpu_resources_for_window(w);
|
|
if (w->render_data.screen->cell_size.width != osw->fonts_data->fcm.cell_width ||
|
|
w->render_data.screen->cell_size.height != osw->fonts_data->fcm.cell_height)
|
|
resize_screen(osw, w->render_data.screen, true);
|
|
else screen_dirty_sprite_positions(w->render_data.screen);
|
|
w->render_data.screen->reload_all_gpu_data = true;
|
|
screen_visibility_changed(w->render_data.screen, is_os_window_potentially_visible(osw) && t == osw->active_tab && w->visible);
|
|
break;
|
|
}
|
|
}
|
|
END_WITH_TAB;
|
|
}
|
|
|
|
static void
|
|
destroy_tab(Tab *tab) {
|
|
for (size_t i = tab->num_windows; i > 0; i--) remove_window_inner(tab, tab->windows[i - 1].id);
|
|
free_vao(tab->border_rects.vao_idx);
|
|
free(tab->border_rects.rect_buf);
|
|
tab->border_rects.rect_buf = NULL;
|
|
free(tab->windows);
|
|
tab->windows = NULL;
|
|
}
|
|
|
|
static void
|
|
remove_tab_inner(OSWindow *os_window, id_type id) {
|
|
id_type active_tab_id = 0;
|
|
if (os_window->active_tab < os_window->num_tabs) active_tab_id = os_window->tabs[os_window->active_tab].id;
|
|
make_os_window_context_current(os_window);
|
|
REMOVER(os_window->tabs, id, os_window->num_tabs, destroy_tab, os_window->capacity);
|
|
if (active_tab_id) {
|
|
for (unsigned int i = 0; i < os_window->num_tabs; i++) {
|
|
if (os_window->tabs[i].id == active_tab_id) {
|
|
os_window->active_tab = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
remove_tab(id_type os_window_id, id_type id) {
|
|
WITH_OS_WINDOW(os_window_id)
|
|
remove_tab_inner(os_window, id);
|
|
END_WITH_OS_WINDOW
|
|
}
|
|
|
|
static void
|
|
destroy_os_window_item(OSWindow *w) {
|
|
for (size_t t = w->num_tabs; t > 0; t--) {
|
|
Tab *tab = w->tabs + t - 1;
|
|
remove_tab_inner(w, tab->id);
|
|
}
|
|
Py_CLEAR(w->window_title);
|
|
Py_CLEAR(w->tab_bar_render_data.screen);
|
|
free_vao(w->tab_bar_render_data.vao_idx);
|
|
free(w->tabs);
|
|
w->tabs = NULL;
|
|
free_bgimage(&w->background_image.override, true);
|
|
zero_at_ptr(&w->background_image);
|
|
if (w->indirect_output.framebuffer_id) free_framebuffer(&w->indirect_output.framebuffer_id);
|
|
if (w->indirect_output.extra_fbo_id) free_framebuffer(&w->indirect_output.extra_fbo_id);
|
|
if (w->indirect_output.fbo_a_id) free_framebuffer(&w->indirect_output.fbo_a_id);
|
|
if (w->indirect_output.fbo_b_id) free_framebuffer(&w->indirect_output.fbo_b_id);
|
|
if (w->persist_texture_id) free_texture(&w->persist_texture_id);
|
|
if (w->persist_fbo_id) free_framebuffer(&w->persist_fbo_id);
|
|
free(w->pointer_map.data);
|
|
zero_at_ptr(&w->pointer_map);
|
|
}
|
|
|
|
bool
|
|
remove_os_window(id_type os_window_id) {
|
|
bool found = false;
|
|
WITH_OS_WINDOW(os_window_id)
|
|
found = true;
|
|
make_os_window_context_current(os_window);
|
|
END_WITH_OS_WINDOW
|
|
if (found) {
|
|
WITH_OS_WINDOW_REFS
|
|
REMOVER(global_state.os_windows, os_window_id, global_state.num_os_windows, destroy_os_window_item, global_state.capacity);
|
|
END_WITH_OS_WINDOW_REFS
|
|
update_os_window_references();
|
|
if (global_state.num_os_windows == 0) {
|
|
if (global_state.layers_render_texture.texture_id) free_texture(&global_state.layers_render_texture.texture_id);
|
|
if (global_state.layers_render_texture.framebuffer_id) free_framebuffer(&global_state.layers_render_texture.framebuffer_id);
|
|
if (global_state.layers_render_texture.extra_texture_id) free_texture(&global_state.layers_render_texture.extra_texture_id);
|
|
if (global_state.layers_render_texture.extra_texture_setup_fbo_id) free_framebuffer(&global_state.layers_render_texture.extra_texture_setup_fbo_id);
|
|
if (global_state.layers_render_texture.texture_a_id) free_texture(&global_state.layers_render_texture.texture_a_id);
|
|
if (global_state.layers_render_texture.texture_a_fbo_id) free_framebuffer(&global_state.layers_render_texture.texture_a_fbo_id);
|
|
if (global_state.layers_render_texture.texture_b_id) free_texture(&global_state.layers_render_texture.texture_b_id);
|
|
if (global_state.layers_render_texture.texture_b_fbo_id) free_framebuffer(&global_state.layers_render_texture.texture_b_fbo_id);
|
|
global_state.layers_render_texture.width = 0;
|
|
global_state.layers_render_texture.height = 0;
|
|
}
|
|
}
|
|
return found;
|
|
}
|
|
|
|
static void
|
|
mark_os_window_dirty(id_type os_window_id) {
|
|
WITH_OS_WINDOW(os_window_id)
|
|
os_window->needs_render = true;
|
|
END_WITH_OS_WINDOW
|
|
}
|
|
|
|
static void
|
|
set_active_tab(id_type os_window_id, unsigned int idx) {
|
|
WITH_OS_WINDOW(os_window_id)
|
|
os_window->active_tab = idx;
|
|
os_window->needs_render = true;
|
|
update_os_window_visibility_reports(os_window);
|
|
END_WITH_OS_WINDOW
|
|
}
|
|
|
|
static void
|
|
set_active_window(id_type os_window_id, id_type tab_id, id_type window_id) {
|
|
WITH_TAB(os_window_id, tab_id)
|
|
tab->active_window = 0;
|
|
for (unsigned w = 0; w < tab->num_windows; w++) {
|
|
if (tab->windows[w].id == window_id) {
|
|
tab->active_window = w;
|
|
break;
|
|
}
|
|
}
|
|
osw->needs_render = true;
|
|
set_os_window_chrome(osw);
|
|
END_WITH_TAB;
|
|
}
|
|
|
|
static bool
|
|
buffer_keys_in_window(id_type os_window_id, id_type tab_id, id_type window_id, bool enable) {
|
|
WITH_WINDOW(os_window_id, tab_id, window_id)
|
|
window->buffered_keys.enabled = enable;
|
|
if (!enable) dispatch_buffered_keys(window);
|
|
return true;
|
|
END_WITH_WINDOW;
|
|
return false;
|
|
}
|
|
|
|
static bool
|
|
set_redirect_keys_to_overlay(id_type os_window_id, id_type tab_id, id_type window_id, id_type overlay_id) {
|
|
WITH_WINDOW(os_window_id, tab_id, window_id)
|
|
window->redirect_keys_to_overlay = overlay_id;
|
|
return true;
|
|
END_WITH_WINDOW;
|
|
return false;
|
|
}
|
|
|
|
|
|
static void
|
|
swap_tabs(id_type os_window_id, unsigned int a, unsigned int b) {
|
|
WITH_OS_WINDOW(os_window_id)
|
|
Tab t = os_window->tabs[b];
|
|
os_window->tabs[b] = os_window->tabs[a];
|
|
os_window->tabs[a] = t;
|
|
END_WITH_OS_WINDOW
|
|
}
|
|
|
|
static PyObject *
|
|
pyreorder_tabs(PyObject *self UNUSED, PyObject *args) {
|
|
if (PyTuple_GET_SIZE(args) < 2) Py_RETURN_NONE;
|
|
id_type os_window_id = PyLong_AsUnsignedLongLong(PyTuple_GET_ITEM(args, 0));
|
|
WITH_OS_WINDOW(os_window_id)
|
|
if (PyTuple_GET_SIZE(args) != (Py_ssize_t)(os_window->num_tabs + 1)) {
|
|
PyErr_SetString(PyExc_ValueError, "number of tabs not correct");
|
|
return NULL;
|
|
}
|
|
if (!os_window->num_tabs) Py_RETURN_NONE;
|
|
RAII_ALLOC(Tab, tabs, calloc(os_window->capacity, sizeof(Tab)));
|
|
RAII_ALLOC(char, used, calloc(os_window->num_tabs, sizeof(char)));
|
|
if (!tabs || !used) { return PyErr_NoMemory(); }
|
|
for (Py_ssize_t i = 1; i < PyTuple_GET_SIZE(args); i++) {
|
|
id_type tab_id = PyLong_AsUnsignedLongLong(PyTuple_GET_ITEM(args, i));
|
|
bool found = false;
|
|
for (size_t t = 0; t < os_window->num_tabs; t++) {
|
|
if (os_window->tabs[t].id == tab_id) {
|
|
tabs[i - 1] = os_window->tabs[t];
|
|
found = true;
|
|
if (used[t]) {
|
|
PyErr_SetString(PyExc_ValueError, "duplicate tab ids found");
|
|
return NULL;
|
|
}
|
|
used[t] = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (!found) {
|
|
PyErr_SetString(PyExc_ValueError, "tab id not found");
|
|
return NULL;
|
|
}
|
|
}
|
|
free(os_window->tabs);
|
|
os_window->tabs = tabs;
|
|
tabs = NULL;
|
|
END_WITH_OS_WINDOW
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
pyset_borders_rects(PyObject *self UNUSED, PyObject *args) {
|
|
id_type os_window_id, tab_id;
|
|
PyObject *rects;
|
|
if (!PyArg_ParseTuple(args, "KKO!", &os_window_id, &tab_id, &PyList_Type, &rects)) return NULL;
|
|
WITH_TAB(os_window_id, tab_id)
|
|
BorderRects *br = &tab->border_rects;
|
|
br->is_dirty = true;
|
|
br->num_border_rects = PyList_GET_SIZE(rects);
|
|
br->num_rounded_rects = 0;
|
|
ensure_space_for(br, rect_buf, BorderRect, br->num_border_rects + 1, capacity, 32, false);
|
|
for (unsigned i = 0; i < br->num_border_rects; i++) {
|
|
PyObject *pr = PyList_GET_ITEM(rects, i);
|
|
unsigned long color;
|
|
long long border_type;
|
|
BorderRect *r = br->rect_buf + i;
|
|
int horizontal, render;
|
|
if (!PyArg_ParseTuple(
|
|
pr, "IIIIkLppII", &r->px.left, &r->px.top, &r->px.right, &r->px.bottom, &color, &border_type, &horizontal, &render, &r->radius, &r->thickness))
|
|
return NULL;
|
|
r->left = gl_pos_x(r->px.left, osw->viewport_width);
|
|
r->top = gl_pos_y(r->px.top, osw->viewport_height);
|
|
r->right = r->left + gl_size(r->px.right - r->px.left, osw->viewport_width);
|
|
r->bottom = r->top - gl_size(r->px.bottom - r->px.top, osw->viewport_height);
|
|
r->color = color;
|
|
r->border_type = border_type;
|
|
r->horizontal = horizontal;
|
|
if (r->radius && r->thickness) br->num_rounded_rects++;
|
|
if (!render) r->left = r->top = r->right = r->bottom = -2.f;
|
|
}
|
|
END_WITH_TAB
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
|
|
static unsigned
|
|
vertical_tab_bar_cols(const OSWindow *os_window, long margin_outer, long margin_inner) {
|
|
unsigned cell_width = MAX(1u, os_window->fonts_data->fcm.cell_width);
|
|
long available_width = (long)os_window->viewport_width - margin_outer - margin_inner;
|
|
if (available_width <= 0) return 0;
|
|
unsigned available_cols = MAX(1u, (unsigned)available_width / cell_width);
|
|
// Without an explicit title length use a default sidebar wide enough for
|
|
// about twenty title cells, otherwise fit the title and whatever
|
|
// decorations the tab bar style draws around it.
|
|
unsigned desired_cols = 28u;
|
|
if (OPT(tab_title_max_length) > 0) desired_cols = MAX((unsigned)OPT(tab_title_max_length) + OPT(vertical_tab_bar.padding), OPT(vertical_tab_bar.min_cols));
|
|
unsigned soft_max = available_cols / 3u;
|
|
if (soft_max < 6u) soft_max = available_cols;
|
|
return MAX(1u, MIN(available_cols, MIN(desired_cols, MAX(1u, soft_max))));
|
|
}
|
|
|
|
void
|
|
os_window_regions(const OSWindow *os_window, Region *central, Region *tab_bar) {
|
|
if (!OPT(tab_bar_hidden) && os_window->num_tabs && !os_window->has_too_few_tabs) {
|
|
long margin_outer = pt_to_px_for_os_window(OPT(tab_bar_margin_height.outer), os_window);
|
|
long margin_inner = pt_to_px_for_os_window(OPT(tab_bar_margin_height.inner), os_window);
|
|
central->left = 0;
|
|
central->right = os_window->viewport_width;
|
|
central->top = 0;
|
|
central->bottom = os_window->viewport_height;
|
|
switch (OPT(tab_bar_edge)) {
|
|
case TOP_EDGE: {
|
|
unsigned tab_bar_height = os_window->fonts_data->fcm.cell_height + margin_inner + margin_outer;
|
|
central->top = tab_bar_height;
|
|
central->bottom = os_window->viewport_height;
|
|
central->top = MIN(central->top, central->bottom);
|
|
tab_bar->top = margin_outer;
|
|
tab_bar->left = central->left;
|
|
tab_bar->right = central->right;
|
|
tab_bar->bottom = tab_bar->top + os_window->fonts_data->fcm.cell_height;
|
|
break;
|
|
}
|
|
case LEFT_EDGE: {
|
|
unsigned left_cols = vertical_tab_bar_cols(os_window, margin_outer, margin_inner);
|
|
if (!left_cols) {
|
|
zero_at_ptr(tab_bar);
|
|
return;
|
|
}
|
|
unsigned left_width = left_cols * os_window->fonts_data->fcm.cell_width;
|
|
central->left = MIN((long)(left_width + margin_inner + margin_outer), (long)central->right);
|
|
tab_bar->left = margin_outer;
|
|
tab_bar->right = tab_bar->left + left_width;
|
|
tab_bar->top = central->top;
|
|
tab_bar->bottom = central->bottom;
|
|
break;
|
|
}
|
|
case RIGHT_EDGE: {
|
|
unsigned right_cols = vertical_tab_bar_cols(os_window, margin_outer, margin_inner);
|
|
if (!right_cols) {
|
|
zero_at_ptr(tab_bar);
|
|
return;
|
|
}
|
|
unsigned right_width = right_cols * os_window->fonts_data->fcm.cell_width;
|
|
central->right = MAX(0, (long)os_window->viewport_width - (long)(right_width + margin_inner + margin_outer));
|
|
tab_bar->left = central->right + margin_inner;
|
|
tab_bar->right = tab_bar->left + right_width;
|
|
tab_bar->top = central->top;
|
|
tab_bar->bottom = central->bottom;
|
|
break;
|
|
}
|
|
default: {
|
|
unsigned tab_bar_height = os_window->fonts_data->fcm.cell_height + margin_inner + margin_outer;
|
|
central->top = 0;
|
|
long bottom = os_window->viewport_height - tab_bar_height;
|
|
central->bottom = MAX(0, bottom);
|
|
tab_bar->top = central->bottom + margin_inner;
|
|
tab_bar->left = central->left;
|
|
tab_bar->right = central->right;
|
|
tab_bar->bottom = tab_bar->top + os_window->fonts_data->fcm.cell_height;
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
zero_at_ptr(tab_bar);
|
|
central->left = 0;
|
|
central->top = 0;
|
|
central->right = os_window->viewport_width;
|
|
central->bottom = os_window->viewport_height;
|
|
}
|
|
}
|
|
|
|
void
|
|
mark_os_window_for_close(OSWindow *w, CloseRequest cr) {
|
|
global_state.has_pending_closes = true;
|
|
w->close_request = cr;
|
|
}
|
|
|
|
static bool
|
|
owners_for_window_id(id_type window_id, OSWindow **os_window, Tab **tab) {
|
|
if (os_window) *os_window = NULL;
|
|
if (tab) *tab = NULL;
|
|
for (size_t o = 0; o < global_state.num_os_windows; o++) {
|
|
OSWindow *osw = global_state.os_windows + o;
|
|
for (size_t t = 0; t < osw->num_tabs; t++) {
|
|
Tab *qtab = osw->tabs + t;
|
|
for (size_t w = 0; w < qtab->num_windows; w++) {
|
|
Window *window = qtab->windows + w;
|
|
if (window->id == window_id) {
|
|
if (os_window) *os_window = osw;
|
|
if (tab) *tab = qtab;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
bool
|
|
make_window_context_current(id_type window_id) {
|
|
OSWindow *os_window;
|
|
if (owners_for_window_id(window_id, &os_window, NULL) && os_window->handle) {
|
|
make_os_window_context_current(os_window);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void
|
|
dispatch_pending_clicks(id_type timer_id UNUSED, void *data UNUSED) {
|
|
bool dispatched = false, any_dispatched = false;
|
|
do { // dispatching a click can cause windows/tabs/etc to close so do it one at a time.
|
|
const monotonic_t now = monotonic();
|
|
dispatched = false;
|
|
for (size_t o = 0; o < global_state.num_os_windows && !dispatched; o++) {
|
|
OSWindow *osw = global_state.os_windows + o;
|
|
for (size_t t = 0; t < osw->num_tabs && !dispatched; t++) {
|
|
Tab *qtab = osw->tabs + t;
|
|
for (size_t w = 0; w < qtab->num_windows && !dispatched; w++) {
|
|
Window *window = qtab->windows + w;
|
|
for (size_t i = 0; i < window->pending_clicks.num && !dispatched; i++) {
|
|
if (now - window->pending_clicks.clicks[i].at >= OPT(click_interval)) {
|
|
dispatched = true;
|
|
send_pending_click_to_window(window, i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
any_dispatched |= dispatched;
|
|
} while (dispatched);
|
|
// This runs from a timer, outside the main loop tick, so ensure any state
|
|
// changed by the click actions is processed and rendered
|
|
if (any_dispatched) request_tick_callback();
|
|
}
|
|
|
|
void
|
|
update_ime_state_in_os_window(OSWindow *osw, Window *window, int update_focus) {
|
|
OSWindow *orig = global_state.callback_os_window;
|
|
global_state.callback_os_window = osw;
|
|
if (update_focus) update_ime_focus(osw, update_focus > 0);
|
|
if (update_focus >= 0 && window->render_data.screen) { update_ime_position(window, window->render_data.screen); }
|
|
global_state.callback_os_window = orig;
|
|
}
|
|
|
|
bool
|
|
update_ime_position_for_window(id_type window_id, bool force, int update_focus) {
|
|
for (size_t o = 0; o < global_state.num_os_windows; o++) {
|
|
OSWindow *osw = global_state.os_windows + o;
|
|
for (size_t t = 0; t < osw->num_tabs; t++) {
|
|
Tab *qtab = osw->tabs + t;
|
|
for (size_t w = 0; w < qtab->num_windows; w++) {
|
|
Window *window = qtab->windows + w;
|
|
if (window->id == window_id) {
|
|
// The screen may not be ready after the new window is created and focused, and still needs to enable IME.
|
|
if ((window->render_data.screen && (force || osw->is_focused)) || update_focus > 0) {
|
|
update_ime_state_in_os_window(osw, window, update_focus);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
// Python API {{{
|
|
#define PYWRAP0(name) static PyObject *py##name(PYNOARG)
|
|
#define PYWRAP1(name) static PyObject *py##name(PyObject UNUSED *self, PyObject *args)
|
|
#define PA(fmt, ...) \
|
|
if (!PyArg_ParseTuple(args, fmt, __VA_ARGS__)) return NULL;
|
|
#define ONE_UINT(name) \
|
|
PYWRAP1(name) { \
|
|
name((unsigned int)PyLong_AsUnsignedLong(args)); \
|
|
Py_RETURN_NONE; \
|
|
}
|
|
#define TWO_UINT(name) \
|
|
PYWRAP1(name) { \
|
|
unsigned int a, b; \
|
|
PA("II", &a, &b); \
|
|
name(a, b); \
|
|
Py_RETURN_NONE; \
|
|
}
|
|
#define THREE_UINT(name) \
|
|
PYWRAP1(name) { \
|
|
unsigned int a, b, c; \
|
|
PA("III", &a, &b, &c); \
|
|
name(a, b, c); \
|
|
Py_RETURN_NONE; \
|
|
}
|
|
#define TWO_ID(name) \
|
|
PYWRAP1(name) { \
|
|
id_type a, b; \
|
|
PA("KK", &a, &b); \
|
|
name(a, b); \
|
|
Py_RETURN_NONE; \
|
|
}
|
|
#define THREE_ID(name) \
|
|
PYWRAP1(name) { \
|
|
id_type a, b, c; \
|
|
PA("KKK", &a, &b, &c); \
|
|
name(a, b, c); \
|
|
Py_RETURN_NONE; \
|
|
}
|
|
#define THREE_ID_OBJ(name) \
|
|
PYWRAP1(name) { \
|
|
id_type a, b, c; \
|
|
PyObject *o; \
|
|
PA("KKKO", &a, &b, &c, &o); \
|
|
name(a, b, c, o); \
|
|
Py_RETURN_NONE; \
|
|
}
|
|
#define K(name) \
|
|
PYWRAP1(name) { \
|
|
id_type a; \
|
|
PA("K", &a); \
|
|
name(a); \
|
|
Py_RETURN_NONE; \
|
|
}
|
|
#define KI(name) \
|
|
PYWRAP1(name) { \
|
|
id_type a; \
|
|
unsigned int b; \
|
|
PA("KI", &a, &b); \
|
|
name(a, b); \
|
|
Py_RETURN_NONE; \
|
|
}
|
|
#define KII(name) \
|
|
PYWRAP1(name) { \
|
|
id_type a; \
|
|
unsigned int b, c; \
|
|
PA("KII", &a, &b, &c); \
|
|
name(a, b, c); \
|
|
Py_RETURN_NONE; \
|
|
}
|
|
#define KKI(name) \
|
|
PYWRAP1(name) { \
|
|
id_type a, b; \
|
|
unsigned int c; \
|
|
PA("KKI", &a, &b, &c); \
|
|
name(a, b, c); \
|
|
Py_RETURN_NONE; \
|
|
}
|
|
#define KKK(name) \
|
|
PYWRAP1(name) { \
|
|
id_type a, b, c; \
|
|
PA("KKK", &a, &b, &c); \
|
|
name(a, b, c); \
|
|
Py_RETURN_NONE; \
|
|
}
|
|
#define KKII(name) \
|
|
PYWRAP1(name) { \
|
|
id_type a, b; \
|
|
unsigned int c, d; \
|
|
PA("KKII", &a, &b, &c, &d); \
|
|
name(a, b, c, d); \
|
|
Py_RETURN_NONE; \
|
|
}
|
|
#define KKKK(name) \
|
|
PYWRAP1(name) { \
|
|
id_type a, b, c, d; \
|
|
PA("KKKK", &a, &b, &c, &d); \
|
|
name(a, b, c, d); \
|
|
Py_RETURN_NONE; \
|
|
}
|
|
#define KK5I(name) \
|
|
PYWRAP1(name) { \
|
|
id_type a, b; \
|
|
unsigned int c, d, e, f, g; \
|
|
PA("KKIIIII", &a, &b, &c, &d, &e, &f, &g); \
|
|
name(a, b, c, d, e, f, g); \
|
|
Py_RETURN_NONE; \
|
|
}
|
|
#define BOOL_SET(name) \
|
|
PYWRAP1(set_##name) { \
|
|
global_state.name = PyObject_IsTrue(args); \
|
|
Py_RETURN_NONE; \
|
|
}
|
|
#define dict_iter(d) \
|
|
{ \
|
|
PyObject *key, *value; \
|
|
Py_ssize_t pos = 0; \
|
|
while (PyDict_Next(d, &pos, &key, &value))
|
|
|
|
PYWRAP1(update_ime_position_for_window) {
|
|
id_type window_id;
|
|
int force = 0;
|
|
int update_focus = 0;
|
|
PA("K|pi", &window_id, &force, &update_focus);
|
|
if (update_ime_position_for_window(window_id, force, update_focus)) Py_RETURN_TRUE;
|
|
Py_RETURN_FALSE;
|
|
}
|
|
|
|
PYWRAP0(next_window_id) { return PyLong_FromUnsignedLongLong(global_state.window_id_counter + 1); }
|
|
|
|
PYWRAP0(last_focused_os_window_id) { return PyLong_FromUnsignedLongLong(last_focused_os_window_id()); }
|
|
|
|
PYWRAP0(current_focused_os_window_id) { return PyLong_FromUnsignedLongLong(current_focused_os_window_id()); }
|
|
|
|
|
|
PYWRAP1(handle_for_window_id) {
|
|
id_type os_window_id;
|
|
PA("K", &os_window_id);
|
|
WITH_OS_WINDOW(os_window_id)
|
|
return PyLong_FromVoidPtr(os_window->handle);
|
|
END_WITH_OS_WINDOW
|
|
PyErr_SetString(PyExc_ValueError, "No such window");
|
|
return NULL;
|
|
}
|
|
|
|
|
|
PYWRAP0(get_options) {
|
|
if (!global_state.options_object) {
|
|
PyErr_SetString(PyExc_RuntimeError, "Must call set_options() before using get_options()");
|
|
return NULL;
|
|
}
|
|
Py_INCREF(global_state.options_object);
|
|
return global_state.options_object;
|
|
}
|
|
|
|
static bool
|
|
set_vertical_tab_bar_padding(PyObject *py_opts, Options *opts) {
|
|
// The number of cells each tab bar style draws around the title in a
|
|
// vertical tab bar, see the draw_tab_with_* functions in tab_bar.py.
|
|
// Custom styles can draw anything, so give them generous room.
|
|
opts->vertical_tab_bar.padding = 8;
|
|
opts->vertical_tab_bar.min_cols = 1;
|
|
RAII_PyObject(style, PyObject_GetAttrString(py_opts, "tab_bar_style"));
|
|
if (!style) return false;
|
|
if (PyUnicode_CompareWithASCIIString(style, "fade") == 0) {
|
|
RAII_PyObject(fade, PyObject_GetAttrString(py_opts, "tab_fade"));
|
|
if (!fade) return false;
|
|
Py_ssize_t n = PyObject_Length(fade);
|
|
if (n < 0) return false;
|
|
// Fade cells on both sides of the title, the trailing ones are only
|
|
// drawn when they end before the last column
|
|
opts->vertical_tab_bar.padding = 2 * (unsigned)n + (n < 2 ? 1 : 0);
|
|
} else if (PyUnicode_CompareWithASCIIString(style, "powerline") == 0) {
|
|
// Leading space, trailing space and the separator
|
|
opts->vertical_tab_bar.padding = 3;
|
|
} else if (PyUnicode_CompareWithASCIIString(style, "slant") == 0) {
|
|
// Separators and spaces on both sides of the title, tabs narrower
|
|
// than six cells show only an ellipsis
|
|
opts->vertical_tab_bar.padding = 4;
|
|
opts->vertical_tab_bar.min_cols = 6;
|
|
} else if (PyUnicode_CompareWithASCIIString(style, "separator") == 0) {
|
|
// The spaces in tab_separator, plus the column reserved at the end
|
|
RAII_PyObject(sep, PyObject_GetAttrString(py_opts, "tab_separator"));
|
|
if (!sep) return false;
|
|
Py_ssize_t len = PyUnicode_GetLength(sep);
|
|
if (len < 0) return false;
|
|
unsigned spaces = 0;
|
|
for (Py_ssize_t i = 0; i < len && PyUnicode_READ_CHAR(sep, i) == ' '; i++) spaces++;
|
|
for (Py_ssize_t i = len - 1; i >= (Py_ssize_t)spaces && PyUnicode_READ_CHAR(sep, i) == ' '; i--) spaces++;
|
|
opts->vertical_tab_bar.padding = spaces + 1;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
PYWRAP1(set_options) {
|
|
PyObject *opts;
|
|
int is_wayland = 0, debug_rendering = 0, debug_font_fallback = 0;
|
|
PA("O|ppp", &opts, &is_wayland, &debug_rendering, &debug_font_fallback);
|
|
if (opts == Py_None) {
|
|
Py_CLEAR(global_state.options_object);
|
|
Py_RETURN_NONE;
|
|
}
|
|
#ifdef __APPLE__
|
|
global_state.is_apple = true;
|
|
global_state.has_render_frames = true;
|
|
#endif
|
|
global_state.is_wayland = is_wayland ? true : false;
|
|
if (global_state.is_wayland) global_state.has_render_frames = true;
|
|
global_state.debug_rendering = debug_rendering ? true : false;
|
|
global_state.debug_font_fallback = debug_font_fallback ? true : false;
|
|
if (!convert_opts_from_python_opts(opts, &global_state.opts)) return NULL;
|
|
if (!set_wheel_mappings(opts, &global_state.opts)) return NULL;
|
|
if (!set_url_mappings(opts, &global_state.opts)) return NULL;
|
|
if (!set_vertical_tab_bar_padding(opts, &global_state.opts)) return NULL;
|
|
push_modifier_remap_to_glfw();
|
|
Py_XDECREF(global_state.options_object);
|
|
global_state.options_object = Py_NewRef(opts);
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PYWRAP1(set_ignore_os_keyboard_processing) {
|
|
set_ignore_os_keyboard_processing(PyObject_IsTrue(args));
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static void
|
|
init_window_render_data(WindowRenderData *d, const WindowGeometry g, Screen *screen) {
|
|
d->geometry = g;
|
|
Py_CLEAR(d->screen);
|
|
d->screen = (Screen *)Py_NewRef(screen);
|
|
}
|
|
|
|
PYWRAP1(set_tab_bar_render_data) {
|
|
WindowGeometry g;
|
|
id_type os_window_id;
|
|
Screen *screen;
|
|
PA("KOIIII", &os_window_id, &screen, &g.left, &g.top, &g.right, &g.bottom);
|
|
WITH_OS_WINDOW(os_window_id)
|
|
init_window_render_data(&os_window->tab_bar_render_data, g, screen);
|
|
END_WITH_OS_WINDOW
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PYWRAP1(set_window_drag_overlay) {
|
|
id_type os_window_id, tab_id, window_id;
|
|
int quadrant;
|
|
PA("KKKi", &os_window_id, &tab_id, &window_id, &quadrant);
|
|
WITH_WINDOW(os_window_id, tab_id, window_id)
|
|
Screen *s = window->render_data.screen;
|
|
if (s) {
|
|
if (quadrant == 0) {
|
|
s->start_drag_overlay_at = 0;
|
|
s->drag_overlay_quadrant = 0;
|
|
} else if (s->drag_overlay_quadrant != (uint8_t)quadrant) {
|
|
s->start_drag_overlay_at = monotonic();
|
|
s->drag_overlay_quadrant = (uint8_t)quadrant;
|
|
}
|
|
}
|
|
END_WITH_WINDOW
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PYWRAP1(set_window_title_bar_render_data) {
|
|
WindowGeometry g = {0};
|
|
id_type os_window_id, tab_id, window_id;
|
|
Screen *screen;
|
|
PA("KKKOIIII", &os_window_id, &tab_id, &window_id, &screen, &g.left, &g.top, &g.right, &g.bottom);
|
|
WITH_WINDOW(os_window_id, tab_id, window_id)
|
|
init_window_render_data(&window->window_title_render_data, g, screen);
|
|
screen->reload_all_gpu_data = true;
|
|
END_WITH_WINDOW
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyTypeObject RegionType;
|
|
static PyStructSequence_Field region_fields[] = {{"left", ""}, {"top", ""}, {"right", ""}, {"bottom", ""}, {"width", ""}, {"height", ""}, {NULL, NULL}};
|
|
static PyStructSequence_Desc region_desc = {"Region", NULL, region_fields, 6};
|
|
|
|
static PyObject *
|
|
wrap_region(Region *r) {
|
|
PyObject *ans = PyStructSequence_New(&RegionType);
|
|
if (ans) {
|
|
PyStructSequence_SET_ITEM(ans, 0, PyLong_FromUnsignedLong(r->left));
|
|
PyStructSequence_SET_ITEM(ans, 1, PyLong_FromUnsignedLong(r->top));
|
|
PyStructSequence_SET_ITEM(ans, 2, PyLong_FromUnsignedLong(r->right));
|
|
PyStructSequence_SET_ITEM(ans, 3, PyLong_FromUnsignedLong(r->bottom));
|
|
PyStructSequence_SET_ITEM(ans, 4, PyLong_FromUnsignedLong(r->right - r->left));
|
|
PyStructSequence_SET_ITEM(ans, 5, PyLong_FromUnsignedLong(r->bottom - r->top));
|
|
}
|
|
return ans;
|
|
}
|
|
|
|
PYWRAP1(viewport_for_window) {
|
|
id_type os_window_id;
|
|
int vw = 100, vh = 100;
|
|
unsigned int cell_width = 1, cell_height = 1;
|
|
PA("K", &os_window_id);
|
|
Region central = {0}, tab_bar = {0};
|
|
WITH_OS_WINDOW(os_window_id)
|
|
os_window_regions(os_window, ¢ral, &tab_bar);
|
|
vw = os_window->viewport_width;
|
|
vh = os_window->viewport_height;
|
|
cell_width = os_window->fonts_data->fcm.cell_width;
|
|
cell_height = os_window->fonts_data->fcm.cell_height;
|
|
goto end;
|
|
END_WITH_OS_WINDOW
|
|
end:
|
|
return Py_BuildValue("NNiiII", wrap_region(¢ral), wrap_region(&tab_bar), vw, vh, cell_width, cell_height);
|
|
}
|
|
|
|
PYWRAP1(cell_size_for_window) {
|
|
id_type os_window_id;
|
|
unsigned int cell_width = 0, cell_height = 0;
|
|
PA("K", &os_window_id);
|
|
WITH_OS_WINDOW(os_window_id)
|
|
cell_width = os_window->fonts_data->fcm.cell_width;
|
|
cell_height = os_window->fonts_data->fcm.cell_height;
|
|
goto end;
|
|
END_WITH_OS_WINDOW
|
|
end:
|
|
return Py_BuildValue("II", cell_width, cell_height);
|
|
}
|
|
|
|
|
|
PYWRAP1(os_window_has_background_image) {
|
|
id_type os_window_id;
|
|
PA("K", &os_window_id);
|
|
WITH_OS_WINDOW(os_window_id)
|
|
if (background_image_for_os_window(os_window) != NULL) Py_RETURN_TRUE;
|
|
END_WITH_OS_WINDOW
|
|
Py_RETURN_FALSE;
|
|
}
|
|
|
|
PYWRAP1(mark_os_window_for_close) {
|
|
id_type os_window_id;
|
|
CloseRequest cr = IMPERATIVE_CLOSE_REQUESTED;
|
|
PA("K|i", &os_window_id, &cr);
|
|
WITH_OS_WINDOW(os_window_id)
|
|
mark_os_window_for_close(os_window, cr);
|
|
Py_RETURN_TRUE;
|
|
END_WITH_OS_WINDOW
|
|
Py_RETURN_FALSE;
|
|
}
|
|
|
|
PYWRAP1(set_application_quit_request) {
|
|
CloseRequest cr = IMPERATIVE_CLOSE_REQUESTED;
|
|
int cause = -1;
|
|
PA("|ii", &cr, &cause);
|
|
global_state.quit_request = cr;
|
|
if (cr == NO_CLOSE_REQUESTED) {
|
|
global_state.logout_quit.requested = false;
|
|
global_state.quit_cause = QUIT_CAUSE_NONE;
|
|
} else if (cause >= QUIT_CAUSE_NONE && cause <= QUIT_CAUSE_FATAL_ERROR) global_state.quit_cause = cause;
|
|
global_state.has_pending_closes = true;
|
|
request_tick_callback();
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PYWRAP0(current_application_quit_request) { return Py_BuildValue("i", global_state.quit_request); }
|
|
|
|
PYWRAP0(current_application_quit_cause) { return Py_BuildValue("i", global_state.quit_cause); }
|
|
|
|
PYWRAP0(application_logout_requested_at) {
|
|
// The monotonic time at which the OS asked kitty to quit for a logout, restart or shutdown, or -1 if it has not done so since
|
|
// the last time a quit was cancelled
|
|
return PyFloat_FromDouble(global_state.logout_quit.requested ? monotonic_t_to_s_double(global_state.logout_quit.at) : -1);
|
|
}
|
|
|
|
PYWRAP1(focus_os_window) {
|
|
id_type os_window_id;
|
|
int also_raise = 1;
|
|
const char *activation_token = NULL;
|
|
PA("K|pz", &os_window_id, &also_raise, &activation_token);
|
|
WITH_OS_WINDOW(os_window_id)
|
|
if (!os_window->is_focused || (activation_token && activation_token[0])) focus_os_window(os_window, also_raise, activation_token);
|
|
Py_RETURN_TRUE;
|
|
END_WITH_OS_WINDOW
|
|
Py_RETURN_FALSE;
|
|
}
|
|
|
|
PYWRAP1(run_with_activation_token) {
|
|
for (size_t o = 0; o < global_state.num_os_windows; o++) {
|
|
OSWindow *os_window = global_state.os_windows + o;
|
|
if (os_window->is_focused) {
|
|
run_with_activation_token_in_os_window(os_window, args);
|
|
Py_RETURN_TRUE;
|
|
}
|
|
}
|
|
id_type os_window_id = last_focused_os_window_id();
|
|
if (!os_window_id) {
|
|
if (!global_state.num_os_windows) Py_RETURN_FALSE;
|
|
os_window_id = global_state.os_windows[0].id;
|
|
}
|
|
for (size_t o = 0; o < global_state.num_os_windows; o++) {
|
|
OSWindow *os_window = global_state.os_windows + o;
|
|
if (os_window->id == os_window_id) {
|
|
run_with_activation_token_in_os_window(os_window, args);
|
|
Py_RETURN_TRUE;
|
|
}
|
|
}
|
|
Py_RETURN_FALSE;
|
|
}
|
|
|
|
PYWRAP1(set_os_window_chrome) {
|
|
id_type os_window_id;
|
|
PA("K", &os_window_id);
|
|
WITH_OS_WINDOW(os_window_id)
|
|
set_os_window_chrome(os_window);
|
|
Py_RETURN_TRUE;
|
|
END_WITH_OS_WINDOW
|
|
Py_RETURN_FALSE;
|
|
}
|
|
|
|
PYWRAP1(mark_tab_bar_dirty) {
|
|
id_type os_window_id;
|
|
int should_be_shown;
|
|
PA("Kp", &os_window_id, &should_be_shown);
|
|
WITH_OS_WINDOW(os_window_id)
|
|
os_window->has_too_few_tabs = !should_be_shown;
|
|
os_window->tab_bar_data_updated = false;
|
|
// This can be called outside the main loop tick, so ensure the tab bar is redrawn
|
|
request_tick_callback();
|
|
END_WITH_OS_WINDOW
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PYWRAP1(is_tab_bar_visible) {
|
|
id_type os_window_id;
|
|
PA("K", &os_window_id);
|
|
if (!OPT(tab_bar_hidden)) {
|
|
WITH_OS_WINDOW(os_window_id)
|
|
return (os_window->num_tabs == 0 || os_window->has_too_few_tabs) ? Py_NewRef(Py_False) : Py_NewRef(Py_True);
|
|
END_WITH_OS_WINDOW
|
|
}
|
|
Py_RETURN_FALSE;
|
|
}
|
|
|
|
|
|
PYWRAP1(change_background_opacity) {
|
|
id_type os_window_id;
|
|
float opacity;
|
|
PA("Kf", &os_window_id, &opacity);
|
|
WITH_OS_WINDOW(os_window_id)
|
|
os_window->background_opacity.alpha = opacity;
|
|
if (!os_window->redraw_count) os_window->redraw_count++;
|
|
set_os_window_chrome(os_window); // on macOS titlebar opacity can depend on background_opacity
|
|
Py_RETURN_TRUE;
|
|
END_WITH_OS_WINDOW
|
|
Py_RETURN_FALSE;
|
|
}
|
|
|
|
PYWRAP1(background_opacity_of) {
|
|
id_type os_window_id = PyLong_AsUnsignedLongLong(args);
|
|
if (PyErr_Occurred()) return NULL;
|
|
WITH_OS_WINDOW(os_window_id)
|
|
return PyFloat_FromDouble((double)effective_os_window_alpha(os_window));
|
|
END_WITH_OS_WINDOW
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PYWRAP1(set_window_padding) {
|
|
id_type os_window_id, tab_id, window_id;
|
|
unsigned int left, top, right, bottom;
|
|
PA("KKKIIII", &os_window_id, &tab_id, &window_id, &left, &top, &right, &bottom);
|
|
WITH_WINDOW(os_window_id, tab_id, window_id);
|
|
window->padding.left = left;
|
|
window->padding.top = top;
|
|
window->padding.right = right;
|
|
window->padding.bottom = bottom;
|
|
END_WITH_WINDOW;
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PYWRAP1(set_window_render_data) {
|
|
#define B(name) &(g.name)
|
|
#define S(name) &(g.spaces.name)
|
|
id_type os_window_id, tab_id, window_id;
|
|
WindowGeometry g = {0};
|
|
Screen *screen;
|
|
unsigned int cl, ct, cr, cb;
|
|
PA("KKKOIIIIIIIIIIII",
|
|
&os_window_id,
|
|
&tab_id,
|
|
&window_id,
|
|
&screen,
|
|
B(left),
|
|
B(top),
|
|
B(right),
|
|
B(bottom),
|
|
S(left),
|
|
S(top),
|
|
S(right),
|
|
S(bottom),
|
|
&cl,
|
|
&ct,
|
|
&cr,
|
|
&cb);
|
|
|
|
WITH_WINDOW(os_window_id, tab_id, window_id);
|
|
init_window_render_data(&window->render_data, g, screen);
|
|
window->size_mismatch_padding.left = cl;
|
|
window->size_mismatch_padding.top = ct;
|
|
window->size_mismatch_padding.right = cr;
|
|
window->size_mismatch_padding.bottom = cb;
|
|
END_WITH_WINDOW;
|
|
Py_RETURN_NONE;
|
|
#undef B
|
|
#undef S
|
|
}
|
|
|
|
PYWRAP1(update_window_visibility) {
|
|
id_type os_window_id, tab_id, window_id;
|
|
int visible;
|
|
PA("KKKp", &os_window_id, &tab_id, &window_id, &visible);
|
|
WITH_WINDOW(os_window_id, tab_id, window_id);
|
|
bool was_visible = window->visible & 1;
|
|
window->visible = visible & 1;
|
|
if (!was_visible && window->visible) global_state.check_for_active_animated_images = true;
|
|
if (window->render_data.screen) {
|
|
screen_visibility_changed(window->render_data.screen, is_os_window_potentially_visible(osw) && t == osw->active_tab && window->visible);
|
|
}
|
|
END_WITH_WINDOW;
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
|
|
PYWRAP1(sync_os_window_title) {
|
|
id_type os_window_id;
|
|
PA("K", &os_window_id);
|
|
WITH_OS_WINDOW(os_window_id)
|
|
update_os_window_title(os_window);
|
|
END_WITH_OS_WINDOW
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PYWRAP1(set_os_window_title) {
|
|
id_type os_window_id;
|
|
PyObject *title;
|
|
PA("KU", &os_window_id, &title);
|
|
WITH_OS_WINDOW(os_window_id)
|
|
if (os_window->disallow_title_changes) break;
|
|
if (PyUnicode_GetLength(title)) {
|
|
os_window->title_is_overriden = true;
|
|
Py_XDECREF(os_window->window_title);
|
|
os_window->window_title = title;
|
|
Py_INCREF(title);
|
|
set_os_window_title(os_window, PyUnicode_AsUTF8(title));
|
|
} else {
|
|
os_window->title_is_overriden = false;
|
|
if (os_window->window_title) set_os_window_title(os_window, PyUnicode_AsUTF8(os_window->window_title));
|
|
update_os_window_title(os_window);
|
|
}
|
|
END_WITH_OS_WINDOW
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PYWRAP1(get_os_window_title) {
|
|
id_type os_window_id;
|
|
int only_if_overridden = 0;
|
|
PA("K|p", &os_window_id, &only_if_overridden);
|
|
WITH_OS_WINDOW(os_window_id)
|
|
if (only_if_overridden && !os_window->disallow_title_changes && !os_window->title_is_overriden) break;
|
|
if (os_window->window_title) return Py_BuildValue("O", os_window->window_title);
|
|
END_WITH_OS_WINDOW
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PYWRAP1(os_window_is_invisible) {
|
|
id_type os_window_id = PyLong_AsUnsignedLongLong(args);
|
|
if (PyErr_Occurred()) return NULL;
|
|
WITH_OS_WINDOW(os_window_id)
|
|
if (should_os_window_be_rendered(os_window)) { Py_RETURN_FALSE; }
|
|
Py_RETURN_TRUE;
|
|
END_WITH_OS_WINDOW
|
|
Py_RETURN_FALSE;
|
|
}
|
|
|
|
PYWRAP1(pt_to_px) {
|
|
double pt;
|
|
id_type os_window_id = 0;
|
|
PA("d|K", &pt, &os_window_id);
|
|
return PyLong_FromLong(pt_to_px(pt, os_window_id));
|
|
}
|
|
|
|
PYWRAP1(global_font_size) {
|
|
double set_val = -1;
|
|
PA("|d", &set_val);
|
|
if (set_val > 0) OPT(font_size) = set_val;
|
|
return Py_BuildValue("d", OPT(font_size));
|
|
}
|
|
|
|
PYWRAP1(os_window_font_size) {
|
|
id_type os_window_id;
|
|
int force = 0;
|
|
double new_sz = -1;
|
|
PA("K|dp", &os_window_id, &new_sz, &force);
|
|
WITH_OS_WINDOW(os_window_id)
|
|
if (new_sz > 0 && (force || new_sz != os_window->fonts_data->font_sz_in_pts)) {
|
|
on_os_window_font_size_change(os_window, new_sz);
|
|
send_prerendered_sprites_for_window(os_window);
|
|
resize_screen(os_window, os_window->tab_bar_render_data.screen, false);
|
|
for (size_t ti = 0; ti < os_window->num_tabs; ti++) {
|
|
Tab *tab = os_window->tabs + ti;
|
|
for (size_t wi = 0; wi < tab->num_windows; wi++) {
|
|
Window *w = tab->windows + wi;
|
|
resize_screen(os_window, w->render_data.screen, true);
|
|
}
|
|
}
|
|
// On Wayland with CSD title needs to be re-rendered in a different font size
|
|
if (os_window->window_title && global_state.is_wayland) set_os_window_title(os_window, NULL);
|
|
}
|
|
return Py_BuildValue("d", os_window->fonts_data->font_sz_in_pts);
|
|
END_WITH_OS_WINDOW
|
|
return Py_BuildValue("d", 0.0);
|
|
}
|
|
|
|
PYWRAP1(set_os_window_size) {
|
|
id_type os_window_id;
|
|
int width, height;
|
|
PA("Kii", &os_window_id, &width, &height);
|
|
WITH_OS_WINDOW(os_window_id)
|
|
set_os_window_size(os_window, width, height);
|
|
Py_RETURN_TRUE;
|
|
END_WITH_OS_WINDOW
|
|
Py_RETURN_FALSE;
|
|
}
|
|
|
|
PYWRAP1(get_os_window_size) {
|
|
id_type os_window_id;
|
|
PA("K", &os_window_id);
|
|
WITH_OS_WINDOW(os_window_id)
|
|
double xdpi, ydpi;
|
|
float xscale, yscale;
|
|
int width, height, fw, fh;
|
|
get_os_window_size(os_window, &width, &height, &fw, &fh);
|
|
get_os_window_content_scale(os_window, &xdpi, &ydpi, &xscale, &yscale);
|
|
unsigned int cell_width = os_window->fonts_data->fcm.cell_width, cell_height = os_window->fonts_data->fcm.cell_height;
|
|
return Py_BuildValue(
|
|
"{si si si si sf sf sd sd sI sI sO}",
|
|
"width",
|
|
width,
|
|
"height",
|
|
height,
|
|
"framebuffer_width",
|
|
fw,
|
|
"framebuffer_height",
|
|
fh,
|
|
"xscale",
|
|
xscale,
|
|
"yscale",
|
|
yscale,
|
|
"xdpi",
|
|
xdpi,
|
|
"ydpi",
|
|
ydpi,
|
|
"cell_width",
|
|
cell_width,
|
|
"cell_height",
|
|
cell_height,
|
|
"is_layer_shell",
|
|
os_window->is_layer_shell ? Py_True : Py_False);
|
|
END_WITH_OS_WINDOW
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PYWRAP1(get_os_window_pos) {
|
|
id_type os_window_id;
|
|
PA("K", &os_window_id);
|
|
WITH_OS_WINDOW(os_window_id)
|
|
int x, y;
|
|
get_os_window_pos(os_window, &x, &y);
|
|
return Py_BuildValue("ii", x, y);
|
|
END_WITH_OS_WINDOW
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PYWRAP1(set_os_window_pos) {
|
|
id_type os_window_id;
|
|
int x, y;
|
|
PA("Kii", &os_window_id, &x, &y);
|
|
WITH_OS_WINDOW(os_window_id)
|
|
set_os_window_pos(os_window, x, y);
|
|
END_WITH_OS_WINDOW
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PYWRAP1(set_boss) {
|
|
Py_CLEAR(global_state.boss);
|
|
if (args == Py_None) {
|
|
global_state.boss = NULL;
|
|
} else {
|
|
global_state.boss = args;
|
|
Py_INCREF(global_state.boss);
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PYWRAP0(get_boss) {
|
|
if (global_state.boss) {
|
|
Py_INCREF(global_state.boss);
|
|
return global_state.boss;
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PYWRAP0(apply_options_update) {
|
|
for (size_t o = 0; o < global_state.num_os_windows; o++) {
|
|
OSWindow *os_window = global_state.os_windows + o;
|
|
get_platform_dependent_config_values(os_window->handle);
|
|
os_window->background_opacity.alpha = OPT(background_opacity);
|
|
set_os_window_chrome(os_window);
|
|
if (!os_window->redraw_count) os_window->redraw_count++;
|
|
for (size_t t = 0; t < os_window->num_tabs; t++) {
|
|
Tab *tab = os_window->tabs + t;
|
|
for (size_t w = 0; w < tab->num_windows; w++) {
|
|
Window *window = tab->windows + w;
|
|
if (window->window_logo.using_default) {
|
|
set_window_logo(window, OPT(default_window_logo), OPT(window_logo_position), OPT(window_logo_alpha), true, NULL, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
// Indexed color images use the url color, so the color tables on the GPU must
|
|
// be refreshed when it changes
|
|
static void
|
|
mark_all_color_profiles_dirty(void) {
|
|
for (size_t o = 0; o < global_state.num_os_windows; o++) {
|
|
OSWindow *osw = global_state.os_windows + o;
|
|
for (size_t t = 0; t < osw->num_tabs; t++) {
|
|
Tab *tab = osw->tabs + t;
|
|
for (size_t w = 0; w < tab->num_windows; w++) {
|
|
Screen *screen = tab->windows[w].render_data.screen;
|
|
if (screen) {
|
|
screen->color_profile->dirty = true;
|
|
screen->paused_rendering.color_profile.dirty = true;
|
|
screen->is_dirty = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
PYWRAP1(patch_global_colors) {
|
|
PyObject *spec;
|
|
int configured;
|
|
if (!PyArg_ParseTuple(args, "Op", &spec, &configured)) return NULL;
|
|
#define P(name, convert) \
|
|
{ \
|
|
PyObject *val = PyDict_GetItemString(spec, #name); \
|
|
if (val) { \
|
|
if (val == Py_None) OPT(name) = 0; \
|
|
else if (PyLong_Check(val)) { \
|
|
const __typeof__(convert(val)) converted = convert(val); \
|
|
if (PyErr_Occurred()) return NULL; \
|
|
OPT(name) = converted; \
|
|
} \
|
|
} \
|
|
}
|
|
P(active_border_color, PyLong_AsLong);
|
|
P(inactive_border_color, PyLong_AsLong);
|
|
P(bell_border_color, PyLong_AsLong);
|
|
P(tab_bar_background, PyLong_AsLong);
|
|
P(tab_bar_margin_color, PyLong_AsLong);
|
|
// Signed because of the negative light/dark sentinels. An RGB payload with
|
|
// bit 31 set would overflow a 32-bit long, but macOS is 64-bit only.
|
|
P(macos_titlebar_color, PyLong_AsLong);
|
|
// The RGB payload of these options can set bit 31.
|
|
P(wayland_titlebar_color, PyLong_AsUnsignedLong);
|
|
P(scrollbar_handle_color, PyLong_AsUnsignedLong);
|
|
P(scrollbar_track_color, PyLong_AsUnsignedLong);
|
|
if (configured) {
|
|
P(background, PyLong_AsLong);
|
|
const color_type prev_url_color = OPT(url_color);
|
|
P(url_color, PyLong_AsLong);
|
|
if (OPT(url_color) != prev_url_color) mark_all_color_profiles_dirty();
|
|
}
|
|
#undef P
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PYWRAP1(update_tab_bar_edge_colors) {
|
|
id_type os_window_id;
|
|
int is_vertical = 0;
|
|
PA("K|p", &os_window_id, &is_vertical);
|
|
WITH_OS_WINDOW(os_window_id)
|
|
Screen *screen = os_window->tab_bar_render_data.screen;
|
|
if (screen) {
|
|
bool left_is_default = true, right_is_default = true;
|
|
bool ok;
|
|
if (!is_vertical) {
|
|
ok = get_line_edge_colors_at_row(
|
|
screen, screen->cursor->y, &os_window->tab_bar_edge_color.left, &os_window->tab_bar_edge_color.right, &left_is_default, &right_is_default);
|
|
} else {
|
|
color_type top_color = 0, bottom_color = 0;
|
|
bool top_is_default = true, bottom_is_default = true;
|
|
// For vertical bars we only need the left-edge color of each row (the
|
|
// right-edge output is unused since tabs span the full row width).
|
|
ok = get_line_edge_colors_at_row(screen, 0, &top_color, NULL, &top_is_default, NULL) &&
|
|
get_line_edge_colors_at_row(screen, screen->lines - 1, &bottom_color, NULL, &bottom_is_default, NULL);
|
|
if (ok) {
|
|
os_window->tab_bar_edge_color.left = top_color;
|
|
os_window->tab_bar_edge_color.right = bottom_color;
|
|
left_is_default = top_is_default;
|
|
right_is_default = bottom_is_default;
|
|
}
|
|
}
|
|
if (ok) { return Py_BuildValue("OO", left_is_default ? Py_True : Py_False, right_is_default ? Py_True : Py_False); }
|
|
}
|
|
END_WITH_OS_WINDOW
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
pyset_background_image(PyObject *self UNUSED, PyObject *args, PyObject *kw) {
|
|
const char *path;
|
|
PyObject *layout_name = NULL, *pylinear = NULL, *pytint = NULL, *pytint_gaps = NULL;
|
|
PyObject *os_window_ids;
|
|
int configured = 0;
|
|
char *png_data = NULL;
|
|
Py_ssize_t png_data_size = 0;
|
|
int global_index = -1;
|
|
int is_increment = 0;
|
|
static char *kwds[] = {
|
|
"path", "os_window_ids", "configured", "layout_name", "png_data", "linear", "tint", "tint_gaps", "global_index", "is_increment", NULL};
|
|
if (!PyArg_ParseTupleAndKeywords(
|
|
args,
|
|
kw,
|
|
"zO!|pOy#OOOip",
|
|
kwds,
|
|
&path,
|
|
&PyTuple_Type,
|
|
&os_window_ids,
|
|
&configured,
|
|
&layout_name,
|
|
&png_data,
|
|
&png_data_size,
|
|
&pylinear,
|
|
&pytint,
|
|
&pytint_gaps,
|
|
&global_index,
|
|
&is_increment))
|
|
return NULL;
|
|
size_t size;
|
|
BackgroundImageLayout layout = PyUnicode_Check(layout_name) ? bglayout(layout_name) : OPT(background_image_layout);
|
|
BackgroundImage *bgimage = NULL;
|
|
if (path) {
|
|
bgimage = calloc(1, sizeof(BackgroundImage));
|
|
if (!bgimage) return PyErr_NoMemory();
|
|
bool ok;
|
|
if (png_data && png_data_size) {
|
|
ok = png_from_data(png_data, png_data_size, path, &bgimage->bitmap, &bgimage->width, &bgimage->height, &size);
|
|
} else {
|
|
ok = image_path_to_bitmap(path, &bgimage->bitmap, &bgimage->width, &bgimage->height, &bgimage->mmap_size);
|
|
}
|
|
if (!ok) {
|
|
PyErr_Format(PyExc_ValueError, "Failed to load image from: %s", path);
|
|
free(bgimage);
|
|
return NULL;
|
|
}
|
|
bgimage->id = ++bg_image_id_counter;
|
|
if (!send_bgimage_to_gpu(layout, bgimage)) {
|
|
PyErr_Format(PyExc_ValueError, "Failed to send image to GPU image from: %s", path);
|
|
free(bgimage);
|
|
return NULL;
|
|
}
|
|
bgimage->refcnt++;
|
|
}
|
|
if (configured) {
|
|
if (bgimage) {
|
|
if (global_background_image(0)) {
|
|
free_bgimage(&global_state.background_images.images[0], true);
|
|
} else {
|
|
free_global_background_images(true);
|
|
global_state.background_images.images = calloc(1, sizeof(global_state.background_images.images[0]));
|
|
if (!global_state.background_images.images) fatal("Out of memory");
|
|
global_state.background_images.count = 1;
|
|
global_state.background_images.generation = OPT(background_images).generation;
|
|
}
|
|
global_state.background_images.images[0] = bgimage;
|
|
bgimage->refcnt++;
|
|
if (OPT(background_images).count > 0) {
|
|
free(OPT(background_images).paths[0]);
|
|
char *new_path = strdup(path);
|
|
if (!new_path) fatal("Out of memory");
|
|
OPT(background_images).paths[0] = new_path;
|
|
}
|
|
} else free_global_background_images(true);
|
|
OPT(background_image_layout) = layout;
|
|
if (pylinear && pylinear != Py_None) convert_from_python_background_image_linear(pylinear, &global_state.opts);
|
|
if (pytint && pytint != Py_None) convert_from_python_background_tint(pytint, &global_state.opts);
|
|
if (pytint_gaps && pytint_gaps != Py_None) convert_from_python_background_tint_gaps(pytint_gaps, &global_state.opts);
|
|
}
|
|
for (Py_ssize_t i = 0; i < PyTuple_GET_SIZE(os_window_ids); i++) {
|
|
id_type os_window_id = PyLong_AsUnsignedLongLong(PyTuple_GET_ITEM(os_window_ids, i));
|
|
WITH_OS_WINDOW(os_window_id)
|
|
unsigned idx = os_window->background_image.global_bg_images_idx;
|
|
make_os_window_context_current(os_window);
|
|
free_bgimage(&os_window->background_image.override, true);
|
|
zero_at_ptr(&os_window->background_image);
|
|
os_window->render_calls = 0;
|
|
if (bgimage) {
|
|
if (!configured) { // configured means we use the zero index global image
|
|
os_window->background_image.override = bgimage;
|
|
os_window->background_image.layout = layout;
|
|
os_window->background_image.has_layout = true;
|
|
bgimage->refcnt++;
|
|
}
|
|
} else if (is_increment) {
|
|
os_window->background_image.global_bg_images_idx = increment_bg_image_idx(idx, global_index);
|
|
} else if (global_index < 0) os_window->background_image.no_image = true;
|
|
else os_window->background_image.global_bg_images_idx = global_index;
|
|
END_WITH_OS_WINDOW
|
|
}
|
|
if (bgimage) free_bgimage(&bgimage, true);
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PYWRAP0(destroy_global_data) {
|
|
Py_CLEAR(global_state.boss);
|
|
free(global_state.os_windows);
|
|
global_state.os_windows = NULL;
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PYWRAP0(wakeup_main_loop) {
|
|
wakeup_main_loop();
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static void
|
|
destroy_mock_window(PyObject *capsule) {
|
|
Window *w = PyCapsule_GetPointer(capsule, "Window");
|
|
if (w) {
|
|
destroy_window(w);
|
|
PyMem_Free(w);
|
|
}
|
|
}
|
|
|
|
static PyObject *
|
|
pycreate_mock_window(PyObject *self UNUSED, PyObject *args) {
|
|
Screen *screen;
|
|
PyObject *title = NULL;
|
|
if (!PyArg_ParseTuple(args, "O|U", &screen, &title)) return NULL;
|
|
Window *w = PyMem_Calloc(sizeof(Window), 1);
|
|
if (!w) return NULL;
|
|
Py_INCREF(screen);
|
|
PyObject *ans = PyCapsule_New(w, "Window", destroy_mock_window);
|
|
if (ans != NULL) {
|
|
initialize_window(w, title, false);
|
|
w->render_data.screen = screen;
|
|
}
|
|
return ans;
|
|
}
|
|
|
|
static bool
|
|
click_mouse_url(id_type os_window_id, id_type tab_id, id_type window_id) {
|
|
bool clicked = false;
|
|
WITH_WINDOW(os_window_id, tab_id, window_id);
|
|
clicked = mouse_open_url(window);
|
|
END_WITH_WINDOW;
|
|
return clicked;
|
|
}
|
|
|
|
static bool
|
|
click_mouse_cmd_output(id_type os_window_id, id_type tab_id, id_type window_id, int select_cmd_output) {
|
|
bool handled = false;
|
|
WITH_WINDOW(os_window_id, tab_id, window_id);
|
|
handled = mouse_set_last_visited_cmd_output(window);
|
|
if (select_cmd_output && handled) handled = mouse_select_cmd_output(window);
|
|
END_WITH_WINDOW;
|
|
return handled;
|
|
}
|
|
|
|
static bool
|
|
move_cursor_to_mouse_if_in_prompt(id_type os_window_id, id_type tab_id, id_type window_id) {
|
|
bool moved = false;
|
|
WITH_WINDOW(os_window_id, tab_id, window_id);
|
|
moved = move_cursor_to_mouse_if_at_shell_prompt(window);
|
|
END_WITH_WINDOW;
|
|
return moved;
|
|
}
|
|
|
|
void
|
|
update_pointer_shape_for_kitty_window(id_type kitty_window_id) {
|
|
OSWindow *os_window = os_window_for_kitty_window(kitty_window_id);
|
|
if (!os_window || !os_window->is_focused) return;
|
|
OSWindow *orig = global_state.callback_os_window;
|
|
global_state.callback_os_window = os_window;
|
|
update_mouse_pointer_shape();
|
|
global_state.callback_os_window = orig;
|
|
}
|
|
|
|
static PyObject *
|
|
pymouse_selection(PyObject *self UNUSED, PyObject *args) {
|
|
id_type os_window_id, tab_id, window_id;
|
|
int code, button;
|
|
PA("KKKii", &os_window_id, &tab_id, &window_id, &code, &button);
|
|
WITH_WINDOW(os_window_id, tab_id, window_id);
|
|
mouse_selection(window, code, button);
|
|
END_WITH_WINDOW;
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PYWRAP1(get_window_logo_settings_if_not_default) {
|
|
id_type os_window_id, tab_id, window_id;
|
|
PA("KKK", &os_window_id, &tab_id, &window_id);
|
|
WITH_WINDOW(os_window_id, tab_id, window_id);
|
|
if (window->window_logo.instance != NULL && window->window_logo.id && !window->window_logo.using_default) {
|
|
WindowLogo *wl = find_window_logo(global_state.all_window_logos, window->window_logo.id);
|
|
if (wl != NULL && wl->load_from_disk_ok) {
|
|
const char *path = window_logo_path_for_id(global_state.all_window_logos, window->window_logo.id);
|
|
if (path) {
|
|
ImageAnchorPosition *p = &window->window_logo.position;
|
|
return Py_BuildValue("sfN", path, window->window_logo.alpha, Py_BuildValue("ffff", p->image_x, p->image_y, p->canvas_x, p->canvas_y));
|
|
}
|
|
}
|
|
}
|
|
END_WITH_WINDOW;
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PYWRAP1(set_window_logo) {
|
|
id_type os_window_id, tab_id, window_id;
|
|
const char *path;
|
|
PyObject *position;
|
|
float alpha = 0.5;
|
|
char *png_data = NULL;
|
|
Py_ssize_t png_data_size = 0;
|
|
PA("KKKsUf|y#", &os_window_id, &tab_id, &window_id, &path, &position, &alpha, &png_data, &png_data_size);
|
|
bool ok = false;
|
|
WITH_WINDOW(os_window_id, tab_id, window_id);
|
|
ok = set_window_logo(
|
|
window,
|
|
path,
|
|
PyObject_IsTrue(position) ? bganchor(position) : OPT(window_logo_position),
|
|
(0 <= alpha && alpha <= 1) ? alpha : OPT(window_logo_alpha),
|
|
false,
|
|
png_data,
|
|
png_data_size);
|
|
END_WITH_WINDOW;
|
|
if (ok) Py_RETURN_TRUE;
|
|
Py_RETURN_FALSE;
|
|
}
|
|
|
|
|
|
PYWRAP1(click_mouse_url) {
|
|
id_type a, b, c;
|
|
PA("KKK", &a, &b, &c);
|
|
if (click_mouse_url(a, b, c)) { Py_RETURN_TRUE; }
|
|
Py_RETURN_FALSE;
|
|
}
|
|
|
|
PYWRAP1(click_mouse_cmd_output) {
|
|
id_type a, b, c;
|
|
int d;
|
|
PA("KKKp", &a, &b, &c, &d);
|
|
if (click_mouse_cmd_output(a, b, c, d)) { Py_RETURN_TRUE; }
|
|
Py_RETURN_FALSE;
|
|
}
|
|
|
|
PYWRAP1(move_cursor_to_mouse_if_in_prompt) {
|
|
id_type a, b, c;
|
|
PA("KKK", &a, &b, &c);
|
|
if (move_cursor_to_mouse_if_in_prompt(a, b, c)) Py_RETURN_TRUE;
|
|
Py_RETURN_FALSE;
|
|
}
|
|
|
|
PYWRAP1(redirect_mouse_handling) {
|
|
global_state.redirect_mouse_handling = PyObject_IsTrue(args) ? true : false;
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
PYWRAP1(buffer_keys_in_window) {
|
|
int enabled = 1;
|
|
id_type a, b, c;
|
|
PA("KKK|p", &a, &b, &c, &enabled);
|
|
if (buffer_keys_in_window(a, b, c, enabled)) Py_RETURN_TRUE;
|
|
Py_RETURN_FALSE;
|
|
}
|
|
|
|
THREE_ID_OBJ(update_window_title)
|
|
THREE_ID(remove_window)
|
|
THREE_ID(detach_window)
|
|
THREE_ID(attach_window)
|
|
PYWRAP1(move_window_to_tab) {
|
|
id_type os_window_id, src_tab_id, dest_tab_id, window_id;
|
|
PA("KKKK", &os_window_id, &src_tab_id, &dest_tab_id, &window_id);
|
|
if (move_window_to_tab(os_window_id, src_tab_id, dest_tab_id, window_id)) Py_RETURN_TRUE;
|
|
Py_RETURN_FALSE;
|
|
}
|
|
PYWRAP1(add_tab) { return PyLong_FromUnsignedLongLong(add_tab(PyLong_AsUnsignedLongLong(args))); }
|
|
PYWRAP1(add_window) {
|
|
PyObject *title;
|
|
id_type a, b;
|
|
PA("KKO", &a, &b, &title);
|
|
return PyLong_FromUnsignedLongLong(add_window(a, b, title));
|
|
}
|
|
PYWRAP0(current_os_window) {
|
|
OSWindow *w = current_os_window();
|
|
if (!w) Py_RETURN_NONE;
|
|
return PyLong_FromUnsignedLongLong(w->id);
|
|
}
|
|
TWO_ID(remove_tab)
|
|
KI(set_active_tab)
|
|
K(mark_os_window_dirty)
|
|
KKK(set_active_window)
|
|
KII(swap_tabs)
|
|
KKKK(set_redirect_keys_to_overlay)
|
|
|
|
static PyObject *
|
|
os_window_focus_counters(PyObject *self UNUSED, PyObject *args UNUSED) {
|
|
RAII_PyObject(ans, PyDict_New());
|
|
for (size_t i = 0; i < global_state.num_os_windows; i++) {
|
|
OSWindow *w = &global_state.os_windows[i];
|
|
RAII_PyObject(key, PyLong_FromUnsignedLongLong(w->id));
|
|
RAII_PyObject(val, PyLong_FromUnsignedLongLong(w->last_focused_counter));
|
|
if (!key || !val) return NULL;
|
|
if (PyDict_SetItem(ans, key, val) != 0) return NULL;
|
|
}
|
|
Py_INCREF(ans);
|
|
return ans;
|
|
}
|
|
|
|
static PyObject *
|
|
get_mouse_data_for_window(PyObject *self UNUSED, PyObject *args) {
|
|
id_type os_window_id, tab_id, window_id;
|
|
PA("KKK", &os_window_id, &tab_id, &window_id);
|
|
WITH_WINDOW(os_window_id, tab_id, window_id)
|
|
return Py_BuildValue(
|
|
"{sI sI sO}",
|
|
"cell_x",
|
|
window->mouse_pos.cell_x,
|
|
"cell_y",
|
|
window->mouse_pos.cell_y,
|
|
"in_left_half_of_cell",
|
|
window->mouse_pos.in_left_half_of_cell ? Py_True : Py_False);
|
|
END_WITH_WINDOW
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
#define tbd global_state.tab_being_dragged
|
|
static PyObject *
|
|
set_tab_being_dragged(PyObject *self UNUSED, PyObject *args) {
|
|
zero_at_ptr(&tbd);
|
|
if (!PyArg_ParseTuple(args, "|Kpdd", &tbd.id, &tbd.drag_started, &tbd.x, &tbd.y)) return NULL;
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
get_tab_being_dragged(PyObject *self UNUSED, PyObject *args UNUSED) {
|
|
return Py_BuildValue("KOdd", tbd.id, tbd.drag_started ? Py_True : Py_False, tbd.x, tbd.y);
|
|
}
|
|
#undef tbd
|
|
|
|
#define wbd global_state.window_being_dragged
|
|
static PyObject *
|
|
set_window_being_dragged(PyObject *self UNUSED, PyObject *args) {
|
|
zero_at_ptr(&wbd);
|
|
if (!PyArg_ParseTuple(args, "|Kpdd", &wbd.id, &wbd.drag_started, &wbd.x, &wbd.y)) return NULL;
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyObject *
|
|
get_window_being_dragged(PyObject *self UNUSED, PyObject *args UNUSED) {
|
|
return Py_BuildValue("KOdd", wbd.id, wbd.drag_started ? Py_True : Py_False, wbd.x, wbd.y);
|
|
}
|
|
#undef wbd
|
|
|
|
static PyObject *
|
|
request_callback_with_thumbnail(PyObject *self UNUSED, PyObject *args) {
|
|
unsigned long long os_window_id, window_id = 0;
|
|
const char *callback;
|
|
int include_tab_bar = 0, no_scaling = 0;
|
|
double scale = 0.25;
|
|
unsigned max_width = 480;
|
|
if (!PyArg_ParseTuple(args, "sK|KpdIp", &callback, &os_window_id, &window_id, &include_tab_bar, &scale, &max_width, &no_scaling)) return NULL;
|
|
WITH_OS_WINDOW(os_window_id)
|
|
global_state.thumbnail_callback.os_window = os_window->id;
|
|
global_state.thumbnail_callback.window = window_id;
|
|
global_state.thumbnail_callback.include_tab_bar = include_tab_bar;
|
|
snprintf(global_state.thumbnail_callback.callback, arraysz(global_state.thumbnail_callback.callback), "%s", callback);
|
|
global_state.thumbnail_callback.max_width = max_width;
|
|
global_state.thumbnail_callback.scale = scale;
|
|
global_state.thumbnail_callback.no_scaling = no_scaling;
|
|
mark_os_window_dirty(os_window_id);
|
|
END_WITH_OS_WINDOW
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
|
|
#define M(name, arg_type) {#name, (PyCFunction)name, arg_type, NULL}
|
|
#define MW(name, arg_type) {#name, (PyCFunction)py##name, arg_type, NULL}
|
|
|
|
static PyMethodDef module_methods[] = {
|
|
M(os_window_focus_counters, METH_NOARGS),
|
|
M(get_mouse_data_for_window, METH_VARARGS),
|
|
M(request_callback_with_thumbnail, METH_VARARGS),
|
|
M(set_tab_being_dragged, METH_VARARGS),
|
|
M(get_tab_being_dragged, METH_NOARGS),
|
|
M(set_window_being_dragged, METH_VARARGS),
|
|
M(get_window_being_dragged, METH_NOARGS),
|
|
MW(current_os_window, METH_NOARGS),
|
|
MW(next_window_id, METH_NOARGS),
|
|
MW(last_focused_os_window_id, METH_NOARGS),
|
|
MW(current_focused_os_window_id, METH_NOARGS),
|
|
MW(set_options, METH_VARARGS),
|
|
MW(get_options, METH_NOARGS),
|
|
MW(click_mouse_url, METH_VARARGS),
|
|
MW(click_mouse_cmd_output, METH_VARARGS),
|
|
MW(move_cursor_to_mouse_if_in_prompt, METH_VARARGS),
|
|
MW(redirect_mouse_handling, METH_O),
|
|
MW(mouse_selection, METH_VARARGS),
|
|
MW(set_window_logo, METH_VARARGS),
|
|
MW(get_window_logo_settings_if_not_default, METH_VARARGS),
|
|
MW(set_ignore_os_keyboard_processing, METH_O),
|
|
MW(handle_for_window_id, METH_VARARGS),
|
|
MW(update_ime_position_for_window, METH_VARARGS),
|
|
MW(pt_to_px, METH_VARARGS),
|
|
MW(add_tab, METH_O),
|
|
MW(add_window, METH_VARARGS),
|
|
MW(update_window_title, METH_VARARGS),
|
|
MW(remove_tab, METH_VARARGS),
|
|
MW(remove_window, METH_VARARGS),
|
|
MW(detach_window, METH_VARARGS),
|
|
MW(attach_window, METH_VARARGS),
|
|
MW(move_window_to_tab, METH_VARARGS),
|
|
MW(set_active_tab, METH_VARARGS),
|
|
MW(mark_os_window_dirty, METH_VARARGS),
|
|
MW(set_redirect_keys_to_overlay, METH_VARARGS),
|
|
MW(buffer_keys_in_window, METH_VARARGS),
|
|
MW(set_active_window, METH_VARARGS),
|
|
MW(swap_tabs, METH_VARARGS),
|
|
MW(reorder_tabs, METH_VARARGS),
|
|
MW(set_borders_rects, METH_VARARGS),
|
|
MW(set_tab_bar_render_data, METH_VARARGS),
|
|
MW(set_window_title_bar_render_data, METH_VARARGS),
|
|
MW(set_window_render_data, METH_VARARGS),
|
|
MW(set_window_drag_overlay, METH_VARARGS),
|
|
MW(set_window_padding, METH_VARARGS),
|
|
MW(viewport_for_window, METH_VARARGS),
|
|
MW(cell_size_for_window, METH_VARARGS),
|
|
MW(os_window_has_background_image, METH_VARARGS),
|
|
MW(mark_os_window_for_close, METH_VARARGS),
|
|
MW(set_application_quit_request, METH_VARARGS),
|
|
MW(current_application_quit_request, METH_NOARGS),
|
|
MW(current_application_quit_cause, METH_NOARGS),
|
|
MW(application_logout_requested_at, METH_NOARGS),
|
|
MW(set_os_window_chrome, METH_VARARGS),
|
|
MW(focus_os_window, METH_VARARGS),
|
|
MW(mark_tab_bar_dirty, METH_VARARGS),
|
|
MW(is_tab_bar_visible, METH_VARARGS),
|
|
MW(run_with_activation_token, METH_O),
|
|
MW(change_background_opacity, METH_VARARGS),
|
|
MW(background_opacity_of, METH_O),
|
|
MW(update_window_visibility, METH_VARARGS),
|
|
MW(sync_os_window_title, METH_VARARGS),
|
|
MW(get_os_window_title, METH_VARARGS),
|
|
MW(set_os_window_title, METH_VARARGS),
|
|
MW(get_os_window_pos, METH_VARARGS),
|
|
MW(set_os_window_pos, METH_VARARGS),
|
|
MW(global_font_size, METH_VARARGS),
|
|
{"set_background_image", (PyCFunction)(void (*)(void))pyset_background_image, METH_VARARGS | METH_KEYWORDS, ""},
|
|
MW(os_window_font_size, METH_VARARGS),
|
|
MW(set_os_window_size, METH_VARARGS),
|
|
MW(get_os_window_size, METH_VARARGS),
|
|
MW(os_window_is_invisible, METH_O),
|
|
MW(update_tab_bar_edge_colors, METH_VARARGS),
|
|
MW(set_boss, METH_O),
|
|
MW(get_boss, METH_NOARGS),
|
|
MW(apply_options_update, METH_NOARGS),
|
|
MW(patch_global_colors, METH_VARARGS),
|
|
MW(create_mock_window, METH_VARARGS),
|
|
MW(destroy_global_data, METH_NOARGS),
|
|
MW(wakeup_main_loop, METH_NOARGS),
|
|
|
|
{NULL, NULL, 0, NULL} /* Sentinel */
|
|
};
|
|
|
|
static void
|
|
finalize(void) {
|
|
while (detached_windows.num_windows--) { destroy_window(&detached_windows.windows[detached_windows.num_windows]); }
|
|
if (detached_windows.windows) free(detached_windows.windows);
|
|
detached_windows.capacity = 0;
|
|
Py_CLEAR(global_state.options_object);
|
|
free_animation(OPT(animation.cursor));
|
|
free_animation(OPT(animation.visual_bell));
|
|
// we leak the texture here since it is not guaranteed
|
|
// that freeing the texture will work during shutdown and
|
|
// the GPU driver should take care of it when the OpenGL context is
|
|
// destroyed.
|
|
free_global_background_images(false);
|
|
free_window_logo_table(&global_state.all_window_logos);
|
|
free_drag_source();
|
|
Py_CLEAR(global_state.drop_dest.data);
|
|
zero_at_ptr(&global_state.drop_dest);
|
|
|
|
free_allocs_in_options(&global_state.opts);
|
|
}
|
|
|
|
bool
|
|
init_state(PyObject *module) {
|
|
OPT(font_size) = 11.0;
|
|
#ifdef __APPLE__
|
|
#define DPI 72.0
|
|
#else
|
|
#define DPI 96.0
|
|
#endif
|
|
global_state.default_dpi.x = DPI;
|
|
global_state.default_dpi.y = DPI;
|
|
global_state.all_window_logos = alloc_window_logo_table();
|
|
if (!global_state.all_window_logos) {
|
|
PyErr_NoMemory();
|
|
return false;
|
|
}
|
|
if (PyModule_AddFunctions(module, module_methods) != 0) return false;
|
|
if (PyStructSequence_InitType2(&RegionType, ®ion_desc) != 0) return false;
|
|
Py_INCREF((PyObject *)&RegionType);
|
|
PyModule_AddObject(module, "Region", (PyObject *)&RegionType);
|
|
PyModule_AddIntConstant(module, "IMPERATIVE_CLOSE_REQUESTED", IMPERATIVE_CLOSE_REQUESTED);
|
|
PyModule_AddIntConstant(module, "QUIT_CAUSE_NONE", QUIT_CAUSE_NONE);
|
|
PyModule_AddIntConstant(module, "QUIT_CAUSE_ACTION", QUIT_CAUSE_ACTION);
|
|
PyModule_AddIntConstant(module, "QUIT_CAUSE_OS_REQUEST", QUIT_CAUSE_OS_REQUEST);
|
|
PyModule_AddIntConstant(module, "QUIT_CAUSE_LOGOUT", QUIT_CAUSE_LOGOUT);
|
|
PyModule_AddIntConstant(module, "QUIT_CAUSE_SIGNAL", QUIT_CAUSE_SIGNAL);
|
|
PyModule_AddIntConstant(module, "QUIT_CAUSE_FATAL_ERROR", QUIT_CAUSE_FATAL_ERROR);
|
|
PyModule_AddIntConstant(module, "NO_CLOSE_REQUESTED", NO_CLOSE_REQUESTED);
|
|
PyModule_AddIntConstant(module, "CLOSE_BEING_CONFIRMED", CLOSE_BEING_CONFIRMED);
|
|
PyModule_AddIntMacro(module, WINDOW_NORMAL);
|
|
PyModule_AddIntMacro(module, WINDOW_FULLSCREEN);
|
|
PyModule_AddIntMacro(module, WINDOW_MAXIMIZED);
|
|
PyModule_AddIntMacro(module, WINDOW_HIDDEN);
|
|
PyModule_AddIntMacro(module, WINDOW_MINIMIZED);
|
|
PyModule_AddIntMacro(module, LEFT_EDGE);
|
|
PyModule_AddIntMacro(module, RIGHT_EDGE);
|
|
PyModule_AddIntMacro(module, TOP_EDGE);
|
|
PyModule_AddIntMacro(module, BOTTOM_EDGE);
|
|
register_at_exit_cleanup_func(STATE_CLEANUP_FUNC, finalize);
|
|
return true;
|
|
}
|
|
// }}}
|