|
|
@@ -0,0 +1,1497 @@
|
|
|
+/******************************************************************************
|
|
|
+ Copyright (C) 2014-2015 by Ruwen Hahn <[email protected]>
|
|
|
+
|
|
|
+ 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 <inttypes.h>
|
|
|
+
|
|
|
+#include "obs-internal.h"
|
|
|
+
|
|
|
+static inline bool lock(void)
|
|
|
+{
|
|
|
+ if (!obs)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ pthread_mutex_lock(&obs->hotkeys.mutex);
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+static inline void unlock(void)
|
|
|
+{
|
|
|
+ pthread_mutex_unlock(&obs->hotkeys.mutex);
|
|
|
+}
|
|
|
+
|
|
|
+obs_hotkey_id obs_hotkey_get_id(const obs_hotkey_t *key)
|
|
|
+{
|
|
|
+ return key->id;
|
|
|
+}
|
|
|
+
|
|
|
+const char *obs_hotkey_get_name(const obs_hotkey_t *key)
|
|
|
+{
|
|
|
+ return key->name;
|
|
|
+}
|
|
|
+
|
|
|
+const char *obs_hotkey_get_description(const obs_hotkey_t *key)
|
|
|
+{
|
|
|
+ return key->description;
|
|
|
+}
|
|
|
+
|
|
|
+obs_hotkey_registerer_t obs_hotkey_get_registerer_type(const obs_hotkey_t *key)
|
|
|
+{
|
|
|
+ return key->registerer_type;
|
|
|
+}
|
|
|
+
|
|
|
+void *obs_hotkey_get_registerer(const obs_hotkey_t *key)
|
|
|
+{
|
|
|
+ return key->registerer;
|
|
|
+}
|
|
|
+
|
|
|
+obs_hotkey_id obs_hotkey_get_pair_partner_id(const obs_hotkey_t *key)
|
|
|
+{
|
|
|
+ return key->pair_partner_id;
|
|
|
+}
|
|
|
+
|
|
|
+obs_key_combination_t obs_hotkey_binding_get_key_combination(
|
|
|
+ obs_hotkey_binding_t *binding)
|
|
|
+{
|
|
|
+ return binding->key;
|
|
|
+}
|
|
|
+
|
|
|
+obs_hotkey_id obs_hotkey_binding_get_hotkey_id(obs_hotkey_binding_t *binding)
|
|
|
+{
|
|
|
+ return binding->hotkey_id;
|
|
|
+}
|
|
|
+
|
|
|
+obs_hotkey_t *obs_hotkey_binding_get_hotkey(obs_hotkey_binding_t *binding)
|
|
|
+{
|
|
|
+ return binding->hotkey;
|
|
|
+}
|
|
|
+
|
|
|
+static void hotkey_signal(const char *signal, obs_hotkey_t *hotkey)
|
|
|
+{
|
|
|
+ calldata_t data;
|
|
|
+ calldata_init(&data);
|
|
|
+ calldata_set_ptr(&data, "key", hotkey);
|
|
|
+
|
|
|
+ signal_handler_signal(obs->hotkeys.signals, signal, &data);
|
|
|
+
|
|
|
+ calldata_free(&data);
|
|
|
+}
|
|
|
+
|
|
|
+static inline void fixup_pointers(void);
|
|
|
+static inline void load_bindings(obs_hotkey_t *hotkey, obs_data_array_t *data);
|
|
|
+
|
|
|
+static inline void context_add_hotkey(struct obs_context_data *context,
|
|
|
+ obs_hotkey_id id)
|
|
|
+{
|
|
|
+ da_push_back(context->hotkeys, &id);
|
|
|
+}
|
|
|
+
|
|
|
+static inline obs_hotkey_id obs_hotkey_register_internal(
|
|
|
+ obs_hotkey_registerer_t type, void *registerer,
|
|
|
+ struct obs_context_data *context,
|
|
|
+ const char *name, const char *description,
|
|
|
+ obs_hotkey_func func, void *data)
|
|
|
+{
|
|
|
+ if ((obs->hotkeys.next_id + 1) == OBS_INVALID_HOTKEY_ID)
|
|
|
+ blog(LOG_WARNING, "obs-hotkey: Available hotkey ids exhausted");
|
|
|
+
|
|
|
+ obs_hotkey_t *base_addr = obs->hotkeys.hotkeys.array;
|
|
|
+ obs_hotkey_id result = obs->hotkeys.next_id++;
|
|
|
+ obs_hotkey_t *hotkey = da_push_back_new(obs->hotkeys.hotkeys);
|
|
|
+
|
|
|
+ hotkey->id = result;
|
|
|
+ hotkey->name = bstrdup(name);
|
|
|
+ hotkey->description = bstrdup(description);
|
|
|
+ hotkey->func = func;
|
|
|
+ hotkey->data = data;
|
|
|
+ hotkey->registerer_type = type;
|
|
|
+ hotkey->registerer = registerer;
|
|
|
+ hotkey->pair_partner_id = OBS_INVALID_HOTKEY_PAIR_ID;
|
|
|
+
|
|
|
+ if (context) {
|
|
|
+ obs_data_array_t *data =
|
|
|
+ obs_data_get_array(context->hotkey_data, name);
|
|
|
+ load_bindings(hotkey, data);
|
|
|
+ obs_data_array_release(data);
|
|
|
+
|
|
|
+ context_add_hotkey(context, result);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (base_addr != obs->hotkeys.hotkeys.array)
|
|
|
+ fixup_pointers();
|
|
|
+
|
|
|
+ hotkey_signal("hotkey_register", hotkey);
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+obs_hotkey_id obs_hotkey_register_frontend(const char *name,
|
|
|
+ const char *description, obs_hotkey_func func, void *data)
|
|
|
+{
|
|
|
+ if (!lock())
|
|
|
+ return OBS_INVALID_HOTKEY_ID;
|
|
|
+
|
|
|
+ obs_hotkey_id id = obs_hotkey_register_internal(
|
|
|
+ OBS_HOTKEY_REGISTERER_FRONTEND, NULL, NULL,
|
|
|
+ name, description, func, data);
|
|
|
+
|
|
|
+ unlock();
|
|
|
+ return id;
|
|
|
+}
|
|
|
+
|
|
|
+obs_hotkey_id obs_hotkey_register_encoder(obs_encoder_t *encoder,
|
|
|
+ const char *name, const char *description,
|
|
|
+ obs_hotkey_func func, void *data)
|
|
|
+{
|
|
|
+ if (!encoder || !lock())
|
|
|
+ return OBS_INVALID_HOTKEY_ID;
|
|
|
+
|
|
|
+ obs_hotkey_id id = obs_hotkey_register_internal(
|
|
|
+ OBS_HOTKEY_REGISTERER_ENCODER,
|
|
|
+ obs_encoder_get_weak_encoder(encoder),
|
|
|
+ &encoder->context, name, description,
|
|
|
+ func, data);
|
|
|
+
|
|
|
+ unlock();
|
|
|
+ return id;
|
|
|
+}
|
|
|
+
|
|
|
+obs_hotkey_id obs_hotkey_register_output(obs_output_t *output,
|
|
|
+ const char *name, const char *description,
|
|
|
+ obs_hotkey_func func, void *data)
|
|
|
+{
|
|
|
+ if (!output || !lock())
|
|
|
+ return OBS_INVALID_HOTKEY_ID;
|
|
|
+
|
|
|
+ obs_hotkey_id id = obs_hotkey_register_internal(
|
|
|
+ OBS_HOTKEY_REGISTERER_OUTPUT,
|
|
|
+ obs_output_get_weak_output(output),
|
|
|
+ &output->context, name, description,
|
|
|
+ func, data);
|
|
|
+
|
|
|
+ unlock();
|
|
|
+ return id;
|
|
|
+}
|
|
|
+
|
|
|
+obs_hotkey_id obs_hotkey_register_service(obs_service_t *service,
|
|
|
+ const char *name, const char *description,
|
|
|
+ obs_hotkey_func func, void *data)
|
|
|
+{
|
|
|
+ if (!service || !lock())
|
|
|
+ return OBS_INVALID_HOTKEY_ID;
|
|
|
+
|
|
|
+ obs_hotkey_id id = obs_hotkey_register_internal(
|
|
|
+ OBS_HOTKEY_REGISTERER_SERVICE,
|
|
|
+ obs_service_get_weak_service(service),
|
|
|
+ &service->context, name, description,
|
|
|
+ func, data);
|
|
|
+
|
|
|
+ unlock();
|
|
|
+ return id;
|
|
|
+}
|
|
|
+
|
|
|
+obs_hotkey_id obs_hotkey_register_source(obs_source_t *source, const char *name,
|
|
|
+ const char *description, obs_hotkey_func func, void *data)
|
|
|
+{
|
|
|
+ if (!source || !lock())
|
|
|
+ return OBS_INVALID_HOTKEY_ID;
|
|
|
+
|
|
|
+ obs_hotkey_id id = obs_hotkey_register_internal(
|
|
|
+ OBS_HOTKEY_REGISTERER_SOURCE,
|
|
|
+ obs_source_get_weak_source(source),
|
|
|
+ &source->context, name, description,
|
|
|
+ func, data);
|
|
|
+
|
|
|
+ unlock();
|
|
|
+ return id;
|
|
|
+}
|
|
|
+
|
|
|
+static inline void fixup_pair_pointers(void);
|
|
|
+
|
|
|
+static obs_hotkey_pair_t *create_hotkey_pair(struct obs_context_data *context,
|
|
|
+ obs_hotkey_active_func func0, obs_hotkey_active_func func1,
|
|
|
+ void *data0, void *data1)
|
|
|
+{
|
|
|
+ if ((obs->hotkeys.next_pair_id + 1) == OBS_INVALID_HOTKEY_PAIR_ID)
|
|
|
+ blog(LOG_WARNING, "obs-hotkey: Available hotkey pair ids "
|
|
|
+ "exhausted");
|
|
|
+
|
|
|
+ obs_hotkey_pair_t *base_addr = obs->hotkeys.hotkey_pairs.array;
|
|
|
+ obs_hotkey_pair_t *pair =
|
|
|
+ da_push_back_new(obs->hotkeys.hotkey_pairs);
|
|
|
+
|
|
|
+ pair->pair_id = obs->hotkeys.next_pair_id++;
|
|
|
+ pair->func[0] = func0;
|
|
|
+ pair->func[1] = func1;
|
|
|
+ pair->id[0] = OBS_INVALID_HOTKEY_ID;
|
|
|
+ pair->id[1] = OBS_INVALID_HOTKEY_ID;
|
|
|
+ pair->data[0] = data0;
|
|
|
+ pair->data[1] = data1;
|
|
|
+
|
|
|
+ if (context)
|
|
|
+ da_push_back(context->hotkey_pairs, &pair->pair_id);
|
|
|
+
|
|
|
+ if (base_addr != obs->hotkeys.hotkey_pairs.array)
|
|
|
+ fixup_pair_pointers();
|
|
|
+
|
|
|
+ return pair;
|
|
|
+}
|
|
|
+
|
|
|
+static void obs_hotkey_pair_first_func(void *data,
|
|
|
+ obs_hotkey_id id, obs_hotkey_t *hotkey, bool pressed)
|
|
|
+{
|
|
|
+ UNUSED_PARAMETER(id);
|
|
|
+
|
|
|
+ obs_hotkey_pair_t *pair = data;
|
|
|
+ if (pair->pressed1)
|
|
|
+ return;
|
|
|
+
|
|
|
+ if (pair->pressed0 && !pressed)
|
|
|
+ pair->pressed0 = false;
|
|
|
+ else if (pair->func[0](pair->data[0], pair->pair_id, hotkey, pressed))
|
|
|
+ pair->pressed0 = pressed;
|
|
|
+}
|
|
|
+
|
|
|
+static void obs_hotkey_pair_second_func(void *data,
|
|
|
+ obs_hotkey_id id, obs_hotkey_t *hotkey, bool pressed)
|
|
|
+{
|
|
|
+ UNUSED_PARAMETER(id);
|
|
|
+
|
|
|
+ obs_hotkey_pair_t *pair = data;
|
|
|
+ if (pair->pressed0)
|
|
|
+ return;
|
|
|
+
|
|
|
+ if (pair->pressed1 && !pressed)
|
|
|
+ pair->pressed1 = false;
|
|
|
+ else if (pair->func[1](pair->data[0], pair->pair_id, hotkey, pressed))
|
|
|
+ pair->pressed1 = pressed;
|
|
|
+}
|
|
|
+
|
|
|
+static inline bool find_id(obs_hotkey_id id, size_t *idx);
|
|
|
+static obs_hotkey_pair_id register_hotkey_pair_internal(
|
|
|
+ obs_hotkey_registerer_t type, void *registerer,
|
|
|
+ void *(*weak_ref)(void*),
|
|
|
+ struct obs_context_data *context,
|
|
|
+ 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)
|
|
|
+{
|
|
|
+
|
|
|
+ if (!lock())
|
|
|
+ return OBS_INVALID_HOTKEY_PAIR_ID;
|
|
|
+
|
|
|
+ obs_hotkey_pair_t *pair = create_hotkey_pair(context,
|
|
|
+ func0, func1, data0, data1);
|
|
|
+
|
|
|
+ pair->id[0] = obs_hotkey_register_internal(
|
|
|
+ type, weak_ref(registerer), context,
|
|
|
+ name0, description0,
|
|
|
+ obs_hotkey_pair_first_func, pair);
|
|
|
+
|
|
|
+ pair->id[1] = obs_hotkey_register_internal(
|
|
|
+ type, weak_ref(registerer), context,
|
|
|
+ name1, description1,
|
|
|
+ obs_hotkey_pair_second_func, pair);
|
|
|
+
|
|
|
+ size_t idx;
|
|
|
+ if (find_id(pair->id[0], &idx))
|
|
|
+ obs->hotkeys.hotkeys.array[idx].pair_partner_id = pair->id[1];
|
|
|
+
|
|
|
+ if (find_id(pair->id[1], &idx))
|
|
|
+ obs->hotkeys.hotkeys.array[idx].pair_partner_id = pair->id[0];
|
|
|
+
|
|
|
+ obs_hotkey_pair_id id = pair->pair_id;
|
|
|
+
|
|
|
+ unlock();
|
|
|
+ return id;
|
|
|
+}
|
|
|
+
|
|
|
+static inline void *obs_id_(void *id_)
|
|
|
+{
|
|
|
+ return id_;
|
|
|
+}
|
|
|
+
|
|
|
+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)
|
|
|
+{
|
|
|
+ return register_hotkey_pair_internal(
|
|
|
+ OBS_HOTKEY_REGISTERER_FRONTEND, NULL, obs_id_, NULL,
|
|
|
+ name0, description0, name1, description1,
|
|
|
+ func0, func1, data0, data1);
|
|
|
+}
|
|
|
+
|
|
|
+static inline void *weak_encoder_ref(void *ref)
|
|
|
+{
|
|
|
+ return obs_encoder_get_weak_encoder(ref);
|
|
|
+}
|
|
|
+
|
|
|
+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)
|
|
|
+{
|
|
|
+ if (!encoder) return OBS_INVALID_HOTKEY_PAIR_ID;
|
|
|
+ return register_hotkey_pair_internal(
|
|
|
+ OBS_HOTKEY_REGISTERER_ENCODER, encoder,
|
|
|
+ weak_encoder_ref,
|
|
|
+ &encoder->context,
|
|
|
+ name0, description0, name1, description1,
|
|
|
+ func0, func1, data0, data1);
|
|
|
+}
|
|
|
+
|
|
|
+static inline void *weak_output_ref(void *ref)
|
|
|
+{
|
|
|
+ return obs_output_get_weak_output(ref);
|
|
|
+}
|
|
|
+
|
|
|
+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)
|
|
|
+{
|
|
|
+ if (!output) return OBS_INVALID_HOTKEY_PAIR_ID;
|
|
|
+ return register_hotkey_pair_internal(
|
|
|
+ OBS_HOTKEY_REGISTERER_OUTPUT, output,
|
|
|
+ weak_output_ref,
|
|
|
+ &output->context,
|
|
|
+ name0, description0, name1, description1,
|
|
|
+ func0, func1, data0, data1);
|
|
|
+}
|
|
|
+
|
|
|
+static inline void *weak_service_ref(void *ref)
|
|
|
+{
|
|
|
+ return obs_service_get_weak_service(ref);
|
|
|
+}
|
|
|
+
|
|
|
+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)
|
|
|
+{
|
|
|
+ if (!service) return OBS_INVALID_HOTKEY_PAIR_ID;
|
|
|
+ return register_hotkey_pair_internal(
|
|
|
+ OBS_HOTKEY_REGISTERER_SERVICE, service,
|
|
|
+ weak_service_ref,
|
|
|
+ &service->context,
|
|
|
+ name0, description0, name1, description1,
|
|
|
+ func0, func1, data0, data1);
|
|
|
+}
|
|
|
+
|
|
|
+static inline void *weak_source_ref(void *ref)
|
|
|
+{
|
|
|
+ return obs_source_get_weak_source(ref);
|
|
|
+}
|
|
|
+
|
|
|
+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)
|
|
|
+{
|
|
|
+ if (!source) return OBS_INVALID_HOTKEY_PAIR_ID;
|
|
|
+ return register_hotkey_pair_internal(
|
|
|
+ OBS_HOTKEY_REGISTERER_SOURCE, source,
|
|
|
+ weak_source_ref,
|
|
|
+ &source->context,
|
|
|
+ name0, description0, name1, description1,
|
|
|
+ func0, func1, data0, data1);
|
|
|
+}
|
|
|
+
|
|
|
+typedef bool (*obs_hotkey_internal_enum_func)(void *data,
|
|
|
+ size_t idx, obs_hotkey_t *hotkey);
|
|
|
+
|
|
|
+static inline void enum_hotkeys(obs_hotkey_internal_enum_func func, void *data)
|
|
|
+{
|
|
|
+ const size_t num = obs->hotkeys.hotkeys.num;
|
|
|
+ obs_hotkey_t *array = obs->hotkeys.hotkeys.array;
|
|
|
+ for (size_t i = 0; i < num; i++) {
|
|
|
+ if (!func(data, i, &array[i]))
|
|
|
+ break;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+typedef bool (*obs_hotkey_pair_internal_enum_func)(size_t idx,
|
|
|
+ obs_hotkey_pair_t *pair, void *data);
|
|
|
+
|
|
|
+static inline void enum_hotkey_pairs(obs_hotkey_pair_internal_enum_func func,
|
|
|
+ void *data)
|
|
|
+{
|
|
|
+ const size_t num = obs->hotkeys.hotkey_pairs.num;
|
|
|
+ obs_hotkey_pair_t *array = obs->hotkeys.hotkey_pairs.array;
|
|
|
+ for (size_t i = 0; i < num; i++) {
|
|
|
+ if (!func(i, &array[i], data))
|
|
|
+ break;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+typedef bool (*obs_hotkey_binding_internal_enum_func)(void *data,
|
|
|
+ size_t idx, obs_hotkey_binding_t *binding);
|
|
|
+
|
|
|
+static inline void enum_bindings(obs_hotkey_binding_internal_enum_func func,
|
|
|
+ void *data)
|
|
|
+{
|
|
|
+ const size_t num = obs->hotkeys.bindings.num;
|
|
|
+ obs_hotkey_binding_t *array = obs->hotkeys.bindings.array;
|
|
|
+ for (size_t i = 0; i < num; i++) {
|
|
|
+ if (!func(data, i, &array[i]))
|
|
|
+ break;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+struct obs_hotkey_internal_find_forward {
|
|
|
+ obs_hotkey_id id;
|
|
|
+ bool found;
|
|
|
+ size_t idx;
|
|
|
+};
|
|
|
+
|
|
|
+static inline bool find_id_helper(void *data, size_t idx, obs_hotkey_t *hotkey)
|
|
|
+{
|
|
|
+ struct obs_hotkey_internal_find_forward *find = data;
|
|
|
+ if (hotkey->id != find->id)
|
|
|
+ return true;
|
|
|
+
|
|
|
+ find->idx = idx;
|
|
|
+ find->found = true;
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+static inline bool find_id(obs_hotkey_id id, size_t *idx)
|
|
|
+{
|
|
|
+ struct obs_hotkey_internal_find_forward find = {id, false, 0};
|
|
|
+ enum_hotkeys(find_id_helper, &find);
|
|
|
+ *idx = find.idx;
|
|
|
+ return find.found;
|
|
|
+}
|
|
|
+
|
|
|
+static inline bool pointer_fixup_func(void *data,
|
|
|
+ size_t idx, obs_hotkey_binding_t *binding)
|
|
|
+{
|
|
|
+ UNUSED_PARAMETER(idx);
|
|
|
+ UNUSED_PARAMETER(data);
|
|
|
+
|
|
|
+ size_t idx_;
|
|
|
+ if (!find_id(binding->hotkey_id, &idx_)) {
|
|
|
+ bcrash("obs-hotkey: Could not find hotkey id '%" PRIuMAX "' "
|
|
|
+ "for binding '%s' (modifiers 0x%x)",
|
|
|
+ (uintmax_t)binding->hotkey_id,
|
|
|
+ obs_key_to_name(binding->key.key),
|
|
|
+ binding->key.modifiers);
|
|
|
+ binding->hotkey = NULL;
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ binding->hotkey = &obs->hotkeys.hotkeys.array[idx_];
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+static inline void fixup_pointers(void)
|
|
|
+{
|
|
|
+ enum_bindings(pointer_fixup_func, NULL);
|
|
|
+}
|
|
|
+
|
|
|
+struct obs_hotkey_internal_find_pair_forward {
|
|
|
+ obs_hotkey_pair_id id;
|
|
|
+ bool found;
|
|
|
+ size_t idx;
|
|
|
+};
|
|
|
+
|
|
|
+static inline bool find_pair_id_helper(size_t idx, obs_hotkey_pair_t *pair,
|
|
|
+ void *data)
|
|
|
+{
|
|
|
+ struct obs_hotkey_internal_find_pair_forward *find = data;
|
|
|
+ if (pair->pair_id != find->id)
|
|
|
+ return true;
|
|
|
+
|
|
|
+ find->idx = idx;
|
|
|
+ find->found = true;
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+static inline bool find_pair_id(obs_hotkey_pair_id id, size_t *idx)
|
|
|
+{
|
|
|
+ struct obs_hotkey_internal_find_pair_forward find = {id, false, 0};
|
|
|
+ enum_hotkey_pairs(find_pair_id_helper, &find);
|
|
|
+ *idx = find.idx;
|
|
|
+ return find.found;
|
|
|
+}
|
|
|
+
|
|
|
+static inline bool pair_pointer_fixup_func(size_t idx,
|
|
|
+ obs_hotkey_pair_t *pair, void *data)
|
|
|
+{
|
|
|
+ UNUSED_PARAMETER(idx);
|
|
|
+ UNUSED_PARAMETER(data);
|
|
|
+
|
|
|
+ if (find_id(pair->id[0], &idx))
|
|
|
+ obs->hotkeys.hotkeys.array[idx].data = pair;
|
|
|
+
|
|
|
+ if (find_id(pair->id[1], &idx))
|
|
|
+ obs->hotkeys.hotkeys.array[idx].data = pair;
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+static inline void fixup_pair_pointers(void)
|
|
|
+{
|
|
|
+ enum_hotkey_pairs(pair_pointer_fixup_func, NULL);
|
|
|
+}
|
|
|
+
|
|
|
+static inline void enum_context_hotkeys(struct obs_context_data *context,
|
|
|
+ obs_hotkey_internal_enum_func func, void *data)
|
|
|
+{
|
|
|
+ const size_t num = context->hotkeys.num;
|
|
|
+ const obs_hotkey_id *array = context->hotkeys.array;
|
|
|
+ obs_hotkey_t *hotkey_array = obs->hotkeys.hotkeys.array;
|
|
|
+ for (size_t i = 0; i < num; i++) {
|
|
|
+ size_t idx;
|
|
|
+ if (!find_id(array[i], &idx))
|
|
|
+ continue;
|
|
|
+
|
|
|
+ if (!func(data, idx, &hotkey_array[idx]))
|
|
|
+ break;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static inline void load_modifier(uint32_t *modifiers, obs_data_t *data,
|
|
|
+ const char *name, uint32_t flag)
|
|
|
+{
|
|
|
+ if (obs_data_get_bool(data, name))
|
|
|
+ *modifiers |= flag;
|
|
|
+}
|
|
|
+
|
|
|
+static inline void create_binding(obs_hotkey_t *hotkey,
|
|
|
+ obs_key_combination_t combo)
|
|
|
+{
|
|
|
+ obs_hotkey_binding_t *binding = da_push_back_new(obs->hotkeys.bindings);
|
|
|
+ if (!binding)
|
|
|
+ return;
|
|
|
+
|
|
|
+ binding->key = combo;
|
|
|
+ binding->hotkey_id = hotkey->id;
|
|
|
+ binding->hotkey = hotkey;
|
|
|
+}
|
|
|
+
|
|
|
+static inline void load_binding(obs_hotkey_t *hotkey, obs_data_t *data)
|
|
|
+{
|
|
|
+ if (!hotkey || !data)
|
|
|
+ return;
|
|
|
+
|
|
|
+ obs_key_combination_t combo = {0};
|
|
|
+ uint32_t *modifiers = &combo.modifiers;
|
|
|
+ load_modifier(modifiers, data, "shift", INTERACT_SHIFT_KEY);
|
|
|
+ load_modifier(modifiers, data, "control", INTERACT_CONTROL_KEY);
|
|
|
+ load_modifier(modifiers, data, "alt", INTERACT_ALT_KEY);
|
|
|
+ load_modifier(modifiers, data, "command", INTERACT_COMMAND_KEY);
|
|
|
+
|
|
|
+ combo.key = obs_key_from_name(obs_data_get_string(data, "key"));
|
|
|
+ if (!modifiers && (combo.key == OBS_KEY_NONE ||
|
|
|
+ combo.key >= OBS_KEY_LAST_VALUE))
|
|
|
+ return;
|
|
|
+
|
|
|
+ create_binding(hotkey, combo);
|
|
|
+}
|
|
|
+
|
|
|
+static inline void load_bindings(obs_hotkey_t *hotkey, obs_data_array_t *data)
|
|
|
+{
|
|
|
+ const size_t count = obs_data_array_count(data);
|
|
|
+ for (size_t i = 0; i < count; i++) {
|
|
|
+ obs_data_t *item = obs_data_array_item(data, i);
|
|
|
+ load_binding(hotkey, item);
|
|
|
+ obs_data_release(item);
|
|
|
+ }
|
|
|
+
|
|
|
+ hotkey_signal("hotkey_bindings_changed", hotkey);
|
|
|
+}
|
|
|
+
|
|
|
+static inline void remove_bindings(obs_hotkey_id id);
|
|
|
+
|
|
|
+void obs_hotkey_load_bindings(obs_hotkey_id id,
|
|
|
+ obs_key_combination_t *combinations, size_t num)
|
|
|
+{
|
|
|
+ size_t idx;
|
|
|
+
|
|
|
+ if (!lock())
|
|
|
+ return;
|
|
|
+
|
|
|
+ if (find_id(id, &idx)) {
|
|
|
+ obs_hotkey_t *hotkey = &obs->hotkeys.hotkeys.array[idx];
|
|
|
+ remove_bindings(id);
|
|
|
+ for (size_t i = 0; i < num; i++)
|
|
|
+ create_binding(hotkey, combinations[i]);
|
|
|
+
|
|
|
+ hotkey_signal("hotkey_bindings_changed", hotkey);
|
|
|
+ }
|
|
|
+ unlock();
|
|
|
+}
|
|
|
+
|
|
|
+void obs_hotkey_load(obs_hotkey_id id, obs_data_array_t *data)
|
|
|
+{
|
|
|
+ size_t idx;
|
|
|
+
|
|
|
+ if (!lock())
|
|
|
+ return;
|
|
|
+
|
|
|
+ if (find_id(id, &idx)) {
|
|
|
+ remove_bindings(id);
|
|
|
+ load_bindings(&obs->hotkeys.hotkeys.array[idx], data);
|
|
|
+ }
|
|
|
+ unlock();
|
|
|
+}
|
|
|
+
|
|
|
+static inline bool enum_load_bindings(void *data,
|
|
|
+ size_t idx, obs_hotkey_t *hotkey)
|
|
|
+{
|
|
|
+ UNUSED_PARAMETER(idx);
|
|
|
+
|
|
|
+ obs_data_array_t *hotkey_data = obs_data_get_array(data, hotkey->name);
|
|
|
+ if (!hotkey_data)
|
|
|
+ return true;
|
|
|
+
|
|
|
+ load_bindings(hotkey, hotkey_data);
|
|
|
+ obs_data_array_release(hotkey_data);
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+void obs_hotkeys_load_encoder(obs_encoder_t *encoder, obs_data_t *hotkeys)
|
|
|
+{
|
|
|
+ if (!encoder || !hotkeys)
|
|
|
+ return;
|
|
|
+ if (!lock())
|
|
|
+ return;
|
|
|
+
|
|
|
+ enum_context_hotkeys(&encoder->context, enum_load_bindings, hotkeys);
|
|
|
+ unlock();
|
|
|
+}
|
|
|
+
|
|
|
+void obs_hotkeys_load_output(obs_output_t *output, obs_data_t *hotkeys)
|
|
|
+{
|
|
|
+ if (!output || !hotkeys)
|
|
|
+ return;
|
|
|
+ if (!lock())
|
|
|
+ return;
|
|
|
+
|
|
|
+ enum_context_hotkeys(&output->context, enum_load_bindings, hotkeys);
|
|
|
+ unlock();
|
|
|
+}
|
|
|
+
|
|
|
+void obs_hotkeys_load_service(obs_service_t *service, obs_data_t *hotkeys)
|
|
|
+{
|
|
|
+ if (!service || !hotkeys)
|
|
|
+ return;
|
|
|
+ if (!lock())
|
|
|
+ return;
|
|
|
+
|
|
|
+ enum_context_hotkeys(&service->context, enum_load_bindings, hotkeys);
|
|
|
+ unlock();
|
|
|
+}
|
|
|
+
|
|
|
+void obs_hotkeys_load_source(obs_source_t *source, obs_data_t *hotkeys)
|
|
|
+{
|
|
|
+ if (!source || !hotkeys)
|
|
|
+ return;
|
|
|
+ if (!lock())
|
|
|
+ return;
|
|
|
+
|
|
|
+ enum_context_hotkeys(&source->context, enum_load_bindings, hotkeys);
|
|
|
+ unlock();
|
|
|
+}
|
|
|
+
|
|
|
+void obs_hotkey_pair_load(obs_hotkey_pair_id id, obs_data_array_t *data0,
|
|
|
+ obs_data_array_t *data1)
|
|
|
+{
|
|
|
+ if ((!data0 && !data1) || !lock())
|
|
|
+ return;
|
|
|
+
|
|
|
+ size_t idx;
|
|
|
+ if (!find_pair_id(id, &idx))
|
|
|
+ goto unlock;
|
|
|
+
|
|
|
+ obs_hotkey_pair_t *pair = &obs->hotkeys.hotkey_pairs.array[idx];
|
|
|
+
|
|
|
+ if (find_id(pair->id[0], &idx)) {
|
|
|
+ remove_bindings(pair->id[0]);
|
|
|
+ load_bindings(&obs->hotkeys.hotkeys.array[idx], data0);
|
|
|
+ }
|
|
|
+ if (find_id(pair->id[1], &idx)) {
|
|
|
+ remove_bindings(pair->id[1]);
|
|
|
+ load_bindings(&obs->hotkeys.hotkeys.array[idx], data1);
|
|
|
+ }
|
|
|
+
|
|
|
+unlock:
|
|
|
+ unlock();
|
|
|
+}
|
|
|
+
|
|
|
+static inline void save_modifier(uint32_t modifiers, obs_data_t *data,
|
|
|
+ const char *name, uint32_t flag)
|
|
|
+{
|
|
|
+ if ((modifiers & flag) == flag)
|
|
|
+ obs_data_set_bool(data, name, true);
|
|
|
+}
|
|
|
+
|
|
|
+struct save_bindings_helper_t {
|
|
|
+ obs_data_array_t *array;
|
|
|
+ obs_hotkey_t *hotkey;
|
|
|
+};
|
|
|
+
|
|
|
+static inline bool save_bindings_helper(void *data,
|
|
|
+ size_t idx, obs_hotkey_binding_t *binding)
|
|
|
+{
|
|
|
+ UNUSED_PARAMETER(idx);
|
|
|
+ struct save_bindings_helper_t *h = data;
|
|
|
+
|
|
|
+ if (h->hotkey->id != binding->hotkey_id)
|
|
|
+ return true;
|
|
|
+
|
|
|
+ obs_data_t *hotkey = obs_data_create();
|
|
|
+
|
|
|
+ uint32_t modifiers = binding->key.modifiers;
|
|
|
+ save_modifier(modifiers, hotkey, "shift", INTERACT_SHIFT_KEY);
|
|
|
+ save_modifier(modifiers, hotkey, "control", INTERACT_CONTROL_KEY);
|
|
|
+ save_modifier(modifiers, hotkey, "alt", INTERACT_ALT_KEY);
|
|
|
+ save_modifier(modifiers, hotkey, "command", INTERACT_COMMAND_KEY);
|
|
|
+
|
|
|
+ obs_data_set_string(hotkey, "key", obs_key_to_name(binding->key.key));
|
|
|
+
|
|
|
+ obs_data_array_push_back(h->array, hotkey);
|
|
|
+
|
|
|
+ obs_data_release(hotkey);
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+static inline obs_data_array_t *save_hotkey(obs_hotkey_t *hotkey)
|
|
|
+{
|
|
|
+ obs_data_array_t *data = obs_data_array_create();
|
|
|
+
|
|
|
+ struct save_bindings_helper_t arg = {data, hotkey};
|
|
|
+ enum_bindings(save_bindings_helper, &arg);
|
|
|
+
|
|
|
+ return data;
|
|
|
+}
|
|
|
+
|
|
|
+obs_data_array_t *obs_hotkey_save(obs_hotkey_id id)
|
|
|
+{
|
|
|
+ size_t idx;
|
|
|
+ obs_data_array_t *result = NULL;
|
|
|
+
|
|
|
+ if (!lock())
|
|
|
+ return result;
|
|
|
+
|
|
|
+ if (find_id(id, &idx))
|
|
|
+ result = save_hotkey(&obs->hotkeys.hotkeys.array[idx]);
|
|
|
+ unlock();
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+static inline bool enum_save_hotkey(void *data,
|
|
|
+ size_t idx, obs_hotkey_t *hotkey)
|
|
|
+{
|
|
|
+ UNUSED_PARAMETER(idx);
|
|
|
+
|
|
|
+ obs_data_array_t *hotkey_data = save_hotkey(hotkey);
|
|
|
+ obs_data_set_array(data, hotkey->name, hotkey_data);
|
|
|
+ obs_data_array_release(hotkey_data);
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+static inline obs_data_t *save_context_hotkeys(struct obs_context_data *context)
|
|
|
+{
|
|
|
+ if (!context->hotkeys.num)
|
|
|
+ return NULL;
|
|
|
+
|
|
|
+ obs_data_t *result = obs_data_create();
|
|
|
+ enum_context_hotkeys(context, enum_save_hotkey, result);
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+obs_data_t *obs_hotkeys_save_encoder(obs_encoder_t *encoder)
|
|
|
+{
|
|
|
+ obs_data_t *result = NULL;
|
|
|
+
|
|
|
+ if (!lock())
|
|
|
+ return result;
|
|
|
+
|
|
|
+ result = save_context_hotkeys(&encoder->context);
|
|
|
+ unlock();
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+obs_data_t *obs_hotkeys_save_output(obs_output_t *output)
|
|
|
+{
|
|
|
+ obs_data_t *result = NULL;
|
|
|
+
|
|
|
+ if (!lock())
|
|
|
+ return result;
|
|
|
+
|
|
|
+ result = save_context_hotkeys(&output->context);
|
|
|
+ unlock();
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+obs_data_t *obs_hotkeys_save_service(obs_service_t *service)
|
|
|
+{
|
|
|
+ obs_data_t *result = NULL;
|
|
|
+
|
|
|
+ if (!lock())
|
|
|
+ return result;
|
|
|
+
|
|
|
+ result = save_context_hotkeys(&service->context);
|
|
|
+ unlock();
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+obs_data_t *obs_hotkeys_save_source(obs_source_t *source)
|
|
|
+{
|
|
|
+ obs_data_t *result = NULL;
|
|
|
+
|
|
|
+ if (!lock())
|
|
|
+ return result;
|
|
|
+
|
|
|
+ result = save_context_hotkeys(&source->context);
|
|
|
+ unlock();
|
|
|
+
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+struct binding_find_data {
|
|
|
+ obs_hotkey_id id;
|
|
|
+ size_t *idx;
|
|
|
+ bool found;
|
|
|
+};
|
|
|
+
|
|
|
+static inline bool binding_finder(void *data,
|
|
|
+ size_t idx, obs_hotkey_binding_t *binding)
|
|
|
+{
|
|
|
+ struct binding_find_data *find = data;
|
|
|
+ if (binding->hotkey_id != find->id)
|
|
|
+ return true;
|
|
|
+
|
|
|
+ *find->idx = idx;
|
|
|
+ find->found = true;
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+static inline bool find_binding(obs_hotkey_id id, size_t *idx)
|
|
|
+{
|
|
|
+ struct binding_find_data data = {id, idx, false};
|
|
|
+ enum_bindings(binding_finder, &data);
|
|
|
+ return data.found;
|
|
|
+}
|
|
|
+
|
|
|
+static inline void release_pressed_binding(obs_hotkey_binding_t *binding);
|
|
|
+
|
|
|
+static inline void remove_bindings(obs_hotkey_id id)
|
|
|
+{
|
|
|
+ size_t idx;
|
|
|
+ while (find_binding(id, &idx)) {
|
|
|
+ obs_hotkey_binding_t *binding =
|
|
|
+ &obs->hotkeys.bindings.array[idx];
|
|
|
+
|
|
|
+ if (binding->pressed)
|
|
|
+ release_pressed_binding(binding);
|
|
|
+
|
|
|
+ da_erase(obs->hotkeys.bindings, idx);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static void release_registerer(obs_hotkey_t *hotkey)
|
|
|
+{
|
|
|
+ switch (hotkey->registerer_type) {
|
|
|
+ case OBS_HOTKEY_REGISTERER_FRONTEND:
|
|
|
+ break;
|
|
|
+
|
|
|
+ case OBS_HOTKEY_REGISTERER_ENCODER:
|
|
|
+ obs_weak_encoder_release(hotkey->registerer);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case OBS_HOTKEY_REGISTERER_OUTPUT:
|
|
|
+ obs_weak_output_release(hotkey->registerer);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case OBS_HOTKEY_REGISTERER_SERVICE:
|
|
|
+ obs_weak_service_release(hotkey->registerer);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case OBS_HOTKEY_REGISTERER_SOURCE:
|
|
|
+ obs_weak_source_release(hotkey->registerer);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ hotkey->registerer = NULL;
|
|
|
+}
|
|
|
+
|
|
|
+static inline bool unregister_hotkey(obs_hotkey_id id)
|
|
|
+{
|
|
|
+ if (id >= obs->hotkeys.next_id)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ size_t idx;
|
|
|
+ if (!find_id(id, &idx))
|
|
|
+ return false;
|
|
|
+
|
|
|
+ obs_hotkey_t *hotkey = &obs->hotkeys.hotkeys.array[idx];
|
|
|
+
|
|
|
+ hotkey_signal("hotkey_unregister", hotkey);
|
|
|
+
|
|
|
+ release_registerer(hotkey);
|
|
|
+
|
|
|
+ bfree(hotkey->name);
|
|
|
+ bfree(hotkey->description);
|
|
|
+
|
|
|
+ if (hotkey->registerer_type == OBS_HOTKEY_REGISTERER_SOURCE)
|
|
|
+ obs_weak_source_release(hotkey->registerer);
|
|
|
+
|
|
|
+ da_erase(obs->hotkeys.hotkeys, idx);
|
|
|
+ remove_bindings(id);
|
|
|
+
|
|
|
+ return obs->hotkeys.hotkeys.num >= idx;
|
|
|
+}
|
|
|
+
|
|
|
+static inline bool unregister_hotkey_pair(obs_hotkey_pair_id id)
|
|
|
+{
|
|
|
+ if (id >= obs->hotkeys.next_pair_id)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ size_t idx;
|
|
|
+ if (!find_pair_id(id, &idx))
|
|
|
+ return false;
|
|
|
+
|
|
|
+ obs_hotkey_pair_t *pair = &obs->hotkeys.hotkey_pairs.array[idx];
|
|
|
+
|
|
|
+ bool need_fixup = unregister_hotkey(pair->id[0]);
|
|
|
+ need_fixup = unregister_hotkey(pair->id[1]) || need_fixup;
|
|
|
+ if (need_fixup)
|
|
|
+ fixup_pointers();
|
|
|
+
|
|
|
+ da_erase(obs->hotkeys.hotkey_pairs, idx);
|
|
|
+ return obs->hotkeys.hotkey_pairs.num >= idx;
|
|
|
+}
|
|
|
+
|
|
|
+void obs_hotkey_unregister(obs_hotkey_id id)
|
|
|
+{
|
|
|
+ if (!lock())
|
|
|
+ return;
|
|
|
+ if (unregister_hotkey(id))
|
|
|
+ fixup_pointers();
|
|
|
+ unlock();
|
|
|
+}
|
|
|
+
|
|
|
+void obs_hotkey_pair_unregister(obs_hotkey_pair_id id)
|
|
|
+{
|
|
|
+ if (!lock())
|
|
|
+ return;
|
|
|
+
|
|
|
+ if (unregister_hotkey_pair(id))
|
|
|
+ fixup_pair_pointers();
|
|
|
+
|
|
|
+ unlock();
|
|
|
+}
|
|
|
+
|
|
|
+static void context_release_hotkeys(struct obs_context_data *context)
|
|
|
+{
|
|
|
+ if (!context->hotkeys.num)
|
|
|
+ goto cleanup;
|
|
|
+
|
|
|
+ bool need_fixup = false;
|
|
|
+ for (size_t i = 0; i < context->hotkeys.num; i++)
|
|
|
+ need_fixup = unregister_hotkey(context->hotkeys.array[i]) ||
|
|
|
+ need_fixup;
|
|
|
+
|
|
|
+ if (need_fixup)
|
|
|
+ fixup_pointers();
|
|
|
+
|
|
|
+cleanup:
|
|
|
+ da_free(context->hotkeys);
|
|
|
+}
|
|
|
+
|
|
|
+static void context_release_hotkey_pairs(struct obs_context_data *context)
|
|
|
+{
|
|
|
+ if (!context->hotkey_pairs.num)
|
|
|
+ goto cleanup;
|
|
|
+
|
|
|
+ bool need_fixup = false;
|
|
|
+ for (size_t i = 0; i < context->hotkey_pairs.num; i++)
|
|
|
+ need_fixup =
|
|
|
+ unregister_hotkey_pair(context->hotkey_pairs.array[i])
|
|
|
+ || need_fixup;
|
|
|
+
|
|
|
+ if (need_fixup)
|
|
|
+ fixup_pair_pointers();
|
|
|
+
|
|
|
+cleanup:
|
|
|
+ da_free(context->hotkey_pairs);
|
|
|
+}
|
|
|
+
|
|
|
+void obs_hotkeys_context_release(struct obs_context_data *context)
|
|
|
+{
|
|
|
+ if (!lock())
|
|
|
+ return;
|
|
|
+
|
|
|
+ context_release_hotkeys(context);
|
|
|
+ context_release_hotkey_pairs(context);
|
|
|
+
|
|
|
+ obs_data_release(context->hotkey_data);
|
|
|
+ unlock();
|
|
|
+}
|
|
|
+
|
|
|
+void obs_hotkeys_free(void)
|
|
|
+{
|
|
|
+ const size_t num = obs->hotkeys.hotkeys.num;
|
|
|
+ obs_hotkey_t *hotkeys = obs->hotkeys.hotkeys.array;
|
|
|
+ for (size_t i = 0; i < num; i++) {
|
|
|
+ bfree(hotkeys[i].name);
|
|
|
+ bfree(hotkeys[i].description);
|
|
|
+
|
|
|
+ release_registerer(&hotkeys[i]);
|
|
|
+ }
|
|
|
+ da_free(obs->hotkeys.bindings);
|
|
|
+ da_free(obs->hotkeys.hotkeys);
|
|
|
+ da_free(obs->hotkeys.hotkey_pairs);
|
|
|
+
|
|
|
+ for (size_t i = 0; i < OBS_KEY_LAST_VALUE; i++) {
|
|
|
+ if (obs->hotkeys.translations[i]) {
|
|
|
+ bfree(obs->hotkeys.translations[i]);
|
|
|
+ obs->hotkeys.translations[i] = NULL;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+struct obs_hotkey_internal_enum_forward {
|
|
|
+ obs_hotkey_enum_func func;
|
|
|
+ void *data;
|
|
|
+};
|
|
|
+
|
|
|
+static inline bool enum_hotkey(void *data, size_t idx, obs_hotkey_t *hotkey)
|
|
|
+{
|
|
|
+ UNUSED_PARAMETER(idx);
|
|
|
+
|
|
|
+ struct obs_hotkey_internal_enum_forward *forward = data;
|
|
|
+ return forward->func(forward->data, hotkey->id, hotkey);
|
|
|
+}
|
|
|
+
|
|
|
+void obs_enum_hotkeys(obs_hotkey_enum_func func, void *data)
|
|
|
+{
|
|
|
+ struct obs_hotkey_internal_enum_forward forwarder = {func, data};
|
|
|
+ if (!lock())
|
|
|
+ return;
|
|
|
+
|
|
|
+ enum_hotkeys(enum_hotkey, &forwarder);
|
|
|
+ unlock();
|
|
|
+}
|
|
|
+
|
|
|
+void obs_enum_hotkey_bindings(obs_hotkey_binding_enum_func func, void *data)
|
|
|
+{
|
|
|
+ if (!lock())
|
|
|
+ return;
|
|
|
+
|
|
|
+ enum_bindings(func, data);
|
|
|
+ unlock();
|
|
|
+}
|
|
|
+
|
|
|
+static inline bool modifiers_match(obs_hotkey_binding_t *binding,
|
|
|
+ uint32_t modifiers_, bool strict_modifiers)
|
|
|
+{
|
|
|
+ uint32_t modifiers = binding->key.modifiers;
|
|
|
+ return !modifiers ||
|
|
|
+ (!strict_modifiers && (modifiers & modifiers_) == modifiers) ||
|
|
|
+ (strict_modifiers && modifiers == modifiers_);
|
|
|
+}
|
|
|
+
|
|
|
+static inline bool is_pressed(obs_key_t key)
|
|
|
+{
|
|
|
+ return obs_hotkeys_platform_is_pressed(obs->hotkeys.platform_context,
|
|
|
+ key);
|
|
|
+}
|
|
|
+
|
|
|
+static inline void press_released_binding(obs_hotkey_binding_t *binding)
|
|
|
+{
|
|
|
+ binding->pressed = true;
|
|
|
+
|
|
|
+ obs_hotkey_t *hotkey = binding->hotkey;
|
|
|
+ if (hotkey->pressed++)
|
|
|
+ return;
|
|
|
+
|
|
|
+ if (!obs->hotkeys.reroute_hotkeys)
|
|
|
+ hotkey->func(hotkey->data, hotkey->id, hotkey, true);
|
|
|
+ else if (obs->hotkeys.router_func)
|
|
|
+ obs->hotkeys.router_func(obs->hotkeys.router_func_data,
|
|
|
+ hotkey->id, true);
|
|
|
+}
|
|
|
+
|
|
|
+static inline void release_pressed_binding(obs_hotkey_binding_t *binding)
|
|
|
+{
|
|
|
+ binding->pressed = false;
|
|
|
+
|
|
|
+ obs_hotkey_t *hotkey = binding->hotkey;
|
|
|
+ if (--hotkey->pressed)
|
|
|
+ return;
|
|
|
+
|
|
|
+ if (!obs->hotkeys.reroute_hotkeys)
|
|
|
+ hotkey->func(hotkey->data, hotkey->id, hotkey, false);
|
|
|
+ else if (obs->hotkeys.router_func)
|
|
|
+ obs->hotkeys.router_func(obs->hotkeys.router_func_data,
|
|
|
+ hotkey->id, false);
|
|
|
+}
|
|
|
+
|
|
|
+static inline void handle_binding(obs_hotkey_binding_t *binding,
|
|
|
+ uint32_t modifiers, bool no_press, bool strict_modifiers,
|
|
|
+ bool *pressed)
|
|
|
+{
|
|
|
+ bool modifiers_match_ = modifiers_match(binding, modifiers,
|
|
|
+ strict_modifiers);
|
|
|
+ bool modifiers_only = binding->key.key == OBS_KEY_NONE;
|
|
|
+
|
|
|
+ if (!binding->key.modifiers)
|
|
|
+ binding->modifiers_match = true;
|
|
|
+
|
|
|
+ if (modifiers_only)
|
|
|
+ pressed = &modifiers_only;
|
|
|
+
|
|
|
+ if (!binding->key.modifiers && modifiers_only)
|
|
|
+ goto reset;
|
|
|
+
|
|
|
+ if ((!binding->modifiers_match && !modifiers_only) || !modifiers_match_)
|
|
|
+ goto reset;
|
|
|
+
|
|
|
+ if ((pressed && !*pressed) ||
|
|
|
+ (!pressed && !is_pressed(binding->key.key)))
|
|
|
+ goto reset;
|
|
|
+
|
|
|
+ if (binding->pressed || no_press)
|
|
|
+ return;
|
|
|
+
|
|
|
+ press_released_binding(binding);
|
|
|
+ return;
|
|
|
+
|
|
|
+reset:
|
|
|
+ binding->modifiers_match = modifiers_match_;
|
|
|
+ if (!binding->pressed)
|
|
|
+ return;
|
|
|
+
|
|
|
+ release_pressed_binding(binding);
|
|
|
+}
|
|
|
+
|
|
|
+struct obs_hotkey_internal_inject {
|
|
|
+ obs_key_combination_t hotkey;
|
|
|
+ bool pressed : 1;
|
|
|
+ bool strict_modifiers : 1;
|
|
|
+};
|
|
|
+
|
|
|
+static inline bool inject_hotkey(void *data,
|
|
|
+ size_t idx, obs_hotkey_binding_t *binding)
|
|
|
+{
|
|
|
+ UNUSED_PARAMETER(idx);
|
|
|
+ struct obs_hotkey_internal_inject *event = data;
|
|
|
+
|
|
|
+ if (modifiers_match(binding, event->hotkey.modifiers,
|
|
|
+ event->strict_modifiers)) {
|
|
|
+ bool pressed = binding->key.key == event->hotkey.key &&
|
|
|
+ event->pressed;
|
|
|
+ handle_binding(binding, event->hotkey.modifiers, false,
|
|
|
+ event->strict_modifiers, &pressed);
|
|
|
+ }
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+void obs_hotkey_inject_event(obs_key_combination_t hotkey, bool pressed)
|
|
|
+{
|
|
|
+ if (!lock())
|
|
|
+ return;
|
|
|
+
|
|
|
+ struct obs_hotkey_internal_inject event = {
|
|
|
+ {hotkey.modifiers, hotkey.key},
|
|
|
+ pressed, obs->hotkeys.strict_modifiers,
|
|
|
+ };
|
|
|
+ enum_bindings(inject_hotkey, &event);
|
|
|
+ unlock();
|
|
|
+}
|
|
|
+
|
|
|
+void obs_hotkey_enable_background_press(bool enable)
|
|
|
+{
|
|
|
+ if (!lock())
|
|
|
+ return;
|
|
|
+
|
|
|
+ obs->hotkeys.thread_disable_press = !enable;
|
|
|
+ unlock();
|
|
|
+}
|
|
|
+
|
|
|
+void obs_hotkey_enable_strict_modifiers(bool enable)
|
|
|
+{
|
|
|
+ if (!lock())
|
|
|
+ return;
|
|
|
+
|
|
|
+ obs->hotkeys.strict_modifiers = enable;
|
|
|
+ unlock();
|
|
|
+}
|
|
|
+
|
|
|
+struct obs_query_hotkeys_helper {
|
|
|
+ uint32_t modifiers;
|
|
|
+ bool no_press : 1;
|
|
|
+ bool strict_modifiers : 1;
|
|
|
+};
|
|
|
+
|
|
|
+static inline bool query_hotkey(void *data,
|
|
|
+ size_t idx, obs_hotkey_binding_t *binding)
|
|
|
+{
|
|
|
+ UNUSED_PARAMETER(idx);
|
|
|
+
|
|
|
+ struct obs_query_hotkeys_helper *param =
|
|
|
+ (struct obs_query_hotkeys_helper*)data;
|
|
|
+ handle_binding(binding, param->modifiers, param->no_press,
|
|
|
+ param->strict_modifiers, NULL);
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+static inline void query_hotkeys()
|
|
|
+{
|
|
|
+ uint32_t modifiers = 0;
|
|
|
+ if (is_pressed(OBS_KEY_SHIFT))
|
|
|
+ modifiers |= INTERACT_SHIFT_KEY;
|
|
|
+ if (is_pressed(OBS_KEY_CONTROL))
|
|
|
+ modifiers |= INTERACT_CONTROL_KEY;
|
|
|
+ if (is_pressed(OBS_KEY_ALT))
|
|
|
+ modifiers |= INTERACT_ALT_KEY;
|
|
|
+ if (is_pressed(OBS_KEY_META))
|
|
|
+ modifiers |= INTERACT_COMMAND_KEY;
|
|
|
+
|
|
|
+ struct obs_query_hotkeys_helper param = {
|
|
|
+ modifiers,
|
|
|
+ obs->hotkeys.thread_disable_press,
|
|
|
+ obs->hotkeys.strict_modifiers,
|
|
|
+ };
|
|
|
+ enum_bindings(query_hotkey, ¶m);
|
|
|
+}
|
|
|
+
|
|
|
+void *obs_hotkey_thread(void *arg)
|
|
|
+{
|
|
|
+ UNUSED_PARAMETER(arg);
|
|
|
+ while (os_event_timedwait(obs->hotkeys.stop_event, 25) == ETIMEDOUT) {
|
|
|
+ if (!lock())
|
|
|
+ continue;
|
|
|
+
|
|
|
+ query_hotkeys();
|
|
|
+ unlock();
|
|
|
+ }
|
|
|
+ return NULL;
|
|
|
+}
|
|
|
+
|
|
|
+void obs_hotkey_trigger_routed_callback(obs_hotkey_id id, bool pressed)
|
|
|
+{
|
|
|
+ if (!lock())
|
|
|
+ return;
|
|
|
+
|
|
|
+ if (!obs->hotkeys.reroute_hotkeys)
|
|
|
+ goto unlock;
|
|
|
+
|
|
|
+ size_t idx;
|
|
|
+ if (!find_id(id, &idx))
|
|
|
+ goto unlock;
|
|
|
+
|
|
|
+ obs_hotkey_t *hotkey = &obs->hotkeys.hotkeys.array[idx];
|
|
|
+ hotkey->func(hotkey->data, id, hotkey, pressed);
|
|
|
+
|
|
|
+unlock:
|
|
|
+ unlock();
|
|
|
+}
|
|
|
+
|
|
|
+void obs_hotkey_set_callback_routing_func(obs_hotkey_callback_router_func func,
|
|
|
+ void *data)
|
|
|
+{
|
|
|
+ if (!lock())
|
|
|
+ return;
|
|
|
+
|
|
|
+ obs->hotkeys.router_func = func;
|
|
|
+ obs->hotkeys.router_func_data = data;
|
|
|
+ unlock();
|
|
|
+}
|
|
|
+
|
|
|
+void obs_hotkey_enable_callback_rerouting(bool enable)
|
|
|
+{
|
|
|
+ if (!lock())
|
|
|
+ return;
|
|
|
+
|
|
|
+ obs->hotkeys.reroute_hotkeys = enable;
|
|
|
+ unlock();
|
|
|
+}
|
|
|
+
|
|
|
+static void obs_set_key_translation(obs_key_t key, const char *translation)
|
|
|
+{
|
|
|
+ bfree(obs->hotkeys.translations[key]);
|
|
|
+ obs->hotkeys.translations[key] = NULL;
|
|
|
+
|
|
|
+ if (translation)
|
|
|
+ obs->hotkeys.translations[key] = bstrdup(translation);
|
|
|
+}
|
|
|
+
|
|
|
+void obs_hotkeys_set_translations_s(
|
|
|
+ struct obs_hotkeys_translations *translations, size_t size)
|
|
|
+{
|
|
|
+#define ADD_TRANSLATION(key_name, var_name) \
|
|
|
+ if (t.var_name) \
|
|
|
+ obs_set_key_translation(key_name, t.var_name);
|
|
|
+
|
|
|
+ struct obs_hotkeys_translations t = {0};
|
|
|
+ struct dstr numpad = {0};
|
|
|
+ struct dstr mouse = {0};
|
|
|
+ struct dstr button = {0};
|
|
|
+
|
|
|
+ if (!translations) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ memcpy(&t, translations, (size < sizeof(t)) ? size : sizeof(t));
|
|
|
+
|
|
|
+ ADD_TRANSLATION(OBS_KEY_INSERT, insert);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_DELETE, del);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_HOME, home);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_END, end);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_PAGEUP, page_up);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_PAGEDOWN, page_down);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_NUMLOCK, num_lock);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_SCROLLLOCK, scroll_lock);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_CAPSLOCK, caps_lock);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_BACKSPACE, backspace);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_TAB, tab);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_PRINT, print);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_PAUSE, pause);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_SHIFT, shift);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_ALT, alt);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_CONTROL, control);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_META, meta);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_MENU, menu);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_SPACE, space);
|
|
|
+#ifdef __APPLE__
|
|
|
+ const char *numpad_str = t.apple_keypad_num;
|
|
|
+ ADD_TRANSLATION(OBS_KEY_NUMSLASH, apple_keypad_divide);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_NUMASTERISK, apple_keypad_multiply);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_NUMMINUS, apple_keypad_minus);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_NUMPLUS, apple_keypad_plus);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_NUMPERIOD, apple_keypad_decimal);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_NUMEQUAL, apple_keypad_equal);
|
|
|
+#else
|
|
|
+ const char *numpad_str = t.numpad_num;
|
|
|
+ ADD_TRANSLATION(OBS_KEY_NUMSLASH, numpad_divide);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_NUMASTERISK, numpad_multiply);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_NUMMINUS, numpad_minus);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_NUMPLUS, numpad_plus);
|
|
|
+ ADD_TRANSLATION(OBS_KEY_NUMPERIOD, numpad_decimal);
|
|
|
+#endif
|
|
|
+
|
|
|
+ if (numpad_str) {
|
|
|
+ dstr_copy(&numpad, numpad_str);
|
|
|
+ dstr_depad(&numpad);
|
|
|
+
|
|
|
+ if (dstr_find(&numpad, "%1") == NULL) {
|
|
|
+ dstr_cat(&numpad, " %1");
|
|
|
+ }
|
|
|
+
|
|
|
+#define ADD_NUMPAD_NUM(idx) \
|
|
|
+ dstr_copy_dstr(&button, &numpad); \
|
|
|
+ dstr_replace(&button, "%1", #idx); \
|
|
|
+ obs_set_key_translation(OBS_KEY_NUM ## idx, button.array)
|
|
|
+
|
|
|
+ ADD_NUMPAD_NUM(0);
|
|
|
+ ADD_NUMPAD_NUM(1);
|
|
|
+ ADD_NUMPAD_NUM(2);
|
|
|
+ ADD_NUMPAD_NUM(3);
|
|
|
+ ADD_NUMPAD_NUM(4);
|
|
|
+ ADD_NUMPAD_NUM(5);
|
|
|
+ ADD_NUMPAD_NUM(6);
|
|
|
+ ADD_NUMPAD_NUM(7);
|
|
|
+ ADD_NUMPAD_NUM(8);
|
|
|
+ ADD_NUMPAD_NUM(9);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (t.mouse_num) {
|
|
|
+ dstr_copy(&mouse, t.mouse_num);
|
|
|
+ dstr_depad(&mouse);
|
|
|
+
|
|
|
+ if (dstr_find(&mouse, "%1") == NULL) {
|
|
|
+ dstr_cat(&mouse, " %1");
|
|
|
+ }
|
|
|
+
|
|
|
+#define ADD_MOUSE_NUM(idx) \
|
|
|
+ dstr_copy_dstr(&button, &mouse); \
|
|
|
+ dstr_replace(&button, "%1", #idx); \
|
|
|
+ obs_set_key_translation(OBS_KEY_MOUSE ## idx, button.array)
|
|
|
+
|
|
|
+ ADD_MOUSE_NUM(1);
|
|
|
+ ADD_MOUSE_NUM(2);
|
|
|
+ ADD_MOUSE_NUM(3);
|
|
|
+ ADD_MOUSE_NUM(4);
|
|
|
+ ADD_MOUSE_NUM(5);
|
|
|
+ ADD_MOUSE_NUM(6);
|
|
|
+ ADD_MOUSE_NUM(7);
|
|
|
+ ADD_MOUSE_NUM(8);
|
|
|
+ ADD_MOUSE_NUM(9);
|
|
|
+ ADD_MOUSE_NUM(10);
|
|
|
+ ADD_MOUSE_NUM(11);
|
|
|
+ ADD_MOUSE_NUM(12);
|
|
|
+ ADD_MOUSE_NUM(13);
|
|
|
+ ADD_MOUSE_NUM(14);
|
|
|
+ ADD_MOUSE_NUM(15);
|
|
|
+ ADD_MOUSE_NUM(16);
|
|
|
+ ADD_MOUSE_NUM(17);
|
|
|
+ ADD_MOUSE_NUM(18);
|
|
|
+ ADD_MOUSE_NUM(19);
|
|
|
+ ADD_MOUSE_NUM(20);
|
|
|
+ ADD_MOUSE_NUM(21);
|
|
|
+ ADD_MOUSE_NUM(22);
|
|
|
+ ADD_MOUSE_NUM(23);
|
|
|
+ ADD_MOUSE_NUM(24);
|
|
|
+ ADD_MOUSE_NUM(25);
|
|
|
+ ADD_MOUSE_NUM(26);
|
|
|
+ ADD_MOUSE_NUM(27);
|
|
|
+ ADD_MOUSE_NUM(28);
|
|
|
+ ADD_MOUSE_NUM(29);
|
|
|
+ }
|
|
|
+
|
|
|
+ dstr_free(&numpad);
|
|
|
+ dstr_free(&mouse);
|
|
|
+ dstr_free(&button);
|
|
|
+}
|
|
|
+
|
|
|
+const char *obs_get_hotkey_translation(obs_key_t key, const char *def)
|
|
|
+{
|
|
|
+ if (key == OBS_KEY_NONE) {
|
|
|
+ return NULL;
|
|
|
+ }
|
|
|
+
|
|
|
+ return obs->hotkeys.translations[key] ?
|
|
|
+ obs->hotkeys.translations[key] : def;
|
|
|
+}
|
|
|
+
|
|
|
+void obs_hotkey_update_atomic(obs_hotkey_atomic_update_func func, void *data)
|
|
|
+{
|
|
|
+ if (!lock()) return;
|
|
|
+
|
|
|
+ func(data);
|
|
|
+
|
|
|
+ unlock();
|
|
|
+}
|
Palana