void test_set_candPerPage() { const int VALUE[] = { MIN_CAND_PER_PAGE, MAX_CAND_PER_PAGE, }; const int INVALID_VALUE[] = { MIN_CAND_PER_PAGE - 1, MAX_CAND_PER_PAGE + 1, }; ChewingContext *ctx; size_t i; size_t j; ctx = chewing_new(); start_testcase( ctx, fd ); for ( i = 0; i < ARRAY_SIZE( VALUE ); ++i ) { chewing_set_candPerPage( ctx, VALUE[i] ); ok( chewing_get_candPerPage( ctx ) == VALUE[i], "candPerPage shall be `%d'", VALUE[i] ); for ( j = 0; j < ARRAY_SIZE( INVALID_VALUE ); ++j ) { // mode shall not change when set mode has invalid value. chewing_set_candPerPage( ctx, INVALID_VALUE[j] ); ok( chewing_get_candPerPage( ctx ) == VALUE[i], "candPerPage shall be `%d'", VALUE[i] ); } } chewing_delete( ctx ); }
MainWindow::MainWindow() { this->_lblChewing = new QLabel(); this->_lblCommit = new QLabel(); this->_lblBuffer = new QLabel(); this->_lblAux = new QLabel(); this->_lblLine = new QLabel(); chewing_Init("/usr/share/chewing", "."); this->_ct = chewing_new(); chewing_set_candPerPage(this->_ct, 9); chewing_set_maxChiSymbolLen(this->_ct, 20); chewing_set_escCleanAllBuf(this->_ct, 1); QWidget* container = new QWidget; QVBoxLayout* layout = new QVBoxLayout(); layout->addWidget(new QLabel("Chewing symbol in buffer")); layout->addWidget(this->_lblChewing); layout->addWidget(new QLabel("Preedit buffer")); layout->addWidget(this->_lblBuffer); layout->addWidget(new QLabel("Commit output")); layout->addWidget(this->_lblCommit); layout->addWidget(new QLabel("Aux buffer")); layout->addWidget(this->_lblAux); layout->addWidget(new QLabel("Final output")); layout->addWidget(this->_lblLine); container->setLayout(layout); this->setCentralWidget(container); }
void test_libchewing_googlecode_issue_473() { /* FIXME: Add const cause gcc warning */ static char *INPUT[] = { "t<N->_ M1<N+>H[Ls3<L><N1>PL+Z]4<C1>&(^H*H<TT>Sc<N->P]!|<CB>-<C6>S<H><N1><C0>U<B>d}P!f<EN><N.><C7>V!U!w|4-=S<C1>b<N2>Q", "wv<C0><C5><N9>$FIF<D><N4>B *<C2>E4*<C2>q)Kf)<SS><TT>4=<N5>%<R>mN4<EN>H<N9><N.>8s{XTD<N6>jZV(y3G`9<C6>JTy<B>J<C1>SNc<E>hC<SL><N/><R><C6>@an<C3><N7>wzF<C3>P*<N*><B>l<C3><N6>W<N*> $<SR><N.><N1><E><E><N0><N6>Y", }; size_t i; ChewingContext *ctx; ctx = chewing_new(); start_testcase(ctx, fd); chewing_set_maxChiSymbolLen(ctx, 16); chewing_set_autoShiftCur(ctx, 1); chewing_set_candPerPage(ctx, 9); chewing_set_addPhraseDirection(ctx, 1); chewing_set_spaceAsSelection(ctx, 1); for (i = 0; i < ARRAY_SIZE(INPUT); ++i) { chewing_Reset(ctx); type_keystroke_by_string(ctx, INPUT[i]); } chewing_delete(ctx); }
void ibus_chewing_lookup_table_resize(IBusLookupTable * iTable, IBusChewingProperties * iProperties, ChewingContext * context) { gint selKSym[MAX_SELKEY]; const gchar *selKeyStr = mkdg_properties_get_string_by_key(iProperties->properties, "sel-keys"); guint candPerPage = mkdg_properties_get_uint_by_key(iProperties->properties, "cand-per-page"); int len = MIN(strlen(selKeyStr), MAX_SELKEY); len = MIN(len, candPerPage); IBusText *iText; int i; if (iTable != NULL) { ibus_lookup_table_clear(iTable); for (i = 0; i < len; i++) { selKSym[i] = (gint) selKeyStr[i]; iText = g_object_ref_sink(ibus_text_new_from_unichar ((gunichar) selKeyStr[i])); ibus_lookup_table_set_label(iTable, i, iText); } } chewing_set_candPerPage(context, len); chewing_set_selKey(context, selKSym, len); }
/** * @brief initialize the extra input method * * @param arg * @return successful or not **/ __EXPORT_API void* FcitxChewingCreate(FcitxInstance* instance) { if (GetFcitxChewingConfigDesc() == NULL) return NULL; char* user_path = NULL; FILE* fp = FcitxXDGGetFileUserWithPrefix("chewing", ".place_holder", "w", NULL); if (fp) fclose(fp); FcitxXDGGetFileUserWithPrefix("chewing", "", NULL, &user_path); FcitxLog(INFO, "Chewing storage path %s", user_path); if (0 == chewing_Init(CHEWING_DATADIR, user_path)) { FcitxLog(DEBUG, "chewing init ok"); } else { FcitxLog(DEBUG, "chewing init failed"); return NULL; } FcitxChewing* chewing = (FcitxChewing*) fcitx_utils_malloc0(sizeof(FcitxChewing)); FcitxGlobalConfig* config = FcitxInstanceGetGlobalConfig(instance); FcitxInputState *input = FcitxInstanceGetInputState(instance); FcitxCandidateWordSetChoose(FcitxInputStateGetCandidateList(input), DIGIT_STR_CHOOSE); bindtextdomain("fcitx-chewing", LOCALEDIR); chewing->context = chewing_new(); ChewingContext * c = chewing->context; chewing->owner = instance; chewing_set_ChiEngMode(c, CHINESE_MODE); chewing_set_maxChiSymbolLen(c, 16); // chewing will crash without set page chewing_set_candPerPage(c, config->iMaxCandWord); FcitxCandidateWordSetPageSize(FcitxInputStateGetCandidateList(input), config->iMaxCandWord); chewing_set_selKey(c, selKey, 10); LoadChewingConfig(&chewing->config); ConfigChewing(chewing); FcitxInstanceRegisterIM( instance, chewing, "chewing", _("Chewing"), "chewing", FcitxChewingInit, FcitxChewingReset, FcitxChewingDoInput, FcitxChewingGetCandWords, NULL, NULL, FcitxChewingReloadConfig, NULL, 1, "zh_TW" ); return chewing; }
Chewing::Chewing( bool spaceAsSelection, int keyLayout ) { ctx = chewing_new(); chewing_set_KBType( ctx, keyLayout ); chewing_set_candPerPage( ctx, 9 ); chewing_set_maxChiSymbolLen( ctx, 20 ); //chewing_set_addPhraseDirection( ctx, 1 ); //chewing_set_selKey( ctx, selKey_define, 10 ); chewing_set_spaceAsSelection( ctx, spaceAsSelection ); }
static void candPerPage_set_callback(PropertyContext *ctx, GValue *value){ #ifdef IBUS_CHEWING_MAIN IBusChewingEngine *engine=(IBusChewingEngine *) ctx->userData; chewing_set_candPerPage(engine->context,g_value_get_int(value)); if (engine->table){ ibus_lookup_table_clear(engine->table); engine->table->page_size=g_value_get_int(value); }else{ engine->table=g_object_ref_sink(ibus_lookup_table_new(g_value_get_int(value),0,FALSE,TRUE)); } #endif }
CHEWING_API int chewing_Configure( ChewingContext *ctx, ChewingConfigData *pcd ) { chewing_set_candPerPage( ctx, pcd->candPerPage ); chewing_set_maxChiSymbolLen( ctx, pcd->maxChiSymbolLen ); chewing_set_selKey( ctx, pcd->selKey, MAX_SELKEY ); chewing_set_addPhraseDirection( ctx, pcd->bAddPhraseForward ); chewing_set_spaceAsSelection( ctx, pcd->bSpaceAsSelection ); chewing_set_escCleanAllBuf( ctx, pcd->bEscCleanAllBuf ); chewing_set_autoShiftCur( ctx, pcd->bAutoShiftCur ); chewing_set_easySymbolInput( ctx, pcd->bEasySymbolInput ); chewing_set_phraseChoiceRearward( ctx, pcd->bPhraseChoiceRearward ); return 0; }
int main(int argc, char *argv[]) { ChewingContext *ctx; int i; FILE *fp = stdin; /* Initialize libchewing */ putenv("CHEWING_PATH=" CHEWING_DATA_PREFIX); /* for the sake of testing, we should not change existing hash data */ putenv("CHEWING_USER_PATH=" TEST_HASH_DIR); if (argc == 2) { fp = fopen(argv[1], "r"); if (!fp) { fprintf(stderr, "failed to open '%s'\n", argv[1]); return 1; } } /* Request handle to ChewingContext */ ctx = chewing_new(); /* Set keyboard type */ chewing_set_KBType(ctx, chewing_KBStr2Num("KB_DEFAULT")); chewing_set_candPerPage(ctx, 9); chewing_set_maxChiSymbolLen(ctx, 16); chewing_set_addPhraseDirection(ctx, 1); chewing_set_selKey(ctx, selKey_define, 10); chewing_set_spaceAsSelection(ctx, 1); while (1) { i = get_keystroke(get_char_from_fp, fp); if (i == END) goto end; type_single_keystroke(ctx, i); commit_string(ctx); } end: /* Free Chewing IM handle */ chewing_delete(ctx); if (fp) fclose(fp); return 0; }
void test_symbol_cand_page() { ChewingContext *ctx; chewing_Init( NULL, NULL ); ctx = chewing_new(); chewing_set_candPerPage( ctx, 10 ); chewing_set_maxChiSymbolLen( ctx, 16 ); chewing_handle_Default( ctx, '`' ); ok( chewing_cand_CurrentPage( ctx ) == 0, "current page shall be 0" ); ok( chewing_cand_TotalPage( ctx ) == 2, "total page shall be 2" ); ok_candidate( ctx, CAND, ARRAY_SIZE( CAND ) ); chewing_delete( ctx ); chewing_Terminate(); }
void test_PageUp_in_select() { ChewingContext *ctx; ctx = chewing_new(); start_testcase(ctx, fd); chewing_set_candPerPage(ctx, 10); type_keystroke_by_string(ctx, "hk4<D>"); ok(chewing_cand_TotalPage(ctx) == 3, "total page shall be 3"); ok(chewing_cand_CurrentPage(ctx) == 0, "current page shall be 0"); type_keystroke_by_string(ctx, "<PU>"); /* rollover */ ok(chewing_cand_CurrentPage(ctx) == 2, "current page shall be 2"); type_keystroke_by_string(ctx, "<PU>"); /* to previous page */ ok(chewing_cand_CurrentPage(ctx) == 1, "current page shall be 1"); chewing_delete(ctx); }
void test_type_symbol() { ChewingContext *ctx; int i; chewing_Init( NULL, NULL ); ctx = chewing_new(); chewing_set_candPerPage( ctx, 10 ); chewing_set_maxChiSymbolLen( ctx, 16 ); for (i = 0; i < ARRAY_SIZE(SYMBOL); ++i ) { type_keystroke_by_string( ctx, SYMBOL[i].token ); ok_preedit_buffer( ctx, "" ); ok_commit_buffer( ctx, SYMBOL[i].expected ); } chewing_delete( ctx ); chewing_Terminate(); }
int main( int argc, char *argv[] ) { ChewingContext *ctx; FILE *fout; FILE *fout2; char *prefix = CHEWING_DATA_PREFIX; char *out_file = "tmp.txt"; char *out_file2 = "tmp_out.txt"; int ch; int width, height; int add_phrase_length; /*if ( argc < 2 ) { fprintf( stderr, "usage: genkeystroke filename\n" ); exit( 1 ); } else { fout = fopen( argv[ 1 ], "w" );*/ fout = fopen( out_file, "w" ); if ( ! fout ) { fprintf( stderr, "Error: failed to open %s\n", out_file ); exit( 1 ); } fout2 = fopen( out_file2, "w" ); if ( ! fout2 ) { fprintf( stderr, "Error: failed to open %s\n", out_file2 ); exit( 1 ); } /*}*/ /* Initialize curses library */ setlocale(LC_CTYPE, ""); initscr(); if ( has_colors() == TRUE ) { start_color(); init_pair( 1, COLOR_WHITE, COLOR_BLUE ); init_pair( 2, COLOR_RED, COLOR_YELLOW ); init_pair( 3, COLOR_WHITE, COLOR_RED ); hasColor = 1; } cbreak(); noecho(); keypad( stdscr, 1 ); getmaxyx( stdscr, height, width ); start_color(); clear(); refresh(); /* Initialize libchewing */ /* for the sake of testing, we should not change existing hash data */ chewing_Init( prefix, TEST_HASH_DIR ); /* Request handle to ChewingContext */ ctx = chewing_new(); /* Set keyboard type */ chewing_set_KBType( ctx, chewing_KBStr2Num( "KB_DEFAULT" ) ); /* Fill configuration values */ chewing_set_candPerPage( ctx, 9 ); chewing_set_maxChiSymbolLen( ctx, 16 ); chewing_set_addPhraseDirection( ctx, 1 ); chewing_set_selKey( ctx, selKey_define, 10 ); chewing_set_spaceAsSelection( ctx, 1 ); chewing_set_autoShiftCur( ctx, 1 ); chewing_set_phraseChoiceRearward( ctx, 1 ); clear(); mvaddstr( 0, 0, "Any key to start testing..." ); while ( TRUE ) { ch = getch(); switch ( ch ) { case KEY_LEFT: chewing_handle_Left( ctx ); fprintf( fout, "<L>" ); break; case KEY_SLEFT: chewing_handle_ShiftLeft( ctx ); fprintf( fout, "<SL>" ); break; case KEY_RIGHT: chewing_handle_Right( ctx ); fprintf( fout, "<R>" ); break; case KEY_SRIGHT: chewing_handle_ShiftRight( ctx ); fprintf( fout, "<SR>" ); break; case KEY_UP: chewing_handle_Up( ctx ); fprintf( fout, "<U>" ); break; case KEY_DOWN: chewing_handle_Down( ctx ); fprintf( fout, "<D>" ); break; case KEY_SPACE: chewing_handle_Space( ctx ); fprintf( fout, " " ); break; case KEY_ENTER: chewing_handle_Enter( ctx ); fprintf( fout, "<E>" ); break; case KEY_BACKSPACE: chewing_handle_Backspace( ctx ); fprintf( fout, "<B>" ); break; case KEY_ESC: chewing_handle_Esc( ctx ); fprintf( fout, "<EE>" ); break; case KEY_DC: chewing_handle_Del( ctx ); fprintf( fout, "<DC>" ); break; case KEY_HOME: chewing_handle_Home( ctx ); fprintf( fout, "<H>" ); break; case KEY_END: chewing_handle_End( ctx ); fprintf( fout, "<EN>" ); break; case KEY_TAB: chewing_handle_Tab( ctx ); fprintf( fout, "<T>" ); break; case CTRL_0: case CTRL_1: case CTRL_2: case CTRL_3: case CTRL_4: case CTRL_5: case CTRL_6: case CTRL_7: case CTRL_8: case CTRL_9: add_phrase_length = ( ch - CTRL_0 + '0' ); chewing_handle_CtrlNum( ctx, add_phrase_length ); fprintf( fout, "<C%c>", add_phrase_length ); break; case KEY_CTRL_('B'): /* emulate CapsLock */ chewing_handle_Capslock( ctx ); fprintf( fout, "<CB>"); break; case KEY_CTRL_('D'): case EOF: goto end; case KEY_CTRL_('H'): /* emulate Shift */ if ( chewing_get_ShapeMode( ctx ) == FULLSHAPE_MODE ) chewing_set_ShapeMode( ctx, HALFSHAPE_MODE ); else chewing_set_ShapeMode( ctx, FULLSHAPE_MODE ); break; default: chewing_handle_Default( ctx, (char) ch ); fprintf( fout, "%c", (char) ch ); break; } drawline( 0, 0 ); drawline( 2, 0 ); show_interval_buffer( 3, 0, ctx ); drawline( 4, 0 ); show_choose_buffer( 5, 0, ctx ); drawline( 6, 0 ); show_zuin_buffer( 7, 0, ctx ); show_full_shape( 7, 5, ctx ); drawline( 8, 0 ); mvaddstr( 9, 0, "Ctrl + d : leave" ); mvaddstr( 9, 20, "Ctrl + b : toggle Eng/Chi mode" ); mvaddstr( 10, 0, "F1, F2, F3, ..., F9 : Add user defined phrase"); mvaddstr( 11, 0, "Crtl + h : toggle Full/Half shape mode" ); show_commit_string( ctx ); store_commit_string( ctx, fout2 ); show_userphrase( 7, 12, ctx ); show_edit_buffer( 1, 0, ctx ); } end: endwin(); /* Release Chewing context */ chewing_delete( ctx ); /* Termate Chewing services */ chewing_Terminate(); fprintf( fout, "\n" ); fprintf( fout2, "\n" ); fclose( fout ); fclose( fout2 ); return 0; }
void Chewing::SetCandPerPage(int len) { chewing_set_candPerPage(ctx, len); }
int main() { ChewingContext *ct; char *buf; int counter; /* * Initialize Chewing input method engine * Parameter 1:data path * Parameter 2:path to keep user-defined phrases */ chewing_Init("../data/", "."); ct = chewing_new(); /* Chinese mode by default */ if (chewing_get_ChiEngMode(ct) == CHINESE_MODE) printf("Chinese mode!\n"); /* Set the selection keys, otherwise you can not select candidates. */ chewing_set_selKey(ct, selKeys, 9); /* Set the legth of maximum Chinese symbol */ chewing_set_maxChiSymbolLen(ct, 10); /* Set the amount of candidates per page */ chewing_set_candPerPage(ct, 9); /* * Sequence 1:'綠茶' */ chewing_handle_Default(ct, 'x'); /* ㄌ */ chewing_handle_Default(ct, 'm'); /* ㄩ */ chewing_handle_Default(ct, '4'); /* ˋ */ chewing_handle_Default(ct, 't'); /* ㄔ */ chewing_handle_Default(ct, '8'); /* ㄚ */ chewing_handle_Default(ct, '6'); /* ˊ */ /* commit buffer to output area */ chewing_handle_Enter(ct); /* Copy stribf from output area */ buf = chewing_commit_String(ct); printf("%s\n", buf); free(buf); /* * Sequence 2:Input 'ㄓ' and select candidates */ chewing_handle_Default(ct, '5'); chewing_handle_Space(ct); /* * The expected key to enter candidate selection is 'Down'. * If 'Down' is not triggered, we can not use the further * chewing_cand_Enumerate() to get the detailed listing. */ chewing_handle_Down(ct); /* * Start the enumeration of candidate. It follows the typical iterator design. * (1) chewing_cand_Enumerate(): specify the iterator by ChewingContext * (2) chewing_cand_hasNext(): find out the next element in iterator * (3) chewing_cand_String(): get the current element and advance */ chewing_cand_Enumerate(ct); counter = 0; while (chewing_cand_hasNext(ct)) { counter += 1; char *s = chewing_cand_String(ct); printf("%s ", s); free(s); if (counter == 5) { counter = 0; printf("\n"); } } printf("\nSelecting 13rd:"); /* * 剛才按下了↓,目前正在選字。 * 我想選第13個字,那就必須換頁,然後選第二頁的第4個字(9+4=13) * 換頁的按鍵是空白鍵 * (一頁有多少候選字的設定,在 chewing_set_candPerPage(ct, 9); 這個呼叫中) */ chewing_handle_Space(ct); chewing_handle_Default(ct, '4'); chewing_handle_Enter(ct); buf = chewing_commit_String(ct); printf("%s\n", buf); free(buf); /* Finalize Chewing input method engine */ chewing_delete(ct); chewing_Terminate(); return 0; }
void test_null() { int ret; char *buf; const char *const_buf; int *key; unsigned short *phone; start_testcase(NULL, fd); chewing_Reset(NULL); // shall not crash ret = chewing_set_KBType(NULL, 0); ok(ret == -1, "chewing_set_KBType() returns `%d' shall be `%d'", ret, -1); ret = chewing_get_KBType(NULL); ok(ret == -1, "chewing_get_KBType() returns `%d' shall be `%d'", ret, -1); buf = chewing_get_KBString(NULL); ok(strcmp(buf, "") == 0, "chewing_get_KBString() returns `%s' shall be `%s'", buf, ""); chewing_free(buf); chewing_delete(NULL); // shall not crash chewing_free(NULL); // shall not crash chewing_set_candPerPage(NULL, 0); // shall not crash ret = chewing_get_candPerPage(NULL); ok(ret == -1, "chewing_get_candPerPage() returns `%d' shall be `%d'", ret, -1); chewing_set_maxChiSymbolLen(NULL, 0); // shall not crash ret = chewing_get_maxChiSymbolLen(NULL); ok(ret == -1, "chewing_get_maxChiSymbolLen() returns `%d' shall be `%d'", ret, -1); chewing_set_selKey(NULL, NULL, 0); // shall not crash key = chewing_get_selKey(NULL); ok(key == NULL, "chewing_get_selKey() returns NULL"); chewing_free(key); chewing_set_addPhraseDirection(NULL, 0); // shall not crash ret = chewing_get_addPhraseDirection(NULL); ok(ret == -1, "chewing_get_addPhraseDirection() returns `%d' shall be `%d'", ret, -1); chewing_set_spaceAsSelection(NULL, 0); // shall not crash ret = chewing_get_spaceAsSelection(NULL); ok(ret == -1, "chewing_get_spaceAsSelection() returns `%d' shall be `%d'", ret, -1); chewing_set_escCleanAllBuf(NULL, 0); // shall not crash ret = chewing_get_escCleanAllBuf(NULL); ok(ret == -1, "chewing_get_escCleanAllBuf() returns `%d' shall be `%d'", ret, -1); chewing_set_autoShiftCur(NULL, 0); // shall not crash ret = chewing_get_autoShiftCur(NULL); ok(ret == -1, "chewing_get_autoShiftCur() returns `%d' shall be `%d'", ret, -1); chewing_set_easySymbolInput(NULL, 0); // shall not crash ret = chewing_get_easySymbolInput(NULL); ok(ret == -1, "chewing_get_easySymbolInput() returns `%d' shall be `%d'", ret, -1); chewing_set_phraseChoiceRearward(NULL, 0); ret = chewing_get_phraseChoiceRearward(NULL); ok(ret == -1, "chewing_get_phraseChoiceRearward() returns `%d' shall be `%d'", ret, -1); chewing_set_ChiEngMode(NULL, 0); // shall not crash ret = chewing_get_ChiEngMode(NULL); ok(ret == -1, "chewing_get_ChiEngMode() returns `%d' shall be `%d'", ret, -1); chewing_set_ShapeMode(NULL, 0); // shall not crash ret = chewing_handle_Space(NULL); ok(ret == -1, "chewing_handle_Space() returns `%d' shall be `%d'", ret, -1); ret = chewing_handle_Esc(NULL); ok(ret == -1, "chewing_handle_Esc() returns `%d' shall be `%d'", ret, -1); ret = chewing_handle_Enter(NULL); ok(ret == -1, "chewing_handle_Enter() returns `%d' shall be `%d'", ret, -1); ret = chewing_handle_Del(NULL); ok(ret == -1, "chewing_handle_Del() returns `%d' shall be `%d'", ret, -1); ret = chewing_handle_Backspace(NULL); ok(ret == -1, "chewing_handle_Backspace() returns `%d' shall be `%d'", ret, -1); ret = chewing_handle_Up(NULL); ok(ret == -1, "chewing_handle_Up() returns `%d' shall be `%d'", ret, -1); ret = chewing_handle_Down(NULL); ok(ret == -1, "chewing_handle_Down() returns `%d' shall be `%d'", ret, -1); ret = chewing_handle_ShiftLeft(NULL); ok(ret == -1, "chewing_handle_ShiftLeft() returns `%d' shall be `%d'", ret, -1); ret = chewing_handle_Left(NULL); ok(ret == -1, "chewing_handle_Left() returns `%d' shall be `%d'", ret, -1); ret = chewing_handle_ShiftRight(NULL); ok(ret == -1, "chewing_handle_ShiftRight() returns `%d' shall be `%d'", ret, -1); ret = chewing_handle_Right(NULL); ok(ret == -1, "chewing_handle_Right() returns `%d' shall be `%d'", ret, -1); ret = chewing_handle_Tab(NULL); ok(ret == -1, "chewing_handle_Tab() returns `%d' shall be `%d'", ret, -1); ret = chewing_handle_DblTab(NULL); ok(ret == -1, "chewing_handle_DblTab() returns `%d' shall be `%d'", ret, -1); ret = chewing_handle_Capslock(NULL); ok(ret == -1, "chewing_handle_Capslock() returns `%d' shall be `%d'", ret, -1); ret = chewing_handle_Home(NULL); ok(ret == -1, "chewing_handle_Home() returns `%d' shall be `%d'", ret, -1); ret = chewing_handle_PageUp(NULL); ok(ret == -1, "chewing_handle_PageUp() returns `%d' shall be `%d'", ret, -1); ret = chewing_handle_PageDown(NULL); ok(ret == -1, "chewing_handle_PageDown() returns `%d' shall be `%d'", ret, -1); ret = chewing_handle_Default(NULL, 0); ok(ret == -1, "chewing_handle_Default() returns `%d' shall be `%d'", ret, -1); ret = chewing_handle_CtrlNum(NULL, 0); ok(ret == -1, "chewing_handle_CtrlNum() returns `%d' shall be `%d'", ret, -1); ret = chewing_handle_ShiftSpace(NULL); ok(ret == -1, "chewing_handle_ShiftSpace() returns `%d' shall be `%d'", ret, -1); ret = chewing_handle_Numlock(NULL, 0); ok(ret == -1, "chewing_handle_Numlock() returns `%d' shall be `%d'", ret, -1); phone = chewing_get_phoneSeq(NULL); ok(phone == NULL, "chewing_get_phoneSeq() returns NULL"); chewing_free(phone); ret = chewing_get_phoneSeqLen(NULL); ok(ret == -1, "chewing_get_phoneSeqLen() returns `%d' shall be `%d'", ret, -1); chewing_set_logger(NULL, NULL, NULL); ret = chewing_userphrase_enumerate(NULL); ok(ret == -1, "chewing_userphrase_enumerate() returns `%d' shall be `%d'", ret, -1); ret = chewing_userphrase_has_next(NULL, NULL, NULL); ok(ret == 0, "chewing_userphrase_has_next() returns `%d' shall be `%d'", ret, 0); ret = chewing_userphrase_get(NULL, NULL, 0, NULL, 0); ok(ret == -1, "chewing_userphrase_get() returns `%d' shall be `%d'", ret, -1); ret = chewing_userphrase_add(NULL, NULL, NULL); ok(ret == -1, "chewing_userphrase_add() returns `%d' shall be `%d'", ret, -1); ret = chewing_userphrase_remove(NULL, NULL, NULL); ok(ret == -1, "chewing_userphrase_remove() returns `%d' shall be `%d'", ret, -1); ret = chewing_userphrase_lookup(NULL, NULL, NULL); ok(ret == 0, "chewing_userphrase_lookup() returns `%d' shall be `%d'", ret, 0); ret = chewing_cand_open(NULL); ok(ret == -1, "chewing_cand_open() returns `%d' shall be `%d'", ret, -1); ret = chewing_cand_close(NULL); ok(ret == -1, "chewing_cand_open() returns `%d' shall be `%d'", ret, -1); ret = chewing_cand_choose_by_index(NULL, 0); ok(ret == -1, "chewing_cand_choose_by_index() returns `%d' shall be `%d'", ret, -1); ret = chewing_cand_list_first(NULL); ok(ret == -1, "chewing_cand_list_first() returns `%d' shall be `%d'", ret, -1); ret = chewing_cand_list_last(NULL); ok(ret == -1, "chewing_cand_list_last() returns `%d' shall be `%d'", ret, -1); ret = chewing_cand_list_has_next(NULL); ok(ret == 0, "chewing_cand_list_has_next() returns `%d' shall be `%d'", ret, 0); ret = chewing_cand_list_has_prev(NULL); ok(ret == 0, "chewing_cand_list_has_prev() returns `%d' shall be `%d'", ret, 0); ret = chewing_cand_list_next(NULL); ok(ret == -1, "chewing_cand_list_next() returns `%d' shall be `%d'", ret, -1); ret = chewing_cand_list_prev(NULL); ok(ret == -1, "chewing_cand_list_prev() returns `%d' shall be `%d'", ret, -1); ret = chewing_commit_preedit_buf(NULL); ok(ret == -1, "chewing_commit_preedit_buf() returns `%d' shall be `%d'", ret, -1); ret = chewing_clean_preedit_buf(NULL); ok(ret == -1, "chewing_clean_preedit_buf() returns `%d' shall be `%d'", ret, -1); ret = chewing_clean_bopomofo_buf(NULL); ok(ret == -1, "chewing_clean_bopomofo_buf() returns `%d' shall be `%d'", ret, -1); ret = chewing_commit_Check(NULL); ok(ret == -1, "chewing_commit_Check() returns `%d' shall be `%d'", ret, -1); buf = chewing_commit_String(NULL); ok(strcmp(buf, "") == 0, "chewing_commit_String() returns `%s' shall be `%s'", buf, ""); chewing_free(buf); const_buf = chewing_commit_String_static(NULL); ok(strcmp(const_buf, "") == 0, "chewing_commit_String() returns `%s' shall be `%s'", const_buf, ""); ret = chewing_buffer_Check(NULL); ok(ret == -1, "chewing_buffer_Check() returns `%d' shall be `%d'", ret, -1); ret = chewing_buffer_Len(NULL); ok(ret == -1, "chewing_buffer_Len() returns `%d' shall be `%d'", ret, -1); buf = chewing_buffer_String(NULL); ok(strcmp(buf, "") == 0, "chewing_buffer_String() returns `%s' shall be `%s'", buf, ""); chewing_free(buf); const_buf = chewing_buffer_String_static(NULL); ok(strcmp(const_buf, "") == 0, "chewing_buffer_String_static() returns `%s' shall be `%s'", const_buf, ""); const_buf = chewing_bopomofo_String_static(NULL); ok(strcmp(const_buf, "") == 0, "chewing_bopomofo_String_static() returns `%s' shall be `%s'", const_buf, ""); BEGIN_IGNORE_DEPRECATIONS buf = chewing_zuin_String(NULL, NULL); END_IGNORE_DEPRECATIONS ok(strcmp(buf, "") == 0, "chewing_zuin_String() returns `%s' shall be `%s'", buf, ""); chewing_free(buf); ret = chewing_bopomofo_Check(NULL); ok(ret == -1, "chewing_bopomofo_Check() returns `%d' shall be `%d'", ret, -1); BEGIN_IGNORE_DEPRECATIONS chewing_zuin_Check(NULL); // shall not crash END_IGNORE_DEPRECATIONS ret = chewing_cursor_Current(NULL); ok(ret == -1, "chewing_cursor_Current() returns `%d' shall be `%d'", ret, -1); ret = chewing_cand_CheckDone(NULL); ok(ret == -1, "chewing_cand_CheckDone() returns `%d' shall be `%d'", ret, -1); ret = chewing_cand_TotalPage(NULL); ok(ret == -1, "chewing_cand_TotalPage() returns `%d' shall be `%d'", ret, -1); ret = chewing_cand_ChoicePerPage(NULL); ok(ret == -1, "chewing_cand_ChoicePerPage() returns `%d' shall be `%d'", ret, -1); ret = chewing_cand_TotalChoice(NULL); ok(ret == -1, "chewing_cand_TotalChoice() returns `%d' shall be `%d'", ret, -1); ret = chewing_cand_CurrentPage(NULL); ok(ret == -1, "chewing_cand_CurrentPage() returns `%d' shall be `%d'", ret, -1); chewing_cand_Enumerate(NULL); // shall not crash ret = chewing_cand_hasNext(NULL); ok(ret == -1, "chewing_cand_hasNext() returns `%d' shall be `%d'", ret, -1); const_buf = chewing_cand_String_static(NULL); ok(strcmp(const_buf, "") == 0, "chewing_cand_String_static() returns `%s' shall be `%s'", const_buf, ""); buf = chewing_cand_String(NULL); ok(strcmp(buf, "") == 0, "chewing_cand_String() returns `%s' shall be `%s'", buf, ""); chewing_free(buf); chewing_interval_Enumerate(NULL); // shall not crash ret = chewing_interval_hasNext(NULL); ok(ret == -1, "chewing_interval_hasNext() returns `%d' shall be `%d'", ret, -1); chewing_interval_Get(NULL, NULL); // shall not crash ret = chewing_aux_Check(NULL); ok(ret == -1, "chewing_aux_Check() returns `%d' shall be `%d'", ret, -1); ret = chewing_aux_Length(NULL); ok(ret == -1, "chewing_aux_Length() returns `%d' shall be `%d'", ret, -1); const_buf = chewing_aux_String_static(NULL); ok(strcmp(const_buf, "") == 0, "chewing_aux_String_static() returns `%s' shall be `%s'", const_buf, ""); buf = chewing_aux_String(NULL); ok(strcmp(buf, "") == 0, "chewing_aux_String() returns `%s' shall be `%s'", buf, ""); chewing_free(buf); ret = chewing_keystroke_CheckIgnore(NULL); ok(ret == -1, "chewing_keystroke_CheckIgnore() returns `%d' shall be `%d'", ret, -1); ret = chewing_keystroke_CheckAbsorb(NULL); ok(ret == -1, "chewing_keystroke_CheckAbsorb() returns `%d' shall be `%d'", ret, -1); chewing_kbtype_Enumerate(NULL); // shall not crash ret = chewing_kbtype_hasNext(NULL); ok(ret == -1, "chewing_kbtype_hasNext() returns `%d' shall be `%d'", ret, -1); const_buf = chewing_kbtype_String_static(NULL); ok(strcmp(const_buf, "") == 0, "chewing_kbtype_String_static() returns `%s' shall be `%s'", const_buf, ""); buf = chewing_kbtype_String(NULL); ok(strcmp(buf, "") == 0, "chewing_kbtype_String() returns `%s' shall be `%s'", buf, ""); chewing_free(buf); }
/** * @brief function DoInput has done everything for us. * * @param searchMode * @return INPUT_RETURN_VALUE **/ __EXPORT_API INPUT_RETURN_VALUE FcitxChewingGetCandWords(void* arg) { FcitxChewing* chewing = (FcitxChewing*) arg; FcitxInputState *input = FcitxInstanceGetInputState(chewing->owner); FcitxMessages *msgPreedit = FcitxInputStateGetPreedit(input); FcitxMessages *clientPreedit = FcitxInputStateGetClientPreedit(input); ChewingContext * c = chewing->context; FcitxGlobalConfig* config = FcitxInstanceGetGlobalConfig(chewing->owner); chewing_set_candPerPage(c, config->iMaxCandWord); FcitxCandidateWordSetPageSize(FcitxInputStateGetCandidateList(input), config->iMaxCandWord); //clean up window asap FcitxInstanceCleanInputWindow(chewing->owner); char * buf_str = chewing_buffer_String(c); char * zuin_str = chewing_zuin_String(c, NULL); ConfigChewing(chewing); FcitxLog(DEBUG, "%s %s", buf_str, zuin_str); /* if not check done, so there is candidate word */ if (!chewing_cand_CheckDone(c)) { //get candidate word chewing_cand_Enumerate(c); int index = 0; while (chewing_cand_hasNext(c)) { char* str = chewing_cand_String(c); FcitxCandidateWord cw; ChewingCandWord* w = (ChewingCandWord*) fcitx_utils_malloc0(sizeof(ChewingCandWord)); w->index = index; cw.callback = FcitxChewingGetCandWord; cw.owner = chewing; cw.priv = w; cw.strExtra = NULL; cw.strWord = strdup(str); cw.wordType = MSG_OTHER; FcitxCandidateWordAppend(FcitxInputStateGetCandidateList(input), &cw); chewing_free(str); index ++; } } // setup cursor FcitxInputStateSetShowCursor(input, true); int buf_len = chewing_buffer_Len(c); int cur = chewing_cursor_Current(c); FcitxLog(DEBUG, "buf len: %d, cur: %d", buf_len, cur); int rcur = FcitxChewingGetRawCursorPos(buf_str, cur); FcitxInputStateSetCursorPos(input, rcur); FcitxInputStateSetClientCursorPos(input, rcur); // insert zuin in the middle char * half1 = strndup(buf_str, rcur); char * half2 = strdup(buf_str + rcur); FcitxMessagesAddMessageAtLast(msgPreedit, MSG_INPUT, "%s%s%s", half1, zuin_str, half2); FcitxMessagesAddMessageAtLast(clientPreedit, MSG_INPUT, "%s%s%s", half1, zuin_str, half2); chewing_free(buf_str); chewing_free(zuin_str); free(half1); free(half2); return IRV_DISPLAY_CANDWORDS; }
int main( int argc, char *argv[] ) #endif { ChewingContext *ctx; char *prefix = CHEWING_DATA_PREFIX; int i; int ctrl_shifted; /* Initialize libchewing */ /* for the sake of testing, we should not change existing hash data */ chewing_Init( prefix, TEST_HASH_DIR ); /* Request handle to ChewingContext */ ctx = chewing_new(); /* Set keyboard type */ chewing_set_KBType( ctx, chewing_KBStr2Num( "KB_DEFAULT" ) ); chewing_set_candPerPage( ctx, 9 ); chewing_set_maxChiSymbolLen( ctx, 16 ); chewing_set_addPhraseDirection( ctx, 1 ); chewing_set_selKey( ctx, selKey_define, 10 ); chewing_set_spaceAsSelection( ctx, 1 ); while ( 1 ) { i = get_keystroke(); switch ( i ) { case KEY_LEFT: chewing_handle_Left( ctx ); break; case KEY_SLEFT: chewing_handle_ShiftLeft( ctx ); break; case KEY_RIGHT: chewing_handle_Right( ctx ); break; case KEY_SRIGHT: chewing_handle_ShiftRight( ctx ); break; case KEY_UP: chewing_handle_Up( ctx ); break; case KEY_DOWN: chewing_handle_Down( ctx ); break; case KEY_SPACE: chewing_handle_Space( ctx ); break; case KEY_ENTER: chewing_handle_Enter( ctx ); break; case KEY_BACKSPACE: chewing_handle_Backspace( ctx ); break; case KEY_ESC: chewing_handle_Esc( ctx ); break; case KEY_DELETE: chewing_handle_Del( ctx ); break; case KEY_HOME: chewing_handle_Home( ctx ); break; case KEY_END: chewing_handle_End( ctx ); break; case KEY_TAB: chewing_handle_Tab( ctx ); break; case KEY_CAPSLOCK: chewing_handle_Capslock( ctx ); break; case END: goto end; default: ctrl_shifted = ( i - KEY_CTRL_BASE ); if ( ( ctrl_shifted >= '0' ) && ( ctrl_shifted <= '9' ) ) { chewing_handle_CtrlNum( ctx, ctrl_shifted ); } else { chewing_handle_Default( ctx, (char) i ); } break; } commit_string( ctx ); #ifdef USED_IN_SIMULATION if ( i == KEY_ENTER ) compare_per_run(); #endif } end: /* Free Chewing IM handle */ chewing_delete( ctx ); /* Termate Chewing services */ chewing_Terminate(); #ifndef USED_IN_SIMULATION printf( "\n" ); #endif return 0; }
int main(int argc, char *argv[]) { size_t i; int flag_random_init = 0; int flag_random_extra = 0; int flag_loop = -1; int (*get_input)() = &random256; for (i = 1; i < argc; i++) { if (strcmp(argv[i], "-init") == 0) flag_random_init = 1; else if (strcmp(argv[i], "-extra") == 0 && argv[i + 1]) flag_random_extra = 1; else if (strcmp(argv[i], "-loop") == 0 && argv[i + 1]) flag_loop = atoi(argv[++i]); else if (strcmp(argv[i], "-stdin") == 0) get_input = &get_stdin; else { printf("Usage: %s [-init] [-extra] [-loop N] [-stdin]\n", argv[0]); printf("\t-init Random initial configuration\n"); printf("\t-extra Random change all configurations during input.\n"); printf("\t This is usually unexpected.\n"); printf("\t-stdin Get random input from stdin\n"); printf("\t-loop N How many iterations to test (default infinite=-1)\n"); exit(1); } } /* Initialize libchewing */ putenv("CHEWING_PATH=" CHEWING_DATA_PREFIX); /* for the sake of testing, we should not change existing hash data */ putenv("CHEWING_USER_PATH=" TEST_HASH_DIR); for (i = 0; i != flag_loop; i++) { ChewingContext *ctx = chewing_new(); /* typical configuration */ chewing_set_KBType(ctx, chewing_KBStr2Num("KB_DEFAULT")); chewing_set_candPerPage(ctx, 9); chewing_set_maxChiSymbolLen(ctx, 16); chewing_set_addPhraseDirection(ctx, 1); chewing_set_selKey(ctx, selKey_define, 10); chewing_set_spaceAsSelection(ctx, 1); if (flag_random_init) { chewing_set_KBType(ctx, get_input()); chewing_set_candPerPage(ctx, get_input()); chewing_set_maxChiSymbolLen(ctx, get_input()); chewing_set_addPhraseDirection(ctx, get_input()); chewing_set_selKey(ctx, selKey_define, get_input() % 11); chewing_set_spaceAsSelection(ctx, get_input()); chewing_set_escCleanAllBuf(ctx, get_input()); chewing_set_autoShiftCur(ctx, get_input()); chewing_set_easySymbolInput(ctx, get_input()); chewing_set_phraseChoiceRearward(ctx, get_input()); } while (1) { /* Random value: [0, max_key) for keys, [max_key, 0xff] for * configurations. Use a fixed range here because I don't want the * meaning of input changed a lot frequently if we add more keys in * the future. */ const int max_key = 192; /* arbitrary number */ int v = get_input(); if (v == EOF) break; assert(max_key * sizeof(all_key[0]) >= sizeof(all_key)); if (v >= max_key) { const int typical = 2; int handled = 1; v = v - max_key; if (flag_random_extra || v < typical) { switch (v) { /* typical configurations may be changed during input */ case 0: chewing_set_ChiEngMode(ctx, get_input()); break; case 1: chewing_set_ShapeMode(ctx, get_input()); break; /* usually not changed during input */ case 2: chewing_set_KBType(ctx, get_input()); break; case 3: chewing_set_candPerPage(ctx, get_input()); break; case 4: chewing_set_maxChiSymbolLen(ctx, get_input()); break; case 5: chewing_set_addPhraseDirection(ctx, get_input()); break; case 6: chewing_set_selKey(ctx, selKey_define, get_input() % 11); break; case 7: chewing_set_spaceAsSelection(ctx, get_input()); break; case 8: chewing_set_escCleanAllBuf(ctx, get_input()); break; case 9: chewing_set_autoShiftCur(ctx, get_input()); break; case 10: chewing_set_easySymbolInput(ctx, get_input()); break; case 11: chewing_set_phraseChoiceRearward(ctx, get_input()); break; default: handled = 0; break; } } else { handled = 0; } if (!handled) break; } else { if (0 <= v && v < max_key) { int key = all_key[v]; type_single_keystroke(ctx, key); } else { break; } } commit_string(ctx); } chewing_delete(ctx); if (i % 10000 == 0) printf("%zu\n", i); if (getenv("AFL_PERSISTENT")) raise(SIGSTOP); } return 0; }