void* FcitxXkbDBusCreate(FcitxInstance* instance)
{
FcitxXkbDBus* xkbdbus = fcitx_utils_new(FcitxXkbDBus);
xkbdbus->owner = instance;
do {
FcitxModuleFunctionArg arg;
DBusConnection* conn = InvokeFunction(instance, FCITX_DBUS, GETCONNECTION, arg);
if (conn == NULL) {
FcitxLog(ERROR, "DBus Not initialized");
break;
}
DBusObjectPathVTable fcitxIPCVTable = {NULL, &FcitxXkbDBusEventHandler, NULL, NULL, NULL, NULL };
if (!dbus_connection_register_object_path(conn, FCITX_XKB_PATH,
&fcitxIPCVTable, xkbdbus)) {
FcitxLog(ERROR, "No memory");
break;
}
FcitxModuleFunctionArg args;
FcitxXkbRules* rules = InvokeFunction(instance, FCITX_XKB, GETRULES, args);
if (!rules)
break;
xkbdbus->rules = rules;
xkbdbus->isocodes = FcitxXkbReadIsoCodes(ISOCODES_ISO639_XML, ISOCODES_ISO3166_XML);
return xkbdbus;
} while(0);
free(xkbdbus);
return NULL;
}
void GetScreenSize(FcitxClassicUI* classicui, int* width, int* height)
{
FcitxModuleFunctionArg arg;
arg.args[0] = width;
arg.args[1] = height;
InvokeFunction(classicui->owner, FCITX_X11, GETSCREENSIZE, arg);
}
MessageWindow* CreateMessageWindow (FcitxLightUI * lightui)
{
MessageWindow* messageWindow = fcitx_malloc0(sizeof(MessageWindow));
Display *dpy = lightui->dpy;
int iScreen= lightui->iScreen;
messageWindow->owner = lightui;
messageWindow->color.r = messageWindow->color.g = messageWindow->color.b = 220.0 / 256;
messageWindow->fontColor.r = messageWindow->fontColor.g = messageWindow->fontColor.b = 0;
messageWindow->fontSize = 15;
messageWindow->width = 1;
messageWindow->height = 1;
messageWindow->window =
XCreateSimpleWindow (dpy, DefaultRootWindow (dpy), 0, 0, 1, 1, 0, WhitePixel (dpy, DefaultScreen (dpy)), WhitePixel (dpy, DefaultScreen (dpy)));
if (messageWindow->window == None)
return False;
InitMessageWindowProperty (messageWindow);
XSelectInput (dpy, messageWindow->window, ExposureMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask );
FcitxModuleFunctionArg arg;
arg.args[0] = MessageWindowEventHandler;
arg.args[1] = messageWindow;
InvokeFunction(lightui->owner, FCITX_X11, ADDXEVENTHANDLER, arg);
return messageWindow;
}
XlibMenu* CreateXlibMenu(FcitxLightUI *lightui)
{
XlibMenu *menu = fcitx_malloc0(sizeof(XlibMenu));
menu->owner = lightui;
InitXlibMenu(menu);
FcitxModuleFunctionArg arg;
arg.args[0] = MenuWindowEventHandler;
arg.args[1] = menu;
InvokeFunction(lightui->owner, FCITX_X11, ADDXEVENTHANDLER, arg);
arg.args[0] = ReloadXlibMenu;
arg.args[1] = menu;
InvokeFunction(lightui->owner, FCITX_X11, ADDCOMPOSITEHANDLER, arg);
return menu;
}
void ClassicUISetWindowProperty(FcitxClassicUI* classicui, Window window, FcitxXWindowType type, char *windowTitle)
{
FcitxModuleFunctionArg arg;
arg.args[0] = &window;
arg.args[1] = &type;
arg.args[2] = windowTitle;
InvokeFunction(classicui->owner, FCITX_X11, SETWINDOWPROP, arg);
}
void* LightUICreate(FcitxInstance* instance)
{
FcitxModuleFunctionArg arg;
FcitxLightUI* lightui = fcitx_utils_malloc0(sizeof(FcitxLightUI));
FcitxAddon* lightuiaddon = FcitxAddonsGetAddonByName(FcitxInstanceGetAddons(instance), FCITX_LIGHT_UI_NAME);
lightui->owner = instance;
if (!LoadLightUIConfig(lightui))
{
free(lightui);
return NULL;
}
lightui->dpy = InvokeFunction(instance, FCITX_X11, GETDISPLAY, arg);
if (lightui->dpy == NULL)
{
free(lightui);
return NULL;
}
lightui->isfallback = FcitxUIIsFallback(instance, lightuiaddon);
lightui->iScreen = DefaultScreen(lightui->dpy);
CreateFont(lightui);
lightui->protocolAtom = XInternAtom (lightui->dpy, "WM_PROTOCOLS", False);
lightui->killAtom = XInternAtom (lightui->dpy, "WM_DELETE_WINDOW", False);
/* Main Menu Initial */
FcitxMenuInit(&lightui->mainMenu);
FcitxUIMenu **menupp;
UT_array* uimenus = FcitxInstanceGetUIMenus(instance);
for (menupp = (FcitxUIMenu **) utarray_front(uimenus);
menupp != NULL;
menupp = (FcitxUIMenu **) utarray_next(uimenus, menupp)
)
{
FcitxUIMenu * menup = *menupp;
if (!menup->isSubMenu)
FcitxMenuAddMenuItem(&lightui->mainMenu, menup->name, MENUTYPE_SUBMENU, menup);
}
FcitxMenuAddMenuItem(&lightui->mainMenu, NULL, MENUTYPE_DIVLINE, NULL);
FcitxMenuAddMenuItem(&lightui->mainMenu, _("Configure"), MENUTYPE_SIMPLE, NULL);
FcitxMenuAddMenuItem(&lightui->mainMenu, _("Exit"), MENUTYPE_SIMPLE, NULL);
lightui->mainMenu.MenuAction = MainMenuAction;
lightui->mainMenu.priv = lightui;
lightui->mainMenu.mark = -1;
lightui->inputWindow = CreateInputWindow(lightui);
lightui->mainWindow = CreateMainWindow(lightui);
lightui->trayWindow = CreateTrayWindow(lightui);
lightui->mainMenuWindow = CreateMainMenuWindow(lightui);
FcitxIMEventHook resethk;
resethk.arg = lightui;
resethk.func = LightUIInputReset;
FcitxInstanceRegisterResetInputHook(instance, resethk);
return lightui;
}
FcitxRect GetScreenGeometry(FcitxClassicUI* classicui, int x, int y)
{
FcitxModuleFunctionArg arg;
FcitxRect result = { 0, 0 , 0 , 0 };
arg.args[0] = &x;
arg.args[1] = &y;
arg.args[2] = &result;
InvokeFunction(classicui->owner, FCITX_X11, GETSCREENGEOMETRY, arg);
return result;
}
TrayWindow* CreateTrayWindow(FcitxClassicUI *classicui)
{
TrayWindow *trayWindow = fcitx_utils_malloc0(sizeof(TrayWindow));
trayWindow->owner = classicui;
FcitxModuleFunctionArg arg;
arg.args[0] = TrayEventHandler;
arg.args[1] = trayWindow;
InvokeFunction(classicui->owner, FCITX_X11, ADDXEVENTHANDLER, arg);
InitTrayWindow(trayWindow);
return trayWindow;
}
boolean
ClassicUIMouseClick(FcitxClassicUI* classicui, Window window, int *x, int *y)
{
boolean bMoved = false;
FcitxModuleFunctionArg arg;
arg.args[0] = &window;
arg.args[1] = x;
arg.args[2] = y;
arg.args[3] = &bMoved;
InvokeFunction(classicui->owner, FCITX_X11, MOUSECLICK, arg);
return bMoved;
}
void
ClassicUIInitWindowAttribute(FcitxClassicUI* classicui, Visual ** vs, Colormap * cmap,
XSetWindowAttributes * attrib,
unsigned long *attribmask, int *depth)
{
FcitxModuleFunctionArg arg;
arg.args[0] = vs;
arg.args[1] = cmap;
arg.args[2] = attrib;
arg.args[3] = attribmask;
arg.args[4] = depth;
InvokeFunction(classicui->owner, FCITX_X11, INITWINDOWATTR, arg);
}
boolean QuickPhrasePostFilter(void* arg, FcitxKeySym sym,
unsigned int state,
INPUT_RETURN_VALUE *retval
)
{
QuickPhraseState *qpstate = (QuickPhraseState*) arg;
FcitxInputState *input = FcitxInstanceGetInputState(qpstate->owner);
boolean disableQuickPhrase = FcitxInstanceGetContextBoolean(qpstate->owner, CONTEXT_DISABLE_QUICKPHRASE);
if (*retval != IRV_TO_PROCESS)
return false;
if (!disableQuickPhrase
&& !qpstate->enabled
&& FcitxInputStateGetRawInputBufferSize(input) == 0
&& FcitxHotkeyIsHotKey(sym, state, QuickPhraseTriggerKeys[qpstate->triggerKey])) {
FcitxInstanceCleanInputWindow(qpstate->owner);
FcitxInputStateSetShowCursor(input, true);
FcitxMessagesAddMessageAtLast(FcitxInputStateGetAuxUp(input), MSG_TIPS, "%s", _("Quick Phrase: "));
FcitxInputStateSetCursorPos(input, 0);
char c[2] = { (char) (QuickPhraseTriggerKeys[qpstate->triggerKey][0].sym & 0xff), '\0'};
FcitxModuleFunctionArg farg;
FcitxKeySym s = QuickPhraseTriggerKeys[qpstate->triggerKey][0].sym;
farg.args[0] = &s;
char* strTemp = InvokeFunction(qpstate->owner, FCITX_PUNC, GETPUNC, farg);
const char* full = strTemp ? strTemp : c;
FcitxMessagesAddMessageAtLast(FcitxInputStateGetAuxDown(input), MSG_TIPS, _("Space for %s Enter for %s") , full, c);
qpstate->enabled = true;
*retval = IRV_DISPLAY_MESSAGE;
return true;
}
return false;
}
void* ClassicUICreate(FcitxInstance* instance)
{
FcitxAddon* classicuiaddon = FcitxAddonsGetAddonByName(FcitxInstanceGetAddons(instance), FCITX_CLASSIC_UI_NAME);
FcitxModuleFunctionArg arg;
FcitxClassicUI* classicui = fcitx_utils_malloc0(sizeof(FcitxClassicUI));
classicui->owner = instance;
if (!LoadClassicUIConfig(classicui)) {
free(classicui);
return NULL;
}
if (GetSkinDesc() == NULL) {
free(classicui);
return NULL;
}
classicui->dpy = InvokeFunction(instance, FCITX_X11, GETDISPLAY, arg);
if (classicui->dpy == NULL) {
free(classicui);
return NULL;
}
if (LoadSkinConfig(&classicui->skin, &classicui->skinType)) {
free(classicui);
return NULL;
}
classicui->isfallback = FcitxUIIsFallback(instance, classicuiaddon);
classicui->iScreen = DefaultScreen(classicui->dpy);
classicui->protocolAtom = XInternAtom(classicui->dpy, "WM_PROTOCOLS", False);
classicui->killAtom = XInternAtom(classicui->dpy, "WM_DELETE_WINDOW", False);
InitSkinMenu(classicui);
FcitxUIRegisterMenu(instance, &classicui->skinMenu);
/* Main Menu Initial */
FcitxMenuInit(&classicui->mainMenu);
FcitxMenuAddMenuItem(&classicui->mainMenu, _("About Fcitx"), MENUTYPE_SIMPLE, NULL);
FcitxMenuAddMenuItem(&classicui->mainMenu, _("Online Help"), MENUTYPE_SIMPLE, NULL);
FcitxMenuAddMenuItem(&classicui->mainMenu, NULL, MENUTYPE_DIVLINE, NULL);
FcitxUIMenu **menupp;
UT_array* uimenus = FcitxInstanceGetUIMenus(instance);
for (menupp = (FcitxUIMenu **) utarray_front(uimenus);
menupp != NULL;
menupp = (FcitxUIMenu **) utarray_next(uimenus, menupp)
) {
FcitxUIMenu * menup = *menupp;
if (!menup->isSubMenu)
FcitxMenuAddMenuItem(&classicui->mainMenu, menup->name, MENUTYPE_SUBMENU, menup);
}
FcitxMenuAddMenuItem(&classicui->mainMenu, NULL, MENUTYPE_DIVLINE, NULL);
FcitxMenuAddMenuItem(&classicui->mainMenu, _("Configure"), MENUTYPE_SIMPLE, NULL);
FcitxMenuAddMenuItem(&classicui->mainMenu, _("Exit"), MENUTYPE_SIMPLE, NULL);
classicui->mainMenu.MenuAction = MainMenuAction;
classicui->mainMenu.priv = classicui;
classicui->mainMenu.mark = -1;
classicui->inputWindow = CreateInputWindow(classicui);
classicui->mainWindow = CreateMainWindow(classicui);
classicui->trayWindow = CreateTrayWindow(classicui);
classicui->aboutWindow = CreateAboutWindow(classicui);
classicui->messageWindow = CreateMessageWindow(classicui);
classicui->mainMenuWindow = CreateMainMenuWindow(classicui);
FcitxIMEventHook resethk;
resethk.arg = classicui;
resethk.func = ClassicUIInputReset;
FcitxInstanceRegisterResetInputHook(instance, resethk);
DisplaySkin(classicui, classicui->skinType);
/* ensure order ! */
AddFunction(classicuiaddon, ClassicUILoadImage);
AddFunction(classicuiaddon, ClassicUIGetKeyBoardFontColor);
AddFunction(classicuiaddon, ClassicUIGetFont);
return classicui;
}
DBusHandlerResult FcitxXkbDBusEventHandler (DBusConnection *connection,
DBusMessage *message,
void *user_data)
{
FcitxXkbDBus* xkbdbus = user_data;
if (dbus_message_is_method_call(message, DBUS_INTERFACE_INTROSPECTABLE, "Introspect")) {
DBusMessage *reply = dbus_message_new_method_return(message);
dbus_message_append_args(reply, DBUS_TYPE_STRING, &introspection_xml, DBUS_TYPE_INVALID);
dbus_connection_send(connection, reply, NULL);
dbus_message_unref(reply);
return DBUS_HANDLER_RESULT_HANDLED;
} else if (dbus_message_is_method_call(message, FCITX_XKB_INTERFACE, "GetLayouts")) {
DBusMessage *reply = dbus_message_new_method_return(message);
FcitxXkbDBusGetLayouts(xkbdbus, reply);
dbus_connection_send(connection, reply, NULL);
dbus_message_unref(reply);
dbus_connection_flush(connection);
return DBUS_HANDLER_RESULT_HANDLED;
} else if (dbus_message_is_method_call(message, FCITX_XKB_INTERFACE, "SetLayoutForIM")) {
DBusError error;
dbus_error_init(&error);
char* im, *layout, *variant;
if (dbus_message_get_args(message, &error, DBUS_TYPE_STRING, &im, DBUS_TYPE_STRING, &layout, DBUS_TYPE_STRING, &variant, DBUS_TYPE_INVALID)) {
FcitxModuleFunctionArg args;
args.args[0] = im;
args.args[1] = layout;
args.args[2] = variant;
InvokeFunction(xkbdbus->owner, FCITX_XKB, SETLAYOUTOVERRIDE, args);
}
DBusMessage *reply = dbus_message_new_method_return(message);
dbus_connection_send(connection, reply, NULL);
dbus_message_unref(reply);
dbus_connection_flush(connection);
return DBUS_HANDLER_RESULT_HANDLED;
} else if (dbus_message_is_method_call(message, FCITX_XKB_INTERFACE, "SetDefaultLayout")) {
DBusError error;
dbus_error_init(&error);
char *layout, *variant;
if (dbus_message_get_args(message, &error, DBUS_TYPE_STRING, &layout, DBUS_TYPE_STRING, &variant, DBUS_TYPE_INVALID)) {
FcitxModuleFunctionArg args;
args.args[0] = layout;
args.args[1] = variant;
InvokeFunction(xkbdbus->owner, FCITX_XKB, SETDEFAULTLAYOUT, args);
}
DBusMessage *reply = dbus_message_new_method_return(message);
dbus_connection_send(connection, reply, NULL);
dbus_message_unref(reply);
dbus_connection_flush(connection);
return DBUS_HANDLER_RESULT_HANDLED;
} else if (dbus_message_is_method_call(message, FCITX_XKB_INTERFACE, "GetLayoutForIM")) {
DBusError error;
dbus_error_init(&error);
char* im = NULL, *layout = NULL, *variant = NULL;
if (dbus_message_get_args(message, &error, DBUS_TYPE_STRING, &im, DBUS_TYPE_INVALID)) {
FcitxModuleFunctionArg args;
args.args[0] = im;
args.args[1] = &layout;
args.args[2] = &variant;
InvokeFunction(xkbdbus->owner, FCITX_XKB, GETLAYOUTOVERRIDE, args);
if (!layout)
layout = "";
if (!variant)
variant = "";
DBusMessage *reply = dbus_message_new_method_return(message);
dbus_message_append_args(reply, DBUS_TYPE_STRING, &layout, DBUS_TYPE_STRING, &variant, DBUS_TYPE_INVALID);
dbus_connection_send(connection, reply, NULL);
dbus_message_unref(reply);
dbus_connection_flush(connection);
}
return DBUS_HANDLER_RESULT_HANDLED;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
char *GetCurrentString(FcitxCloudPinyin* cloudpinyin)
{
FcitxIM* im = FcitxInstanceGetCurrentIM(cloudpinyin->owner);
if (!im)
return NULL;
FcitxInputState* input = FcitxInstanceGetInputState(cloudpinyin->owner);
char* string = FcitxUIMessagesToCString(FcitxInputStateGetPreedit(input));
char p[MAX_USER_INPUT + 1], *pinyin, *lastpos;
pinyin = SplitHZAndPY(string);
lastpos = pinyin;
boolean endflag;
int hzlength = pinyin - string;
size_t plength = hzlength;
strncpy(p, string, hzlength);
p[hzlength] = '\0';
do
{
endflag = (*pinyin != '\0');
if (*pinyin == ' ' || *pinyin == '\'' || *pinyin == '\0')
{
*pinyin = 0;
if (*lastpos != '\0')
{
char* result = NULL;
FcitxModuleFunctionArg arg;
arg.args[0] = lastpos;
boolean isshuangpin = false;
if (strcmp(im->uniqueName, "sunpinyin") == 0)
{
boolean issp = false;
arg.args[1] = &issp;
result = FcitxModuleInvokeFunctionByName(cloudpinyin->owner, "fcitx-sunpinyin", 0, arg);
isshuangpin = issp;
}
else if (strcmp(im->uniqueName, "shuangpin") == 0)
{
isshuangpin = true;
result = InvokeFunction(cloudpinyin->owner, FCITX_PINYIN, SP2QP, arg);
}
if (isshuangpin)
{
if (result)
{
if (plength + strlen(result) < MAX_USER_INPUT)
{
strcat(p + plength, result);
plength += strlen(result);
free(result);
}
else
{
p[hzlength] = '\0';
break;
}
}
}
else
{
if (plength + strlen(lastpos) < MAX_USER_INPUT)
{
strcat(p + plength, lastpos);
plength += strlen(lastpos);
}
else
{
p[hzlength] = '\0';
break;
}
}
}
lastpos = pinyin + 1;
}
pinyin ++;
} while(endflag);
free(string);
/* no pinyin append, return NULL for off it */
if (p[hzlength] == '\0')
return NULL;
else
return strdup(p);
}
INPUT_RETURN_VALUE QuickPhraseGetCandWords(QuickPhraseState* qpstate)
{
int iInputLen;
QUICK_PHRASE searchKey, *pKey, *currentQuickPhrase, *lastQuickPhrase;
FcitxInputState *input = FcitxInstanceGetInputState(qpstate->owner);
FcitxInstance *instance = qpstate->owner;
FcitxGlobalConfig* config = FcitxInstanceGetGlobalConfig(instance);
FcitxInstanceCleanInputWindowDown(qpstate->owner);
FcitxCandidateWordSetPageSize(FcitxInputStateGetCandidateList(input), config->iMaxCandWord);
FcitxCandidateWordSetChoose(FcitxInputStateGetCandidateList(input), DIGIT_STR_CHOOSE);
pKey = &searchKey;
{
FcitxModuleFunctionArg arg;
char *text = FcitxInputStateGetRawInputBuffer(input);
arg.args[0] = text;
arg.args[1] = QuickPhraseGetLuaCandWord;
arg.args[2] = qpstate;
InvokeFunction(qpstate->owner, FCITX_LUA, CALLCOMMAND, arg);
}
if (!qpstate->quickPhrases)
return IRV_DISPLAY_MESSAGE;
iInputLen = strlen(FcitxInputStateGetRawInputBuffer(input));
if (iInputLen > QUICKPHRASE_CODE_LEN)
return IRV_DISPLAY_MESSAGE;
strcpy(searchKey.strCode, FcitxInputStateGetRawInputBuffer(input));
currentQuickPhrase = utarray_custom_bsearch(pKey, qpstate->quickPhrases, false, PhraseCmp);
qpstate->iFirstQuickPhrase = utarray_eltidx(qpstate->quickPhrases, currentQuickPhrase);
lastQuickPhrase = utarray_custom_bsearch(pKey, qpstate->quickPhrases, false, PhraseCmpA);
qpstate->iLastQuickPhrase = utarray_eltidx(qpstate->quickPhrases, lastQuickPhrase);
if (qpstate->iLastQuickPhrase < 0)
qpstate->iLastQuickPhrase = utarray_len(qpstate->quickPhrases);
if (!currentQuickPhrase || strncmp(FcitxInputStateGetRawInputBuffer(input), currentQuickPhrase->strCode, iInputLen)) {
currentQuickPhrase = NULL;
return IRV_DISPLAY_MESSAGE;
}
for (currentQuickPhrase = (QUICK_PHRASE*) utarray_eltptr(qpstate->quickPhrases,
qpstate->iFirstQuickPhrase);
currentQuickPhrase != NULL;
currentQuickPhrase = (QUICK_PHRASE*) utarray_next(qpstate->quickPhrases, currentQuickPhrase)) {
if (!strncmp(FcitxInputStateGetRawInputBuffer(input), currentQuickPhrase->strCode, iInputLen)) {
QuickPhraseCand* qpcand = fcitx_utils_malloc0(sizeof(QuickPhraseCand));
qpcand->cand = currentQuickPhrase;
FcitxCandidateWord candWord;
candWord.callback = QuickPhraseGetCandWord;
candWord.owner = qpstate;
candWord.priv = qpcand;
candWord.strExtra = strdup(currentQuickPhrase->strCode + iInputLen);
candWord.strWord = strdup(currentQuickPhrase->strPhrase);
candWord.wordType = MSG_OTHER;
candWord.extraType = MSG_CODE;
FcitxCandidateWordAppend(FcitxInputStateGetCandidateList(input), &candWord);
}
}
return IRV_DISPLAY_MESSAGE;
}
boolean QuickPhrasePreFilter(void* arg, FcitxKeySym sym,
unsigned int state,
INPUT_RETURN_VALUE *retval
)
{
QuickPhraseState *qpstate = (QuickPhraseState*) arg;
FcitxInputState *input = FcitxInstanceGetInputState(qpstate->owner);
if (qpstate->enabled) {
FcitxKeySym keymain = FcitxHotkeyPadToMain(sym);
if (FcitxHotkeyIsHotKeySimple(keymain, state)) {
*retval = QuickPhraseDoInput(qpstate, keymain, state);
if (*retval == IRV_TO_PROCESS) {
if (strlen(FcitxInputStateGetRawInputBuffer(input)) == 0
&& (FcitxHotkeyIsHotKey(keymain, state, QuickPhraseTriggerKeys[qpstate->triggerKey]) || FcitxHotkeyIsHotKey(keymain, state, FCITX_SPACE))) {
char c[2] = { (char) (QuickPhraseTriggerKeys[qpstate->triggerKey][0].sym & 0xff), '\0'};
FcitxModuleFunctionArg farg;
FcitxKeySym s = QuickPhraseTriggerKeys[qpstate->triggerKey][0].sym;
farg.args[0] = &s;
char* strTemp = InvokeFunction(qpstate->owner, FCITX_PUNC, GETPUNC, farg);
strcpy(FcitxInputStateGetOutputString(input), strTemp ? strTemp : c);
*retval = IRV_COMMIT_STRING;
} else {
char buf[2];
buf[0] = keymain;
buf[1] = '\0';
if (strlen(FcitxInputStateGetRawInputBuffer(input)) < MAX_USER_INPUT)
strcat(FcitxInputStateGetRawInputBuffer(input), buf);
ShowQuickPhraseMessage(qpstate);
*retval = QuickPhraseGetCandWords(qpstate);
}
} else
return true;
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_BACKSPACE)) {
size_t len = strlen(FcitxInputStateGetRawInputBuffer(input));
if (len > 0)
FcitxInputStateGetRawInputBuffer(input)[--len] = '\0';
if (len == 0) {
*retval = IRV_CLEAN;
} else {
ShowQuickPhraseMessage(qpstate);
*retval = QuickPhraseGetCandWords(qpstate);
}
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_ENTER)) {
if (strlen(FcitxInputStateGetRawInputBuffer(input)) > 0) {
strcpy(FcitxInputStateGetOutputString(input), FcitxInputStateGetRawInputBuffer(input));
QuickPhraseReset(qpstate);
*retval = IRV_COMMIT_STRING;
} else {
char c[2] = { (char) (QuickPhraseTriggerKeys[qpstate->triggerKey][0].sym & 0xff), '\0'};
strcpy(FcitxInputStateGetOutputString(input), c);
*retval = IRV_COMMIT_STRING;
}
} else if (FcitxHotkeyIsHotKey(sym, state, FCITX_ESCAPE)) {
*retval = IRV_CLEAN;
} else
*retval = IRV_DO_NOTHING;
if (*retval == IRV_DISPLAY_MESSAGE) {
FcitxMessagesSetMessageCount(FcitxInputStateGetAuxDown(input), 0);
if (FcitxCandidateWordPageCount(FcitxInputStateGetCandidateList(input)) == 0)
FcitxMessagesAddMessageAtLast(FcitxInputStateGetAuxDown(input), MSG_TIPS, "%s", _("Press Enter to input text"));
}
return true;
}
return false;
}
Visual * ClassicUIFindARGBVisual(FcitxClassicUI* classicui)
{
FcitxModuleFunctionArg arg;
return InvokeFunction(classicui->owner, FCITX_X11, FINDARGBVISUAL, arg);
}
void* XimCreate(FcitxInstance* instance, int frontendid)
{
if (ximfrontend != NULL)
return NULL;
FcitxXimFrontend* xim = fcitx_utils_malloc0(sizeof(FcitxXimFrontend));
if (xim == NULL)
return NULL;
ximfrontend = xim;
XIMStyles *input_styles;
XIMEncodings *encodings;
char *imname = NULL;
char *p;
FcitxModuleFunctionArg arg;
xim->display = InvokeFunction(instance, FCITX_X11, GETDISPLAY, arg);
if (xim->display == NULL) {
FcitxLog(FATAL, _("X11 not initialized"));
free(xim);
return NULL;
}
xim->iScreen = DefaultScreen(xim->display);
xim->owner = instance;
xim->frontendid = frontendid;
xim->ximWindow = XCreateSimpleWindow(xim->display, DefaultRootWindow(xim->display), 0, 0, 1, 1, 1, 0, 0);
if (xim->ximWindow == (Window) NULL) {
FcitxLog(FATAL, _("Can't Create imWindow"));
free(xim);
return NULL;
}
if (!imname) {
imname = getenv("XMODIFIERS");
if (imname) {
if (strstr(imname, "@im="))
imname += 4;
else {
FcitxLog(WARNING, _("XMODIFIERS Error."));
imname = DEFAULT_IMNAME;
}
} else {
FcitxLog(WARNING, _("Please set XMODIFIERS."));
imname = DEFAULT_IMNAME;
}
}
if (GetXimConfigDesc() == NULL)
xim->bUseOnTheSpotStyle = false;
else {
FcitxConfigFileDesc* configDesc = GetXimConfigDesc();
FILE *fp;
char *file;
fp = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-xim.config", "r", &file);
FcitxLog(DEBUG, "Load Config File %s", file);
free(file);
if (!fp) {
if (errno == ENOENT) {
char *file;
FILE *fp2 = FcitxXDGGetFileUserWithPrefix("conf", "fcitx-xim.config", "w", &file);
FcitxLog(DEBUG, "Save Config to %s", file);
FcitxConfigSaveConfigFileFp(fp2, &xim->gconfig, configDesc);
free(file);
if (fp2)
fclose(fp2);
}
}
FcitxConfigFile *cfile = FcitxConfigParseConfigFileFp(fp, configDesc);
FcitxXimFrontendConfigBind(xim, cfile, configDesc);
FcitxConfigBindSync((FcitxGenericConfig*)xim);
if (fp)
fclose(fp);
}
input_styles = (XIMStyles *) malloc(sizeof(XIMStyles));
if (xim->bUseOnTheSpotStyle) {
input_styles->count_styles = sizeof(OnTheSpot_Styles) / sizeof(XIMStyle) - 1;
input_styles->supported_styles = OnTheSpot_Styles;
} else {
input_styles->count_styles = sizeof(OverTheSpot_Styles) / sizeof(XIMStyle) - 1;
input_styles->supported_styles = OverTheSpot_Styles;
}
encodings = (XIMEncodings *) malloc(sizeof(XIMEncodings));
encodings->count_encodings = sizeof(zhEncodings) / sizeof(XIMEncoding) - 1;
encodings->supported_encodings = zhEncodings;
p = getenv("LC_CTYPE");
if (!p) {
p = getenv("LC_ALL");
if (!p)
p = getenv("LANG");
}
if (p) {
if (!strcasestr(strLocale, p)) {
strcat(strLocale, ",");
strcat(strLocale, p);
}
}
xim->ims = IMOpenIM(xim->display,
IMModifiers, "Xi18n",
IMServerWindow, xim->ximWindow,
IMServerName, imname,
IMLocale, strLocale,
IMServerTransport, "X/",
IMInputStyles, input_styles,
IMEncodingList, encodings,
IMProtocolHandler, XimProtocolHandler,
IMFilterEventMask, KeyPressMask | KeyReleaseMask,
NULL);
free(input_styles);
free(encodings);
if (xim->ims == (XIMS) NULL) {
FcitxLog(ERROR, _("Start XIM error. Another XIM daemon named %s is running?"), imname);
free(xim);
return NULL;
}
return xim;
}
//------------------------------------------------------------------------------
float Evaluator::Evaluate(const vector<Token>& expression, const Environment* env)
{
// Now perform the actual shunting :)
for (size_t i = 0; i < expression.size(); ++i)
{
const Token& t = expression[i];
if (t.type == Token::Type::Constant)
{
operandStack.push_back(t);
}
else if (t.type == Token::Type::BinOp)
{
// Apply any higher priority operators
int prio = BINOP_PRIO[t.binOp];
while (!operatorStack.empty())
{
const Token& op = operatorStack.back();
if (op.type == Token::Type::BinOp && BINOP_PRIO[op.binOp] >= prio)
{
ApplyBinOp(op.binOp);
operatorStack.pop_back();
}
else
break;
}
operatorStack.push_back(t);
}
else if (t.type == Token::Type::FuncCall)
{
operatorStack.push_back(t);
}
else if (t.type == Token::Type::LeftParen)
{
operatorStack.push_back(t);
}
else if (t.type == Token::Type::Comma)
{
// apply all the operators until the left paren
ApplyUntilLeftParen(false);
}
else if (t.type == Token::Type::RightParen)
{
ApplyUntilLeftParen(true);
if (!operatorStack.empty())
{
// if the token at the top of the operator stack is a function call,
// then invoke it
Token t = operatorStack.back();
if (t.type == Token::Type::FuncCall)
{
InvokeFunction(t, env);
operatorStack.pop_back();
}
}
}
else if (t.type == Token::Type::Var)
{
LookupVar(t, env);
}
}
// apply all the remaining operators
while (!operatorStack.empty())
{
ApplyBinOp(PopOperator().binOp);
}
return PopValue();
}
Visual * LightUIFindARGBVisual (FcitxLightUI* lightui)
{
FcitxModuleFunctionArg arg;
return InvokeFunction(lightui->owner, FCITX_X11, FINDARGBVISUAL, arg);
}
