void Action::activate() {
FCITX_D();
if (!d->enabled_) {
return;
}
emit<Action::Activated>();
}
void SurroundingText::invalidate() {
FCITX_D();
d->valid_ = false;
d->anchor_ = 0;
d->cursor_ = 0;
d->text_ = std::string();
}
void InputMethodManager::save() {
FCITX_D();
InputMethodConfig config;
std::vector<InputMethodGroupConfig> groups;
config.currentGroup.setValue(d->currentGroup_);
config.groupOrder.setValue(std::vector<std::string>{d->groupOrder_.begin(), d->groupOrder_.end()});
for (auto &p : d->groups_) {
auto &group = p.second;
groups.emplace_back();
auto &groupConfig = groups.back();
groupConfig.name.setValue(group.name());
groupConfig.defaultLayout.setValue(group.defaultLayout());
groupConfig.defaultInputMethod.setValue(group.defaultInputMethod());
std::vector<InputMethodGroupItemConfig> itemsConfig;
for (auto &item : group.inputMethodList()) {
itemsConfig.emplace_back();
auto &itemConfig = itemsConfig.back();
itemConfig.name.setValue(item.name());
itemConfig.layout.setValue(item.layout());
}
groupConfig.items.setValue(std::move(itemsConfig));
}
config.groups.setValue(std::move(groups));
RawConfig rawConfig;
config.save(rawConfig);
auto file = StandardPath::global().openUserTemp(StandardPath::Type::Config, "fcitx5/profile");
if (file.fd() >= 0) {
writeAsIni(rawConfig, file.fd());
}
}
void SurroundingText::setText(const std::string &text, unsigned int cursor, unsigned int anchor) {
FCITX_D();
d->valid_ = true;
d->text_ = text;
d->cursor_ = cursor;
d->anchor_ = anchor;
}
void Action::setMenu(Menu *menu) {
FCITX_D();
if (menu) {
menu->connect<DynamicTrackableObject::Destroyed>([this](void *) { setMenu(nullptr); });
}
d->menu_ = menu;
}
SignalBase *ConnectableObject::findSignal(const std::string &name) {
FCITX_D();
auto iter = d->signals_.find(name);
if (iter != d->signals_.end()) {
return iter->second.get();
}
return nullptr;
}
FocusGroup::~FocusGroup() {
FCITX_D();
while (!d->ics.empty()) {
auto ic = *d->ics.begin();
ic->setFocusGroup(nullptr);
}
d->manager.unregisterFocusGroup(*this);
}
void InputMethodManager::setInstance(Instance *instance) {
FCITX_D();
d->instance_ = instance;
d->eventWatcher_.reset(
d->instance_->watchEvent(EventType::InputContextKeyEvent, EventWatcherPhase::InputMethod, [this](Event &event) {
FCITX_D();
auto &keyEvent = static_cast<KeyEvent &>(event);
auto entry = d->instance_->inputMethodEntry(keyEvent.inputContext());
if (!entry) {
return;
}
auto engine = static_cast<InputMethodEngine *>(d->instance_->addonManager().addon(entry->addon()));
if (!engine) {
return;
}
engine->keyEvent(*entry, keyEvent);
}));
}
void FocusGroup::removeInputContext(InputContext *ic) {
FCITX_D();
if (ic == d->focus) {
setFocusedInputContext(nullptr);
}
auto iter = d->ics.find(ic);
assert(iter != d->ics.end());
d->ics.erase(ic);
}
void FocusGroup::setFocusedInputContext(InputContext *ic) {
FCITX_D();
assert(!ic || d->ics.count(ic) > 0);
if (d->focus) {
d->focus->setHasFocus(false);
}
d->focus = ic;
if (d->focus) {
d->focus->setHasFocus(true);
}
}
void InputMethodManager::setCurrentGroup(const std::string &groupName) {
FCITX_D();
if (std::any_of(d->groups_.begin(), d->groups_.end(),
[&groupName](const auto &group) { return group.second.name() == groupName; })) {
d->currentGroup_ = groupName;
} else {
d->currentGroup_ = d->groups_.begin()->second.name();
}
// TODO Adjust group order
// TODO, post event
}
void InputMethodManager::buildDefaultGroup() {
FCITX_D();
std::string name = _("Default");
auto result = d->groups_.emplace(name, InputMethodGroup(name));
auto &group = result.first->second;
// FIXME
group.inputMethodList().emplace_back(InputMethodGroupItem("fcitx-keyboard-us"));
group.setDefaultInputMethod("");
group.setDefaultLayout("us");
setCurrentGroup(name);
setGroupOrder({name});
}
void UserInterfaceManager::load() {
FCITX_D();
auto names = d->addonManager_->addonNames(AddonCategory::UI);
// FIXME: implement fallback
for (auto &name : names) {
auto ui = d->addonManager_->addon(name);
if (ui) {
d->ui_ = ui;
break;
}
}
}
void InputMethodManager::setGroupOrder(const std::vector<std::string> &groupOrder) {
FCITX_D();
d->groupOrder_.clear();
std::unordered_set<std::string> added;
for (auto &groupName : groupOrder) {
if (d->groups_.count(groupName)) {
d->groupOrder_.push_back(groupName);
added.insert(groupName);
}
}
for (auto &p : d->groups_) {
if (!added.count(p.first)) {
d->groupOrder_.push_back(p.first);
}
}
assert(d->groupOrder_.size() == d->groups_.size());
}
void InputMethodManager::loadConfig() {
FCITX_D();
auto &path = StandardPath::global();
auto file = path.open(StandardPath::Type::Config, "fcitx5/profile", O_RDONLY);
RawConfig config;
if (file.fd() >= 0) {
readFromIni(config, file.fd());
}
InputMethodConfig imConfig;
imConfig.load(config);
d->groups_.clear();
std::vector<std::string> tempOrder;
if (imConfig.groups.value().size()) {
auto &groupsConfig = imConfig.groups.value();
for (auto &groupConfig : groupsConfig) {
// group must have a name
if (groupConfig.name.value().empty() || groupConfig.defaultLayout.value().empty()) {
continue;
}
auto result = d->groups_.emplace(groupConfig.name.value(), InputMethodGroup(groupConfig.name.value()));
tempOrder.push_back(groupConfig.name.value());
auto &group = result.first->second;
group.setDefaultLayout(groupConfig.defaultLayout.value());
auto &items = groupConfig.items.value();
for (auto &item : items) {
group.inputMethodList().emplace_back(
std::move(InputMethodGroupItem(item.name.value()).setLayout(item.layout.value())));
}
group.setDefaultInputMethod(groupConfig.defaultInputMethod.value());
}
}
if (d->groups_.size() == 0) {
buildDefaultGroup();
} else {
setCurrentGroup(imConfig.currentGroup.value());
if (imConfig.groupOrder.value().size()) {
setGroupOrder(imConfig.groupOrder.value());
} else {
setGroupOrder(tempOrder);
}
}
}
void InputMethodManager::load() {
FCITX_D();
auto inputMethods = d->addonManager_->addonNames(AddonCategory::InputMethod);
auto &path = StandardPath::global();
auto files = path.multiOpenAll(StandardPath::Type::Data, "fcitx5/inputmethod", O_RDONLY, filter::Suffix(".conf"));
for (const auto &file : files) {
auto &files = file.second;
RawConfig config;
// reverse the order, so we end up parse user file at last.
for (auto iter = files.rbegin(), end = files.rend(); iter != end; iter++) {
auto fd = iter->fd();
readFromIni(config, fd);
}
InputMethodInfo imInfo;
imInfo.load(config);
InputMethodEntry entry = toInputMethodEntry(imInfo);
if (checkEntry(entry, inputMethods) && d->entries_.count(entry.uniqueName()) == 0) {
d->entries_.emplace(std::string(entry.uniqueName()), std::move(entry));
}
}
for (const auto &addonName : inputMethods) {
auto addonInfo = d->addonManager_->addonInfo(addonName);
// on request input method should always provides entry with config file
if (!addonInfo || addonInfo->onRequest()) {
continue;
}
auto engine = static_cast<InputMethodEngine *>(d->addonManager_->addon(addonName));
if (!engine) {
continue;
}
auto newEntries = engine->listInputMethods();
for (auto &newEntry : newEntries) {
// ok we can't let you register something werid.
if (checkEntry(newEntry, inputMethods) && newEntry.addon() == addonName &&
d->entries_.count(newEntry.uniqueName()) == 0) {
d->entries_.emplace(std::string(newEntry.uniqueName()), std::move(newEntry));
}
}
}
loadConfig();
}
void SurroundingText::deleteText(int offset, unsigned int size) {
FCITX_D();
if (!d->valid_) {
return;
}
/*
* do the real deletion here, and client might update it, but input method
* itself
* would expect a up to date value after this call.
*
* Make their life easier.
*/
int cursor_pos = d->cursor_ + offset;
size_t len = utf8::length(d->text_);
if (cursor_pos >= 0 && len - cursor_pos >= size) {
/*
* the original size must be larger, so we can do in-place copy here
* without alloc new string
*/
auto start = utf8::nthChar(d->text_, cursor_pos);
auto end = utf8::nthChar(d->text_, start, size);
int copylen = d->text_.length() - end;
for (int i = 0; i < copylen; i++) {
d->text_[start + i] = d->text_[end + i];
d->text_.erase(end);
}
d->cursor_ = cursor_pos;
} else {
d->text_.clear();
d->cursor_ = 0;
}
d->anchor_ = d->cursor_;
}
void ConnectableObject::_registerSignal(std::string name, std::unique_ptr<fcitx::SignalBase> signal) {
FCITX_D();
d->signals_.emplace(std::move(name), std::move(signal));
}
void SurroundingText::setCursor(unsigned int cursor, unsigned int anchor) {
FCITX_D();
d->cursor_ = cursor;
d->anchor_ = anchor;
}
Action &Action::setEnabled(bool enabled) {
FCITX_D();
d->enabled_ = enabled;
return *this;
}
unsigned int SurroundingText::cursor() const {
FCITX_D();
return d->cursor_;
}
unsigned int SurroundingText::anchor() const {
FCITX_D();
return d->anchor_;
}
const InputMethodGroup &InputMethodManager::currentGroup() const {
FCITX_D();
return d->groups_.find(d->currentGroup_)->second;
}
bool SurroundingText::isValid() const {
FCITX_D();
return d->valid_;
}
const InputMethodEntry *InputMethodManager::entry(const std::string &name) const {
FCITX_D();
return findValue(d->entries_, name);
}
void FocusGroup::addInputContext(InputContext *ic) {
FCITX_D();
auto iter = d->ics.insert(ic);
assert(iter.second);
}
InputContext *FocusGroup::focusedInputContext() const {
FCITX_D();
return d->focus;
}
void ConnectableObject::_unregisterSignal(const std::string &name) {
FCITX_D();
d->signals_.erase(name);
}
int InputMethodManager::groupCount() const {
FCITX_D();
return d->groups_.size();
}
const std::string &SurroundingText::text() const {
FCITX_D();
return d->text_;
}
