libobs: Add global hotkey support
This commit is contained in:
Palana
parent
4daa5c7aa7
commit
5ad553d06d
@ -216,6 +216,8 @@ set(libobs_libobs_SOURCES
|
||||
obs.c
|
||||
obs-properties.c
|
||||
obs-data.c
|
||||
obs-hotkey.c
|
||||
obs-hotkey-name-map.c
|
||||
obs-module.c
|
||||
obs-display.c
|
||||
obs-view.c
|
||||
@ -233,6 +235,8 @@ set(libobs_libobs_HEADERS
|
||||
obs-properties.h
|
||||
obs-data.h
|
||||
obs-interaction.h
|
||||
obs-hotkey.h
|
||||
obs-hotkeys.h
|
||||
obs-module.h
|
||||
obs-scene.h
|
||||
obs-source.h
|
||||
|
||||
@ -182,3 +182,49 @@ void log_system_info(void)
|
||||
log_os();
|
||||
log_kernel_version();
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
struct obs_hotkeys_platform {
|
||||
};
|
||||
|
||||
void obs_key_to_str(obs_key_t key, struct dstr *str)
|
||||
{
|
||||
UNUSED_PARAMETER(key);
|
||||
UNUSED_PARAMETER(str);
|
||||
}
|
||||
|
||||
void obs_key_combination_to_str(obs_key_combination_t key, struct dstr *str)
|
||||
{
|
||||
UNUSED_PARAMETER(key);
|
||||
UNUSED_PARAMETER(str);
|
||||
}
|
||||
|
||||
obs_key_t obs_key_from_virtual_key(int code)
|
||||
{
|
||||
UNUSED_PARAMETER(code);
|
||||
|
||||
return OBS_KEY_NONE;
|
||||
}
|
||||
|
||||
bool obs_hotkeys_platform_init(struct obs_core_hotkeys *hotkeys)
|
||||
{
|
||||
UNUSED_PARAMETER(hotkeys);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void obs_hotkeys_platform_free(struct obs_core_hotkeys *hotkeys)
|
||||
{
|
||||
UNUSED_PARAMETER(hotkeys);
|
||||
}
|
||||
|
||||
bool obs_hotkeys_platform_is_pressed(obs_hotkeys_platform_t *plat,
|
||||
obs_key_t key)
|
||||
{
|
||||
UNUSED_PARAMETER(plat);
|
||||
UNUSED_PARAMETER(key);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -42,7 +42,7 @@ static bool init_encoder(struct obs_encoder *encoder, const char *name,
|
||||
pthread_mutex_init_value(&encoder->callbacks_mutex);
|
||||
pthread_mutex_init_value(&encoder->outputs_mutex);
|
||||
|
||||
if (!obs_context_data_init(&encoder->context, settings, name))
|
||||
if (!obs_context_data_init(&encoder->context, settings, name, NULL))
|
||||
return false;
|
||||
if (pthread_mutex_init(&encoder->callbacks_mutex, NULL) != 0)
|
||||
return false;
|
||||
|
||||
411
libobs/obs-hotkey-name-map.c
Normal file
411
libobs/obs-hotkey-name-map.c
Normal file
@ -0,0 +1,411 @@
|
||||
/******************************************************************************
|
||||
Copyright (C) 2014 by Ruwen Hahn <palana@stunned.de>
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
******************************************************************************/
|
||||
|
||||
#include <string.h>
|
||||
#include <assert.h>
|
||||
|
||||
#include <util/bmem.h>
|
||||
#include <util/c99defs.h>
|
||||
#include <util/darray.h>
|
||||
|
||||
#include "obs-internal.h"
|
||||
|
||||
struct obs_hotkey_name_map_edge;
|
||||
struct obs_hotkey_name_map_node;
|
||||
struct obs_hotkey_name_map;
|
||||
|
||||
typedef struct obs_hotkey_name_map_edge obs_hotkey_name_map_edge_t;
|
||||
typedef struct obs_hotkey_name_map_node obs_hotkey_name_map_node_t;
|
||||
typedef struct obs_hotkey_name_map obs_hotkey_name_map_t;
|
||||
|
||||
struct obs_hotkey_name_map_node {
|
||||
bool is_leaf;
|
||||
union {
|
||||
int val;
|
||||
DARRAY(obs_hotkey_name_map_edge_t) children;
|
||||
};
|
||||
};
|
||||
|
||||
struct obs_hotkey_name_map {
|
||||
obs_hotkey_name_map_node_t root;
|
||||
obs_hotkey_name_map_node_t *leaves;
|
||||
size_t num_leaves;
|
||||
size_t next_leaf;
|
||||
};
|
||||
|
||||
struct obs_hotkey_name_map_edge_prefix {
|
||||
uint8_t prefix_len;
|
||||
char *prefix;
|
||||
};
|
||||
|
||||
#define NAME_MAP_COMPRESS_LENGTH \
|
||||
(sizeof(struct obs_hotkey_name_map_edge_prefix) - sizeof(uint8_t))
|
||||
|
||||
struct obs_hotkey_name_map_edge {
|
||||
union {
|
||||
struct {
|
||||
uint8_t prefix_len;
|
||||
char *prefix;
|
||||
};
|
||||
struct {
|
||||
uint8_t compressed_len;
|
||||
char compressed_prefix[NAME_MAP_COMPRESS_LENGTH];
|
||||
};
|
||||
};
|
||||
struct obs_hotkey_name_map_node *node;
|
||||
};
|
||||
|
||||
|
||||
static inline obs_hotkey_name_map_node_t *new_node(void)
|
||||
{
|
||||
return bzalloc(sizeof(obs_hotkey_name_map_node_t));
|
||||
}
|
||||
|
||||
static inline obs_hotkey_name_map_node_t *new_leaf(void)
|
||||
{
|
||||
obs_hotkey_name_map_t *name_map = obs->hotkeys.name_map;
|
||||
obs_hotkey_name_map_node_t *node =
|
||||
&name_map->leaves[name_map->next_leaf];
|
||||
name_map->next_leaf += 1;
|
||||
|
||||
node->is_leaf = true;
|
||||
return node;
|
||||
}
|
||||
|
||||
static inline char *get_prefix(obs_hotkey_name_map_edge_t *e)
|
||||
{
|
||||
return e->prefix_len >= NAME_MAP_COMPRESS_LENGTH ?
|
||||
e->prefix : e->compressed_prefix;
|
||||
}
|
||||
|
||||
static void set_prefix(obs_hotkey_name_map_edge_t *e, const char *prefix,
|
||||
size_t l)
|
||||
{
|
||||
assert(e->prefix_len == 0);
|
||||
|
||||
e->compressed_len = (uint8_t)l;
|
||||
if (l < NAME_MAP_COMPRESS_LENGTH)
|
||||
strncpy(e->compressed_prefix, prefix, l);
|
||||
else
|
||||
e->prefix = bstrdup_n(prefix, l);
|
||||
}
|
||||
|
||||
static obs_hotkey_name_map_edge_t *add_leaf(obs_hotkey_name_map_node_t *node,
|
||||
const char *key, size_t l, int v)
|
||||
{
|
||||
obs_hotkey_name_map_edge_t *e = da_push_back_new(node->children);
|
||||
|
||||
set_prefix(e, key, l);
|
||||
|
||||
e->node = new_leaf();
|
||||
e->node->val = v;
|
||||
|
||||
return e;
|
||||
}
|
||||
|
||||
static void shrink_prefix(obs_hotkey_name_map_edge_t *e, size_t l)
|
||||
{
|
||||
bool old_comp = e->prefix_len < NAME_MAP_COMPRESS_LENGTH;
|
||||
bool new_comp = l < NAME_MAP_COMPRESS_LENGTH;
|
||||
|
||||
char *str = get_prefix(e);
|
||||
|
||||
e->prefix_len = (uint8_t)l;
|
||||
if (get_prefix(e) != str)
|
||||
strncpy(get_prefix(e), str, l);
|
||||
else
|
||||
str[l] = 0;
|
||||
|
||||
if (!old_comp && new_comp)
|
||||
bfree(str);
|
||||
}
|
||||
|
||||
static void connect(obs_hotkey_name_map_edge_t *e,
|
||||
obs_hotkey_name_map_node_t *n)
|
||||
{
|
||||
e->node = n;
|
||||
}
|
||||
|
||||
static void reduce_edge(obs_hotkey_name_map_edge_t *e, const char *key,
|
||||
size_t l, int v)
|
||||
{
|
||||
const char *str = get_prefix(e), *str_ = key;
|
||||
size_t common_length = 0;
|
||||
while (*str == *str_) {
|
||||
common_length += 1;
|
||||
str += 1;
|
||||
str_ += 1;
|
||||
}
|
||||
|
||||
obs_hotkey_name_map_node_t *new_node_ = new_node();
|
||||
obs_hotkey_name_map_edge_t *tail =
|
||||
da_push_back_new(new_node_->children);
|
||||
|
||||
connect(tail, e->node);
|
||||
set_prefix(tail, str, e->prefix_len - common_length);
|
||||
|
||||
add_leaf(new_node_, str_, l - common_length, v);
|
||||
|
||||
connect(e, new_node_);
|
||||
shrink_prefix(e, common_length);
|
||||
}
|
||||
|
||||
enum obs_hotkey_name_map_edge_compare_result {
|
||||
RES_MATCHES,
|
||||
RES_NO_MATCH,
|
||||
RES_COMMON_PREFIX,
|
||||
RES_PREFIX_MATCHES,
|
||||
};
|
||||
|
||||
static enum obs_hotkey_name_map_edge_compare_result compare_prefix(
|
||||
obs_hotkey_name_map_edge_t *edge, const char *key, size_t l)
|
||||
{
|
||||
uint8_t pref_len = edge->prefix_len;
|
||||
const char *str = get_prefix(edge);
|
||||
size_t i = 0;
|
||||
|
||||
for (; i < l && i < pref_len; i++)
|
||||
if (str[i] != key[i])
|
||||
break;
|
||||
|
||||
|
||||
if (i != 0 && pref_len == i)
|
||||
return l == i ? RES_MATCHES : RES_PREFIX_MATCHES;
|
||||
if (i != 0)
|
||||
return pref_len == i ? RES_PREFIX_MATCHES : RES_COMMON_PREFIX;
|
||||
return RES_NO_MATCH;
|
||||
}
|
||||
|
||||
static void insert(obs_hotkey_name_map_edge_t *edge,
|
||||
obs_hotkey_name_map_node_t *node,
|
||||
const char *key, size_t l, int v)
|
||||
{
|
||||
if (node->is_leaf && l > 0) {
|
||||
obs_hotkey_name_map_node_t *new_node_ = new_node();
|
||||
connect(edge, new_node_);
|
||||
|
||||
obs_hotkey_name_map_edge_t *edge =
|
||||
da_push_back_new(new_node_->children);
|
||||
connect(edge, node);
|
||||
add_leaf(new_node_, key, l, v);
|
||||
return;
|
||||
}
|
||||
|
||||
if (node->is_leaf && l == 0) {
|
||||
node->val = v;
|
||||
return;
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < node->children.num; i++) {
|
||||
obs_hotkey_name_map_edge_t *e = &node->children.array[i];
|
||||
|
||||
switch (compare_prefix(e, key, l)) {
|
||||
case RES_NO_MATCH:
|
||||
continue;
|
||||
|
||||
case RES_MATCHES:
|
||||
case RES_PREFIX_MATCHES:
|
||||
insert(e, e->node, key + e->prefix_len,
|
||||
l - e->prefix_len, v);
|
||||
return;
|
||||
|
||||
case RES_COMMON_PREFIX:
|
||||
reduce_edge(e, key, l, v);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
add_leaf(node, key, l, v);
|
||||
}
|
||||
|
||||
static void obs_hotkey_name_map_insert(obs_hotkey_name_map_t *trie,
|
||||
const char *key, int v)
|
||||
{
|
||||
if (!trie || !key)
|
||||
return;
|
||||
|
||||
insert(NULL, &trie->root, key, strlen(key), v);
|
||||
}
|
||||
|
||||
static bool obs_hotkey_name_map_lookup(obs_hotkey_name_map_t *trie,
|
||||
const char *key, int *v)
|
||||
{
|
||||
if (!trie || !key)
|
||||
return false;
|
||||
|
||||
size_t len = strlen(key);
|
||||
obs_hotkey_name_map_node_t *n = &trie->root;
|
||||
|
||||
size_t i = 0;
|
||||
for (; i < n->children.num;) {
|
||||
obs_hotkey_name_map_edge_t *e = &n->children.array[i];
|
||||
|
||||
switch (compare_prefix(e, key, len)) {
|
||||
case RES_NO_MATCH:
|
||||
i++;
|
||||
continue;
|
||||
|
||||
case RES_COMMON_PREFIX:
|
||||
return false;
|
||||
|
||||
case RES_PREFIX_MATCHES:
|
||||
key += e->prefix_len;
|
||||
len -= e->prefix_len;
|
||||
n = e->node;
|
||||
i = 0;
|
||||
continue;
|
||||
|
||||
case RES_MATCHES:
|
||||
n = e->node;
|
||||
if (!n->is_leaf) {
|
||||
for (size_t j = 0; j < n->children.num; j++) {
|
||||
if (n->children.array[j].prefix_len)
|
||||
continue;
|
||||
|
||||
if (v) *v =
|
||||
n->children.array[j].node->val;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
if (v) *v = n->val;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static void show_node(obs_hotkey_name_map_node_t *node, int in)
|
||||
{
|
||||
if (node->is_leaf) {
|
||||
printf(": % 3d\n", node->val);
|
||||
return;
|
||||
}
|
||||
|
||||
printf("\n");
|
||||
for (int i = 0; i < in; i += 2)
|
||||
printf("| ");
|
||||
printf("%zu:\n", node->children.num);
|
||||
|
||||
for (size_t i = 0; i < node->children.num; i++) {
|
||||
for (int i = 0; i < in; i += 2)
|
||||
printf("| ");
|
||||
printf("\\ ");
|
||||
|
||||
obs_hotkey_name_map_edge_t *e = &node->children.array[i];
|
||||
printf("%s", get_prefix(e));
|
||||
show_node(e->node, in+2);
|
||||
}
|
||||
}
|
||||
|
||||
void trie_print_size(obs_hotkey_name_map_t *trie)
|
||||
{
|
||||
show_node(&trie->root, 0);
|
||||
}
|
||||
|
||||
static const char* obs_key_names[] = {
|
||||
#define OBS_HOTKEY(x) #x,
|
||||
#include "obs-hotkeys.h"
|
||||
#undef OBS_HOTKEY
|
||||
};
|
||||
|
||||
const char* obs_key_to_name(obs_key_t key)
|
||||
{
|
||||
if (key >= OBS_KEY_LAST_VALUE) {
|
||||
blog(LOG_ERROR, "obs-hotkey.c: queried unknown key "
|
||||
"with code %d", (int)key);
|
||||
return "";
|
||||
}
|
||||
|
||||
return obs_key_names[key];
|
||||
}
|
||||
|
||||
static obs_key_t obs_key_from_name_fallback(const char *name)
|
||||
{
|
||||
#define OBS_HOTKEY(x) if (strcmp(#x, name) == 0) return x;
|
||||
#include "obs-hotkeys.h"
|
||||
#undef OBS_HOTKEY
|
||||
return OBS_KEY_NONE;
|
||||
}
|
||||
|
||||
static void init_name_map(void)
|
||||
{
|
||||
obs->hotkeys.name_map = bzalloc(sizeof(struct obs_hotkey_name_map));
|
||||
obs_hotkey_name_map_t *name_map = obs->hotkeys.name_map;
|
||||
|
||||
#define OBS_HOTKEY(x) name_map->num_leaves += 1;
|
||||
#include "obs-hotkeys.h"
|
||||
#undef OBS_HOTKEY
|
||||
|
||||
size_t size = sizeof(obs_hotkey_name_map_node_t) * name_map->num_leaves;
|
||||
name_map->leaves = bzalloc(size);
|
||||
|
||||
#define OBS_HOTKEY(x) obs_hotkey_name_map_insert(name_map, #x, x);
|
||||
#include "obs-hotkeys.h"
|
||||
#undef OBS_HOTKEY
|
||||
}
|
||||
|
||||
obs_key_t obs_key_from_name(const char *name)
|
||||
{
|
||||
if (!obs)
|
||||
return obs_key_from_name_fallback(name);
|
||||
|
||||
if (pthread_once(&obs->hotkeys.name_map_init_token, init_name_map))
|
||||
return obs_key_from_name_fallback(name);
|
||||
|
||||
int v = 0;
|
||||
if (obs_hotkey_name_map_lookup(obs->hotkeys.name_map, name, &v))
|
||||
return v;
|
||||
|
||||
return OBS_KEY_NONE;
|
||||
}
|
||||
|
||||
static void free_node(obs_hotkey_name_map_node_t *node, bool release);
|
||||
|
||||
static void free_edge(obs_hotkey_name_map_edge_t *edge)
|
||||
{
|
||||
free_node(edge->node, true);
|
||||
|
||||
if (edge->prefix_len < NAME_MAP_COMPRESS_LENGTH)
|
||||
return;
|
||||
|
||||
bfree(get_prefix(edge));
|
||||
}
|
||||
|
||||
static void free_node(obs_hotkey_name_map_node_t *node, bool release)
|
||||
{
|
||||
if (!node->is_leaf) {
|
||||
for (size_t i = 0; i < node->children.num; i++)
|
||||
free_edge(&node->children.array[i]);
|
||||
|
||||
da_free(node->children);
|
||||
}
|
||||
|
||||
if (release && !node->is_leaf) bfree(node);
|
||||
}
|
||||
|
||||
void obs_hotkey_name_map_free(void)
|
||||
{
|
||||
if (!obs || !obs->hotkeys.name_map)
|
||||
return;
|
||||
|
||||
free_node(&obs->hotkeys.name_map->root, false);
|
||||
bfree(obs->hotkeys.name_map->leaves);
|
||||
bfree(obs->hotkeys.name_map);
|
||||
}
|
||||
1497
libobs/obs-hotkey.c
Normal file
1497
libobs/obs-hotkey.c
Normal file
File diff suppressed because it is too large
Load Diff
281
libobs/obs-hotkey.h
Normal file
281
libobs/obs-hotkey.h
Normal file
@ -0,0 +1,281 @@
|
||||
/******************************************************************************
|
||||
Copyright (C) 2014-2015 by Ruwen Hahn <palana@stunned.de>
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
******************************************************************************/
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef size_t obs_hotkey_id;
|
||||
#define OBS_INVALID_HOTKEY_ID (~(obs_hotkey_id)0)
|
||||
typedef size_t obs_hotkey_pair_id;
|
||||
#define OBS_INVALID_HOTKEY_PAIR_ID (~(obs_hotkey_pair_id)0)
|
||||
|
||||
enum obs_key {
|
||||
#define OBS_HOTKEY(x) x,
|
||||
#include "obs-hotkeys.h"
|
||||
#undef OBS_HOTKEY
|
||||
OBS_KEY_LAST_VALUE //not an actual key
|
||||
};
|
||||
typedef enum obs_key obs_key_t;
|
||||
|
||||
struct obs_key_combination {
|
||||
uint32_t modifiers;
|
||||
obs_key_t key;
|
||||
};
|
||||
typedef struct obs_key_combination obs_key_combination_t;
|
||||
|
||||
typedef struct obs_hotkey obs_hotkey_t;
|
||||
typedef struct obs_hotkey_binding obs_hotkey_binding_t;
|
||||
|
||||
enum obs_hotkey_registerer_type {
|
||||
OBS_HOTKEY_REGISTERER_FRONTEND,
|
||||
OBS_HOTKEY_REGISTERER_SOURCE,
|
||||
OBS_HOTKEY_REGISTERER_OUTPUT,
|
||||
OBS_HOTKEY_REGISTERER_ENCODER,
|
||||
OBS_HOTKEY_REGISTERER_SERVICE,
|
||||
};
|
||||
typedef enum obs_hotkey_registerer_type obs_hotkey_registerer_t;
|
||||
|
||||
EXPORT obs_hotkey_id obs_hotkey_get_id(const obs_hotkey_t *key);
|
||||
EXPORT const char *obs_hotkey_get_name(const obs_hotkey_t *key);
|
||||
EXPORT const char *obs_hotkey_get_description(const obs_hotkey_t *key);
|
||||
EXPORT obs_hotkey_registerer_t obs_hotkey_get_registerer_type(
|
||||
const obs_hotkey_t *key);
|
||||
EXPORT void *obs_hotkey_get_registerer(const obs_hotkey_t *key);
|
||||
EXPORT obs_hotkey_id obs_hotkey_get_pair_partner_id(const obs_hotkey_t *key);
|
||||
|
||||
|
||||
EXPORT obs_key_combination_t obs_hotkey_binding_get_key_combination(
|
||||
obs_hotkey_binding_t *binding);
|
||||
EXPORT obs_hotkey_id obs_hotkey_binding_get_hotkey_id(
|
||||
obs_hotkey_binding_t *binding);
|
||||
EXPORT obs_hotkey_t *obs_hotkey_binding_get_hotkey(
|
||||
obs_hotkey_binding_t *binding);
|
||||
|
||||
struct obs_hotkeys_translations {
|
||||
const char *insert;
|
||||
const char *del;
|
||||
const char *home;
|
||||
const char *end;
|
||||
const char *page_up;
|
||||
const char *page_down;
|
||||
const char *num_lock;
|
||||
const char *scroll_lock;
|
||||
const char *caps_lock;
|
||||
const char *backspace;
|
||||
const char *tab;
|
||||
const char *print;
|
||||
const char *pause;
|
||||
const char *left;
|
||||
const char *right;
|
||||
const char *up;
|
||||
const char *down;
|
||||
const char *shift;
|
||||
const char *alt;
|
||||
const char *control;
|
||||
const char *meta; /* windows/super key */
|
||||
const char *menu;
|
||||
const char *space;
|
||||
const char *numpad_num; /* For example, "Numpad %1" */
|
||||
const char *numpad_divide;
|
||||
const char *numpad_multiply;
|
||||
const char *numpad_minus;
|
||||
const char *numpad_plus;
|
||||
const char *numpad_decimal;
|
||||
const char *apple_keypad_num; /* For example, "%1 (Keypad)" */
|
||||
const char *apple_keypad_divide;
|
||||
const char *apple_keypad_multiply;
|
||||
const char *apple_keypad_minus;
|
||||
const char *apple_keypad_plus;
|
||||
const char *apple_keypad_decimal;
|
||||
const char *apple_keypad_equal;
|
||||
const char *mouse_num; /* For example, "Mouse %1" */
|
||||
};
|
||||
|
||||
/* This function is an optional way to provide translations for specific keys
|
||||
* that may not have translations. If the operating system can provide
|
||||
* translations for these keys, it will use the operating system's translation
|
||||
* over these translations. If no translations are specified, it will use
|
||||
* the default english translations for that specific operating system. */
|
||||
EXPORT void obs_hotkeys_set_translations_s(
|
||||
struct obs_hotkeys_translations *translations, size_t size);
|
||||
|
||||
#define obs_hotkeys_set_translations(translations) \
|
||||
obs_hotkeys_set_translations_s(translations, \
|
||||
sizeof(struct obs_hotkeys_translations))
|
||||
|
||||
|
||||
/* registering hotkeys (giving hotkeys a name and a function) */
|
||||
|
||||
typedef void (*obs_hotkey_func)(void *data,
|
||||
obs_hotkey_id id, obs_hotkey_t *hotkey, bool pressed);
|
||||
|
||||
EXPORT obs_hotkey_id obs_hotkey_register_frontend(const char *name,
|
||||
const char *description, obs_hotkey_func func, void *data);
|
||||
|
||||
EXPORT obs_hotkey_id obs_hotkey_register_encoder(obs_encoder_t *encoder,
|
||||
const char *name, const char *description,
|
||||
obs_hotkey_func func, void *data);
|
||||
|
||||
EXPORT obs_hotkey_id obs_hotkey_register_output(obs_output_t *output,
|
||||
const char *name, const char *description,
|
||||
obs_hotkey_func func, void *data);
|
||||
|
||||
EXPORT obs_hotkey_id obs_hotkey_register_service(obs_service_t *service,
|
||||
const char *name, const char *description,
|
||||
obs_hotkey_func func, void *data);
|
||||
|
||||
EXPORT obs_hotkey_id obs_hotkey_register_source(obs_source_t *source,
|
||||
const char *name, const char *description,
|
||||
obs_hotkey_func func, void *data);
|
||||
|
||||
typedef bool (*obs_hotkey_active_func)(void *data,
|
||||
obs_hotkey_pair_id id, obs_hotkey_t *hotkey, bool pressed);
|
||||
|
||||
EXPORT obs_hotkey_pair_id obs_hotkey_pair_register_frontend(
|
||||
const char *name0, const char *description0,
|
||||
const char *name1, const char *description1,
|
||||
obs_hotkey_active_func func0, obs_hotkey_active_func func1,
|
||||
void *data0, void *data1);
|
||||
|
||||
EXPORT obs_hotkey_pair_id obs_hotkey_pair_register_encoder(
|
||||
obs_encoder_t *encoder,
|
||||
const char *name0, const char *description0,
|
||||
const char *name1, const char *description1,
|
||||
obs_hotkey_active_func func0, obs_hotkey_active_func func1,
|
||||
void *data0, void *data1);
|
||||
|
||||
EXPORT obs_hotkey_pair_id obs_hotkey_pair_register_output(
|
||||
obs_output_t *output,
|
||||
const char *name0, const char *description0,
|
||||
const char *name1, const char *description1,
|
||||
obs_hotkey_active_func func0, obs_hotkey_active_func func1,
|
||||
void *data0, void *data1);
|
||||
|
||||
EXPORT obs_hotkey_pair_id obs_hotkey_pair_register_service(
|
||||
obs_service_t *service,
|
||||
const char *name0, const char *description0,
|
||||
const char *name1, const char *description1,
|
||||
obs_hotkey_active_func func0, obs_hotkey_active_func func1,
|
||||
void *data0, void *data1);
|
||||
|
||||
EXPORT obs_hotkey_pair_id obs_hotkey_pair_register_source(
|
||||
obs_source_t *source,
|
||||
const char *name0, const char *description0,
|
||||
const char *name1, const char *description1,
|
||||
obs_hotkey_active_func func0, obs_hotkey_active_func func1,
|
||||
void *data0, void *data1);
|
||||
|
||||
EXPORT void obs_hotkey_unregister(obs_hotkey_id id);
|
||||
|
||||
EXPORT void obs_hotkey_pair_unregister(obs_hotkey_pair_id id);
|
||||
|
||||
/* loading hotkeys (associating a hotkey with a physical key and modifiers) */
|
||||
|
||||
EXPORT void obs_hotkey_load_bindings(obs_hotkey_id id,
|
||||
obs_key_combination_t *combinations, size_t num);
|
||||
|
||||
EXPORT void obs_hotkey_load(obs_hotkey_id id, obs_data_array_t *data);
|
||||
|
||||
EXPORT void obs_hotkeys_load_encoder(obs_encoder_t *encoder,
|
||||
obs_data_t *hotkeys);
|
||||
|
||||
EXPORT void obs_hotkeys_load_output(obs_output_t *output, obs_data_t *hotkeys);
|
||||
|
||||
EXPORT void obs_hotkeys_load_service(obs_service_t *service,
|
||||
obs_data_t *hotkeys);
|
||||
|
||||
EXPORT void obs_hotkeys_load_source(obs_source_t *source, obs_data_t *hotkeys);
|
||||
|
||||
EXPORT void obs_hotkey_pair_load(obs_hotkey_pair_id id, obs_data_array_t *data0,
|
||||
obs_data_array_t *data1);
|
||||
|
||||
|
||||
EXPORT obs_data_array_t *obs_hotkey_save(obs_hotkey_id id);
|
||||
|
||||
EXPORT obs_data_t *obs_hotkeys_save_encoder(obs_encoder_t *encoder);
|
||||
|
||||
EXPORT obs_data_t *obs_hotkeys_save_output(obs_output_t *output);
|
||||
|
||||
EXPORT obs_data_t *obs_hotkeys_save_service(obs_service_t *service);
|
||||
|
||||
EXPORT obs_data_t *obs_hotkeys_save_source(obs_source_t *source);
|
||||
|
||||
/* enumerating hotkeys */
|
||||
|
||||
typedef bool (*obs_hotkey_enum_func)(void *data,
|
||||
obs_hotkey_id id, obs_hotkey_t *key);
|
||||
|
||||
EXPORT void obs_enum_hotkeys(obs_hotkey_enum_func func, void *data);
|
||||
|
||||
/* enumerating bindings */
|
||||
|
||||
typedef bool (*obs_hotkey_binding_enum_func)(void *data,
|
||||
size_t idx, obs_hotkey_binding_t* binding);
|
||||
|
||||
EXPORT void obs_enum_hotkey_bindings(obs_hotkey_binding_enum_func func,
|
||||
void *data);
|
||||
|
||||
/* hotkey event control */
|
||||
|
||||
EXPORT void obs_hotkey_inject_event(obs_key_combination_t hotkey, bool pressed);
|
||||
|
||||
EXPORT void obs_hotkey_enable_background_press(bool enable);
|
||||
|
||||
EXPORT void obs_hotkey_enable_strict_modifiers(bool enable);
|
||||
|
||||
/* hotkey callback routing (trigger callbacks through e.g. a UI thread) */
|
||||
|
||||
typedef void (*obs_hotkey_callback_router_func)(void *data,
|
||||
obs_hotkey_id id, bool pressed);
|
||||
|
||||
EXPORT void obs_hotkey_set_callback_routing_func(obs_hotkey_callback_router_func
|
||||
func, void *data);
|
||||
|
||||
EXPORT void obs_hotkey_trigger_routed_callback(obs_hotkey_id id, bool pressed);
|
||||
|
||||
/* hotkey callbacks won't be processed if callback rerouting is enabled and no
|
||||
* router func is set */
|
||||
EXPORT void obs_hotkey_enable_callback_rerouting(bool enable);
|
||||
|
||||
/* misc */
|
||||
|
||||
typedef void (*obs_hotkey_atomic_update_func)(void *);
|
||||
EXPORT void obs_hotkey_update_atomic(obs_hotkey_atomic_update_func func,
|
||||
void *data);
|
||||
|
||||
struct dstr;
|
||||
EXPORT void obs_key_to_str(obs_key_t key, struct dstr *str);
|
||||
EXPORT void obs_key_combination_to_str(obs_key_combination_t key,
|
||||
struct dstr *str);
|
||||
|
||||
EXPORT obs_key_t obs_key_from_virtual_key(int code);
|
||||
EXPORT int obs_key_to_virtual_key(obs_key_t key);
|
||||
|
||||
EXPORT const char *obs_key_to_name(obs_key_t key);
|
||||
EXPORT obs_key_t obs_key_from_name(const char *name);
|
||||
|
||||
inline bool obs_key_combination_is_empty(obs_key_combination_t combo)
|
||||
{
|
||||
return !combo.modifiers && combo.key == OBS_KEY_NONE;
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
477
libobs/obs-hotkeys.h
Normal file
477
libobs/obs-hotkeys.h
Normal file
@ -0,0 +1,477 @@
|
||||
OBS_HOTKEY(OBS_KEY_NONE)
|
||||
|
||||
OBS_HOTKEY(OBS_KEY_RETURN)
|
||||
OBS_HOTKEY(OBS_KEY_ENTER)
|
||||
OBS_HOTKEY(OBS_KEY_ESCAPE)
|
||||
OBS_HOTKEY(OBS_KEY_TAB)
|
||||
OBS_HOTKEY(OBS_KEY_BACKTAB)
|
||||
OBS_HOTKEY(OBS_KEY_BACKSPACE)
|
||||
OBS_HOTKEY(OBS_KEY_INSERT)
|
||||
OBS_HOTKEY(OBS_KEY_DELETE)
|
||||
OBS_HOTKEY(OBS_KEY_PAUSE)
|
||||
OBS_HOTKEY(OBS_KEY_PRINT)
|
||||
OBS_HOTKEY(OBS_KEY_SYSREQ)
|
||||
OBS_HOTKEY(OBS_KEY_CLEAR)
|
||||
OBS_HOTKEY(OBS_KEY_HOME)
|
||||
OBS_HOTKEY(OBS_KEY_END)
|
||||
OBS_HOTKEY(OBS_KEY_LEFT)
|
||||
OBS_HOTKEY(OBS_KEY_UP)
|
||||
OBS_HOTKEY(OBS_KEY_RIGHT)
|
||||
OBS_HOTKEY(OBS_KEY_DOWN)
|
||||
OBS_HOTKEY(OBS_KEY_PAGEUP)
|
||||
OBS_HOTKEY(OBS_KEY_PAGEDOWN)
|
||||
|
||||
OBS_HOTKEY(OBS_KEY_SHIFT)
|
||||
OBS_HOTKEY(OBS_KEY_CONTROL)
|
||||
OBS_HOTKEY(OBS_KEY_META)
|
||||
OBS_HOTKEY(OBS_KEY_ALT)
|
||||
OBS_HOTKEY(OBS_KEY_ALTGR)
|
||||
OBS_HOTKEY(OBS_KEY_CAPSLOCK)
|
||||
OBS_HOTKEY(OBS_KEY_NUMLOCK)
|
||||
OBS_HOTKEY(OBS_KEY_SCROLLLOCK)
|
||||
|
||||
OBS_HOTKEY(OBS_KEY_F1)
|
||||
OBS_HOTKEY(OBS_KEY_F2)
|
||||
OBS_HOTKEY(OBS_KEY_F3)
|
||||
OBS_HOTKEY(OBS_KEY_F4)
|
||||
OBS_HOTKEY(OBS_KEY_F5)
|
||||
OBS_HOTKEY(OBS_KEY_F6)
|
||||
OBS_HOTKEY(OBS_KEY_F7)
|
||||
OBS_HOTKEY(OBS_KEY_F8)
|
||||
OBS_HOTKEY(OBS_KEY_F9)
|
||||
OBS_HOTKEY(OBS_KEY_F10)
|
||||
OBS_HOTKEY(OBS_KEY_F11)
|
||||
OBS_HOTKEY(OBS_KEY_F12)
|
||||
OBS_HOTKEY(OBS_KEY_F13)
|
||||
OBS_HOTKEY(OBS_KEY_F14)
|
||||
OBS_HOTKEY(OBS_KEY_F15)
|
||||
OBS_HOTKEY(OBS_KEY_F16)
|
||||
OBS_HOTKEY(OBS_KEY_F17)
|
||||
OBS_HOTKEY(OBS_KEY_F18)
|
||||
OBS_HOTKEY(OBS_KEY_F19)
|
||||
OBS_HOTKEY(OBS_KEY_F20)
|
||||
OBS_HOTKEY(OBS_KEY_F21)
|
||||
OBS_HOTKEY(OBS_KEY_F22)
|
||||
OBS_HOTKEY(OBS_KEY_F23)
|
||||
OBS_HOTKEY(OBS_KEY_F24)
|
||||
OBS_HOTKEY(OBS_KEY_F25)
|
||||
OBS_HOTKEY(OBS_KEY_F26)
|
||||
OBS_HOTKEY(OBS_KEY_F27)
|
||||
OBS_HOTKEY(OBS_KEY_F28)
|
||||
OBS_HOTKEY(OBS_KEY_F29)
|
||||
OBS_HOTKEY(OBS_KEY_F30)
|
||||
OBS_HOTKEY(OBS_KEY_F31)
|
||||
OBS_HOTKEY(OBS_KEY_F32)
|
||||
OBS_HOTKEY(OBS_KEY_F33)
|
||||
OBS_HOTKEY(OBS_KEY_F34)
|
||||
OBS_HOTKEY(OBS_KEY_F35)
|
||||
|
||||
OBS_HOTKEY(OBS_KEY_MENU)
|
||||
OBS_HOTKEY(OBS_KEY_HYPER_L)
|
||||
OBS_HOTKEY(OBS_KEY_HYPER_R)
|
||||
OBS_HOTKEY(OBS_KEY_HELP)
|
||||
OBS_HOTKEY(OBS_KEY_DIRECTION_L)
|
||||
OBS_HOTKEY(OBS_KEY_DIRECTION_R)
|
||||
|
||||
OBS_HOTKEY(OBS_KEY_SPACE)
|
||||
OBS_HOTKEY(OBS_KEY_EXCLAM)
|
||||
OBS_HOTKEY(OBS_KEY_QUOTEDBL)
|
||||
OBS_HOTKEY(OBS_KEY_NUMBERSIGN)
|
||||
OBS_HOTKEY(OBS_KEY_DOLLAR)
|
||||
OBS_HOTKEY(OBS_KEY_PERCENT)
|
||||
OBS_HOTKEY(OBS_KEY_AMPERSAND)
|
||||
OBS_HOTKEY(OBS_KEY_APOSTROPHE)
|
||||
OBS_HOTKEY(OBS_KEY_PARENLEFT)
|
||||
OBS_HOTKEY(OBS_KEY_PARENRIGHT)
|
||||
OBS_HOTKEY(OBS_KEY_ASTERISK)
|
||||
OBS_HOTKEY(OBS_KEY_PLUS)
|
||||
OBS_HOTKEY(OBS_KEY_COMMA)
|
||||
OBS_HOTKEY(OBS_KEY_MINUS)
|
||||
OBS_HOTKEY(OBS_KEY_PERIOD)
|
||||
OBS_HOTKEY(OBS_KEY_SLASH)
|
||||
OBS_HOTKEY(OBS_KEY_0)
|
||||
OBS_HOTKEY(OBS_KEY_1)
|
||||
OBS_HOTKEY(OBS_KEY_2)
|
||||
OBS_HOTKEY(OBS_KEY_3)
|
||||
OBS_HOTKEY(OBS_KEY_4)
|
||||
OBS_HOTKEY(OBS_KEY_5)
|
||||
OBS_HOTKEY(OBS_KEY_6)
|
||||
OBS_HOTKEY(OBS_KEY_7)
|
||||
OBS_HOTKEY(OBS_KEY_8)
|
||||
OBS_HOTKEY(OBS_KEY_9)
|
||||
OBS_HOTKEY(OBS_KEY_NUMEQUAL)
|
||||
OBS_HOTKEY(OBS_KEY_NUMASTERISK)
|
||||
OBS_HOTKEY(OBS_KEY_NUMPLUS)
|
||||
OBS_HOTKEY(OBS_KEY_NUMCOMMA)
|
||||
OBS_HOTKEY(OBS_KEY_NUMMINUS)
|
||||
OBS_HOTKEY(OBS_KEY_NUMPERIOD)
|
||||
OBS_HOTKEY(OBS_KEY_NUMSLASH)
|
||||
OBS_HOTKEY(OBS_KEY_NUM0)
|
||||
OBS_HOTKEY(OBS_KEY_NUM1)
|
||||
OBS_HOTKEY(OBS_KEY_NUM2)
|
||||
OBS_HOTKEY(OBS_KEY_NUM3)
|
||||
OBS_HOTKEY(OBS_KEY_NUM4)
|
||||
OBS_HOTKEY(OBS_KEY_NUM5)
|
||||
OBS_HOTKEY(OBS_KEY_NUM6)
|
||||
OBS_HOTKEY(OBS_KEY_NUM7)
|
||||
OBS_HOTKEY(OBS_KEY_NUM8)
|
||||
OBS_HOTKEY(OBS_KEY_NUM9)
|
||||
OBS_HOTKEY(OBS_KEY_COLON)
|
||||
OBS_HOTKEY(OBS_KEY_SEMICOLON)
|
||||
OBS_HOTKEY(OBS_KEY_QUOTE)
|
||||
OBS_HOTKEY(OBS_KEY_LESS)
|
||||
OBS_HOTKEY(OBS_KEY_EQUAL)
|
||||
OBS_HOTKEY(OBS_KEY_GREATER)
|
||||
OBS_HOTKEY(OBS_KEY_QUESTION)
|
||||
OBS_HOTKEY(OBS_KEY_AT)
|
||||
OBS_HOTKEY(OBS_KEY_A)
|
||||
OBS_HOTKEY(OBS_KEY_B)
|
||||
OBS_HOTKEY(OBS_KEY_C)
|
||||
OBS_HOTKEY(OBS_KEY_D)
|
||||
OBS_HOTKEY(OBS_KEY_E)
|
||||
OBS_HOTKEY(OBS_KEY_F)
|
||||
OBS_HOTKEY(OBS_KEY_G)
|
||||
OBS_HOTKEY(OBS_KEY_H)
|
||||
OBS_HOTKEY(OBS_KEY_I)
|
||||
OBS_HOTKEY(OBS_KEY_J)
|
||||
OBS_HOTKEY(OBS_KEY_K)
|
||||
OBS_HOTKEY(OBS_KEY_L)
|
||||
OBS_HOTKEY(OBS_KEY_M)
|
||||
OBS_HOTKEY(OBS_KEY_N)
|
||||
OBS_HOTKEY(OBS_KEY_O)
|
||||
OBS_HOTKEY(OBS_KEY_P)
|
||||
OBS_HOTKEY(OBS_KEY_Q)
|
||||
OBS_HOTKEY(OBS_KEY_R)
|
||||
OBS_HOTKEY(OBS_KEY_S)
|
||||
OBS_HOTKEY(OBS_KEY_T)
|
||||
OBS_HOTKEY(OBS_KEY_U)
|
||||
OBS_HOTKEY(OBS_KEY_V)
|
||||
OBS_HOTKEY(OBS_KEY_W)
|
||||
OBS_HOTKEY(OBS_KEY_X)
|
||||
OBS_HOTKEY(OBS_KEY_Y)
|
||||
OBS_HOTKEY(OBS_KEY_Z)
|
||||
OBS_HOTKEY(OBS_KEY_BRACKETLEFT)
|
||||
OBS_HOTKEY(OBS_KEY_BACKSLASH)
|
||||
OBS_HOTKEY(OBS_KEY_BRACKETRIGHT)
|
||||
OBS_HOTKEY(OBS_KEY_ASCIICIRCUM)
|
||||
OBS_HOTKEY(OBS_KEY_UNDERSCORE)
|
||||
OBS_HOTKEY(OBS_KEY_QUOTELEFT)
|
||||
OBS_HOTKEY(OBS_KEY_BRACELEFT)
|
||||
OBS_HOTKEY(OBS_KEY_BAR)
|
||||
OBS_HOTKEY(OBS_KEY_BRACERIGHT)
|
||||
OBS_HOTKEY(OBS_KEY_ASCIITILDE)
|
||||
OBS_HOTKEY(OBS_KEY_NOBREAKSPACE)
|
||||
OBS_HOTKEY(OBS_KEY_EXCLAMDOWN)
|
||||
OBS_HOTKEY(OBS_KEY_CENT)
|
||||
OBS_HOTKEY(OBS_KEY_STERLING)
|
||||
OBS_HOTKEY(OBS_KEY_CURRENCY)
|
||||
OBS_HOTKEY(OBS_KEY_YEN)
|
||||
OBS_HOTKEY(OBS_KEY_BROKENBAR)
|
||||
OBS_HOTKEY(OBS_KEY_SECTION)
|
||||
OBS_HOTKEY(OBS_KEY_DIAERESIS)
|
||||
OBS_HOTKEY(OBS_KEY_COPYRIGHT)
|
||||
OBS_HOTKEY(OBS_KEY_ORDFEMININE)
|
||||
OBS_HOTKEY(OBS_KEY_GUILLEMOTLEFT)
|
||||
OBS_HOTKEY(OBS_KEY_NOTSIGN)
|
||||
OBS_HOTKEY(OBS_KEY_HYPHEN)
|
||||
OBS_HOTKEY(OBS_KEY_REGISTERED)
|
||||
OBS_HOTKEY(OBS_KEY_MACRON)
|
||||
OBS_HOTKEY(OBS_KEY_DEGREE)
|
||||
OBS_HOTKEY(OBS_KEY_PLUSMINUS)
|
||||
OBS_HOTKEY(OBS_KEY_TWOSUPERIOR)
|
||||
OBS_HOTKEY(OBS_KEY_THREESUPERIOR)
|
||||
OBS_HOTKEY(OBS_KEY_ACUTE)
|
||||
OBS_HOTKEY(OBS_KEY_MU)
|
||||
OBS_HOTKEY(OBS_KEY_PARAGRAPH)
|
||||
OBS_HOTKEY(OBS_KEY_PERIODCENTERED)
|
||||
OBS_HOTKEY(OBS_KEY_CEDILLA)
|
||||
OBS_HOTKEY(OBS_KEY_ONESUPERIOR)
|
||||
OBS_HOTKEY(OBS_KEY_MASCULINE)
|
||||
OBS_HOTKEY(OBS_KEY_GUILLEMOTRIGHT)
|
||||
OBS_HOTKEY(OBS_KEY_ONEQUARTER)
|
||||
OBS_HOTKEY(OBS_KEY_ONEHALF)
|
||||
OBS_HOTKEY(OBS_KEY_THREEQUARTERS)
|
||||
OBS_HOTKEY(OBS_KEY_QUESTIONDOWN)
|
||||
OBS_HOTKEY(OBS_KEY_AGRAVE)
|
||||
OBS_HOTKEY(OBS_KEY_AACUTE)
|
||||
OBS_HOTKEY(OBS_KEY_ACIRCUMFLEX)
|
||||
OBS_HOTKEY(OBS_KEY_ATILDE)
|
||||
OBS_HOTKEY(OBS_KEY_ADIAERESIS)
|
||||
OBS_HOTKEY(OBS_KEY_ARING)
|
||||
OBS_HOTKEY(OBS_KEY_AE)
|
||||
OBS_HOTKEY(OBS_KEY_CCEDILLA)
|
||||
OBS_HOTKEY(OBS_KEY_EGRAVE)
|
||||
OBS_HOTKEY(OBS_KEY_EACUTE)
|
||||
OBS_HOTKEY(OBS_KEY_ECIRCUMFLEX)
|
||||
OBS_HOTKEY(OBS_KEY_EDIAERESIS)
|
||||
OBS_HOTKEY(OBS_KEY_IGRAVE)
|
||||
OBS_HOTKEY(OBS_KEY_IACUTE)
|
||||
OBS_HOTKEY(OBS_KEY_ICIRCUMFLEX)
|
||||
OBS_HOTKEY(OBS_KEY_IDIAERESIS)
|
||||
OBS_HOTKEY(OBS_KEY_ETH)
|
||||
OBS_HOTKEY(OBS_KEY_NTILDE)
|
||||
OBS_HOTKEY(OBS_KEY_OGRAVE)
|
||||
OBS_HOTKEY(OBS_KEY_OACUTE)
|
||||
OBS_HOTKEY(OBS_KEY_OCIRCUMFLEX)
|
||||
OBS_HOTKEY(OBS_KEY_OTILDE)
|
||||
OBS_HOTKEY(OBS_KEY_ODIAERESIS)
|
||||
OBS_HOTKEY(OBS_KEY_MULTIPLY)
|
||||
OBS_HOTKEY(OBS_KEY_OOBLIQUE)
|
||||
OBS_HOTKEY(OBS_KEY_UGRAVE)
|
||||
OBS_HOTKEY(OBS_KEY_UACUTE)
|
||||
OBS_HOTKEY(OBS_KEY_UCIRCUMFLEX)
|
||||
OBS_HOTKEY(OBS_KEY_UDIAERESIS)
|
||||
OBS_HOTKEY(OBS_KEY_YACUTE)
|
||||
OBS_HOTKEY(OBS_KEY_THORN)
|
||||
OBS_HOTKEY(OBS_KEY_SSHARP)
|
||||
OBS_HOTKEY(OBS_KEY_DIVISION)
|
||||
OBS_HOTKEY(OBS_KEY_YDIAERESIS)
|
||||
OBS_HOTKEY(OBS_KEY_MULTI_KEY)
|
||||
OBS_HOTKEY(OBS_KEY_CODEINPUT)
|
||||
OBS_HOTKEY(OBS_KEY_SINGLECANDIDATE)
|
||||
OBS_HOTKEY(OBS_KEY_MULTIPLECANDIDATE)
|
||||
OBS_HOTKEY(OBS_KEY_PREVIOUSCANDIDATE)
|
||||
OBS_HOTKEY(OBS_KEY_MODE_SWITCH)
|
||||
OBS_HOTKEY(OBS_KEY_KANJI)
|
||||
OBS_HOTKEY(OBS_KEY_MUHENKAN)
|
||||
OBS_HOTKEY(OBS_KEY_HENKAN)
|
||||
OBS_HOTKEY(OBS_KEY_ROMAJI)
|
||||
OBS_HOTKEY(OBS_KEY_HIRAGANA)
|
||||
OBS_HOTKEY(OBS_KEY_KATAKANA)
|
||||
OBS_HOTKEY(OBS_KEY_HIRAGANA_KATAKANA)
|
||||
OBS_HOTKEY(OBS_KEY_ZENKAKU)
|
||||
OBS_HOTKEY(OBS_KEY_HANKAKU)
|
||||
OBS_HOTKEY(OBS_KEY_ZENKAKU_HANKAKU)
|
||||
OBS_HOTKEY(OBS_KEY_TOUROKU)
|
||||
OBS_HOTKEY(OBS_KEY_MASSYO)
|
||||
OBS_HOTKEY(OBS_KEY_KANA_LOCK)
|
||||
OBS_HOTKEY(OBS_KEY_KANA_SHIFT)
|
||||
OBS_HOTKEY(OBS_KEY_EISU_SHIFT)
|
||||
OBS_HOTKEY(OBS_KEY_EISU_TOGGLE)
|
||||
OBS_HOTKEY(OBS_KEY_HANGUL)
|
||||
OBS_HOTKEY(OBS_KEY_HANGUL_START)
|
||||
OBS_HOTKEY(OBS_KEY_HANGUL_END)
|
||||
OBS_HOTKEY(OBS_KEY_HANGUL_HANJA)
|
||||
OBS_HOTKEY(OBS_KEY_HANGUL_JAMO)
|
||||
OBS_HOTKEY(OBS_KEY_HANGUL_ROMAJA)
|
||||
OBS_HOTKEY(OBS_KEY_HANGUL_JEONJA)
|
||||
OBS_HOTKEY(OBS_KEY_HANGUL_BANJA)
|
||||
OBS_HOTKEY(OBS_KEY_HANGUL_PREHANJA)
|
||||
OBS_HOTKEY(OBS_KEY_HANGUL_POSTHANJA)
|
||||
OBS_HOTKEY(OBS_KEY_HANGUL_SPECIAL)
|
||||
OBS_HOTKEY(OBS_KEY_DEAD_GRAVE)
|
||||
OBS_HOTKEY(OBS_KEY_DEAD_ACUTE)
|
||||
OBS_HOTKEY(OBS_KEY_DEAD_CIRCUMFLEX)
|
||||
OBS_HOTKEY(OBS_KEY_DEAD_TILDE)
|
||||
OBS_HOTKEY(OBS_KEY_DEAD_MACRON)
|
||||
OBS_HOTKEY(OBS_KEY_DEAD_BREVE)
|
||||
OBS_HOTKEY(OBS_KEY_DEAD_ABOVEDOT)
|
||||
OBS_HOTKEY(OBS_KEY_DEAD_DIAERESIS)
|
||||
OBS_HOTKEY(OBS_KEY_DEAD_ABOVERING)
|
||||
OBS_HOTKEY(OBS_KEY_DEAD_DOUBLEACUTE)
|
||||
OBS_HOTKEY(OBS_KEY_DEAD_CARON)
|
||||
OBS_HOTKEY(OBS_KEY_DEAD_CEDILLA)
|
||||
OBS_HOTKEY(OBS_KEY_DEAD_OGONEK)
|
||||
OBS_HOTKEY(OBS_KEY_DEAD_IOTA)
|
||||
OBS_HOTKEY(OBS_KEY_DEAD_VOICED_SOUND)
|
||||
OBS_HOTKEY(OBS_KEY_DEAD_SEMIVOICED_SOUND)
|
||||
OBS_HOTKEY(OBS_KEY_DEAD_BELOWDOT)
|
||||
OBS_HOTKEY(OBS_KEY_DEAD_HOOK)
|
||||
OBS_HOTKEY(OBS_KEY_DEAD_HORN)
|
||||
OBS_HOTKEY(OBS_KEY_BACK)
|
||||
OBS_HOTKEY(OBS_KEY_FORWARD)
|
||||
OBS_HOTKEY(OBS_KEY_STOP)
|
||||
OBS_HOTKEY(OBS_KEY_REFRESH)
|
||||
OBS_HOTKEY(OBS_KEY_VOLUMEDOWN)
|
||||
OBS_HOTKEY(OBS_KEY_VOLUMEMUTE)
|
||||
OBS_HOTKEY(OBS_KEY_VOLUMEUP)
|
||||
OBS_HOTKEY(OBS_KEY_BASSBOOST)
|
||||
OBS_HOTKEY(OBS_KEY_BASSUP)
|
||||
OBS_HOTKEY(OBS_KEY_BASSDOWN)
|
||||
OBS_HOTKEY(OBS_KEY_TREBLEUP)
|
||||
OBS_HOTKEY(OBS_KEY_TREBLEDOWN)
|
||||
OBS_HOTKEY(OBS_KEY_MEDIAPLAY)
|
||||
OBS_HOTKEY(OBS_KEY_MEDIASTOP)
|
||||
OBS_HOTKEY(OBS_KEY_MEDIAPREVIOUS)
|
||||
OBS_HOTKEY(OBS_KEY_MEDIANEXT)
|
||||
OBS_HOTKEY(OBS_KEY_MEDIARECORD)
|
||||
OBS_HOTKEY(OBS_KEY_MEDIAPAUSE)
|
||||
OBS_HOTKEY(OBS_KEY_MEDIATOGGLEPLAYPAUSE)
|
||||
OBS_HOTKEY(OBS_KEY_HOMEPAGE)
|
||||
OBS_HOTKEY(OBS_KEY_FAVORITES)
|
||||
OBS_HOTKEY(OBS_KEY_SEARCH)
|
||||
OBS_HOTKEY(OBS_KEY_STANDBY)
|
||||
OBS_HOTKEY(OBS_KEY_OPENURL)
|
||||
OBS_HOTKEY(OBS_KEY_LAUNCHMAIL)
|
||||
OBS_HOTKEY(OBS_KEY_LAUNCHMEDIA)
|
||||
OBS_HOTKEY(OBS_KEY_LAUNCH0)
|
||||
OBS_HOTKEY(OBS_KEY_LAUNCH1)
|
||||
OBS_HOTKEY(OBS_KEY_LAUNCH2)
|
||||
OBS_HOTKEY(OBS_KEY_LAUNCH3)
|
||||
OBS_HOTKEY(OBS_KEY_LAUNCH4)
|
||||
OBS_HOTKEY(OBS_KEY_LAUNCH5)
|
||||
OBS_HOTKEY(OBS_KEY_LAUNCH6)
|
||||
OBS_HOTKEY(OBS_KEY_LAUNCH7)
|
||||
OBS_HOTKEY(OBS_KEY_LAUNCH8)
|
||||
OBS_HOTKEY(OBS_KEY_LAUNCH9)
|
||||
OBS_HOTKEY(OBS_KEY_LAUNCHA)
|
||||
OBS_HOTKEY(OBS_KEY_LAUNCHB)
|
||||
OBS_HOTKEY(OBS_KEY_LAUNCHC)
|
||||
OBS_HOTKEY(OBS_KEY_LAUNCHD)
|
||||
OBS_HOTKEY(OBS_KEY_LAUNCHE)
|
||||
OBS_HOTKEY(OBS_KEY_LAUNCHF)
|
||||
OBS_HOTKEY(OBS_KEY_LAUNCHG)
|
||||
OBS_HOTKEY(OBS_KEY_LAUNCHH)
|
||||
OBS_HOTKEY(OBS_KEY_MONBRIGHTNESSUP)
|
||||
OBS_HOTKEY(OBS_KEY_MONBRIGHTNESSDOWN)
|
||||
OBS_HOTKEY(OBS_KEY_KEYBOARDLIGHTONOFF)
|
||||
OBS_HOTKEY(OBS_KEY_KEYBOARDBRIGHTNESSUP)
|
||||
OBS_HOTKEY(OBS_KEY_KEYBOARDBRIGHTNESSDOWN)
|
||||
OBS_HOTKEY(OBS_KEY_POWEROFF)
|
||||
OBS_HOTKEY(OBS_KEY_WAKEUP)
|
||||
OBS_HOTKEY(OBS_KEY_EJECT)
|
||||
OBS_HOTKEY(OBS_KEY_SCREENSAVER)
|
||||
OBS_HOTKEY(OBS_KEY_WWW)
|
||||
OBS_HOTKEY(OBS_KEY_MEMO)
|
||||
OBS_HOTKEY(OBS_KEY_LIGHTBULB)
|
||||
OBS_HOTKEY(OBS_KEY_SHOP)
|
||||
OBS_HOTKEY(OBS_KEY_HISTORY)
|
||||
OBS_HOTKEY(OBS_KEY_ADDFAVORITE)
|
||||
OBS_HOTKEY(OBS_KEY_HOTLINKS)
|
||||
OBS_HOTKEY(OBS_KEY_BRIGHTNESSADJUST)
|
||||
OBS_HOTKEY(OBS_KEY_FINANCE)
|
||||
OBS_HOTKEY(OBS_KEY_COMMUNITY)
|
||||
OBS_HOTKEY(OBS_KEY_AUDIOREWIND)
|
||||
OBS_HOTKEY(OBS_KEY_BACKFORWARD)
|
||||
OBS_HOTKEY(OBS_KEY_APPLICATIONLEFT)
|
||||
OBS_HOTKEY(OBS_KEY_APPLICATIONRIGHT)
|
||||
OBS_HOTKEY(OBS_KEY_BOOK)
|
||||
OBS_HOTKEY(OBS_KEY_CD)
|
||||
OBS_HOTKEY(OBS_KEY_CALCULATOR)
|
||||
OBS_HOTKEY(OBS_KEY_TODOLIST)
|
||||
OBS_HOTKEY(OBS_KEY_CLEARGRAB)
|
||||
OBS_HOTKEY(OBS_KEY_CLOSE)
|
||||
OBS_HOTKEY(OBS_KEY_COPY)
|
||||
OBS_HOTKEY(OBS_KEY_CUT)
|
||||
OBS_HOTKEY(OBS_KEY_DISPLAY)
|
||||
OBS_HOTKEY(OBS_KEY_DOS)
|
||||
OBS_HOTKEY(OBS_KEY_DOCUMENTS)
|
||||
OBS_HOTKEY(OBS_KEY_EXCEL)
|
||||
OBS_HOTKEY(OBS_KEY_EXPLORER)
|
||||
OBS_HOTKEY(OBS_KEY_GAME)
|
||||
OBS_HOTKEY(OBS_KEY_GO)
|
||||
OBS_HOTKEY(OBS_KEY_ITOUCH)
|
||||
OBS_HOTKEY(OBS_KEY_LOGOFF)
|
||||
OBS_HOTKEY(OBS_KEY_MARKET)
|
||||
OBS_HOTKEY(OBS_KEY_MEETING)
|
||||
OBS_HOTKEY(OBS_KEY_MENUKB)
|
||||
OBS_HOTKEY(OBS_KEY_MENUPB)
|
||||
OBS_HOTKEY(OBS_KEY_MYSITES)
|
||||
OBS_HOTKEY(OBS_KEY_NEWS)
|
||||
OBS_HOTKEY(OBS_KEY_OFFICEHOME)
|
||||
OBS_HOTKEY(OBS_KEY_OPTION)
|
||||
OBS_HOTKEY(OBS_KEY_PASTE)
|
||||
OBS_HOTKEY(OBS_KEY_PHONE)
|
||||
OBS_HOTKEY(OBS_KEY_CALENDAR)
|
||||
OBS_HOTKEY(OBS_KEY_REPLY)
|
||||
OBS_HOTKEY(OBS_KEY_RELOAD)
|
||||
OBS_HOTKEY(OBS_KEY_ROTATEWINDOWS)
|
||||
OBS_HOTKEY(OBS_KEY_ROTATIONPB)
|
||||
OBS_HOTKEY(OBS_KEY_ROTATIONKB)
|
||||
OBS_HOTKEY(OBS_KEY_SAVE)
|
||||
OBS_HOTKEY(OBS_KEY_SEND)
|
||||
OBS_HOTKEY(OBS_KEY_SPELL)
|
||||
OBS_HOTKEY(OBS_KEY_SPLITSCREEN)
|
||||
OBS_HOTKEY(OBS_KEY_SUPPORT)
|
||||
OBS_HOTKEY(OBS_KEY_TASKPANE)
|
||||
OBS_HOTKEY(OBS_KEY_TERMINAL)
|
||||
OBS_HOTKEY(OBS_KEY_TOOLS)
|
||||
OBS_HOTKEY(OBS_KEY_TRAVEL)
|
||||
OBS_HOTKEY(OBS_KEY_VIDEO)
|
||||
OBS_HOTKEY(OBS_KEY_WORD)
|
||||
OBS_HOTKEY(OBS_KEY_XFER)
|
||||
OBS_HOTKEY(OBS_KEY_ZOOMIN)
|
||||
OBS_HOTKEY(OBS_KEY_ZOOMOUT)
|
||||
OBS_HOTKEY(OBS_KEY_AWAY)
|
||||
OBS_HOTKEY(OBS_KEY_MESSENGER)
|
||||
OBS_HOTKEY(OBS_KEY_WEBCAM)
|
||||
OBS_HOTKEY(OBS_KEY_MAILFORWARD)
|
||||
OBS_HOTKEY(OBS_KEY_PICTURES)
|
||||
OBS_HOTKEY(OBS_KEY_MUSIC)
|
||||
OBS_HOTKEY(OBS_KEY_BATTERY)
|
||||
OBS_HOTKEY(OBS_KEY_BLUETOOTH)
|
||||
OBS_HOTKEY(OBS_KEY_WLAN)
|
||||
OBS_HOTKEY(OBS_KEY_UWB)
|
||||
OBS_HOTKEY(OBS_KEY_AUDIOFORWARD)
|
||||
OBS_HOTKEY(OBS_KEY_AUDIOREPEAT)
|
||||
OBS_HOTKEY(OBS_KEY_AUDIORANDOMPLAY)
|
||||
OBS_HOTKEY(OBS_KEY_SUBTITLE)
|
||||
OBS_HOTKEY(OBS_KEY_AUDIOCYCLETRACK)
|
||||
OBS_HOTKEY(OBS_KEY_TIME)
|
||||
OBS_HOTKEY(OBS_KEY_HIBERNATE)
|
||||
OBS_HOTKEY(OBS_KEY_VIEW)
|
||||
OBS_HOTKEY(OBS_KEY_TOPMENU)
|
||||
OBS_HOTKEY(OBS_KEY_POWERDOWN)
|
||||
OBS_HOTKEY(OBS_KEY_SUSPEND)
|
||||
OBS_HOTKEY(OBS_KEY_CONTRASTADJUST)
|
||||
OBS_HOTKEY(OBS_KEY_MEDIALAST)
|
||||
OBS_HOTKEY(OBS_KEY_CALL)
|
||||
OBS_HOTKEY(OBS_KEY_CAMERA)
|
||||
OBS_HOTKEY(OBS_KEY_CAMERAFOCUS)
|
||||
OBS_HOTKEY(OBS_KEY_CONTEXT1)
|
||||
OBS_HOTKEY(OBS_KEY_CONTEXT2)
|
||||
OBS_HOTKEY(OBS_KEY_CONTEXT3)
|
||||
OBS_HOTKEY(OBS_KEY_CONTEXT4)
|
||||
OBS_HOTKEY(OBS_KEY_FLIP)
|
||||
OBS_HOTKEY(OBS_KEY_HANGUP)
|
||||
OBS_HOTKEY(OBS_KEY_NO)
|
||||
OBS_HOTKEY(OBS_KEY_SELECT)
|
||||
OBS_HOTKEY(OBS_KEY_YES)
|
||||
OBS_HOTKEY(OBS_KEY_TOGGLECALLHANGUP)
|
||||
OBS_HOTKEY(OBS_KEY_VOICEDIAL)
|
||||
OBS_HOTKEY(OBS_KEY_LASTNUMBERREDIAL)
|
||||
OBS_HOTKEY(OBS_KEY_EXECUTE)
|
||||
OBS_HOTKEY(OBS_KEY_PRINTER)
|
||||
OBS_HOTKEY(OBS_KEY_PLAY)
|
||||
OBS_HOTKEY(OBS_KEY_SLEEP)
|
||||
OBS_HOTKEY(OBS_KEY_ZOOM)
|
||||
OBS_HOTKEY(OBS_KEY_CANCEL)
|
||||
|
||||
|
||||
#ifndef OBS_MOUSE_BUTTON
|
||||
#define OBS_MOUSE_BUTTON(x) OBS_HOTKEY(x)
|
||||
#define OBS_MOUSE_BUTTON_DEFAULT 1
|
||||
#endif
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE1)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE2)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE3)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE4)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE5)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE6)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE7)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE8)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE9)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE10)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE11)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE12)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE13)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE14)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE15)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE16)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE17)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE18)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE19)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE20)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE21)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE22)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE23)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE24)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE25)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE26)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE27)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE28)
|
||||
OBS_MOUSE_BUTTON(OBS_KEY_MOUSE29)
|
||||
#ifdef OBS_MOUSE_BUTTON_DEFAULT
|
||||
#undef OBS_MOUSE_BUTTON
|
||||
#undef OBS_MOUSE_BUTTON_DEFAULT
|
||||
#endif
|
||||
@ -95,6 +95,65 @@ static inline bool check_path(const char *data, const char *path,
|
||||
}
|
||||
|
||||
|
||||
/* ------------------------------------------------------------------------- */
|
||||
/* hotkeys */
|
||||
|
||||
struct obs_hotkey {
|
||||
obs_hotkey_id id;
|
||||
char *name;
|
||||
char *description;
|
||||
|
||||
obs_hotkey_func func;
|
||||
void *data;
|
||||
int pressed;
|
||||
|
||||
obs_hotkey_registerer_t registerer_type;
|
||||
void *registerer;
|
||||
|
||||
obs_hotkey_id pair_partner_id;
|
||||
};
|
||||
|
||||
struct obs_hotkey_pair {
|
||||
obs_hotkey_pair_id pair_id;
|
||||
obs_hotkey_id id[2];
|
||||
obs_hotkey_active_func func[2];
|
||||
bool pressed0 : 1;
|
||||
bool pressed1 : 1;
|
||||
void *data[2];
|
||||
};
|
||||
|
||||
typedef struct obs_hotkey_pair obs_hotkey_pair_t;
|
||||
|
||||
typedef struct obs_hotkeys_platform obs_hotkeys_platform_t;
|
||||
|
||||
void *obs_hotkey_thread(void *param);
|
||||
|
||||
struct obs_core_hotkeys;
|
||||
bool obs_hotkeys_platform_init(struct obs_core_hotkeys *hotkeys);
|
||||
void obs_hotkeys_platform_free(struct obs_core_hotkeys *hotkeys);
|
||||
bool obs_hotkeys_platform_is_pressed(obs_hotkeys_platform_t *context,
|
||||
obs_key_t key);
|
||||
|
||||
const char *obs_get_hotkey_translation(obs_key_t key, const char *def);
|
||||
|
||||
struct obs_context_data;
|
||||
void obs_hotkeys_context_release(struct obs_context_data *context);
|
||||
|
||||
void obs_hotkeys_free(void);
|
||||
|
||||
struct obs_hotkey_binding {
|
||||
obs_key_combination_t key;
|
||||
bool pressed : 1;
|
||||
bool modifiers_match : 1;
|
||||
|
||||
obs_hotkey_id hotkey_id;
|
||||
obs_hotkey_t *hotkey;
|
||||
};
|
||||
|
||||
struct obs_hotkey_name_map;
|
||||
void obs_hotkey_name_map_free(void);
|
||||
|
||||
|
||||
/* ------------------------------------------------------------------------- */
|
||||
/* views */
|
||||
|
||||
@ -213,6 +272,35 @@ struct obs_core_data {
|
||||
volatile bool valid;
|
||||
};
|
||||
|
||||
/* user hotkeys */
|
||||
struct obs_core_hotkeys {
|
||||
pthread_mutex_t mutex;
|
||||
DARRAY(obs_hotkey_t) hotkeys;
|
||||
obs_hotkey_id next_id;
|
||||
DARRAY(obs_hotkey_pair_t) hotkey_pairs;
|
||||
obs_hotkey_pair_id next_pair_id;
|
||||
|
||||
pthread_t hotkey_thread;
|
||||
bool hotkey_thread_initialized;
|
||||
os_event_t *stop_event;
|
||||
bool thread_disable_press : 1;
|
||||
bool strict_modifiers : 1;
|
||||
bool reroute_hotkeys : 1;
|
||||
DARRAY(obs_hotkey_binding_t) bindings;
|
||||
|
||||
obs_hotkey_callback_router_func router_func;
|
||||
void *router_func_data;
|
||||
|
||||
obs_hotkeys_platform_t *platform_context;
|
||||
|
||||
pthread_once_t name_map_init_token;
|
||||
struct obs_hotkey_name_map *name_map;
|
||||
|
||||
signal_handler_t *signals;
|
||||
|
||||
char *translations[OBS_KEY_LAST_VALUE];
|
||||
};
|
||||
|
||||
struct obs_core {
|
||||
struct obs_module *first_module;
|
||||
DARRAY(struct obs_module_path) module_paths;
|
||||
@ -236,6 +324,7 @@ struct obs_core {
|
||||
struct obs_core_video video;
|
||||
struct obs_core_audio audio;
|
||||
struct obs_core_data data;
|
||||
struct obs_core_hotkeys hotkeys;
|
||||
};
|
||||
|
||||
extern struct obs_core *obs;
|
||||
@ -253,6 +342,10 @@ struct obs_context_data {
|
||||
signal_handler_t *signals;
|
||||
proc_handler_t *procs;
|
||||
|
||||
DARRAY(obs_hotkey_id) hotkeys;
|
||||
DARRAY(obs_hotkey_pair_id) hotkey_pairs;
|
||||
obs_data_t *hotkey_data;
|
||||
|
||||
DARRAY(char*) rename_cache;
|
||||
pthread_mutex_t rename_cache_mutex;
|
||||
|
||||
@ -264,7 +357,8 @@ struct obs_context_data {
|
||||
extern bool obs_context_data_init(
|
||||
struct obs_context_data *context,
|
||||
obs_data_t *settings,
|
||||
const char *name);
|
||||
const char *name,
|
||||
obs_data_t *hotkey_data);
|
||||
extern void obs_context_data_free(struct obs_context_data *context);
|
||||
|
||||
extern void obs_context_data_insert(struct obs_context_data *context,
|
||||
|
||||
@ -227,3 +227,54 @@ void log_system_info(void)
|
||||
log_distribution_info();
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
struct obs_hotkeys_platform {
|
||||
};
|
||||
|
||||
bool obs_hotkeys_platform_init(struct obs_core_hotkeys *hotkeys)
|
||||
{
|
||||
UNUSED_PARAMETER(hotkeys);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void obs_hotkeys_platform_free(struct obs_core_hotkeys *hotkeys)
|
||||
{
|
||||
UNUSED_PARAMETER(hotkeys);
|
||||
}
|
||||
|
||||
bool obs_hotkeys_platform_is_pressed(obs_hotkeys_platform_t *context,
|
||||
obs_key_t key)
|
||||
{
|
||||
UNUSED_PARAMETER(context);
|
||||
UNUSED_PARAMETER(key);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void obs_key_to_str(obs_key_t key, struct dstr *str)
|
||||
{
|
||||
UNUSED_PARAMETER(key);
|
||||
UNUSED_PARAMETER(str);
|
||||
}
|
||||
|
||||
void obs_key_combination_to_str(obs_key_combination_t key, struct dstr *str)
|
||||
{
|
||||
UNUSED_PARAMETER(key);
|
||||
UNUSED_PARAMETER(str);
|
||||
}
|
||||
|
||||
obs_key_t obs_key_from_virtual_key(int code)
|
||||
{
|
||||
UNUSED_PARAMETER(code);
|
||||
|
||||
return OBS_KEY_NONE;
|
||||
}
|
||||
|
||||
int obs_key_to_virtual_key(obs_key_t key)
|
||||
{
|
||||
UNUSED_PARAMETER(key);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -49,7 +49,7 @@ static const char *output_signals[] = {
|
||||
static bool init_output_handlers(struct obs_output *output, const char *name,
|
||||
obs_data_t *settings)
|
||||
{
|
||||
if (!obs_context_data_init(&output->context, settings, name))
|
||||
if (!obs_context_data_init(&output->context, settings, name, NULL))
|
||||
return false;
|
||||
|
||||
signal_handler_add_array(output->context.signals, output_signals);
|
||||
|
||||
@ -46,7 +46,7 @@ obs_service_t *obs_service_create(const char *id, const char *name,
|
||||
|
||||
service = bzalloc(sizeof(struct obs_service));
|
||||
|
||||
if (!obs_context_data_init(&service->context, settings, name)) {
|
||||
if (!obs_context_data_init(&service->context, settings, name, NULL)) {
|
||||
bfree(service);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@ -96,7 +96,7 @@ static const char *source_signals[] = {
|
||||
bool obs_source_init_context(struct obs_source *source,
|
||||
obs_data_t *settings, const char *name)
|
||||
{
|
||||
if (!obs_context_data_init(&source->context, settings, name))
|
||||
if (!obs_context_data_init(&source->context, settings, name, NULL))
|
||||
return false;
|
||||
|
||||
return signal_handler_add_array(source->context.signals,
|
||||
|
||||
@ -194,3 +194,55 @@ void log_system_info(void)
|
||||
log_available_memory();
|
||||
log_windows_version();
|
||||
}
|
||||
|
||||
|
||||
struct obs_hotkeys_platform {
|
||||
bool blank;
|
||||
};
|
||||
|
||||
bool obs_hotkeys_platform_init(struct obs_core_hotkeys *hotkeys)
|
||||
{
|
||||
UNUSED_PARAMETER(hotkeys);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void obs_hotkeys_platform_free(struct obs_core_hotkeys *hotkeys)
|
||||
{
|
||||
UNUSED_PARAMETER(hotkeys);
|
||||
}
|
||||
|
||||
bool obs_hotkeys_platform_is_pressed(obs_hotkeys_platform_t *context,
|
||||
obs_key_t key)
|
||||
{
|
||||
UNUSED_PARAMETER(context);
|
||||
UNUSED_PARAMETER(key);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void obs_key_to_str(obs_key_t key, struct dstr *str)
|
||||
{
|
||||
UNUSED_PARAMETER(key);
|
||||
UNUSED_PARAMETER(str);
|
||||
}
|
||||
|
||||
void obs_key_combination_to_str(obs_key_combination_t key, struct dstr *str)
|
||||
{
|
||||
UNUSED_PARAMETER(key);
|
||||
UNUSED_PARAMETER(str);
|
||||
}
|
||||
|
||||
obs_key_t obs_key_from_virtual_key(int code)
|
||||
{
|
||||
UNUSED_PARAMETER(code);
|
||||
|
||||
return OBS_KEY_NONE;
|
||||
}
|
||||
|
||||
int obs_key_to_virtual_key(obs_key_t key)
|
||||
{
|
||||
UNUSED_PARAMETER(key);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
101
libobs/obs.c
101
libobs/obs.c
@ -609,6 +609,11 @@ static const char *obs_signals[] = {
|
||||
"void channel_change(int channel, in out ptr source, ptr prev_source)",
|
||||
"void master_volume(in out float volume)",
|
||||
|
||||
"void hotkey_layout_change()",
|
||||
"void hotkey_register(ptr hotkey)",
|
||||
"void hotkey_unregister(ptr hotkey)",
|
||||
"void hotkey_bindings_changed(ptr hotkey)",
|
||||
|
||||
NULL
|
||||
};
|
||||
|
||||
@ -625,6 +630,69 @@ static inline bool obs_init_handlers(void)
|
||||
return signal_handler_add_array(obs->signals, obs_signals);
|
||||
}
|
||||
|
||||
static pthread_once_t obs_pthread_once_init_token = PTHREAD_ONCE_INIT;
|
||||
static inline bool obs_init_hotkeys(void)
|
||||
{
|
||||
struct obs_core_hotkeys *hotkeys = &obs->hotkeys;
|
||||
pthread_mutexattr_t attr;
|
||||
bool success = false;
|
||||
|
||||
assert(hotkeys != NULL);
|
||||
|
||||
da_init(hotkeys->hotkeys);
|
||||
hotkeys->signals = obs->signals;
|
||||
hotkeys->name_map_init_token = obs_pthread_once_init_token;
|
||||
|
||||
if (!obs_hotkeys_platform_init(hotkeys))
|
||||
return false;
|
||||
|
||||
if (pthread_mutexattr_init(&attr) != 0)
|
||||
return false;
|
||||
if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE) != 0)
|
||||
goto fail;
|
||||
if (pthread_mutex_init(&hotkeys->mutex, &attr) != 0)
|
||||
goto fail;
|
||||
|
||||
if (os_event_init(&hotkeys->stop_event, OS_EVENT_TYPE_MANUAL) != 0)
|
||||
goto fail;
|
||||
if (pthread_create(&hotkeys->hotkey_thread, NULL,
|
||||
obs_hotkey_thread, NULL))
|
||||
goto fail;
|
||||
|
||||
hotkeys->hotkey_thread_initialized = true;
|
||||
|
||||
success = true;
|
||||
|
||||
fail:
|
||||
pthread_mutexattr_destroy(&attr);
|
||||
return success;
|
||||
}
|
||||
|
||||
static inline void stop_hotkeys(void)
|
||||
{
|
||||
struct obs_core_hotkeys *hotkeys = &obs->hotkeys;
|
||||
void *thread_ret;
|
||||
|
||||
if (hotkeys->hotkey_thread_initialized) {
|
||||
os_event_signal(hotkeys->stop_event);
|
||||
pthread_join(hotkeys->hotkey_thread, &thread_ret);
|
||||
hotkeys->hotkey_thread_initialized = false;
|
||||
}
|
||||
|
||||
os_event_destroy(hotkeys->stop_event);
|
||||
obs_hotkeys_free();
|
||||
}
|
||||
|
||||
static inline void obs_free_hotkeys(void)
|
||||
{
|
||||
struct obs_core_hotkeys *hotkeys = &obs->hotkeys;
|
||||
|
||||
obs_hotkey_name_map_free();
|
||||
|
||||
obs_hotkeys_platform_free(hotkeys);
|
||||
pthread_mutex_destroy(&hotkeys->mutex);
|
||||
}
|
||||
|
||||
extern const struct obs_source_info scene_info;
|
||||
|
||||
extern void log_system_info(void);
|
||||
@ -639,6 +707,8 @@ static bool obs_init(const char *locale)
|
||||
return false;
|
||||
if (!obs_init_handlers())
|
||||
return false;
|
||||
if (!obs_init_hotkeys())
|
||||
return false;
|
||||
|
||||
obs->locale = bstrdup(locale);
|
||||
obs_register_source(&scene_info);
|
||||
@ -687,9 +757,11 @@ void obs_shutdown(void)
|
||||
da_free(obs->modeless_ui_callbacks);
|
||||
|
||||
stop_video();
|
||||
stop_hotkeys();
|
||||
|
||||
obs_free_data();
|
||||
obs_free_video();
|
||||
obs_free_hotkeys();
|
||||
obs_free_graphics();
|
||||
obs_free_audio();
|
||||
proc_handler_destroy(obs->procs);
|
||||
@ -1347,6 +1419,7 @@ static obs_source_t *obs_load_source_type(obs_data_t *source_data,
|
||||
const char *name = obs_data_get_string(source_data, "name");
|
||||
const char *id = obs_data_get_string(source_data, "id");
|
||||
obs_data_t *settings = obs_data_get_obj(source_data, "settings");
|
||||
obs_data_t *hotkeys = obs_data_get_obj(source_data, "hotkeys");
|
||||
double volume;
|
||||
int64_t sync;
|
||||
uint32_t flags;
|
||||
@ -1354,6 +1427,10 @@ static obs_source_t *obs_load_source_type(obs_data_t *source_data,
|
||||
|
||||
source = obs_source_create(type, id, name, settings);
|
||||
|
||||
obs_data_release(source->context.hotkey_data);
|
||||
source->context.hotkey_data = hotkeys;
|
||||
obs_hotkeys_load_source(source, hotkeys);
|
||||
|
||||
obs_data_set_default_double(source_data, "volume", 1.0);
|
||||
volume = obs_data_get_double(source_data, "volume");
|
||||
obs_source_set_volume(source, (float)volume);
|
||||
@ -1439,6 +1516,8 @@ obs_data_t *obs_save_source(obs_source_t *source)
|
||||
obs_data_array_t *filters = obs_data_array_create();
|
||||
obs_data_t *source_data = obs_data_create();
|
||||
obs_data_t *settings = obs_source_get_settings(source);
|
||||
obs_data_t *hotkey_data = source->context.hotkey_data;
|
||||
obs_data_t *hotkeys;
|
||||
float volume = obs_source_get_volume(source);
|
||||
uint32_t mixers = obs_source_get_audio_mixers(source);
|
||||
int64_t sync = obs_source_get_sync_offset(source);
|
||||
@ -1449,6 +1528,13 @@ obs_data_t *obs_save_source(obs_source_t *source)
|
||||
bool muted = obs_source_muted(source);
|
||||
|
||||
obs_source_save(source);
|
||||
hotkeys = obs_hotkeys_save_source(source);
|
||||
|
||||
if (hotkeys) {
|
||||
obs_data_release(hotkey_data);
|
||||
source->context.hotkey_data = hotkeys;
|
||||
hotkey_data = hotkeys;
|
||||
}
|
||||
|
||||
obs_data_set_string(source_data, "name", name);
|
||||
obs_data_set_string(source_data, "id", id);
|
||||
@ -1459,6 +1545,7 @@ obs_data_t *obs_save_source(obs_source_t *source)
|
||||
obs_data_set_double(source_data, "volume", volume);
|
||||
obs_data_set_bool (source_data, "enabled", enabled);
|
||||
obs_data_set_bool (source_data, "muted", muted);
|
||||
obs_data_set_obj (source_data, "hotkeys", hotkey_data);
|
||||
|
||||
pthread_mutex_lock(&source->filter_mutex);
|
||||
|
||||
@ -1522,7 +1609,8 @@ static inline char *dup_name(const char *name)
|
||||
static inline bool obs_context_data_init_wrap(
|
||||
struct obs_context_data *context,
|
||||
obs_data_t *settings,
|
||||
const char *name)
|
||||
const char *name,
|
||||
obs_data_t *hotkey_data)
|
||||
{
|
||||
assert(context);
|
||||
memset(context, 0, sizeof(*context));
|
||||
@ -1539,17 +1627,19 @@ static inline bool obs_context_data_init_wrap(
|
||||
if (!context->procs)
|
||||
return false;
|
||||
|
||||
context->name = dup_name(name);
|
||||
context->settings = obs_data_newref(settings);
|
||||
context->name = dup_name(name);
|
||||
context->settings = obs_data_newref(settings);
|
||||
context->hotkey_data = obs_data_newref(hotkey_data);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool obs_context_data_init(
|
||||
struct obs_context_data *context,
|
||||
obs_data_t *settings,
|
||||
const char *name)
|
||||
const char *name,
|
||||
obs_data_t *hotkey_data)
|
||||
{
|
||||
if (obs_context_data_init_wrap(context, settings, name)) {
|
||||
if (obs_context_data_init_wrap(context, settings, name, hotkey_data)) {
|
||||
return true;
|
||||
} else {
|
||||
obs_context_data_free(context);
|
||||
@ -1559,6 +1649,7 @@ bool obs_context_data_init(
|
||||
|
||||
void obs_context_data_free(struct obs_context_data *context)
|
||||
{
|
||||
obs_hotkeys_context_release(context);
|
||||
signal_handler_destroy(context->signals);
|
||||
proc_handler_destroy(context->procs);
|
||||
obs_data_release(context->settings);
|
||||
|
||||
@ -72,6 +72,7 @@ typedef struct obs_weak_service obs_weak_service_t;
|
||||
#include "obs-output.h"
|
||||
#include "obs-service.h"
|
||||
#include "obs-audio-controls.h"
|
||||
#include "obs-hotkey.h"
|
||||
|
||||
/**
|
||||
* @file
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user