1 /***************************************************************************
2  *   Copyright (C) 2010~2010 by CSSlayer                                   *
3  *   wengxt@gmail.com                                                      *
4  *                                                                         *
5  *   This program is free software; you can redistribute it and/or modify  *
6  *   it under the terms of the GNU General Public License as published by  *
7  *   the Free Software Foundation; either version 2 of the License, or     *
8  *   (at your option) any later version.                                   *
9  *                                                                         *
10  *   This program is distributed in the hope that it will be useful,       *
11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
13  *   GNU General Public License for more details.                          *
14  *                                                                         *
15  *   You should have received a copy of the GNU General Public License     *
16  *   along with this program; if not, write to the                         *
17  *   Free Software Foundation, Inc.,                                       *
18  *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.              *
19  ***************************************************************************/
20 
21 /**
22  * @addtogroup Fcitx
23  * @{
24  */
25 
26 #ifndef _FCITX_FRONTEND_H_
27 #define _FCITX_FRONTEND_H_
28 
29 #include <stdint.h>
30 
31 #include <fcitx-utils/utarray.h>
32 #include <fcitx-config/fcitx-config.h>
33 #include <fcitx-config/hotkey.h>
34 #include <fcitx/ime.h>
35 
36 #ifdef __cplusplus
37 extern "C" {
38 #endif
39 
40     struct _FcitxInstance;
41     typedef void* (*FcitxICDataAllocCallback)(void* arg);
42     typedef void (*FcitxICDataFreeCallback)(void* arg, void* data);
43     typedef void* (*FcitxICDataCopyCallback)(void* arg, void* data, void* src);
44 
45     /**
46      * Input Method State
47      **/
48     typedef enum _FcitxContextState {
49         IS_CLOSED = 0,
50         IS_INACTIVE,
51         IS_ACTIVE,
52         IS_ENG = IS_INACTIVE /* backward compatible */
53     } FcitxContextState;
54 
55     /** fcitx input context capacity flags */
56     typedef enum _FcitxCapacityFlags {
57         CAPACITY_NONE = 0,
58         CAPACITY_CLIENT_SIDE_UI = (1 << 0),
59         CAPACITY_PREEDIT = (1 << 1),
60         CAPACITY_CLIENT_SIDE_CONTROL_STATE =  (1 << 2),
61         CAPACITY_PASSWORD = (1 << 3),
62         CAPACITY_FORMATTED_PREEDIT = (1 << 4),
63         CAPACITY_CLIENT_UNFOCUS_COMMIT = (1 << 5),
64         CAPACITY_SURROUNDING_TEXT = (1 << 6),
65         CAPACITY_EMAIL = (1 << 7),
66         CAPACITY_DIGIT = (1 << 8),
67         CAPACITY_UPPERCASE = (1 << 9),
68         CAPACITY_LOWERCASE = (1 << 10),
69         CAPACITY_NOAUTOUPPERCASE = (1 << 11),
70         CAPACITY_URL = (1 << 12),
71         CAPACITY_DIALABLE = (1 << 13),
72         CAPACITY_NUMBER = (1 << 14),
73         CAPACITY_NO_ON_SCREEN_KEYBOARD = (1 << 15),
74         CAPACITY_SPELLCHECK = (1 << 16),
75         CAPACITY_NO_SPELLCHECK = (1 << 17),
76         CAPACITY_WORD_COMPLETION = (1 << 18),
77         CAPACITY_UPPERCASE_WORDS = (1 << 19),
78         CAPACITY_UPPERCASE_SENTENCES = (1 << 20),
79         CAPACITY_ALPHA = (1 << 21),
80         CAPACITY_NAME = (1 << 22),
81         CAPACITY_GET_IM_INFO_ON_FOCUS = (1 << 23),
82         CAPACITY_RELATIVE_CURSOR_RECT = (1 << 24),
83     } FcitxCapacityFlags;
84 
85     /**
86      * Input Context, normally one for one program
87      **/
88     typedef struct _FcitxInputContext {
89         FcitxContextState state; /**< input method state */
90         int offset_x; /**< x offset to the window */
91         int offset_y; /**< y offset to the window */
92         int frontendid; /**< frontend id */
93         void *privateic; /**< private input context data */
94         FcitxCapacityFlags contextCaps; /**< input context capacity */
95         struct _FcitxInputContext* next; /**< next input context */
96     } FcitxInputContext;
97 
98     typedef struct _FcitxInputContext2 {
99         FcitxInputContext inputContext;
100         char* imname;
101         intptr_t switchBySwitchKey;
102         UT_array* data;
103         char* prgname; /**< program name */
104         union {
105             FcitxTriState mayUsePreedit;
106             void* _dummy;
107         };
108         void* padding[12];
109     } FcitxInputContext2;
110 
111     /**
112      * Program IM Module Frontend
113      **/
114     typedef struct _FcitxFrontend {
115         void* (*Create)(struct _FcitxInstance*, int frontendindex); /**< frontend create callback */
116         boolean(*Destroy)(void *arg); /**< frontend destroy callback */
117         void (*CreateIC)(void* arg, FcitxInputContext*, void* priv); /**< frontend create input context callback */
118         boolean(*CheckIC)(void* arg, FcitxInputContext* arg1, void* arg2); /**< frontend check context with private value callback */
119         void (*DestroyIC)(void* arg, FcitxInputContext *context); /**< frontend destroy input context callback */
120         void (*EnableIM)(void* arg, FcitxInputContext* arg1); /**< frontend enable input method to client callback */
121         void (*CloseIM)(void* arg, FcitxInputContext* arg1); /**< frontend close input method to client callback */
122         void (*CommitString)(void* arg, FcitxInputContext* arg1, const char* arg2); /**< frontend commit string callback */
123         void (*ForwardKey)(void* arg, FcitxInputContext* arg1, FcitxKeyEventType event, FcitxKeySym sym, unsigned int state); /**< frontend forward key callback */
124         void (*SetWindowOffset)(void* arg, FcitxInputContext* ic, int x, int y); /**< frontend set window offset callback */
125         void (*GetWindowRect)(void* arg, FcitxInputContext* ic, int* x, int* y, int* w, int* h); /**< frontend get window position callback */
126         void (*UpdatePreedit)(void* arg, FcitxInputContext* ic); /**< frontend update preedit callback */
127         void (*UpdateClientSideUI)(void* arg, FcitxInputContext* ic); /**< frontend update client side user interface callback */
128         void (*ReloadConfig)(void* arg); /**< frontend reload config callback */
129         boolean(*CheckICFromSameApplication)(void* arg, FcitxInputContext* icToCheck, FcitxInputContext* ic); /**< frontend check input context from same application callback */
130         pid_t (*GetPid)(void* arg, FcitxInputContext* arg1); /**< get pid for ic, zero for unknown */
131         void (*DeleteSurroundingText)(void* addonInstance, FcitxInputContext* ic, int offset, unsigned int size);
132         boolean (*GetSurroundingPreedit)(void* addonInstance, FcitxInputContext* ic, char** str, unsigned int* cursor, unsigned int* anchor);
133     } FcitxFrontend;
134 
135     /**
136      * Initial frontends array
137      *
138      * @param  frontends array
139      * @return void
140      **/
141     void FcitxFrontendsInit(UT_array* frontends);
142 
143     /**
144      * Find Input Context By Frontend Specific filter
145      *
146      * @param instance
147      * @param frontendid frontend id
148      * @param filter frontend specific filter
149      * @return FcitxInputContext*
150      **/
151     FcitxInputContext* FcitxInstanceFindIC(struct _FcitxInstance* instance, int frontendid, void* filter);
152 
153     /**
154      * Creat New Input Context
155      *
156      * @param instance
157      * @param frontendid frontend id
158      * @param priv frontend specific data
159      * @return FcitxInputContext*
160      **/
161     FcitxInputContext* FcitxInstanceCreateIC(struct _FcitxInstance* instance, int frontendid, void* priv);
162 
163     /**
164      * Destroy Input context
165      *
166      * @param instance
167      * @param frontendid frontend id
168      * @param filter frontend specific filter
169      * @return void
170      **/
171     void FcitxInstanceDestroyIC(struct _FcitxInstance* instance, int frontendid, void* filter);
172 
173     /**
174      * Load All frontend
175      *
176      * @param instance
177      * @return void
178      **/
179     boolean FcitxInstanceLoadFrontend(struct _FcitxInstance* instance);
180 
181     /**
182      * Commit String to Client
183      *
184      * @param instance fcitx instance
185      * @param ic input context
186      * @param str String to commit
187      * @return void
188      **/
189     void FcitxInstanceCommitString(struct _FcitxInstance* instance, FcitxInputContext* ic, const char* str);
190 
191     /**
192      * Get surrounding text for an ic
193      *
194      * @param instance fcitx instance
195      * @param ic input context
196      * @param str surrounding text
197      * @param cursor cursor of surrounding text
198      * @param anchor selection anchor of surrounding text
199      * @return boolean
200      **/
201     boolean FcitxInstanceGetSurroundingText(struct _FcitxInstance* instance, FcitxInputContext* ic, char** str, unsigned int* cursor, unsigned int* anchor);
202 
203     /**
204      * Delete client surrounding text
205      *
206      * @param instance fcitx instance
207      * @param ic input conext
208      * @param offset offset
209      * @param size size
210      * @return void
211      **/
212     void FcitxInstanceDeleteSurroundingText(struct _FcitxInstance* instance, FcitxInputContext* ic, int offset, unsigned int size);
213 
214     /**
215      * Set Cursor Position
216      *
217      * @param instance fcitx instance
218      * @param ic input context
219      * @param x xpos
220      * @param y ypos
221      * @return void
222      **/
223     void FcitxInstanceSetWindowOffset(struct _FcitxInstance* instance, FcitxInputContext* ic, int x, int y);
224 
225     /**
226      * Get Cursor Position
227      *
228      * @param instance fcitx instance
229      * @param ic input context
230      * @param x xpos
231      * @param y ypos
232      * @return void
233      **/
234     void FcitxInstanceGetWindowPosition(struct _FcitxInstance* instance, FcitxInputContext *ic, int* x, int* y);
235 
236     /**
237      * Get Cursor Rect
238      *
239      * @param instance fcitx instance
240      * @param ic input context
241      * @param x xpos
242      * @param y ypos
243      * @param w width
244      * @param h height
245      * @return void
246      **/
247      void FcitxInstanceGetWindowRect(struct _FcitxInstance* instance, FcitxInputContext* ic, int* x, int* y, int* w, int* h);
248 
249     /**
250      * Update preedit text to client window
251      *
252      * @param instance fcitx instance
253      * @param ic input context
254      * @return void
255      **/
256     void FcitxInstanceUpdatePreedit(struct _FcitxInstance* instance, FcitxInputContext* ic);
257 
258     /**
259      * Update all user interface element to client (Aux Text, Preedit, Candidate Word)
260      *
261      * @param instance fcitx instance
262      * @param ic input context
263      * @return void
264      **/
265     void FcitxInstanceUpdateClientSideUI(struct _FcitxInstance* instance, FcitxInputContext* ic);
266 
267     /**
268      * Get Current State, if only want to get state, this function is better, because it will handle the case that Input Context is NULL.
269      *
270      * @param instance fcitx instance
271      * @return IME_STATE
272      **/
273     FcitxContextState FcitxInstanceGetCurrentState(struct _FcitxInstance* instance);
274 
275     /**
276      * Get Current State, consider the option firstAsInactive
277      *
278      * @param instance fcitx instance
279      * @return IME_STATE
280      *
281      * @see FcitxInstanceGetCurrentState
282      **/
283     FcitxContextState FcitxInstanceGetCurrentStatev2(struct _FcitxInstance* instance);
284 
285     /**
286      * get current ic capacity flag, if only want to get capacity, this function is better, because it will handle the case that Input Context is NULL.
287      *
288      * @param instance fcitx instance
289      * @return CapacityFlags
290      **/
291     FcitxCapacityFlags FcitxInstanceGetCurrentCapacity(struct _FcitxInstance* instance);
292 
293     /**
294      * set all ic from same application to the given ic
295      *
296      * @param instance fcitx instance
297      * @param frontendid frontend id
298      * @param ic object ic
299      * @return void
300      **/
301     void FcitxInstanceSetICStateFromSameApplication(struct _FcitxInstance* instance, int frontendid, FcitxInputContext *ic);
302 
303     /**
304      * get a per-ic data
305      *
306      * @param instance fcitx instnace
307      * @param ic input context
308      * @param data slot id
309      *
310      * @return data
311      *
312      * @since 4.2.5
313      **/
314     void* FcitxInstanceGetICData(struct _FcitxInstance* instance, FcitxInputContext* ic, int icdataid);
315 
316 
317     /**
318      * get a per-ic data
319      *
320      * @param instance fcitx instnace
321      * @param ic input context
322      * @param data slot id
323      * @param newdata new data
324      *
325      * @return void
326      *
327      * @since 4.2.5
328      **/
329     void FcitxInstanceSetICData(struct _FcitxInstance* instance, FcitxInputContext* ic, int icdataid, void* newdata);
330 
331     /**
332      * alloc a per-ic data slot
333      *
334      * @param instance fcitx instnace
335      * @param allocCallback alloc callback (set pointer to null, when callback is null)
336      * @param copyCallback copy callback (used when need to share state)
337      * @param freeCallback free callback
338      * @param arg closure data
339      * @return data slot id
340      *
341      * @since 4.2.5
342      **/
343     int FcitxInstanceAllocDataForIC(struct _FcitxInstance* instance, FcitxICDataAllocCallback allocCallback, FcitxICDataCopyCallback copyCallback, FcitxICDataFreeCallback freeCallback, void* arg);
344 
345     /**
346      * check current ic support preedit or not
347      *
348      * @param instance fcitx instnace
349      * @param ic input context
350      * @return result
351      *
352      * @since 4.2.5
353      **/
354     boolean FcitxInstanceICSupportPreedit(struct _FcitxInstance* instance, FcitxInputContext* ic);
355 
356 #ifdef __cplusplus
357 }
358 #endif
359 
360 #endif
361 /**
362  * @}
363  */
364 // kate: indent-mode cstyle; space-indent on; indent-width 0;
365