Fcitx
instance.cpp
1 /*
2  * SPDX-FileCopyrightText: 2016-2016 CSSlayer <wengxt@gmail.com>
3  *
4  * SPDX-License-Identifier: LGPL-2.1-or-later
5  *
6  */
7 #include "config.h"
8 
9 #include <fcntl.h>
10 #include <unistd.h>
11 #include <algorithm>
12 #include <array>
13 #include <cassert>
14 #include <csignal>
15 #include <cstdint>
16 #include <cstdlib>
17 #include <filesystem>
18 #include <functional>
19 #include <iostream>
20 #include <iterator>
21 #include <memory>
22 #include <optional>
23 #include <stdexcept>
24 #include <string>
25 #include <string_view>
26 #include <tuple>
27 #include <unordered_map>
28 #include <unordered_set>
29 #include <utility>
30 #include <vector>
31 #include <getopt.h>
32 #include "fcitx-config/configuration.h"
33 #include "fcitx-config/iniparser.h"
34 #include "fcitx-config/option.h"
36 #include "fcitx-utils/cutf8.h"
37 #include "fcitx-utils/environ.h"
38 #include "fcitx-utils/event.h"
39 #include "fcitx-utils/eventdispatcher.h"
40 #include "fcitx-utils/eventloopinterface.h"
41 #include "fcitx-utils/fs.h"
42 #include "fcitx-utils/handlertable.h"
43 #include "fcitx-utils/i18n.h"
44 #include "fcitx-utils/key.h"
45 #include "fcitx-utils/keysym.h"
46 #include "fcitx-utils/log.h"
47 #include "fcitx-utils/macros.h"
48 #include "fcitx-utils/misc.h"
49 #include "fcitx-utils/misc_p.h"
53 #include "fcitx-utils/utf8.h"
54 #include "../../modules/notifications/notifications_public.h"
55 #include "addonmanager.h"
56 #include "event.h"
57 #include "focusgroup.h"
58 #include "globalconfig.h"
59 #include "inputcontextmanager.h"
60 #include "inputcontextproperty.h"
61 #include "inputmethodengine.h"
62 #include "inputmethodentry.h"
63 #include "inputmethodgroup.h"
64 #include "inputmethodmanager.h"
65 #include "instance.h"
66 #include "instance_p.h"
67 #include "misc_p.h"
68 #include "statusarea.h"
69 #include "text.h"
70 #include "userinterface.h"
71 #include "userinterfacemanager.h"
72 
73 #ifdef HAVE_SYS_WAIT_H
74 #include <sys/wait.h>
75 #endif
76 
77 #ifdef ENABLE_X11
78 #define FCITX_NO_XCB
79 #include <../modules/xcb/xcb_public.h>
80 #endif
81 
82 #ifdef ENABLE_KEYBOARD
83 #include <xkbcommon/xkbcommon-compose.h>
84 #include <xkbcommon/xkbcommon.h>
85 #endif
86 
87 FCITX_DEFINE_LOG_CATEGORY(keyTrace, "key_trace");
88 
89 namespace fcitx {
90 
91 namespace {
92 
93 constexpr uint64_t AutoSaveMinInUsecs = 60ULL * 1000000ULL; // 30 minutes
94 constexpr uint64_t AutoSaveIdleTime = 60ULL * 1000000ULL; // 1 minutes
95 
96 FCITX_CONFIGURATION(DefaultInputMethod,
97  Option<std::vector<std::string>> defaultInputMethods{
98  this, "DefaultInputMethod", "DefaultInputMethod"};
99  Option<std::vector<std::string>> extraLayouts{
100  this, "ExtraLayout", "ExtraLayout"};);
101 
102 void initAsDaemon() {
103 #ifndef _WIN32
104  pid_t pid = fork();
105  if (pid > 0) {
106  waitpid(pid, nullptr, 0);
107  exit(0);
108  }
109  setsid();
110  auto oldint = signal(SIGINT, SIG_IGN);
111  auto oldhup = signal(SIGHUP, SIG_IGN);
112  auto oldquit = signal(SIGQUIT, SIG_IGN);
113  auto oldpipe = signal(SIGPIPE, SIG_IGN);
114  auto oldttou = signal(SIGTTOU, SIG_IGN);
115  auto oldttin = signal(SIGTTIN, SIG_IGN);
116  auto oldchld = signal(SIGCHLD, SIG_IGN);
117  if (fork() > 0) {
118  exit(0);
119  }
120  (void)chdir("/");
121 
122  signal(SIGINT, oldint);
123  signal(SIGHUP, oldhup);
124  signal(SIGQUIT, oldquit);
125  signal(SIGPIPE, oldpipe);
126  signal(SIGTTOU, oldttou);
127  signal(SIGTTIN, oldttin);
128  signal(SIGCHLD, oldchld);
129 #endif
130 }
131 
132 // Switch IM when these capabilities change.
133 bool shouldSwitchIM(const CapabilityFlags &oldFlags,
134  const CapabilityFlags &newFlags) {
135  const bool oldDisable = oldFlags.testAny(
136  CapabilityFlags{CapabilityFlag::Password, CapabilityFlag::Disable});
137  const bool newDisable = newFlags.testAny(
138  CapabilityFlags{CapabilityFlag::Password, CapabilityFlag::Disable});
139  return oldDisable != newDisable;
140 }
141 
142 } // namespace
143 
144 void InstanceArgument::printUsage() const {
145  std::cout
146  << "Usage: " << argv0 << " [Option]\n"
147  << " --disable <addon names>\tA comma separated list of addons to "
148  "be disabled.\n"
149  << "\t\t\t\t\"all\" can be used to disable all addons.\n"
150  << " --enable <addon names>\tA comma separated list of addons to "
151  "be enabled.\n"
152  << "\t\t\t\t\"all\" can be used to enable all addons.\n"
153  << "\t\t\t\tThis value will override the value in the flag "
154  "--disable.\n"
155  << " --verbose <logging rule>\tSet the logging rule for "
156  "displaying message.\n"
157  << "\t\t\t\tSyntax: category1=level1,category2=level2, ...\n"
158  << "\t\t\t\tE.g. default=4,key_trace=5\n"
159  << "\t\t\t\tLevels are numbers ranging from 0 to 5.\n"
160  << "\t\t\t\t\t0 - NoLog\n"
161  << "\t\t\t\t\t1 - Fatal\n"
162  << "\t\t\t\t\t2 - Error\n"
163  << "\t\t\t\t\t3 - Warn\n"
164  << "\t\t\t\t\t4 - Info (default)\n"
165  << "\t\t\t\t\t5 - Debug\n"
166  << "\t\t\t\tSome built-in categories are:\n"
167  << "\t\t\t\t\tdefault - miscellaneous category used by fcitx own "
168  "library.\n"
169  << "\t\t\t\t\tkey_trace - print the key event received by fcitx.\n"
170  << "\t\t\t\t\t\"*\" may be used to represent all logging "
171  "category.\n"
172  << " -u, --ui <addon name>\t\tSet the UI addon to be used.\n"
173  << " -d\t\t\t\tRun as a daemon.\n"
174  << " -D\t\t\t\tDo not run as a daemon (default).\n"
175  << " -s <seconds>\t\t\tNumber of seconds to wait before start.\n"
176  << " -k, --keep\t\t\tKeep running even the main display is "
177  "disconnected.\n"
178  << " -r, --replace\t\t\tReplace the existing instance.\n"
179  << " -o --option <option>\t\tPass the option to addons\n"
180  << "\t\t\t\t<option> is in format like:\n"
181  << "\t\t\t\tname1=opt1a:opt1b,name2=opt2a:opt2b... .\n"
182  << " -v, --version\t\t\tShow version and quit.\n"
183  << " -h, --help\t\t\tShow this help message and quit.\n";
184 }
185 
186 InstancePrivate::InstancePrivate(Instance *q) : QPtrHolder<Instance>(q) {
187 #ifdef ENABLE_KEYBOARD
188  const auto &locale = getCurrentLocale();
189  assert(!locale.empty());
190  xkbContext_.reset(xkb_context_new(XKB_CONTEXT_NO_FLAGS));
191  if (xkbContext_) {
192  xkb_context_set_log_level(xkbContext_.get(), XKB_LOG_LEVEL_CRITICAL);
193  xkbComposeTable_.reset(xkb_compose_table_new_from_locale(
194  xkbContext_.get(), locale.data(), XKB_COMPOSE_COMPILE_NO_FLAGS));
195  if (!xkbComposeTable_) {
196  FCITX_INFO()
197  << "Trying to fallback to compose table for en_US.UTF-8";
198  xkbComposeTable_.reset(xkb_compose_table_new_from_locale(
199  xkbContext_.get(), "en_US.UTF-8",
200  XKB_COMPOSE_COMPILE_NO_FLAGS));
201  }
202  if (!xkbComposeTable_) {
203  FCITX_WARN()
204  << "No compose table is loaded, you may want to check your "
205  "locale settings.";
206  }
207  }
208 #endif
209 }
210 
211 std::unique_ptr<HandlerTableEntry<EventHandler>>
212 InstancePrivate::watchEvent(EventType type, EventWatcherPhase phase,
213  EventHandler callback) {
214  return eventHandlers_[type][phase].add(std::move(callback));
215 }
216 
217 #ifdef ENABLE_KEYBOARD
218 xkb_keymap *InstancePrivate::keymap(const std::string &display,
219  const std::string &layout,
220  const std::string &variant) {
221  auto layoutAndVariant = stringutils::concat(layout, "-", variant);
222  if (auto *keymapPtr = findValue(keymapCache_[display], layoutAndVariant)) {
223  return (*keymapPtr).get();
224  }
225  struct xkb_rule_names names;
226  names.layout = layout.c_str();
227  names.variant = variant.c_str();
228  std::tuple<std::string, std::string, std::string> xkbParam;
229  if (auto *param = findValue(xkbParams_, display)) {
230  xkbParam = *param;
231  } else {
232  if (!xkbParams_.empty()) {
233  xkbParam = xkbParams_.begin()->second;
234  } else {
235  xkbParam = std::make_tuple(DEFAULT_XKB_RULES, "pc101", "");
236  }
237  }
238  if (globalConfig_.overrideXkbOption()) {
239  std::get<2>(xkbParam) = globalConfig_.customXkbOption();
240  }
241  names.rules = std::get<0>(xkbParam).c_str();
242  names.model = std::get<1>(xkbParam).c_str();
243  names.options = std::get<2>(xkbParam).c_str();
244  UniqueCPtr<xkb_keymap, xkb_keymap_unref> keymap(xkb_keymap_new_from_names(
245  xkbContext_.get(), &names, XKB_KEYMAP_COMPILE_NO_FLAGS));
246  auto result =
247  keymapCache_[display].emplace(layoutAndVariant, std::move(keymap));
248  assert(result.second);
249  return result.first->second.get();
250 }
251 #endif
252 
253 std::pair<std::unordered_set<std::string>, std::unordered_set<std::string>>
254 InstancePrivate::overrideAddons() {
255  std::unordered_set<std::string> enabled;
256  std::unordered_set<std::string> disabled;
257  for (const auto &addon : globalConfig_.enabledAddons()) {
258  enabled.insert(addon);
259  }
260  for (const auto &addon : globalConfig_.disabledAddons()) {
261  enabled.erase(addon);
262  disabled.insert(addon);
263  }
264  for (const auto &addon : arg_.enableList) {
265  disabled.erase(addon);
266  enabled.insert(addon);
267  }
268  for (const auto &addon : arg_.disableList) {
269  enabled.erase(addon);
270  disabled.insert(addon);
271  }
272  return {enabled, disabled};
273 }
274 
275 void InstancePrivate::buildDefaultGroup() {
276  /// Figure out XKB layout information from system.
277  auto *defaultGroup = q_func()->defaultFocusGroup();
278  bool infoFound = false;
279  std::string layouts;
280  std::string variants;
281  auto guessLayout = [this, &layouts, &variants,
282  &infoFound](FocusGroup *focusGroup) {
283  // For now we can only do this on X11.
284  if (!stringutils::startsWith(focusGroup->display(), "x11:")) {
285  return true;
286  }
287 #ifdef ENABLE_X11
288  auto *xcb = addonManager_.addon("xcb");
289  auto x11Name = focusGroup->display().substr(4);
290  if (xcb) {
291  auto rules = xcb->call<IXCBModule::xkbRulesNames>(x11Name);
292  if (!rules[2].empty()) {
293  layouts = rules[2];
294  variants = rules[3];
295  infoFound = true;
296  return false;
297  }
298  }
299 #else
300  FCITX_UNUSED(this);
301  FCITX_UNUSED(layouts);
302  FCITX_UNUSED(variants);
303  FCITX_UNUSED(infoFound);
304 #endif
305  return true;
306  };
307  if (!defaultGroup || guessLayout(defaultGroup)) {
308  icManager_.foreachGroup(
309  [defaultGroup, &guessLayout](FocusGroup *focusGroup) {
310  if (defaultGroup == focusGroup) {
311  return true;
312  }
313  return guessLayout(focusGroup);
314  });
315  }
316  if (!infoFound) {
317  layouts = "us";
318  variants = "";
319  }
320 
321  // layouts and variants are comma separated list for layout information.
322  constexpr char imNamePrefix[] = "keyboard-";
323  auto layoutTokens =
324  stringutils::split(layouts, ",", stringutils::SplitBehavior::KeepEmpty);
325  auto variantTokens = stringutils::split(
326  variants, ",", stringutils::SplitBehavior::KeepEmpty);
327  auto size = std::max(layoutTokens.size(), variantTokens.size());
328  // Make sure we have token to be the same size.
329  layoutTokens.resize(size);
330  variantTokens.resize(size);
331 
332  OrderedSet<std::string> imLayouts;
333  for (decltype(size) i = 0; i < size; i++) {
334  if (layoutTokens[i].empty()) {
335  continue;
336  }
337  std::string layoutName = layoutTokens[i];
338  if (!variantTokens[i].empty()) {
339  layoutName = stringutils::concat(layoutName, "-", variantTokens[i]);
340  }
341 
342  // Skip the layout if we don't have it.
343  if (!imManager_.entry(stringutils::concat(imNamePrefix, layoutName))) {
344  continue;
345  }
346  // Avoid add duplicate entry. layout might have weird duplicate.
347  imLayouts.pushBack(layoutName);
348  }
349 
350  // Load the default profile.
351  auto lang = stripLanguage(getCurrentLanguage());
352  DefaultInputMethod defaultIMConfig;
353  readAsIni(defaultIMConfig, StandardPathsType::PkgData,
354  std::filesystem::path("default") / lang);
355 
356  // Add extra layout from profile.
357  for (const auto &extraLayout : defaultIMConfig.extraLayouts.value()) {
358  if (!imManager_.entry(stringutils::concat(imNamePrefix, extraLayout))) {
359  continue;
360  }
361  imLayouts.pushBack(extraLayout);
362  }
363 
364  // Make sure imLayouts is not empty.
365  if (imLayouts.empty()) {
366  imLayouts.pushBack("us");
367  }
368 
369  // Figure out the first available default input method.
370  std::string defaultIM;
371  for (const auto &im : defaultIMConfig.defaultInputMethods.value()) {
372  if (imManager_.entry(im)) {
373  defaultIM = im;
374  break;
375  }
376  }
377 
378  // Create a group for each layout.
379  std::vector<std::string> groupOrders;
380  for (const auto &imLayout : imLayouts) {
381  std::string groupName;
382  if (imLayouts.size() == 1) {
383  groupName = _("Default");
384  } else {
385  groupName = _("Group {}", imManager_.groupCount() + 1);
386  }
387  imManager_.addEmptyGroup(groupName);
388  groupOrders.push_back(groupName);
389  InputMethodGroup group(groupName);
390  group.inputMethodList().emplace_back(
391  InputMethodGroupItem(stringutils::concat(imNamePrefix, imLayout)));
392  if (!defaultIM.empty()) {
393  group.inputMethodList().emplace_back(
394  InputMethodGroupItem(defaultIM));
395  }
396  FCITX_INFO() << "Items in " << groupName << ": "
397  << group.inputMethodList();
398  group.setDefaultLayout(imLayout);
399  imManager_.setGroup(std::move(group));
400  }
401  FCITX_INFO() << "Generated groups: " << groupOrders;
402  imManager_.setGroupOrder(groupOrders);
403 }
404 
405 void InstancePrivate::showInputMethodInformation(InputContext *ic) {
406  FCITX_Q();
407  auto *inputState = ic->propertyFor(&inputStateFactory_);
408  auto *engine = q->inputMethodEngine(ic);
409  const auto *entry = q->inputMethodEntry(ic);
410  auto &imManager = q->inputMethodManager();
411 
412  if (!inputState->isActive() &&
413  !globalConfig_.showFirstInputMethodInformation()) {
414  return;
415  }
416 
417  std::string display;
418  if (engine) {
419  auto subMode = engine->subMode(*entry, *ic);
420  auto subModeLabel = engine->subModeLabel(*entry, *ic);
421  auto name = globalConfig_.compactInputMethodInformation() &&
422  !entry->label().empty()
423  ? entry->label()
424  : entry->name();
425  if (globalConfig_.compactInputMethodInformation() &&
426  !subModeLabel.empty()) {
427  display = std::move(subModeLabel);
428  } else if (subMode.empty()) {
429  display = std::move(name);
430  } else {
431  display = _("{0} ({1})", name, subMode);
432  }
433  } else if (entry) {
434  display = _("{0} (Not available)", entry->name());
435  } else {
436  display = _("(Not available)");
437  }
438  if (!globalConfig_.compactInputMethodInformation() &&
439  imManager.groupCount() > 1) {
440  display = _("Group {0}: {1}", imManager.currentGroup().name(), display);
441  }
442  inputState->showInputMethodInformation(display);
443 }
444 
445 bool InstancePrivate::canActivate(InputContext *ic) {
446  FCITX_Q();
447  if (!q->canTrigger()) {
448  return false;
449  }
450  auto *inputState = ic->propertyFor(&inputStateFactory_);
451  return !inputState->isActive();
452 }
453 
454 bool InstancePrivate::canDeactivate(InputContext *ic) {
455  FCITX_Q();
456  if (!q->canTrigger()) {
457  return false;
458  }
459  auto *inputState = ic->propertyFor(&inputStateFactory_);
460  return inputState->isActive();
461 }
462 
463 void InstancePrivate::navigateGroup(InputContext *ic, const Key &key,
464  bool forward) {
465  auto *inputState = ic->propertyFor(&inputStateFactory_);
466  inputState->pendingGroupIndex_ =
467  (inputState->pendingGroupIndex_ +
468  (forward ? 1 : imManager_.groupCount() - 1)) %
469  imManager_.groupCount();
470  FCITX_DEBUG() << "Switch to group " << inputState->pendingGroupIndex_;
471 
472  if (notifications_ && !isSingleKey(key)) {
473  notifications_->call<INotifications::showTip>(
474  "enumerate-group", _("Input Method"), "input-keyboard",
475  _("Switch group"),
476  _("Switch group to {0}",
477  imManager_.groups()[inputState->pendingGroupIndex_]),
478  3000);
479  }
480 }
481 
482 void InstancePrivate::acceptGroupChange(const Key &key, InputContext *ic) {
483  FCITX_DEBUG() << "Accept group change, isSingleKey: " << key;
484 
485  auto *inputState = ic->propertyFor(&inputStateFactory_);
486  auto groups = imManager_.groups();
487  if (groups.size() > inputState->pendingGroupIndex_) {
488  if (isSingleKey(key)) {
489  FCITX_DEBUG() << "EnumerateGroupTo: "
490  << inputState->pendingGroupIndex_ << " " << key;
491  imManager_.enumerateGroupTo(groups[inputState->pendingGroupIndex_]);
492  } else {
493  FCITX_DEBUG() << "SetCurrentGroup: "
494  << inputState->pendingGroupIndex_ << " " << key;
495  imManager_.setCurrentGroup(groups[inputState->pendingGroupIndex_]);
496  }
497  }
498  inputState->pendingGroupIndex_ = 0;
499 }
500 
501 InputState::InputState(InstancePrivate *d, InputContext *ic)
502  : d_ptr(d), ic_(ic) {
503  active_ = d->globalConfig_.activeByDefault();
504 #ifdef ENABLE_KEYBOARD
505  if (d->xkbComposeTable_) {
506  xkbComposeState_.reset(xkb_compose_state_new(
507  d->xkbComposeTable_.get(), XKB_COMPOSE_STATE_NO_FLAGS));
508  }
509 #endif
510 }
511 
512 void InputState::showInputMethodInformation(const std::string &name) {
513  ic_->inputPanel().setAuxUp(Text(name));
514  ic_->updateUserInterface(UserInterfaceComponent::InputPanel);
515  lastInfo_ = name;
516  imInfoTimer_ = d_ptr->eventLoop_.addTimeEvent(
517  CLOCK_MONOTONIC, now(CLOCK_MONOTONIC) + 1000000, 0,
518  [this](EventSourceTime *, uint64_t) {
519  hideInputMethodInfo();
520  return true;
521  });
522 }
523 
524 #ifdef ENABLE_KEYBOARD
525 xkb_state *InputState::customXkbState(bool refresh) {
526  auto *instance = d_ptr->q_func();
527  const InputMethodGroup &group = d_ptr->imManager_.currentGroup();
528  const auto im = instance->inputMethod(ic_);
529  auto layout = group.layoutFor(im);
530  if (layout.empty() && stringutils::startsWith(im, "keyboard-")) {
531  layout = im.substr(9);
532  }
533  if (layout.empty() || layout == group.defaultLayout()) {
534  // Use system one.
535  xkbState_.reset();
536  modsAllReleased_ = false;
537  lastXkbLayout_.clear();
538  return nullptr;
539  }
540 
541  if (layout == lastXkbLayout_ && !refresh) {
542  return xkbState_.get();
543  }
544 
545  lastXkbLayout_ = layout;
546  const auto layoutAndVariant = parseLayout(layout);
547  if (auto *keymap = d_ptr->keymap(ic_->display(), layoutAndVariant.first,
548  layoutAndVariant.second)) {
549  xkbState_.reset(xkb_state_new(keymap));
550  } else {
551  xkbState_.reset();
552  }
553  modsAllReleased_ = false;
554  return xkbState_.get();
555 }
556 #endif
557 
558 void InputState::setActive(bool active) {
559  if (active_ != active) {
560  active_ = active;
561  ic_->updateProperty(&d_ptr->inputStateFactory_);
562  }
563 }
564 
565 void InputState::setLocalIM(const std::string &localIM) {
566  if (localIM_ != localIM) {
567  localIM_ = localIM;
568  ic_->updateProperty(&d_ptr->inputStateFactory_);
569  }
570 }
571 
572 void InputState::copyTo(InputContextProperty *other) {
573  auto *otherState = static_cast<InputState *>(other);
574  if (otherState->active_ == active_ && otherState->localIM_ == localIM_) {
575  return;
576  }
577 
578  if (otherState->ic_->hasFocus()) {
579  FCITX_DEBUG() << "Sync state to focused ic: "
580  << otherState->ic_->program();
581  CheckInputMethodChanged imChangedRAII(otherState->ic_, d_ptr);
582  otherState->active_ = active_;
583  otherState->localIM_ = localIM_;
584  } else {
585  otherState->active_ = active_;
586  otherState->localIM_ = localIM_;
587  }
588 }
589 
590 void InputState::reset() {
591 #ifdef ENABLE_KEYBOARD
592  if (xkbComposeState_) {
593  xkb_compose_state_reset(xkbComposeState_.get());
594  }
595 #endif
596  pendingGroupIndex_ = 0;
597  keyReleased_ = -1;
598  lastKeyPressed_ = Key();
599  lastKeyPressedTime_ = 0;
600  totallyReleased_ = true;
601 }
602 
603 void InputState::hideInputMethodInfo() {
604  if (!imInfoTimer_) {
605  return;
606  }
607  imInfoTimer_.reset();
608  auto &panel = ic_->inputPanel();
609  if (panel.auxDown().empty() && panel.preedit().empty() &&
610  panel.clientPreedit().empty() &&
611  (!panel.candidateList() || panel.candidateList()->empty()) &&
612  panel.auxUp().size() == 1 && panel.auxUp().stringAt(0) == lastInfo_) {
613  panel.reset();
614  ic_->updateUserInterface(UserInterfaceComponent::InputPanel);
615  }
616 }
617 
618 #ifdef ENABLE_KEYBOARD
619 void InputState::resetXkbState() {
620  lastXkbLayout_.clear();
621  xkbState_.reset();
622 }
623 #endif
624 
625 CheckInputMethodChanged::CheckInputMethodChanged(InputContext *ic,
626  InstancePrivate *instance)
627  : instance_(instance->q_func()), instancePrivate_(instance),
628  ic_(ic->watch()), inputMethod_(instance_->inputMethod(ic)),
629  reason_(InputMethodSwitchedReason::Other) {
630  auto *inputState = ic->propertyFor(&instance->inputStateFactory_);
631  if (!inputState->imChanged_) {
632  inputState->imChanged_ = this;
633  } else {
634  ic_.unwatch();
635  }
636 }
637 
638 CheckInputMethodChanged::~CheckInputMethodChanged() {
639  if (!ic_.isValid()) {
640  return;
641  }
642  auto *ic = ic_.get();
643  auto *inputState = ic->propertyFor(&instancePrivate_->inputStateFactory_);
644  inputState->imChanged_ = nullptr;
645  if (inputMethod_ != instance_->inputMethod(ic) && !ignore_) {
646  instance_->postEvent(
647  InputContextSwitchInputMethodEvent(reason_, inputMethod_, ic));
648  }
649 }
650 
651 Instance::Instance(int argc, char **argv) {
652  InstanceArgument arg;
653  arg.parseOption(argc, argv);
654  if (arg.quietQuit) {
655  throw InstanceQuietQuit();
656  }
657 
658  if (arg.runAsDaemon) {
659  initAsDaemon();
660  }
661 
662  if (arg.overrideDelay > 0) {
663  sleep(arg.overrideDelay);
664  }
665 
666  // we need fork before this
667  d_ptr = std::make_unique<InstancePrivate>(this);
668  FCITX_D();
669  d->arg_ = arg;
670  d->eventDispatcher_.attach(&d->eventLoop_);
671  d->addonManager_.setInstance(this);
672  d->addonManager_.setAddonOptions(arg.addonOptions_);
673  d->icManager_.setInstance(this);
674  d->connections_.emplace_back(
675  d->imManager_.connect<InputMethodManager::CurrentGroupAboutToChange>(
676  [this, d](const std::string &lastGroup) {
677  d->icManager_.foreachFocused([this](InputContext *ic) {
678  assert(ic->hasFocus());
679  InputContextSwitchInputMethodEvent event(
680  InputMethodSwitchedReason::GroupChange, inputMethod(ic),
681  ic);
682  deactivateInputMethod(event);
683  return true;
684  });
685  d->lastGroup_ = lastGroup;
687  }));
688  d->connections_.emplace_back(
689  d->imManager_.connect<InputMethodManager::CurrentGroupChanged>(
690  [this, d](const std::string &newGroup) {
691  d->icManager_.foreachFocused([this](InputContext *ic) {
692  assert(ic->hasFocus());
693  InputContextSwitchInputMethodEvent event(
694  InputMethodSwitchedReason::GroupChange, "", ic);
695  activateInputMethod(event);
696  return true;
697  });
698  postEvent(InputMethodGroupChangedEvent());
699  if (!d->lastGroup_.empty() && !newGroup.empty() &&
700  d->lastGroup_ != newGroup && d->notifications_ &&
701  d->imManager_.groupCount() > 1) {
702  d->notifications_->call<INotifications::showTip>(
703  "enumerate-group", _("Input Method"), "input-keyboard",
704  _("Switch group"),
705  _("Switched group to {0}",
706  d->imManager_.currentGroup().name()),
707  3000);
708  }
709  d->lastGroup_ = newGroup;
710  }));
711 
712  d->eventWatchers_.emplace_back(d->watchEvent(
713  EventType::InputContextCapabilityAboutToChange,
714  EventWatcherPhase::ReservedFirst, [this](Event &event) {
715  auto &capChanged =
716  static_cast<CapabilityAboutToChangeEvent &>(event);
717  if (!capChanged.inputContext()->hasFocus()) {
718  return;
719  }
720 
721  if (!shouldSwitchIM(capChanged.oldFlags(), capChanged.newFlags())) {
722  return;
723  }
724 
727  inputMethod(capChanged.inputContext()),
728  capChanged.inputContext());
729  deactivateInputMethod(switchIM);
730  }));
731  d->eventWatchers_.emplace_back(d->watchEvent(
732  EventType::InputContextCapabilityChanged,
733  EventWatcherPhase::ReservedFirst, [this](Event &event) {
734  auto &capChanged = static_cast<CapabilityChangedEvent &>(event);
735  if (!capChanged.inputContext()->hasFocus()) {
736  return;
737  }
738 
739  if (!shouldSwitchIM(capChanged.oldFlags(), capChanged.newFlags())) {
740  return;
741  }
742 
745  capChanged.inputContext());
746  activateInputMethod(switchIM);
747  }));
748 
749  d->eventWatchers_.emplace_back(watchEvent(
750  EventType::InputContextKeyEvent, EventWatcherPhase::InputMethod,
751  [this, d](Event &event) {
752  auto &keyEvent = static_cast<KeyEvent &>(event);
753  auto *ic = keyEvent.inputContext();
754  CheckInputMethodChanged imChangedRAII(ic, d);
755  auto origKey = keyEvent.origKey().normalize();
756 
757  struct {
758  const KeyList &list;
759  std::function<bool()> check;
760  std::function<void(bool)> trigger;
761  } keyHandlers[] = {
762  {.list = d->globalConfig_.triggerKeys(),
763  .check = [this]() { return canTrigger(); },
764  .trigger =
765  [this, ic](bool totallyReleased) {
766  return trigger(ic, totallyReleased);
767  }},
768  {.list = d->globalConfig_.altTriggerKeys(),
769  .check = [this, ic]() { return canAltTrigger(ic); },
770  .trigger = [this, ic](bool) { return altTrigger(ic); }},
771  {.list = d->globalConfig_.activateKeys(),
772  .check = [ic, d]() { return d->canActivate(ic); },
773  .trigger = [this, ic](bool) { return activate(ic); }},
774  {.list = d->globalConfig_.deactivateKeys(),
775  .check = [ic, d]() { return d->canDeactivate(ic); },
776  .trigger = [this, ic](bool) { return deactivate(ic); }},
777  {.list = d->globalConfig_.enumerateForwardKeys(),
778  .check = [this, ic]() { return canEnumerate(ic); },
779  .trigger = [this, ic](bool) { return enumerate(ic, true); }},
780  {.list = d->globalConfig_.enumerateBackwardKeys(),
781  .check = [this, ic]() { return canEnumerate(ic); },
782  .trigger = [this, ic](bool) { return enumerate(ic, false); }},
783  {.list = d->globalConfig_.enumerateGroupForwardKeys(),
784  .check = [this]() { return canChangeGroup(); },
785  .trigger = [ic, d, origKey](
786  bool) { d->navigateGroup(ic, origKey, true); }},
787  {.list = d->globalConfig_.enumerateGroupBackwardKeys(),
788  .check = [this]() { return canChangeGroup(); },
789  .trigger =
790  [ic, d, origKey](bool) {
791  d->navigateGroup(ic, origKey, false);
792  }},
793  };
794 
795  auto *inputState = ic->propertyFor(&d->inputStateFactory_);
796  int keyReleased = inputState->keyReleased_;
797  Key lastKeyPressed = inputState->lastKeyPressed_;
798  // Keep this value, and reset them in the state
799  inputState->keyReleased_ = -1;
800  const bool isModifier = origKey.isModifier();
801  if (keyEvent.isRelease()) {
802  int idx = 0;
803  for (auto &keyHandler : keyHandlers) {
804  if (keyReleased == idx &&
805  origKey.isReleaseOfModifier(lastKeyPressed) &&
806  keyHandler.check()) {
807  if (isModifier) {
808  if (d->globalConfig_.checkModifierOnlyKeyTimeout(
809  inputState->lastKeyPressedTime_)) {
810  keyHandler.trigger(
811  inputState->totallyReleased_);
812  }
813  inputState->lastKeyPressedTime_ = 0;
814  if (origKey.hasModifier()) {
815  inputState->totallyReleased_ = false;
816  }
817  }
818  keyEvent.filter();
819  break;
820  }
821  idx++;
822  }
823  if (isSingleModifier(origKey)) {
824  inputState->totallyReleased_ = true;
825  }
826  }
827 
828  if (inputState->pendingGroupIndex_ &&
829  inputState->totallyReleased_) {
830  auto *inputState = ic->propertyFor(&d->inputStateFactory_);
831  if (inputState->imChanged_) {
832  inputState->imChanged_->ignore();
833  }
834  d->acceptGroupChange(lastKeyPressed, ic);
835  inputState->lastKeyPressed_ = Key();
836  }
837 
838  if (!keyEvent.filtered() && !keyEvent.isRelease()) {
839  int idx = 0;
840  for (auto &keyHandler : keyHandlers) {
841  auto keyIdx = origKey.keyListIndex(keyHandler.list);
842  if (keyIdx >= 0 && keyHandler.check()) {
843  inputState->keyReleased_ = idx;
844  inputState->lastKeyPressed_ = origKey;
845  if (isModifier) {
846  inputState->lastKeyPressedTime_ =
847  now(CLOCK_MONOTONIC);
848  // don't forward to input method, but make it pass
849  // through to client.
850  keyEvent.filter();
851  return;
852  }
853  keyHandler.trigger(inputState->totallyReleased_);
854  if (origKey.hasModifier()) {
855  inputState->totallyReleased_ = false;
856  }
857  keyEvent.filterAndAccept();
858  return;
859  }
860  idx++;
861  }
862  }
863  }));
864  d->eventWatchers_.emplace_back(watchEvent(
865  EventType::InputContextKeyEvent, EventWatcherPhase::PreInputMethod,
866  [d](Event &event) {
867  auto &keyEvent = static_cast<KeyEvent &>(event);
868  auto *ic = keyEvent.inputContext();
869  if (!keyEvent.isRelease() &&
870  keyEvent.key().checkKeyList(
871  d->globalConfig_.togglePreeditKeys())) {
872  ic->setEnablePreedit(!ic->isPreeditEnabled());
873  if (d->notifications_) {
874  d->notifications_->call<INotifications::showTip>(
875  "toggle-preedit", _("Input Method"), "", _("Preedit"),
876  ic->isPreeditEnabled() ? _("Preedit enabled")
877  : _("Preedit disabled"),
878  3000);
879  }
880  keyEvent.filterAndAccept();
881  }
882  }));
883  d->eventWatchers_.emplace_back(d->watchEvent(
884  EventType::InputContextKeyEvent, EventWatcherPhase::ReservedFirst,
885  [d](Event &event) {
886  // Update auto save.
887  d->idleStartTimestamp_ = now(CLOCK_MONOTONIC);
888  auto &keyEvent = static_cast<KeyEvent &>(event);
889  auto *ic = keyEvent.inputContext();
890  auto *inputState = ic->propertyFor(&d->inputStateFactory_);
891 #ifdef ENABLE_KEYBOARD
892  auto *xkbState = inputState->customXkbState();
893  if (xkbState) {
894  if (auto *mods = findValue(d->stateMask_, ic->display())) {
895  FCITX_KEYTRACE() << "Update mask to customXkbState";
896  // Keep latched, but propagate depressed optionally and
897  // locked.
898  uint32_t depressed;
899  if (inputState->isModsAllReleased()) {
900  depressed = xkb_state_serialize_mods(
901  xkbState, XKB_STATE_MODS_DEPRESSED);
902  } else {
903  depressed = std::get<0>(*mods);
904  }
905  if (std::get<0>(*mods) == 0) {
906  inputState->setModsAllReleased();
907  }
908  auto latched = xkb_state_serialize_mods(
909  xkbState, XKB_STATE_MODS_LATCHED);
910  auto locked = std::get<2>(*mods);
911 
912  // set modifiers in depressed if they don't appear in any of
913  // the final masks
914  // depressed |= ~(depressed | latched | locked);
915  FCITX_DEBUG()
916  << depressed << " " << latched << " " << locked;
917  xkb_state_update_mask(xkbState, depressed, latched, locked,
918  0, 0, 0);
919  }
920  const uint32_t effective = xkb_state_serialize_mods(
921  xkbState, XKB_STATE_MODS_EFFECTIVE);
922  auto newSym = xkb_state_key_get_one_sym(
923  xkbState, keyEvent.rawKey().code());
924  auto newModifier = KeyStates(effective);
925  auto *keymap = xkb_state_get_keymap(xkbState);
926  if (keyEvent.rawKey().states().test(KeyState::Repeat) &&
927  xkb_keymap_key_repeats(keymap, keyEvent.rawKey().code())) {
928  newModifier |= KeyState::Repeat;
929  }
930 
931  const uint32_t modsDepressed = xkb_state_serialize_mods(
932  xkbState, XKB_STATE_MODS_DEPRESSED);
933  const uint32_t modsLatched =
934  xkb_state_serialize_mods(xkbState, XKB_STATE_MODS_LATCHED);
935  const uint32_t modsLocked =
936  xkb_state_serialize_mods(xkbState, XKB_STATE_MODS_LOCKED);
937  FCITX_KEYTRACE() << "Current mods: " << modsDepressed << " "
938  << modsLatched << " " << modsLocked;
939  auto newCode = keyEvent.rawKey().code();
940  Key key(static_cast<KeySym>(newSym), newModifier, newCode);
941  FCITX_KEYTRACE()
942  << "Custom Xkb translated Key: " << key.toString();
943  keyEvent.setRawKey(key);
944  }
945 #endif
946  FCITX_KEYTRACE() << "KeyEvent: " << keyEvent.key()
947  << " rawKey: " << keyEvent.rawKey()
948  << " origKey: " << keyEvent.origKey()
949  << " Release:" << keyEvent.isRelease()
950  << " keycode: " << keyEvent.origKey().code()
951  << " program: " << ic->program();
952 
953  if (keyEvent.isRelease()) {
954  return;
955  }
956  inputState->hideInputMethodInfo();
957  }));
958  d->eventWatchers_.emplace_back(
960  EventWatcherPhase::InputMethod, [this](Event &event) {
961  auto &keyEvent = static_cast<KeyEvent &>(event);
962  auto *ic = keyEvent.inputContext();
963  auto *engine = inputMethodEngine(ic);
964  const auto *entry = inputMethodEntry(ic);
965  if (!engine || !entry) {
966  return;
967  }
968  engine->keyEvent(*entry, keyEvent);
969  }));
970  d->eventWatchers_.emplace_back(watchEvent(
971  EventType::InputContextVirtualKeyboardEvent,
972  EventWatcherPhase::InputMethod, [this](Event &event) {
973  auto &keyEvent = static_cast<VirtualKeyboardEvent &>(event);
974  auto *ic = keyEvent.inputContext();
975  auto *engine = inputMethodEngine(ic);
976  const auto *entry = inputMethodEntry(ic);
977  if (!engine || !entry) {
978  return;
979  }
980  engine->virtualKeyboardEvent(*entry, keyEvent);
981  }));
982  d->eventWatchers_.emplace_back(watchEvent(
983  EventType::InputContextInvokeAction, EventWatcherPhase::InputMethod,
984  [this](Event &event) {
985  auto &invokeActionEvent = static_cast<InvokeActionEvent &>(event);
986  auto *ic = invokeActionEvent.inputContext();
987  auto *engine = inputMethodEngine(ic);
988  const auto *entry = inputMethodEntry(ic);
989  if (!engine || !entry) {
990  return;
991  }
992  engine->invokeAction(*entry, invokeActionEvent);
993  }));
994  d->eventWatchers_.emplace_back(d->watchEvent(
995  EventType::InputContextKeyEvent, EventWatcherPhase::ReservedLast,
996  [this](Event &event) {
997  auto &keyEvent = static_cast<KeyEvent &>(event);
998  auto *ic = keyEvent.inputContext();
999  auto *engine = inputMethodEngine(ic);
1000  const auto *entry = inputMethodEntry(ic);
1001  if (!engine || !entry) {
1002  return;
1003  }
1004  engine->filterKey(*entry, keyEvent);
1005  emit<Instance::KeyEventResult>(keyEvent);
1006 #ifdef ENABLE_KEYBOARD
1007  if (keyEvent.forward()) {
1008  FCITX_D();
1009  // Always let the release key go through, since it shouldn't
1010  // produce character. Otherwise it may wrongly trigger wayland
1011  // client side repetition.
1012  if (keyEvent.isRelease()) {
1013  keyEvent.filter();
1014  return;
1015  }
1016  auto *inputState = ic->propertyFor(&d->inputStateFactory_);
1017  if (auto *xkbState = inputState->customXkbState()) {
1018  if (auto utf32 = xkb_state_key_get_utf32(
1019  xkbState, keyEvent.key().code())) {
1020  // Ignore newline, return, backspace, tab, and delete.
1021  if (utf32 == '\n' || utf32 == '\b' || utf32 == '\r' ||
1022  utf32 == '\t' || utf32 == '\033' ||
1023  utf32 == '\x7f') {
1024  return;
1025  }
1026  if (keyEvent.key().states().test(KeyState::Ctrl) ||
1027  keyEvent.rawKey().sym() ==
1028  keyEvent.origKey().sym()) {
1029  return;
1030  }
1031  FCITX_KEYTRACE() << "Will commit char: " << utf32;
1032  ic->commitString(utf8::UCS4ToUTF8(utf32));
1033  keyEvent.filterAndAccept();
1034  } else if (!keyEvent.key().states().test(KeyState::Ctrl) &&
1035  keyEvent.rawKey().sym() !=
1036  keyEvent.origKey().sym() &&
1037  Key::keySymToUnicode(keyEvent.origKey().sym()) !=
1038  0) {
1039  // filter key for the case that: origKey will produce
1040  // character, while the translated will not.
1041  keyEvent.filterAndAccept();
1042  }
1043  }
1044  }
1045 #endif
1046  }));
1047  d->eventWatchers_.emplace_back(d->watchEvent(
1048  EventType::InputContextFocusIn, EventWatcherPhase::ReservedFirst,
1049  [this, d](Event &event) {
1050  auto &icEvent = static_cast<InputContextEvent &>(event);
1051  auto isSameProgram = [&icEvent, d]() {
1052  // Check if they are same IC, or they are same program.
1053  return (icEvent.inputContext() == d->lastUnFocusedIc_.get()) ||
1054  (!icEvent.inputContext()->program().empty() &&
1055  (icEvent.inputContext()->program() ==
1056  d->lastUnFocusedProgram_));
1057  };
1058 
1059  if (d->globalConfig_.resetStateWhenFocusIn() ==
1060  PropertyPropagatePolicy::All ||
1061  (d->globalConfig_.resetStateWhenFocusIn() ==
1062  PropertyPropagatePolicy::Program &&
1063  !isSameProgram())) {
1064  if (d->globalConfig_.activeByDefault()) {
1065  activate(icEvent.inputContext());
1066  } else {
1067  deactivate(icEvent.inputContext());
1068  }
1069  }
1070 
1071  activateInputMethod(icEvent);
1072 
1073  auto *inputContext = icEvent.inputContext();
1074  if (!inputContext->clientControlVirtualkeyboardShow()) {
1075  inputContext->showVirtualKeyboard();
1076  }
1077 
1078  if (!d->globalConfig_.showInputMethodInformationWhenFocusIn() ||
1079  icEvent.inputContext()->capabilityFlags().test(
1081  return;
1082  }
1083  // Give some time because the cursor location may need some time
1084  // to be updated.
1085  d->focusInImInfoTimer_ = d->eventLoop_.addTimeEvent(
1086  CLOCK_MONOTONIC, now(CLOCK_MONOTONIC) + 30000, 0,
1087  [d, icRef = icEvent.inputContext()->watch()](EventSourceTime *,
1088  uint64_t) {
1089  // Check if ic is still valid and has focus.
1090  if (auto *ic = icRef.get(); ic && ic->hasFocus()) {
1091  d->showInputMethodInformation(ic);
1092  }
1093  return true;
1094  });
1095  }));
1096  d->eventWatchers_.emplace_back(d->watchEvent(
1097  EventType::InputContextFocusOut, EventWatcherPhase::ReservedFirst,
1098  [d](Event &event) {
1099  auto &icEvent = static_cast<InputContextEvent &>(event);
1100  auto *ic = icEvent.inputContext();
1101  auto *inputState = ic->propertyFor(&d->inputStateFactory_);
1102  inputState->reset();
1103  if (!ic->capabilityFlags().test(
1104  CapabilityFlag::ClientUnfocusCommit)) {
1105  // do server side commit
1106  auto commit =
1107  ic->inputPanel().clientPreedit().toStringForCommit();
1108  if (!commit.empty()) {
1109  ic->commitString(commit);
1110  }
1111  }
1112  }));
1113  d->eventWatchers_.emplace_back(d->watchEvent(
1114  EventType::InputContextFocusOut, EventWatcherPhase::InputMethod,
1115  [this, d](Event &event) {
1116  auto &icEvent = static_cast<InputContextEvent &>(event);
1117  d->lastUnFocusedProgram_ = icEvent.inputContext()->program();
1118  d->lastUnFocusedIc_ = icEvent.inputContext()->watch();
1119  deactivateInputMethod(icEvent);
1120 
1121  auto *inputContext = icEvent.inputContext();
1122  if (!inputContext->clientControlVirtualkeyboardHide()) {
1123  inputContext->hideVirtualKeyboard();
1124  }
1125  }));
1126  d->eventWatchers_.emplace_back(d->watchEvent(
1127  EventType::InputContextReset, EventWatcherPhase::ReservedFirst,
1128  [d](Event &event) {
1129  auto &icEvent = static_cast<InputContextEvent &>(event);
1130  auto *ic = icEvent.inputContext();
1131  auto *inputState = ic->propertyFor(&d->inputStateFactory_);
1132  inputState->reset();
1133  }));
1134  d->eventWatchers_.emplace_back(
1135  watchEvent(EventType::InputContextReset, EventWatcherPhase::InputMethod,
1136  [this](Event &event) {
1137  auto &icEvent = static_cast<InputContextEvent &>(event);
1138  auto *ic = icEvent.inputContext();
1139  if (!ic->hasFocus()) {
1140  return;
1141  }
1142  auto *engine = inputMethodEngine(ic);
1143  const auto *entry = inputMethodEntry(ic);
1144  if (!engine || !entry) {
1145  return;
1146  }
1147  engine->reset(*entry, icEvent);
1148  }));
1149  d->eventWatchers_.emplace_back(d->watchEvent(
1151  EventWatcherPhase::ReservedFirst, [this](Event &event) {
1152  auto &icEvent =
1153  static_cast<InputContextSwitchInputMethodEvent &>(event);
1154  auto *ic = icEvent.inputContext();
1155  if (!ic->hasFocus()) {
1156  return;
1157  }
1158  deactivateInputMethod(icEvent);
1159  activateInputMethod(icEvent);
1160  }));
1161  d->eventWatchers_.emplace_back(d->watchEvent(
1163  EventWatcherPhase::ReservedLast, [this, d](Event &event) {
1164  auto &icEvent =
1165  static_cast<InputContextSwitchInputMethodEvent &>(event);
1166  auto *ic = icEvent.inputContext();
1167  if (!ic->hasFocus()) {
1168  return;
1169  }
1170 
1171  auto *inputState = ic->propertyFor(&d->inputStateFactory_);
1172  inputState->lastIMChangeIsAltTrigger_ =
1173  icEvent.reason() == InputMethodSwitchedReason::AltTrigger;
1174 
1175  if ((icEvent.reason() != InputMethodSwitchedReason::Trigger &&
1176  icEvent.reason() != InputMethodSwitchedReason::AltTrigger &&
1177  icEvent.reason() != InputMethodSwitchedReason::Enumerate &&
1178  icEvent.reason() != InputMethodSwitchedReason::Activate &&
1179  icEvent.reason() != InputMethodSwitchedReason::Other &&
1180  icEvent.reason() != InputMethodSwitchedReason::GroupChange &&
1181  icEvent.reason() != InputMethodSwitchedReason::Deactivate)) {
1182  return;
1183  }
1184  showInputMethodInformation(ic);
1185  }));
1186  d->eventWatchers_.emplace_back(
1187  d->watchEvent(EventType::InputMethodGroupChanged,
1188  EventWatcherPhase::ReservedLast, [this, d](Event &) {
1189  // Use a timer here. so we can get focus back to real
1190  // window.
1191  d->imGroupInfoTimer_ = d->eventLoop_.addTimeEvent(
1192  CLOCK_MONOTONIC, now(CLOCK_MONOTONIC) + 30000, 0,
1193  [this](EventSourceTime *, uint64_t) {
1194  inputContextManager().foreachFocused(
1195  [this](InputContext *ic) {
1196  showInputMethodInformation(ic);
1197  return true;
1198  });
1199  return true;
1200  });
1201  }));
1202 
1203  d->eventWatchers_.emplace_back(d->watchEvent(
1204  EventType::InputContextUpdateUI, EventWatcherPhase::ReservedFirst,
1205  [d](Event &event) {
1206  auto &icEvent = static_cast<InputContextUpdateUIEvent &>(event);
1207  if (icEvent.immediate()) {
1208  d->uiManager_.update(icEvent.component(),
1209  icEvent.inputContext());
1210  d->uiManager_.flush();
1211  } else {
1212  d->uiManager_.update(icEvent.component(),
1213  icEvent.inputContext());
1214  d->uiUpdateEvent_->setOneShot();
1215  }
1216  }));
1217  d->eventWatchers_.emplace_back(d->watchEvent(
1218  EventType::InputContextDestroyed, EventWatcherPhase::ReservedFirst,
1219  [d](Event &event) {
1220  auto &icEvent = static_cast<InputContextEvent &>(event);
1221  d->uiManager_.expire(icEvent.inputContext());
1222  }));
1223  d->eventWatchers_.emplace_back(d->watchEvent(
1224  EventType::InputMethodModeChanged, EventWatcherPhase::ReservedFirst,
1225  [d](Event &) { d->uiManager_.updateAvailability(); }));
1226  d->uiUpdateEvent_ = d->eventLoop_.addDeferEvent([d](EventSource *) {
1227  d->uiManager_.flush();
1228  return true;
1229  });
1230  d->uiUpdateEvent_->setEnabled(false);
1231  d->periodicalSave_ = d->eventLoop_.addTimeEvent(
1232  CLOCK_MONOTONIC, now(CLOCK_MONOTONIC) + 1000000, AutoSaveIdleTime,
1233  [this, d](EventSourceTime *time, uint64_t) {
1234  if (exiting()) {
1235  return true;
1236  }
1237 
1238  // Check if the idle time is long enough.
1239  auto currentTime = now(CLOCK_MONOTONIC);
1240  if (currentTime <= d->idleStartTimestamp_ ||
1241  currentTime - d->idleStartTimestamp_ < AutoSaveIdleTime) {
1242  // IF not idle, shorten the next checking period.
1243  time->setNextInterval(2 * AutoSaveIdleTime);
1244  time->setOneShot();
1245  return true;
1246  }
1247 
1248  FCITX_INFO() << "Running autosave...";
1249  save();
1250  FCITX_INFO() << "End autosave";
1251  if (d->globalConfig_.autoSavePeriod() > 0) {
1252  time->setNextInterval(d->globalConfig_.autoSavePeriod() *
1253  AutoSaveMinInUsecs);
1254  time->setOneShot();
1255  }
1256  return true;
1257  });
1258  d->periodicalSave_->setEnabled(false);
1259 }
1260 
1261 Instance::~Instance() {
1262  FCITX_D();
1263  d->icManager_.finalize();
1264  d->addonManager_.unload();
1265  d->notifications_ = nullptr;
1266  d->icManager_.setInstance(nullptr);
1267 }
1268 
1269 void InstanceArgument::parseOption(int argc, char **argv) {
1270  if (argc >= 1) {
1271  argv0 = argv[0];
1272  } else {
1273  argv0 = "fcitx5";
1274  }
1275  struct option longOptions[] = {{"enable", required_argument, nullptr, 0},
1276  {"disable", required_argument, nullptr, 0},
1277  {"verbose", required_argument, nullptr, 0},
1278  {"keep", no_argument, nullptr, 'k'},
1279  {"ui", required_argument, nullptr, 'u'},
1280  {"replace", no_argument, nullptr, 'r'},
1281  {"version", no_argument, nullptr, 'v'},
1282  {"help", no_argument, nullptr, 'h'},
1283  {"option", required_argument, nullptr, 'o'},
1284  {nullptr, 0, 0, 0}};
1285 
1286  int optionIndex = 0;
1287  int c;
1288  std::string addonOptionString;
1289  while ((c = getopt_long(argc, argv, "ru:dDs:hvo:k", longOptions,
1290  &optionIndex)) != EOF) {
1291  switch (c) {
1292  case 0: {
1293  switch (optionIndex) {
1294  case 0:
1295  enableList = stringutils::split(optarg, ",");
1296  break;
1297  case 1:
1298  disableList = stringutils::split(optarg, ",");
1299  break;
1300  case 2:
1301  Log::setLogRule(optarg);
1302  break;
1303  default:
1304  quietQuit = true;
1305  printUsage();
1306  break;
1307  }
1308  } break;
1309  case 'r':
1310  tryReplace = true;
1311  break;
1312  case 'u':
1313  uiName = optarg;
1314  break;
1315  case 'd':
1316  runAsDaemon = true;
1317  break;
1318  case 'D':
1319  runAsDaemon = false;
1320  break;
1321  case 'k':
1322  exitWhenMainDisplayDisconnected = false;
1323  break;
1324  case 's':
1325  overrideDelay = std::atoi(optarg);
1326  break;
1327  case 'h':
1328  quietQuit = true;
1329  printUsage();
1330  break;
1331  case 'v':
1332  quietQuit = true;
1333  printVersion();
1334  break;
1335  case 'o':
1336  addonOptionString = optarg;
1337  break;
1338  default:
1339  quietQuit = true;
1340  printUsage();
1341  }
1342  if (quietQuit) {
1343  break;
1344  }
1345  }
1346 
1347  std::unordered_map<std::string, std::vector<std::string>> addonOptions;
1348  for (const std::string_view item :
1349  stringutils::split(addonOptionString, ",")) {
1350  auto tokens = stringutils::split(item, "=");
1351  if (tokens.size() != 2) {
1352  continue;
1353  }
1354  addonOptions[tokens[0]] = stringutils::split(tokens[1], ":");
1355  }
1356  addonOptions_ = std::move(addonOptions);
1357 }
1358 
1360 #ifdef _WIN32
1361  FCITX_UNUSED(fd);
1362 #else
1363  FCITX_D();
1364  d->signalPipe_ = fd;
1365  d->signalPipeEvent_ = d->eventLoop_.addIOEvent(
1366  fd, IOEventFlag::In, [this](EventSource *, int, IOEventFlags) {
1367  handleSignal();
1368  return true;
1369  });
1370 #endif
1371 }
1372 
1374  FCITX_D();
1375  return d->arg_.tryReplace;
1376 }
1377 
1379  FCITX_D();
1380  return d->arg_.exitWhenMainDisplayDisconnected;
1381 }
1382 
1383 bool Instance::exiting() const {
1384  FCITX_D();
1385  return d->exit_;
1386 }
1387 
1388 void Instance::handleSignal() {
1389 #ifndef _WIN32
1390  FCITX_D();
1391  uint8_t signo = 0;
1392  while (fs::safeRead(d->signalPipe_, &signo, sizeof(signo)) > 0) {
1393  if (signo == SIGINT || signo == SIGTERM || signo == SIGQUIT ||
1394  signo == SIGXCPU) {
1395  exit();
1396  } else if (signo == SIGUSR1) {
1397  reloadConfig();
1398  } else if (signo == SIGCHLD) {
1399  d->zombieReaper_->setNextInterval(2000000);
1400  d->zombieReaper_->setOneShot();
1401  }
1402  }
1403 #endif
1404 }
1405 
1407  FCITX_D();
1408  if (!d->arg_.uiName.empty()) {
1409  d->arg_.enableList.push_back(d->arg_.uiName);
1410  }
1411  reloadConfig();
1412  d->icManager_.registerProperty("inputState", &d->inputStateFactory_);
1413  std::unordered_set<std::string> enabled;
1414  std::unordered_set<std::string> disabled;
1415  std::tie(enabled, disabled) = d->overrideAddons();
1416  FCITX_INFO() << "Override Enabled Addons: " << enabled;
1417  FCITX_INFO() << "Override Disabled Addons: " << disabled;
1418  d->addonManager_.load(enabled, disabled);
1419  if (d->exit_) {
1420  return;
1421  }
1422  d->imManager_.load([d](InputMethodManager &) { d->buildDefaultGroup(); });
1423  d->uiManager_.load(d->arg_.uiName);
1424 
1425  const auto *entry = d->imManager_.entry("keyboard-us");
1426  FCITX_LOG_IF(Error, !entry) << "Couldn't find keyboard-us";
1427  d->preloadInputMethodEvent_ = d->eventLoop_.addTimeEvent(
1428  CLOCK_MONOTONIC, now(CLOCK_MONOTONIC) + 1000000, 0,
1429  [this](EventSourceTime *, uint64_t) {
1430  FCITX_D();
1431  if (d->exit_ || !d->globalConfig_.preloadInputMethod()) {
1432  return false;
1433  }
1434  // Preload first input method.
1435  if (!d->imManager_.currentGroup().inputMethodList().empty()) {
1436  if (const auto *entry =
1437  d->imManager_.entry(d->imManager_.currentGroup()
1438  .inputMethodList()[0]
1439  .name())) {
1440  d->addonManager_.addon(entry->addon(), true);
1441  }
1442  }
1443  // Preload default input method.
1444  if (!d->imManager_.currentGroup().defaultInputMethod().empty()) {
1445  if (const auto *entry = d->imManager_.entry(
1446  d->imManager_.currentGroup().defaultInputMethod())) {
1447  d->addonManager_.addon(entry->addon(), true);
1448  }
1449  }
1450  return false;
1451  });
1452 #ifndef _WIN32
1453  d->zombieReaper_ = d->eventLoop_.addTimeEvent(
1454  CLOCK_MONOTONIC, now(CLOCK_MONOTONIC), 0,
1455  [](EventSourceTime *, uint64_t) {
1456  pid_t res;
1457  while ((res = waitpid(-1, nullptr, WNOHANG)) > 0) {
1458  }
1459  return false;
1460  });
1461  d->zombieReaper_->setEnabled(false);
1462 #endif
1463 
1464  d->exitEvent_ = d->eventLoop_.addExitEvent([this](EventSource *) {
1465  FCITX_DEBUG() << "Running save...";
1466  save();
1467  return false;
1468  });
1469  d->notifications_ = d->addonManager_.addon("notifications", true);
1470 }
1471 
1473  FCITX_D();
1474  if (d->arg_.quietQuit) {
1475  return 0;
1476  }
1477  d->exit_ = false;
1478  d->exitCode_ = 0;
1479  initialize();
1480  if (d->exit_) {
1481  return d->exitCode_;
1482  }
1483  d->running_ = true;
1484  auto r = eventLoop().exec();
1485  d->running_ = false;
1486 
1487  return r ? d->exitCode_ : 1;
1488 }
1489 
1490 void Instance::setRunning(bool running) {
1491  FCITX_D();
1492  d->running_ = running;
1493 }
1494 
1495 bool Instance::isRunning() const {
1496  FCITX_D();
1497  return d->running_;
1498 }
1499 
1500 InputMethodMode Instance::inputMethodMode() const {
1501  FCITX_D();
1502  return d->inputMethodMode_;
1503 }
1504 
1505 void Instance::setInputMethodMode(InputMethodMode mode) {
1506  FCITX_D();
1507  if (d->inputMethodMode_ == mode) {
1508  return;
1509  }
1510  d->inputMethodMode_ = mode;
1511  postEvent(InputMethodModeChangedEvent());
1512 }
1513 
1515  FCITX_D();
1516  return d->restart_;
1517 }
1518 
1519 bool Instance::virtualKeyboardAutoShow() const {
1520  FCITX_D();
1521  return d->virtualKeyboardAutoShow_;
1522 }
1523 
1524 void Instance::setVirtualKeyboardAutoShow(bool autoShow) {
1525  FCITX_D();
1526  d->virtualKeyboardAutoShow_ = autoShow;
1527 }
1528 
1529 bool Instance::virtualKeyboardAutoHide() const {
1530  FCITX_D();
1531  return d->virtualKeyboardAutoHide_;
1532 }
1533 
1534 void Instance::setVirtualKeyboardAutoHide(bool autoHide) {
1535  FCITX_D();
1536  d->virtualKeyboardAutoHide_ = autoHide;
1537 }
1538 
1539 VirtualKeyboardFunctionMode Instance::virtualKeyboardFunctionMode() const {
1540  FCITX_D();
1541  return d->virtualKeyboardFunctionMode_;
1542 }
1543 
1544 void Instance::setVirtualKeyboardFunctionMode(
1545  VirtualKeyboardFunctionMode mode) {
1546  FCITX_D();
1547  d->virtualKeyboardFunctionMode_ = mode;
1548 }
1549 
1551  FCITX_D();
1552  d->binaryMode_ = true;
1553 }
1554 
1555 bool Instance::canRestart() const {
1556  FCITX_D();
1557  const auto &addonNames = d->addonManager_.loadedAddonNames();
1558  return d->binaryMode_ &&
1559  std::all_of(addonNames.begin(), addonNames.end(),
1560  [d](const std::string &name) {
1561  auto *addon = d->addonManager_.lookupAddon(name);
1562  if (!addon) {
1563  return true;
1564  }
1565  return addon->canRestart();
1566  });
1567 }
1568 
1569 InstancePrivate *Instance::privateData() {
1570  FCITX_D();
1571  return d;
1572 }
1573 
1575  FCITX_D();
1576  return d->eventLoop_;
1577 }
1578 
1580  FCITX_D();
1581  return d->eventDispatcher_;
1582 }
1583 
1585  FCITX_D();
1586  return d->icManager_;
1587 }
1588 
1590  FCITX_D();
1591  return d->addonManager_;
1592 }
1593 
1595  FCITX_D();
1596  return d->imManager_;
1597 }
1598 
1600  FCITX_D();
1601  return d->imManager_;
1602 }
1603 
1605  FCITX_D();
1606  return d->uiManager_;
1607 }
1608 
1610  FCITX_D();
1611  return d->globalConfig_;
1612 }
1613 
1614 bool Instance::postEvent(Event &event) {
1615  return std::as_const(*this).postEvent(event);
1616 }
1617 
1618 bool Instance::postEvent(Event &event) const {
1619  FCITX_D();
1620  if (d->exit_) {
1621  return false;
1622  }
1623  auto iter = d->eventHandlers_.find(event.type());
1624  if (iter != d->eventHandlers_.end()) {
1625  const auto &handlers = iter->second;
1626  EventWatcherPhase phaseOrder[] = {
1627  EventWatcherPhase::ReservedFirst, EventWatcherPhase::PreInputMethod,
1628  EventWatcherPhase::InputMethod, EventWatcherPhase::PostInputMethod,
1629  EventWatcherPhase::ReservedLast};
1630 
1631  for (auto phase : phaseOrder) {
1632  if (auto iter2 = handlers.find(phase); iter2 != handlers.end()) {
1633  for (auto &handler : iter2->second.view()) {
1634  handler(event);
1635  if (event.filtered()) {
1636  break;
1637  }
1638  }
1639  }
1640  if (event.filtered()) {
1641  break;
1642  }
1643  }
1644 
1645  // Make sure this part of fix is always executed regardless of the
1646  // filter.
1647  if (event.type() == EventType::InputContextKeyEvent) {
1648  auto &keyEvent = static_cast<KeyEvent &>(event);
1649  auto *ic = keyEvent.inputContext();
1650 #ifdef ENABLE_KEYBOARD
1651  do {
1652  if (!keyEvent.forward() && !keyEvent.origKey().code()) {
1653  break;
1654  }
1655  auto *inputState = ic->propertyFor(&d->inputStateFactory_);
1656  auto *xkbState = inputState->customXkbState();
1657  if (!xkbState) {
1658  break;
1659  }
1660  // This need to be called after xkb_state_key_get_*, and should
1661  // be called against all Key regardless whether they are
1662  // filtered or not.
1663  xkb_state_update_key(xkbState, keyEvent.origKey().code(),
1664  keyEvent.isRelease() ? XKB_KEY_UP
1665  : XKB_KEY_DOWN);
1666  } while (0);
1667 #endif
1668  if (ic->capabilityFlags().test(CapabilityFlag::KeyEventOrderFix) &&
1669  !keyEvent.accepted() && ic->hasPendingEventsStrictOrder()) {
1670  // Re-forward the event to ensure we got delivered later than
1671  // commit.
1672  keyEvent.filterAndAccept();
1673  ic->forwardKey(keyEvent.origKey(), keyEvent.isRelease(),
1674  keyEvent.time());
1675  }
1676  d_ptr->uiManager_.flush();
1677  }
1678  }
1679  return event.accepted();
1680 }
1681 
1682 std::unique_ptr<HandlerTableEntry<EventHandler>>
1683 Instance::watchEvent(EventType type, EventWatcherPhase phase,
1684  EventHandler callback) {
1685  FCITX_D();
1686  if (phase == EventWatcherPhase::ReservedFirst ||
1687  phase == EventWatcherPhase::ReservedLast) {
1688  throw std::invalid_argument("Reserved Phase is only for internal use");
1689  }
1690  return d->watchEvent(type, phase, std::move(callback));
1691 }
1692 
1693 bool groupContains(const InputMethodGroup &group, const std::string &name) {
1694  const auto &list = group.inputMethodList();
1695  auto iter = std::find_if(list.begin(), list.end(),
1696  [&name](const InputMethodGroupItem &item) {
1697  return item.name() == name;
1698  });
1699  return iter != list.end();
1700 }
1701 
1703  FCITX_D();
1704  auto *inputState = ic->propertyFor(&d->inputStateFactory_);
1705  // Small hack to make sure when InputMethodEngine::deactivate is called,
1706  // current im is the right one.
1707  if (!inputState->overrideDeactivateIM_.empty()) {
1708  return inputState->overrideDeactivateIM_;
1709  }
1710 
1711  const auto &group = d->imManager_.currentGroup();
1712  if (ic->capabilityFlags().test(CapabilityFlag::Disable) ||
1713  (ic->capabilityFlags().test(CapabilityFlag::Password) &&
1714  !d->globalConfig_.allowInputMethodForPassword())) {
1715  auto defaultLayoutIM =
1716  stringutils::concat("keyboard-", group.defaultLayout());
1717  const auto *entry = d->imManager_.entry(defaultLayoutIM);
1718  if (!entry) {
1719  entry = d->imManager_.entry("keyboard-us");
1720  }
1721  return entry ? entry->uniqueName() : "";
1722  }
1723 
1724  if (group.inputMethodList().empty()) {
1725  return "";
1726  }
1727  if (inputState->isActive()) {
1728  if (!inputState->localIM_.empty() &&
1729  groupContains(group, inputState->localIM_)) {
1730  return inputState->localIM_;
1731  }
1732  return group.defaultInputMethod();
1733  }
1734 
1735  return group.inputMethodList()[0].name();
1736 }
1737 
1739  FCITX_D();
1740  auto imName = inputMethod(ic);
1741  if (imName.empty()) {
1742  return nullptr;
1743  }
1744  return d->imManager_.entry(imName);
1745 }
1746 
1748  FCITX_D();
1749  const auto *entry = inputMethodEntry(ic);
1750  if (!entry) {
1751  return nullptr;
1752  }
1753  return static_cast<InputMethodEngine *>(
1754  d->addonManager_.addon(entry->addon(), true));
1755 }
1756 
1758  FCITX_D();
1759  const auto *entry = d->imManager_.entry(name);
1760  if (!entry) {
1761  return nullptr;
1762  }
1763  return static_cast<InputMethodEngine *>(
1764  d->addonManager_.addon(entry->addon(), true));
1765 }
1766 
1768  std::string icon;
1769  const auto *entry = inputMethodEntry(ic);
1770  if (entry) {
1771  auto *engine = inputMethodEngine(ic);
1772  if (engine) {
1773  icon = engine->subModeIcon(*entry, *ic);
1774  }
1775  if (icon.empty()) {
1776  icon = entry->icon();
1777  }
1778  } else {
1779  icon = "input-keyboard";
1780  }
1781  return icon;
1782 }
1783 
1785  std::string label;
1786 
1787  const auto *entry = inputMethodEntry(ic);
1788  auto *engine = inputMethodEngine(ic);
1789 
1790  if (engine && entry) {
1791  label = engine->subModeLabel(*entry, *ic);
1792  }
1793  if (label.empty() && entry) {
1794  label = entry->label();
1795  }
1796  return label;
1797 }
1798 
1799 uint32_t Instance::processCompose(InputContext *ic, KeySym keysym) {
1800 #ifdef ENABLE_KEYBOARD
1801  FCITX_D();
1802  auto *state = ic->propertyFor(&d->inputStateFactory_);
1803 
1804  auto *xkbComposeState = state->xkbComposeState();
1805  if (!xkbComposeState) {
1806  return 0;
1807  }
1808 
1809  auto keyval = static_cast<xkb_keysym_t>(keysym);
1810 
1811  enum xkb_compose_feed_result result =
1812  xkb_compose_state_feed(xkbComposeState, keyval);
1813  if (result == XKB_COMPOSE_FEED_IGNORED) {
1814  return 0;
1815  }
1816 
1817  enum xkb_compose_status status =
1818  xkb_compose_state_get_status(xkbComposeState);
1819  if (status == XKB_COMPOSE_NOTHING) {
1820  return 0;
1821  }
1822  if (status == XKB_COMPOSE_COMPOSED) {
1823  char buffer[FCITX_UTF8_MAX_LENGTH + 1] = {'\0', '\0', '\0', '\0',
1824  '\0', '\0', '\0'};
1825  int length =
1826  xkb_compose_state_get_utf8(xkbComposeState, buffer, sizeof(buffer));
1827  xkb_compose_state_reset(xkbComposeState);
1828  if (length == 0) {
1829  return FCITX_INVALID_COMPOSE_RESULT;
1830  }
1831 
1832  uint32_t c = utf8::getChar(buffer);
1833  return utf8::isValidChar(c) ? c : 0;
1834  }
1835  if (status == XKB_COMPOSE_CANCELLED) {
1836  xkb_compose_state_reset(xkbComposeState);
1837  }
1838 
1839  return FCITX_INVALID_COMPOSE_RESULT;
1840 #else
1841  FCITX_UNUSED(ic);
1842  FCITX_UNUSED(keysym);
1843  return 0;
1844 #endif
1845 }
1846 
1847 std::optional<std::string> Instance::processComposeString(InputContext *ic,
1848  KeySym keysym) {
1849 #ifdef ENABLE_KEYBOARD
1850  FCITX_D();
1851  auto *state = ic->propertyFor(&d->inputStateFactory_);
1852 
1853  auto *xkbComposeState = state->xkbComposeState();
1854  if (!xkbComposeState) {
1855  return std::string();
1856  }
1857 
1858  auto keyval = static_cast<xkb_keysym_t>(keysym);
1859  enum xkb_compose_feed_result result =
1860  xkb_compose_state_feed(xkbComposeState, keyval);
1861 
1862  if (result == XKB_COMPOSE_FEED_IGNORED) {
1863  return std::string();
1864  }
1865 
1866  enum xkb_compose_status status =
1867  xkb_compose_state_get_status(xkbComposeState);
1868  if (status == XKB_COMPOSE_NOTHING) {
1869  return std::string();
1870  }
1871  if (status == XKB_COMPOSE_COMPOSED) {
1872  // This may not be NUL-terminiated.
1873  std::array<char, 256> buffer;
1874  auto length = xkb_compose_state_get_utf8(xkbComposeState, buffer.data(),
1875  buffer.size());
1876  xkb_compose_state_reset(xkbComposeState);
1877  if (length == 0) {
1878  return std::nullopt;
1879  }
1880 
1881  auto bufferBegin = buffer.begin();
1882  auto bufferEnd = std::next(bufferBegin, length);
1883  if (utf8::validate(bufferBegin, bufferEnd)) {
1884  return std::string(bufferBegin, bufferEnd);
1885  }
1886  return std::nullopt;
1887  }
1888  if (status == XKB_COMPOSE_CANCELLED) {
1889  xkb_compose_state_reset(xkbComposeState);
1890  }
1891  return std::nullopt;
1892 #else
1893  FCITX_UNUSED(ic);
1894  FCITX_UNUSED(keysym);
1895  return std::string();
1896 #endif
1897 }
1898 
1900 #ifdef ENABLE_KEYBOARD
1901  FCITX_D();
1902  auto *state = inputContext->propertyFor(&d->inputStateFactory_);
1903 
1904  auto *xkbComposeState = state->xkbComposeState();
1905  if (!xkbComposeState) {
1906  return false;
1907  }
1908 
1909  return xkb_compose_state_get_status(xkbComposeState) ==
1910  XKB_COMPOSE_COMPOSING;
1911 #else
1912  FCITX_UNUSED(inputContext);
1913  return false;
1914 #endif
1915 }
1916 
1918 #ifdef ENABLE_KEYBOARD
1919  FCITX_D();
1920  auto *state = inputContext->propertyFor(&d->inputStateFactory_);
1921  auto *xkbComposeState = state->xkbComposeState();
1922  if (!xkbComposeState) {
1923  return;
1924  }
1925  xkb_compose_state_reset(xkbComposeState);
1926 #else
1927  FCITX_UNUSED(inputContext);
1928 #endif
1929 }
1930 
1932  FCITX_D();
1933  // Refresh timestamp for next auto save.
1934  d->idleStartTimestamp_ = now(CLOCK_MONOTONIC);
1935  d->imManager_.save();
1936  d->addonManager_.saveAll();
1937 }
1938 
1940  FCITX_D();
1941  if (auto *ic = mostRecentInputContext()) {
1942  CheckInputMethodChanged imChangedRAII(ic, d);
1943  activate(ic);
1944  }
1945 }
1946 
1947 std::string Instance::addonForInputMethod(const std::string &imName) {
1948 
1949  if (const auto *entry = inputMethodManager().entry(imName)) {
1950  return entry->uniqueName();
1951  }
1952  return {};
1953 }
1954 
1956  startProcess(
1957  {StandardPaths::fcitxPath("bindir", "fcitx5-configtool").string()});
1958 }
1959 
1960 void Instance::configureAddon(const std::string & /*unused*/) {}
1961 
1962 void Instance::configureInputMethod(const std::string & /*unused*/) {}
1963 
1965  if (auto *ic = mostRecentInputContext()) {
1966  if (const auto *entry = inputMethodEntry(ic)) {
1967  return entry->uniqueName();
1968  }
1969  }
1970  return {};
1971 }
1972 
1973 std::string Instance::currentUI() {
1974  FCITX_D();
1975  return d->uiManager_.currentUI();
1976 }
1977 
1979  FCITX_D();
1980  if (auto *ic = mostRecentInputContext()) {
1981  CheckInputMethodChanged imChangedRAII(ic, d);
1982  deactivate(ic);
1983  }
1984 }
1985 
1986 void Instance::exit() { exit(0); }
1987 
1988 void Instance::exit(int exitCode) {
1989  FCITX_D();
1990  d->exit_ = true;
1991  d->exitCode_ = exitCode;
1992  if (d->running_) {
1993  d->eventLoop_.exit();
1994  }
1995 }
1996 
1997 void Instance::reloadAddonConfig(const std::string &addonName) {
1998  auto *addon = addonManager().addon(addonName);
1999  if (addon) {
2000  addon->reloadConfig();
2001  }
2002 }
2003 
2005  FCITX_D();
2006  auto [enabled, disabled] = d->overrideAddons();
2007  d->addonManager_.load(enabled, disabled);
2008  d->imManager_.refresh();
2009 }
2010 
2012  FCITX_D();
2013  readAsIni(d->globalConfig_.config(), StandardPathsType::PkgConfig,
2014  "config");
2015  FCITX_DEBUG() << "Trigger Key: "
2016  << Key::keyListToString(d->globalConfig_.triggerKeys());
2017  d->icManager_.setPropertyPropagatePolicy(
2018  d->globalConfig_.shareInputState());
2019  if (d->globalConfig_.preeditEnabledByDefault() !=
2020  d->icManager_.isPreeditEnabledByDefault()) {
2021  d->icManager_.setPreeditEnabledByDefault(
2022  d->globalConfig_.preeditEnabledByDefault());
2023  d->icManager_.foreach([d](InputContext *ic) {
2024  ic->setEnablePreedit(d->globalConfig_.preeditEnabledByDefault());
2025  return true;
2026  });
2027  }
2028 #ifdef ENABLE_KEYBOARD
2029  d->keymapCache_.clear();
2030  if (d->inputStateFactory_.registered()) {
2031  d->icManager_.foreach([d](InputContext *ic) {
2032  auto *inputState = ic->propertyFor(&d->inputStateFactory_);
2033  inputState->resetXkbState();
2034  return true;
2035  });
2036  }
2037 #endif
2038  if (d->running_) {
2039  postEvent(GlobalConfigReloadedEvent());
2040  }
2041 
2042  if (d->globalConfig_.autoSavePeriod() <= 0) {
2043  d->periodicalSave_->setEnabled(false);
2044  } else {
2045  d->periodicalSave_->setNextInterval(AutoSaveMinInUsecs *
2046  d->globalConfig_.autoSavePeriod());
2047  d->periodicalSave_->setOneShot();
2048  }
2049 }
2050 
2052  FCITX_D();
2053  d->imManager_.reset([d](InputMethodManager &) { d->buildDefaultGroup(); });
2054 }
2055 
2057  FCITX_D();
2058  if (!canRestart()) {
2059  return;
2060  }
2061  d->restart_ = true;
2062  exit();
2063 }
2064 
2065 void Instance::setCurrentInputMethod(const std::string &name) {
2066  setCurrentInputMethod(mostRecentInputContext(), name, false);
2067 }
2068 
2069 void Instance::setCurrentInputMethod(InputContext *ic, const std::string &name,
2070  bool local) {
2071  FCITX_D();
2072  if (!canTrigger()) {
2073  return;
2074  }
2075 
2076  auto &imManager = inputMethodManager();
2077  const auto &imList = imManager.currentGroup().inputMethodList();
2078  auto iter = std::find_if(imList.begin(), imList.end(),
2079  [&name](const InputMethodGroupItem &item) {
2080  return item.name() == name;
2081  });
2082  if (iter == imList.end()) {
2083  return;
2084  }
2085 
2086  auto setGlobalDefaultInputMethod = [d](const std::string &name) {
2087  std::vector<std::unique_ptr<CheckInputMethodChanged>> groupRAIICheck;
2088  d->icManager_.foreachFocused([d, &groupRAIICheck](InputContext *ic) {
2089  assert(ic->hasFocus());
2090  groupRAIICheck.push_back(
2091  std::make_unique<CheckInputMethodChanged>(ic, d));
2092  return true;
2093  });
2094  d->imManager_.setDefaultInputMethod(name);
2095  };
2096 
2097  auto idx = std::distance(imList.begin(), iter);
2098  if (ic) {
2099  CheckInputMethodChanged imChangedRAII(ic, d);
2100  auto currentIM = inputMethod(ic);
2101  if (currentIM == name) {
2102  return;
2103  }
2104  auto *inputState = ic->propertyFor(&d->inputStateFactory_);
2105 
2106  if (idx != 0) {
2107  if (local) {
2108  inputState->setLocalIM(name);
2109  } else {
2110  inputState->setLocalIM({});
2111 
2112  setGlobalDefaultInputMethod(name);
2113  }
2114  inputState->setActive(true);
2115  } else {
2116  inputState->setActive(false);
2117  }
2118  if (inputState->imChanged_) {
2119  inputState->imChanged_->setReason(InputMethodSwitchedReason::Other);
2120  }
2121  } else {
2122  // We can't set local input method if we don't have a IC, but we should
2123  // still to change the global default.
2124  if (local) {
2125  return;
2126  }
2127  if (idx != 0) {
2128  setGlobalDefaultInputMethod(name);
2129  }
2130  return;
2131  }
2132 }
2133 
2135  FCITX_D();
2136  if (auto *ic = mostRecentInputContext()) {
2137  auto *inputState = ic->propertyFor(&d->inputStateFactory_);
2138  return inputState->isActive() ? 2 : 1;
2139  }
2140  return 0;
2141 }
2142 
2144  FCITX_D();
2145  if (auto *ic = mostRecentInputContext()) {
2146  CheckInputMethodChanged imChangedRAII(ic, d);
2147  trigger(ic, true);
2148  }
2149 }
2150 
2151 void Instance::enumerate(bool forward) {
2152  FCITX_D();
2153  if (auto *ic = mostRecentInputContext()) {
2154  CheckInputMethodChanged imChangedRAII(ic, d);
2155  enumerate(ic, forward);
2156  }
2157 }
2158 
2159 bool Instance::canTrigger() const {
2160  const auto &imManager = inputMethodManager();
2161  return (imManager.currentGroup().inputMethodList().size() > 1);
2162 }
2163 
2164 bool Instance::canAltTrigger(InputContext *ic) const {
2165  if (!canTrigger()) {
2166  return false;
2167  }
2168  FCITX_D();
2169  auto *inputState = ic->propertyFor(&d->inputStateFactory_);
2170  if (inputState->isActive()) {
2171  return true;
2172  }
2173  return inputState->lastIMChangeIsAltTrigger_;
2174 }
2175 
2176 bool Instance::canEnumerate(InputContext *ic) const {
2177  FCITX_D();
2178  if (!canTrigger()) {
2179  return false;
2180  }
2181 
2182  if (d->globalConfig_.enumerateSkipFirst()) {
2183  auto *inputState = ic->propertyFor(&d->inputStateFactory_);
2184  if (!inputState->isActive()) {
2185  return false;
2186  }
2187  return d->imManager_.currentGroup().inputMethodList().size() > 2;
2188  }
2189 
2190  return true;
2191 }
2192 
2193 bool Instance::canChangeGroup() const {
2194  const auto &imManager = inputMethodManager();
2195  return (imManager.groupCount() > 1);
2196 }
2197 
2199  FCITX_D();
2200  auto *inputState = ic->propertyFor(&d->inputStateFactory_);
2201  if (!canTrigger()) {
2202  return false;
2203  }
2204  inputState->setActive(!inputState->isActive());
2205  if (inputState->imChanged_) {
2206  inputState->imChanged_->setReason(reason);
2207  }
2208  return true;
2209 }
2210 
2211 bool Instance::trigger(InputContext *ic, bool totallyReleased) {
2212  FCITX_D();
2213  auto *inputState = ic->propertyFor(&d->inputStateFactory_);
2214  if (!canTrigger()) {
2215  return false;
2216  }
2217  // Active -> inactive -> enumerate.
2218  // Inactive -> active -> inactive -> enumerate.
2219  if (totallyReleased) {
2220  toggle(ic);
2221  inputState->firstTrigger_ = true;
2222  } else {
2223  if (!d->globalConfig_.enumerateWithTriggerKeys() ||
2224  (inputState->firstTrigger_ && inputState->isActive()) ||
2225  (d->globalConfig_.enumerateSkipFirst() &&
2226  d->imManager_.currentGroup().inputMethodList().size() <= 2)) {
2227  toggle(ic);
2228  } else {
2229  enumerate(ic, true);
2230  }
2231  inputState->firstTrigger_ = false;
2232  }
2233  return true;
2234 }
2235 
2236 bool Instance::altTrigger(InputContext *ic) {
2237  if (!canAltTrigger(ic)) {
2238  return false;
2239  }
2240 
2242  return true;
2243 }
2244 
2245 bool Instance::activate(InputContext *ic) {
2246  FCITX_D();
2247  auto *inputState = ic->propertyFor(&d->inputStateFactory_);
2248  if (!canTrigger()) {
2249  return false;
2250  }
2251  if (inputState->isActive()) {
2252  return true;
2253  }
2254  inputState->setActive(true);
2255  if (inputState->imChanged_) {
2256  inputState->imChanged_->setReason(InputMethodSwitchedReason::Activate);
2257  }
2258  return true;
2259 }
2260 
2262  FCITX_D();
2263  auto *inputState = ic->propertyFor(&d->inputStateFactory_);
2264  if (!canTrigger()) {
2265  return false;
2266  }
2267  if (!inputState->isActive()) {
2268  return true;
2269  }
2270  inputState->setActive(false);
2271  if (inputState->imChanged_) {
2272  inputState->imChanged_->setReason(
2274  }
2275  return true;
2276 }
2277 
2278 bool Instance::enumerate(InputContext *ic, bool forward) {
2279  FCITX_D();
2280  auto &imManager = inputMethodManager();
2281  auto *inputState = ic->propertyFor(&d->inputStateFactory_);
2282  const auto &imList = imManager.currentGroup().inputMethodList();
2283  if (!canTrigger()) {
2284  return false;
2285  }
2286 
2287  if (d->globalConfig_.enumerateSkipFirst() && imList.size() <= 2) {
2288  return false;
2289  }
2290 
2291  auto currentIM = inputMethod(ic);
2292 
2293  auto iter = std::ranges::find_if(
2294  imList, [&currentIM](const InputMethodGroupItem &item) {
2295  return item.name() == currentIM;
2296  });
2297  if (iter == imList.end()) {
2298  return false;
2299  }
2300  int idx = std::distance(imList.begin(), iter);
2301  auto nextIdx = [forward, &imList](int idx) {
2302  // be careful not to use negative to avoid overflow.
2303  return (idx + (forward ? 1 : (imList.size() - 1))) % imList.size();
2304  };
2305 
2306  idx = nextIdx(idx);
2307  if (d->globalConfig_.enumerateSkipFirst() && idx == 0) {
2308  idx = nextIdx(idx);
2309  }
2310  if (idx != 0) {
2311  std::vector<std::unique_ptr<CheckInputMethodChanged>> groupRAIICheck;
2312  d->icManager_.foreachFocused([d, &groupRAIICheck](InputContext *ic) {
2313  assert(ic->hasFocus());
2314  groupRAIICheck.push_back(
2315  std::make_unique<CheckInputMethodChanged>(ic, d));
2316  return true;
2317  });
2318  imManager.setDefaultInputMethod(imList[idx].name());
2319  inputState->setActive(true);
2320  inputState->setLocalIM({});
2321  } else {
2322  inputState->setActive(false);
2323  }
2324  if (inputState->imChanged_) {
2325  inputState->imChanged_->setReason(InputMethodSwitchedReason::Enumerate);
2326  }
2327 
2328  return true;
2329 }
2330 
2331 std::string Instance::commitFilter(InputContext *inputContext,
2332  const std::string &orig) {
2333  std::string result = orig;
2334  emit<Instance::CommitFilter>(inputContext, result);
2335  return result;
2336 }
2337 
2338 Text Instance::outputFilter(InputContext *inputContext, const Text &orig) {
2339  Text result = orig;
2340  emit<Instance::OutputFilter>(inputContext, result);
2341  if ((&orig == &inputContext->inputPanel().clientPreedit() ||
2342  &orig == &inputContext->inputPanel().preedit()) &&
2343  !globalConfig().showPreeditForPassword() &&
2344  inputContext->capabilityFlags().test(CapabilityFlag::Password)) {
2345  Text newText;
2346  for (int i = 0, e = result.size(); i < e; i++) {
2347  auto length = utf8::length(result.stringAt(i));
2348  std::string dot;
2349  dot.reserve(length * 3);
2350  while (length != 0) {
2351  dot += "\xe2\x80\xa2";
2352  length -= 1;
2353  }
2354  newText.append(std::move(dot),
2355  result.formatAt(i) | TextFormatFlag::DontCommit);
2356  }
2357  result = std::move(newText);
2358  }
2359  return result;
2360 }
2361 
2363  FCITX_D();
2364  return d->icManager_.lastFocusedInputContext();
2365 }
2366 
2368  FCITX_D();
2369  return d->icManager_.mostRecentInputContext();
2370 }
2371 
2373  FCITX_D();
2374  d->uiManager_.flush();
2375 }
2376 
2377 int scoreForGroup(FocusGroup *group, const std::string &displayHint) {
2378  // Hardcode wayland over X11.
2379  if (displayHint.empty()) {
2380  if (group->display() == "x11:") {
2381  return 2;
2382  }
2383  if (stringutils::startsWith(group->display(), "x11:")) {
2384  return 1;
2385  }
2386  if (group->display() == "wayland:") {
2387  return 4;
2388  }
2389  if (stringutils::startsWith(group->display(), "wayland:")) {
2390  return 3;
2391  }
2392  } else {
2393  if (group->display() == displayHint) {
2394  return 2;
2395  }
2396  if (stringutils::startsWith(group->display(), displayHint)) {
2397  return 1;
2398  }
2399  }
2400  return -1;
2401 }
2402 
2403 FocusGroup *Instance::defaultFocusGroup(const std::string &displayHint) {
2404  FCITX_D();
2405  FocusGroup *defaultFocusGroup = nullptr;
2406 
2407  int score = 0;
2408  d->icManager_.foreachGroup(
2409  [&score, &displayHint, &defaultFocusGroup](FocusGroup *group) {
2410  auto newScore = scoreForGroup(group, displayHint);
2411  if (newScore > score) {
2412  defaultFocusGroup = group;
2413  score = newScore;
2414  }
2415 
2416  return true;
2417  });
2418  return defaultFocusGroup;
2419 }
2420 
2421 void Instance::activateInputMethod(InputContextEvent &event) {
2422  FCITX_D();
2423  FCITX_DEBUG() << "Instance::activateInputMethod";
2424  InputContext *ic = event.inputContext();
2425  auto *inputState = ic->propertyFor(&d->inputStateFactory_);
2426  const auto *entry = inputMethodEntry(ic);
2427  if (entry) {
2428  FCITX_DEBUG() << "Activate: "
2429  << "[Last]:" << inputState->lastIM_
2430  << " [Activating]:" << entry->uniqueName();
2431  assert(inputState->lastIM_.empty());
2432  inputState->lastIM_ = entry->uniqueName();
2433  }
2434  auto *engine = inputMethodEngine(ic);
2435  if (!engine || !entry) {
2436  return;
2437  }
2438 #ifdef ENABLE_KEYBOARD
2439  if (auto *xkbState = inputState->customXkbState(true)) {
2440  if (auto *mods = findValue(d->stateMask_, ic->display())) {
2441  FCITX_KEYTRACE() << "Update mask to customXkbState";
2442  auto depressed = std::get<0>(*mods);
2443  auto latched = std::get<1>(*mods);
2444  auto locked = std::get<2>(*mods);
2445 
2446  // set modifiers in depressed if they don't appear in any of the
2447  // final masks
2448  // depressed |= ~(depressed | latched | locked);
2449  FCITX_KEYTRACE() << depressed << " " << latched << " " << locked;
2450  if (depressed == 0) {
2451  inputState->setModsAllReleased();
2452  }
2453  xkb_state_update_mask(xkbState, depressed, latched, locked, 0, 0,
2454  0);
2455  }
2456  }
2457 #endif
2458  ic->statusArea().clearGroup(StatusGroup::InputMethod);
2459  engine->activate(*entry, event);
2460  postEvent(InputMethodActivatedEvent(entry->uniqueName(), ic));
2461 }
2462 
2463 void Instance::deactivateInputMethod(InputContextEvent &event) {
2464  FCITX_D();
2465  FCITX_DEBUG() << "Instance::deactivateInputMethod event_type="
2466  << static_cast<uint32_t>(event.type());
2467  InputContext *ic = event.inputContext();
2468  auto *inputState = ic->propertyFor(&d->inputStateFactory_);
2469  const InputMethodEntry *entry = nullptr;
2470  InputMethodEngine *engine = nullptr;
2471 
2473  auto &icEvent =
2474  static_cast<InputContextSwitchInputMethodEvent &>(event);
2475  FCITX_DEBUG() << "Switch reason: "
2476  << static_cast<int>(icEvent.reason());
2477  FCITX_DEBUG() << "Old Input method: " << icEvent.oldInputMethod();
2478  entry = d->imManager_.entry(icEvent.oldInputMethod());
2479  } else {
2480  entry = inputMethodEntry(ic);
2481  }
2482  if (entry) {
2483  FCITX_DEBUG() << "Deactivate: "
2484  << "[Last]:" << inputState->lastIM_
2485  << " [Deactivating]:" << entry->uniqueName();
2486  assert(entry->uniqueName() == inputState->lastIM_);
2487  engine = static_cast<InputMethodEngine *>(
2488  d->addonManager_.addon(entry->addon()));
2489  }
2490  inputState->lastIM_.clear();
2491  if (!engine || !entry) {
2492  return;
2493  }
2494  inputState->overrideDeactivateIM_ = entry->uniqueName();
2495  engine->deactivate(*entry, event);
2496  inputState->overrideDeactivateIM_.clear();
2497  postEvent(InputMethodDeactivatedEvent(entry->uniqueName(), ic));
2498 }
2499 
2500 bool Instance::enumerateGroup(bool forward) {
2501  auto &imManager = inputMethodManager();
2502  auto groups = imManager.groups();
2503  if (groups.size() <= 1) {
2504  return false;
2505  }
2506  if (forward) {
2507  imManager.setCurrentGroup(groups[1]);
2508  } else {
2509  imManager.setCurrentGroup(groups.back());
2510  }
2511  return true;
2512 }
2513 
2515  FCITX_DEBUG() << "Input method switched";
2516  FCITX_D();
2517  if (!d->globalConfig_.showInputMethodInformation()) {
2518  return;
2519  }
2520  d->showInputMethodInformation(ic);
2521 }
2522 
2524  const std::string &message) {
2525  FCITX_DEBUG() << "Input method switched";
2526  FCITX_D();
2527  auto *inputState = ic->propertyFor(&d->inputStateFactory_);
2528  inputState->showInputMethodInformation(message);
2529 }
2530 
2532  FCITX_D();
2533  return (isInFlatpak() &&
2534  std::filesystem::is_regular_file("/app/.updated")) ||
2535  d->addonManager_.checkUpdate() || d->imManager_.checkUpdate() ||
2536  postEvent(CheckUpdateEvent());
2537 }
2538 
2539 void Instance::setXkbParameters(const std::string &display,
2540  const std::string &rule,
2541  const std::string &model,
2542  const std::string &options) {
2543 #ifdef ENABLE_KEYBOARD
2544  FCITX_D();
2545  bool resetState = false;
2546  if (auto *param = findValue(d->xkbParams_, display)) {
2547  if (std::get<0>(*param) != rule || std::get<1>(*param) != model ||
2548  std::get<2>(*param) != options) {
2549  std::get<0>(*param) = rule;
2550  std::get<1>(*param) = model;
2551  std::get<2>(*param) = options;
2552  resetState = true;
2553  }
2554  } else {
2555  d->xkbParams_.emplace(display, std::make_tuple(rule, model, options));
2556  }
2557 
2558  if (resetState) {
2559  d->keymapCache_[display].clear();
2560  d->icManager_.foreach([d, &display](InputContext *ic) {
2561  if (ic->display() == display ||
2562  !d->xkbParams_.contains(ic->display())) {
2563  auto *inputState = ic->propertyFor(&d->inputStateFactory_);
2564  inputState->resetXkbState();
2565  }
2566  return true;
2567  });
2568  }
2569 #else
2570  FCITX_UNUSED(display);
2571  FCITX_UNUSED(rule);
2572  FCITX_UNUSED(model);
2573  FCITX_UNUSED(options);
2574 #endif
2575 }
2576 
2577 void Instance::updateXkbStateMask(const std::string &display,
2578  uint32_t depressed_mods,
2579  uint32_t latched_mods, uint32_t locked_mods) {
2580  FCITX_D();
2581  d->stateMask_[display] =
2582  std::make_tuple(depressed_mods, latched_mods, locked_mods);
2583 }
2584 
2585 void Instance::clearXkbStateMask(const std::string &display) {
2586  FCITX_D();
2587  d->stateMask_.erase(display);
2588 }
2589 
2590 const char *Instance::version() { return FCITX_VERSION_STRING; }
2591 
2592 } // namespace fcitx
void updateXkbStateMask(const std::string &display, uint32_t depressed_mods, uint32_t latched_mods, uint32_t locked_mods)
Update xkb state mask for given display.
Definition: instance.cpp:2577
Describe a Key in fcitx.
Definition: key.h:41
void restart()
Restart fcitx instance, this should only be used within a regular Fcitx server, not within embedded m...
Definition: instance.cpp:2056
void reloadAddonConfig(const std::string &addonName)
Reload certain addon config.
Definition: instance.cpp:1997
CapabilityFlags capabilityFlags() const
Returns the current capability flags.
FCITXCORE_DEPRECATED uint32_t processCompose(InputContext *ic, KeySym keysym)
Handle current XCompose state.
Definition: instance.cpp:1799
std::string inputMethodIcon(InputContext *ic)
Return the input method icon for input context.
Definition: instance.cpp:1767
void setXkbParameters(const std::string &display, const std::string &rule, const std::string &model, const std::string &options)
Set xkb RLVMO tuple for given display.
Definition: instance.cpp:2539
void activate()
Activate last focused input context. (Switch to the active input method)
Definition: instance.cpp:1939
EventType
Type of input method events.
Definition: event.h:65
Switched by alternative trigger key.
ResetEvent is generated.
void resetCompose(InputContext *inputContext)
Reset the compose state.
Definition: instance.cpp:1917
T::PropertyType * propertyFor(const T *factory)
Helper function to return the input context property in specific type by given factory.
Definition: inputcontext.h:285
std::string UCS4ToUTF8(uint32_t code)
Convert UCS4 to UTF8 string.
Definition: utf8.cpp:19
FocusInEvent is generated when client gets focused.
Formatted string commonly used in user interface.
Whether client request input method to be disabled.
FocusGroup * defaultFocusGroup(const std::string &displayHint={})
Get the default focus group with given display hint.
Definition: instance.cpp:2403
static uint32_t keySymToUnicode(KeySym sym)
Convert keysym to a unicode.
Definition: key.cpp:740
void flushUI()
All user interface update is batched internally.
Definition: instance.cpp:2372
This is generated when input method group changed.
std::string commitFilter(InputContext *inputContext, const std::string &orig)
Update the commit string to frontend.
Definition: instance.cpp:2331
AddonManager & addonManager()
Get the addon manager.
Definition: instance.cpp:1589
std::string currentInputMethod()
Return the current input method of last focused input context.
Definition: instance.cpp:1964
Simple file system related API for checking file status.
size_t length(Iter start, Iter end)
Return the number UTF-8 characters in the string iterator range.
Definition: utf8.h:33
bool validate(Iter start, Iter end)
Check if the string iterator range is valid utf8 string.
Definition: utf8.h:74
when user switch to a different input method by hand such as ctrl+shift by default, or by ui, default behavior is reset IM.
InputMethodSwitchedReason
The reason why input method is switched to another.
Definition: event.h:41
void deactivate()
Deactivate last focused input context.
Definition: instance.cpp:1978
int state()
Return a fcitx5-remote compatible value for the state.
Definition: instance.cpp:2134
Definition: action.cpp:17
InputMethodEngine * inputMethodEngine(InputContext *ic)
Return the input method engine object for given input context.
Definition: instance.cpp:1747
void setSignalPipe(int fd)
Set the pipe forwarding unix signal information.
Definition: instance.cpp:1359
InputMethodMode inputMethodMode() const
The current global input method mode.
Definition: instance.cpp:1500
void initialize()
Initialize fcitx.
Definition: instance.cpp:1406
EventLoop & eventLoop()
Get the fcitx event loop.
Definition: instance.cpp:1574
std::string currentUI()
Return the name of current user interface addon.
Definition: instance.cpp:1973
bool exitWhenMainDisplayDisconnected() const
Check whether command line specify whether to keep fcitx running.
Definition: instance.cpp:1378
C++ Utility functions for handling utf8 strings.
InputContext * mostRecentInputContext()
Return the most recent focused input context.
Definition: instance.cpp:2367
FCITX_NODISCARD std::unique_ptr< HandlerTableEntry< EventHandler > > watchEvent(EventType type, EventWatcherPhase phase, EventHandler callback)
Add a callback to for certain event type.
Definition: instance.cpp:1683
InputContextManager & inputContextManager()
Get the input context manager.
Definition: instance.cpp:1584
void setEnablePreedit(bool enable)
Override the preedit hint from client.
std::vector< std::string > split(std::string_view str, std::string_view delim, SplitBehavior behavior)
Split the string by delim.
virtual bool filtered() const
Whether a event is filtered by handler.
Definition: event.h:241
void clearGroup(StatusGroup group)
Clear only given status group.
Definition: statusarea.cpp:80
bool hasFocus() const
Returns whether the input context holds the input focus.
bool isRunning() const
Whether event loop is started and still running.
Definition: instance.cpp:1495
A class represents a formatted string.
Definition: text.h:27
bool willTryReplace() const
Check whether command line specify if it will replace an existing fcitx server.
Definition: instance.cpp:1373
Class to manage all the input method relation information.
bool isRestartRequested() const
Whether restart is requested.
Definition: instance.cpp:1514
Manager class for user interface.
Instance(int argc, char *argv[])
A main function like construct to be used to create Fcitx Instance.
Definition: instance.cpp:651
Base class for fcitx event.
Definition: event.h:212
virtual void deactivate(const InputMethodEntry &entry, InputContextEvent &event)
Called when input context switch its input method.
bool isValidChar(uint32_t c)
Check the chr value is not two invalid value above.
Definition: utf8.h:97
std::string inputMethodLabel(InputContext *ic)
Return the input method label for input context.
Definition: instance.cpp:1784
void save()
Save everything including input method profile and addon data.
Definition: instance.cpp:1931
Enum type for input context capability.
Class for status area in UI.
void resetInputMethodList()
Reset the input method configuration and recreate based on system language.
Definition: instance.cpp:2051
Switched by capability change (e.g. password field)
Base class for User Interface addon.
A thread safe class to post event to a certain EventLoop.
void clearXkbStateMask(const std::string &display)
Clear xkb state mask for given display.
Definition: instance.cpp:2585
Enum flag for text formatting.
void configure()
Launch configtool.
Definition: instance.cpp:1955
bool checkUpdate() const
Check if need to invoke Instance::refresh.
Definition: instance.cpp:2531
New Utility classes to handle application specific path.
uint32_t getChar(Iter iter, Iter end)
Get next UCS4 char from iter, do not cross end.
Definition: utf8.h:104
InvokeAction event is generated when client click on the preedit.
InputMethodManager & inputMethodManager()
Get the input method manager.
Definition: instance.cpp:1594
void reloadConfig()
Reload global config.
Definition: instance.cpp:2011
int exec()
Start the event loop of Fcitx.
Definition: instance.cpp:1472
C-style utf8 utility functions.
void setBinaryMode()
Set if this instance is running as fcitx5 binary.
Definition: instance.cpp:1550
bool isModifier() const
Check if the key is a modifier press.
Definition: key.cpp:462
InputContext * lastFocusedInputContext()
Return a focused input context.
Definition: instance.cpp:2362
std::string display() const
Returns the display server of the client.
void toggle()
Toggle between the first input method and active input method.
Definition: instance.cpp:2143
Notify the input method mode is changed.
Definition: event.h:646
void setCurrentInputMethod(const std::string &imName)
Set the input method of last focused input context.
Definition: instance.cpp:2065
void setRunning(bool running)
Let other know that event loop is already running.
Definition: instance.cpp:1490
bool canRestart() const
Check if fcitx 5 can safely restart by itself.
Definition: instance.cpp:1555
void showCustomInputMethodInformation(InputContext *ic, const std::string &message)
Show a small popup with input popup window with current input method information. ...
Definition: instance.cpp:2523
std::optional< std::string > processComposeString(InputContext *ic, KeySym keysym)
Handle current XCompose state.
Definition: instance.cpp:1847
void refresh()
Load newly installed input methods and addons.
Definition: instance.cpp:2004
Input method mode changed.
std::string inputMethod(InputContext *ic)
Return the unique name of input method for given input context.
Definition: instance.cpp:1702
UserInterfaceManager & userInterfaceManager()
Get the user interface manager.
Definition: instance.cpp:1604
void enumerate(bool forward)
Enumerate input method with in current group.
Definition: instance.cpp:2151
bool exiting() const
Check whether fcitx is in exiting process.
Definition: instance.cpp:1383
bool startsWith(std::string_view str, std::string_view prefix)
Check if a string starts with a prefix.
Definition: stringutils.cpp:86
Key sym related types.
void showInputMethodInformation(InputContext *ic)
Show a small popup with input popup window with current input method information. ...
Definition: instance.cpp:2514
StatusArea & statusArea()
Returns the associated StatusArea.
String handle utilities.
Input Method Manager For fcitx.
EventType type() const
Type of event, can be used to decide event class.
Definition: event.h:222
bool empty() const
Whether input panel is totally empty.
Definition: inputpanel.cpp:117
void setInputMethodMode(InputMethodMode mode)
Set the current global input method mode.
Definition: instance.cpp:1505
ssize_t safeRead(int fd, void *data, size_t maxlen)
a simple wrapper around read(), ignore EINTR.
Definition: fs.cpp:231
std::string addonForInputMethod(const std::string &imName)
Return the addon name of given input method.
Definition: instance.cpp:1947
Input Context Property for Fcitx.
static std::filesystem::path fcitxPath(const char *path, const std::filesystem::path &subPath={})
Return fcitx specific path defined at compile time.
An input context represents a client of Fcitx.
Definition: inputcontext.h:47
GlobalConfig & globalConfig()
Get the global config.
Definition: instance.cpp:1609
void exit()
Exit the fcitx event loop.
Definition: instance.cpp:1986
EventDispatcher & eventDispatcher()
Return a shared event dispatcher that is already attached to instance&#39;s event loop.
Definition: instance.cpp:1579
Key event is generated when client press or release a key.
const InputMethodEntry * inputMethodEntry(InputContext *ic)
Return the input method entry for given input context.
Definition: instance.cpp:1738
Class to represent a key.
Log utilities.
bool isComposing(InputContext *inputContext)
Check whether input context is composing or not.
Definition: instance.cpp:1899
static std::string keyListToString(const Container &container, KeyStringFormat format=KeyStringFormat::Portable)
Convert a key list to string.
Definition: key.h:204
Notify the global config is reloaded.
Definition: event.h:657
when using lost focus this might be variance case to case.
Addon Manager class.
static const char * version()
Return the version string of Fcitx.
Definition: instance.cpp:2590
Text outputFilter(InputContext *inputContext, const Text &orig)
Update the string that will be displayed in user interface.
Definition: instance.cpp:2338