393 lines
10 KiB
C
393 lines
10 KiB
C
/**
|
|
* arif/examples/arif_rime.c - example Rime IME integration for ARIF
|
|
* ----
|
|
*
|
|
* Copyright (C) 2023 CismonX <admin@cismon.net>
|
|
*
|
|
* This file is part of ARIF, Another Readline Input Framework.
|
|
*
|
|
* ARIF 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 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* ARIF 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 ARIF. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
# include "config.h"
|
|
#endif
|
|
|
|
#include "arif_rime.h"
|
|
|
|
#ifdef HAVE_RIME
|
|
|
|
#include <assert.h>
|
|
#include <limits.h>
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include <strings.h>
|
|
|
|
#include <rime_api.h>
|
|
|
|
#include "arif_defs.h"
|
|
|
|
#ifndef ARIF_RIME_APP_NAME
|
|
# define ARIF_RIME_APP_NAME "rime.arif"
|
|
#endif
|
|
#ifndef ARIF_RIME_DIST_NAME
|
|
# define ARIF_RIME_DIST_NAME "Rime"
|
|
#endif
|
|
#ifndef ARIF_RIME_DIST_CODE_NAME
|
|
# define ARIF_RIME_DIST_CODE_NAME "arif-rime"
|
|
#endif
|
|
|
|
#define VERSION_STR_(major, minor, patch) #major "." #minor "." #patch
|
|
#define VERSION_STR(major, minor, patch) VERSION_STR_(major, minor, patch)
|
|
|
|
#define XK_Down 0xff54 // #include <X11/keysym.h>
|
|
|
|
struct engine_ctx {
|
|
RimeSessionId session;
|
|
struct cand_entry *candidates;
|
|
bool no_more_candidates;
|
|
};
|
|
|
|
// Forward declaration start
|
|
static void arif_rime_finalize (void *);
|
|
static void arif_rime_info (void *, char const **, char const **);
|
|
static int arif_rime_init (void *, void **);
|
|
static int arif_rime_query (void *, char const *, int, int, int,
|
|
struct arif_cand const **);
|
|
static bool copy_candidate (struct arif_cand *, RimeContext *);
|
|
static int init_rime (void);
|
|
static void finalize_rime (void);
|
|
static void free_candidates (struct engine_ctx *);
|
|
static char const * gen_description (void);
|
|
static char const * get_env (char const *, char const *);
|
|
static int get_log_level (char const *);
|
|
static char const ** get_modules (char const *);
|
|
// Forward declaration end
|
|
|
|
struct cand_entry {
|
|
struct cand_entry *next;
|
|
int num_candidates;
|
|
struct arif_cand candidates[];
|
|
};
|
|
|
|
struct arif_engine const arif_rime_engine = {
|
|
.init = arif_rime_init,
|
|
.finalize = arif_rime_finalize,
|
|
.info = arif_rime_info,
|
|
.query = arif_rime_query,
|
|
};
|
|
|
|
static RimeApi *rime_api;
|
|
static char *rime_description;
|
|
static char const **rime_modules;
|
|
|
|
static void
|
|
arif_rime_finalize (
|
|
void *engine_data
|
|
) {
|
|
struct engine_ctx *ctx = engine_data;
|
|
|
|
free_candidates(ctx);
|
|
|
|
if (rime_api != NULL) {
|
|
rime_api->destroy_session(ctx->session);
|
|
}
|
|
|
|
free(ctx);
|
|
}
|
|
|
|
static void
|
|
arif_rime_info (
|
|
void *ARIF_UNUSED_ARG(engine_data),
|
|
char const **name_ptr,
|
|
char const **description_ptr
|
|
) {
|
|
if (name_ptr != NULL) {
|
|
*name_ptr = "rime";
|
|
}
|
|
if (description_ptr != NULL) {
|
|
*description_ptr = gen_description();
|
|
}
|
|
}
|
|
|
|
static int
|
|
arif_rime_init (
|
|
void *ARIF_UNUSED_ARG(args),
|
|
void **engine_data_ptr
|
|
) {
|
|
int status = init_rime();
|
|
if (status != 0) {
|
|
return status;
|
|
}
|
|
|
|
struct engine_ctx *ctx = malloc(sizeof(struct engine_ctx));
|
|
assert(ctx != NULL);
|
|
|
|
*ctx = (struct engine_ctx) {
|
|
.session = 0,
|
|
};
|
|
*engine_data_ptr = ctx;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
arif_rime_query (
|
|
void *engine_data,
|
|
char const *line,
|
|
int offset,
|
|
int len,
|
|
int num_candidates,
|
|
struct arif_cand const **candidates_ptr
|
|
) {
|
|
struct engine_ctx *ctx = engine_data;
|
|
|
|
if (line != NULL) {
|
|
free_candidates(ctx);
|
|
rime_api->destroy_session(ctx->session);
|
|
ctx->session = rime_api->create_session();
|
|
|
|
char const *text = line + offset;
|
|
for (int idx = 0; idx < len; ++idx) {
|
|
if (!rime_api->process_key(ctx->session, text[idx], 0)) {
|
|
return 0;
|
|
}
|
|
}
|
|
} else if (candidates_ptr == NULL) {
|
|
// TODO: handle candidate selection so that we can preserve a
|
|
// Rime session when possible.
|
|
return 0;
|
|
} else {
|
|
if (!rime_api->find_session(ctx->session)) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
size_t candidates_size = sizeof(struct arif_cand) * num_candidates;
|
|
struct cand_entry *entries
|
|
= malloc(sizeof(struct cand_entry) + candidates_size);
|
|
assert(entries != NULL);
|
|
entries->next = ctx->candidates;
|
|
ctx->candidates = entries;
|
|
|
|
int idx = 0;
|
|
for (; !ctx->no_more_candidates && idx < num_candidates; ++idx) {
|
|
RIME_STRUCT(RimeContext, rimectx);
|
|
if (!rime_api->get_context(ctx->session, &rimectx)) {
|
|
break;
|
|
}
|
|
|
|
struct arif_cand *candidate = entries->candidates + idx;
|
|
if (copy_candidate(candidate, &rimectx)) {
|
|
ctx->no_more_candidates = true;
|
|
}
|
|
|
|
rime_api->free_context(&rimectx);
|
|
|
|
if (!rime_api->process_key(ctx->session, XK_Down, 0)) {
|
|
ctx->no_more_candidates = true;
|
|
}
|
|
}
|
|
entries->num_candidates = idx;
|
|
*candidates_ptr = entries->candidates;
|
|
return idx;
|
|
}
|
|
|
|
static bool
|
|
copy_candidate (
|
|
struct arif_cand *dest,
|
|
RimeContext *src
|
|
) {
|
|
RimeMenu *menu = &src->menu;
|
|
RimeComposition *composition = &src->composition;
|
|
int candidate_idx = menu->highlighted_candidate_index;
|
|
|
|
char const *text = menu->candidates[candidate_idx].text;
|
|
int text_len = strlen(text);
|
|
char const *line = composition->preedit;
|
|
int line_len = strlen(line);
|
|
|
|
char *buf = malloc(text_len + line_len);
|
|
assert(buf != NULL);
|
|
|
|
dest->text = memcpy(buf, text, text_len);
|
|
dest->len = text_len;
|
|
dest->replace_len = composition->sel_end - composition->sel_start;
|
|
dest->transform = memcpy(buf + text_len, line, line_len);
|
|
dest->transform_len = line_len;
|
|
|
|
return menu->is_last_page && candidate_idx + 1 == menu->page_size;
|
|
}
|
|
|
|
static void
|
|
free_candidates (
|
|
struct engine_ctx *ctx
|
|
) {
|
|
struct cand_entry *entry, *next;
|
|
for (entry = ctx->candidates; entry != NULL; entry = next) {
|
|
for (int idx = 0; idx < entry->num_candidates; ++idx) {
|
|
struct arif_cand *candidate = entry->candidates + idx;
|
|
free((char *) candidate->text);
|
|
}
|
|
|
|
next = entry->next;
|
|
free(entry);
|
|
}
|
|
ctx->candidates = NULL;
|
|
}
|
|
|
|
static int
|
|
init_rime (void)
|
|
{
|
|
if (rime_api != NULL) {
|
|
return 0;
|
|
}
|
|
|
|
rime_api = rime_get_api();
|
|
if (rime_api == NULL) {
|
|
return -1;
|
|
}
|
|
|
|
RIME_STRUCT(RimeTraits, traits);
|
|
traits.app_name = ARIF_RIME_APP_NAME;
|
|
traits.distribution_name = ARIF_RIME_DIST_NAME;
|
|
traits.distribution_code_name = ARIF_RIME_DIST_CODE_NAME;
|
|
traits.distribution_version
|
|
= VERSION_STR(ARIF_VER_MAJOR, ARIF_VER_MINOR, ARIF_VER_PATCH);
|
|
traits.shared_data_dir
|
|
= get_env("ARIF_RIME_SHARED_DATA_DIR", "/usr/share/rime-data");
|
|
traits.user_data_dir = get_env("ARIF_RIME_USER_DATA_DIR", NULL);
|
|
traits.log_dir = get_env("ARIF_RIME_LOG_DIR", "/tmp");
|
|
traits.min_log_level = get_log_level("ARIF_RIME_LOG_LEVEL");
|
|
traits.modules = get_modules("ARIF_RIME_MODULES");
|
|
|
|
rime_api->setup(&traits);
|
|
rime_api->initialize(&traits);
|
|
|
|
// Rime uses static C++ variables to store its states, which get destroyed
|
|
// on exit. Make sure we finalize Rime API before that.
|
|
atexit(finalize_rime);
|
|
|
|
rime_modules = traits.modules;
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
finalize_rime (void)
|
|
{
|
|
if (rime_api != NULL) {
|
|
rime_api->finalize();
|
|
rime_api = NULL;
|
|
}
|
|
if (rime_modules != NULL) {
|
|
free((char *) rime_modules[0]);
|
|
free(rime_modules);
|
|
rime_modules = NULL;
|
|
}
|
|
free(rime_description);
|
|
}
|
|
|
|
static char const *
|
|
gen_description (void)
|
|
{
|
|
if (rime_description != NULL) {
|
|
return rime_description;
|
|
}
|
|
|
|
char const *fmt = "Example Rime integration for ARIF\n"
|
|
" Rime IME <https://rime.im/> version: %s\n";
|
|
char const *rime_version = rime_api->get_version();
|
|
if (rime_version == NULL) {
|
|
rime_version = "N/A";
|
|
}
|
|
|
|
int desc_len = snprintf(NULL, 0, fmt, rime_version);
|
|
assert(desc_len > 0);
|
|
|
|
rime_description = malloc(sizeof(char) * (desc_len + 1));
|
|
assert(rime_description != NULL);
|
|
sprintf(rime_description, fmt, rime_version);
|
|
|
|
return rime_description;
|
|
}
|
|
|
|
static char const *
|
|
get_env (
|
|
char const *name,
|
|
char const *default_val
|
|
) {
|
|
char const *val = getenv(name);
|
|
if (val == NULL || val[0] == '\0') {
|
|
val = default_val;
|
|
}
|
|
return val;
|
|
}
|
|
|
|
static int
|
|
get_log_level (
|
|
char const *env_name
|
|
) {
|
|
char const *log_level = get_env(env_name, "");
|
|
|
|
if (0 == strcasecmp("INFO", log_level)) {
|
|
return 0;
|
|
}
|
|
if (0 == strcasecmp("WARNING", log_level)) {
|
|
return 1;
|
|
}
|
|
if (0 == strcasecmp("ERROR", log_level)) {
|
|
return 2;
|
|
}
|
|
if (0 == strcasecmp("FATAL", log_level)) {
|
|
return 3;
|
|
}
|
|
return 2;
|
|
}
|
|
|
|
static char const **
|
|
get_modules (
|
|
char const *env_name
|
|
) {
|
|
char const *modules_env = get_env(env_name, NULL);
|
|
if (modules_env == NULL) {
|
|
return NULL;
|
|
}
|
|
size_t modules_len = strlen(modules_env) + 1;
|
|
|
|
char *modules_str = malloc(sizeof(char) * modules_len);
|
|
assert(modules_str != NULL);
|
|
memcpy(modules_str, modules_env, modules_len);
|
|
|
|
size_t modules_size = 4, idx = 0;
|
|
char const **modules = NULL;
|
|
|
|
char const *delim = " \n\t\r\v\f";
|
|
for (char *module = strtok(modules_str, delim); module != NULL;
|
|
module = strtok(NULL, delim)
|
|
) {
|
|
if (modules == NULL || idx == modules_size - 1) {
|
|
modules_size += modules_size / 2;
|
|
modules = realloc(modules, sizeof(char const *) * modules_size);
|
|
assert(modules != NULL);
|
|
}
|
|
modules[idx++] = module;
|
|
}
|
|
modules[idx] = NULL;
|
|
return modules;
|
|
}
|
|
|
|
#endif // defined(HAVE_RIME)
|