static void
setup_romaji_window_value (ScimAnthyTableEditor *editor)
{
GtkTreeView *treeview = GTK_TREE_VIEW (editor->treeview);
GtkTreeModel *model = gtk_tree_view_get_model (treeview);
GtkListStore *store = GTK_LIST_STORE (model);
gtk_list_store_clear (store);
std::vector<String> keys;
__user_style_file.get_key_list (keys, __romaji_fund_table);
if (keys.empty ()) {
load_romaji_theme ();
__user_style_file.get_key_list (keys, __romaji_fund_table);
}
std::vector<String>::iterator it;
for (it = keys.begin (); it != keys.end (); it++) {
std::vector<WideString> value;
__user_style_file.get_string_array (value, __romaji_fund_table, *it);
String result, cont;
if (value.size () > 0) result = utf8_wcstombs(value[0]);
if (value.size () > 1) cont = utf8_wcstombs(value[1]);
GtkTreeIter iter;
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
0, it->c_str (),
1, result.c_str (),
-1);
}
}
void
PinyinPhraseLib::dump_content (std::ostream &os, int minlen, int maxlen)
{
PinyinPhraseLessThanByOffset less_op (this, m_pinyin_key_less);
if (minlen < 1) minlen = 1;
if (maxlen > SCIM_PHRASE_MAX_LENGTH) maxlen = SCIM_PHRASE_MAX_LENGTH;
for (int i = minlen; i <= maxlen; ++ i) {
PinyinPhraseOffsetVector offsets;
for (PinyinPhraseTable::iterator tit = m_phrases [i-1].begin (); tit != m_phrases [i-1].end (); ++ tit) {
PinyinPhraseOffsetVector::iterator begin = tit->get_vector ().begin ();
PinyinPhraseOffsetVector::iterator end = tit->get_vector ().end ();
offsets.insert (offsets.end (), begin, end);
}
std::sort (offsets.begin (), offsets.end (), less_op);
for (PinyinPhraseOffsetVector::iterator oit = offsets.begin (); oit != offsets.end (); ++ oit) {
bool before = false, after = false;
os << get_phrase (oit->first).frequency () << "\t";
if (oit > offsets.begin () && get_phrase ((oit-1)->first) == get_phrase (oit->first)) before = true;
if (oit < offsets.end () - 1 && get_phrase ((oit+1)->first) == get_phrase (oit->first)) after = true;
if (before || after) os << "+";
else os << "-";
os << utf8_wcstombs (get_phrase (oit->first).get_content ());
os << " =";
for (unsigned int j = 0; j < get_phrase (oit->first).length (); ++ j)
os << " " << get_pinyin_key (oit->second + j);
os << "\n";
}
}
}
void update_aux_string (int icid, const WideString &str, const AttributeList &attrs)
{
if (m_send_refcount > 0 && m_current_icid == icid) {
m_send_trans.put_command (SCIM_TRANS_CMD_UPDATE_AUX_STRING);
m_send_trans.put_data (utf8_wcstombs (str));
m_send_trans.put_data (attrs);
}
}
void
HangulInstance::update_candidates ()
{
m_lookup_table.clear ();
m_candidate_comments.clear ();
HanjaList* list = NULL;
// search for symbol character
// key string for symbol character is like:
// 'ㄱ', 'ㄴ', 'ㄷ', etc
WideString preeditw = get_preedit_string();
if (preeditw.length() == 1) {
String key = utf8_wcstombs(preeditw);
list = hanja_table_match_suffix(m_factory->m_symbol_table, key.c_str());
}
// search for hanja
if (list == NULL) {
String str = get_candidate_string();
SCIM_DEBUG_IMENGINE(1) << "candidate string: " << str << "\n";
if (str.length() > 0) {
if (is_hanja_mode() || m_factory->m_commit_by_word) {
list = hanja_table_match_prefix(m_factory->m_hanja_table,
str.c_str());
} else {
list = hanja_table_match_suffix(m_factory->m_hanja_table,
str.c_str());
}
}
}
if (list != NULL) {
int n = hanja_list_get_size(list);
for (int i = 0; i < n; ++i) {
const char* value = hanja_list_get_nth_value(list, i);
const char* comment = hanja_list_get_nth_comment(list, i);
WideString candidate = utf8_mbstowcs(value, -1);
m_lookup_table.append_candidate(candidate);
m_candidate_comments.push_back(String(comment));
}
m_lookup_table.set_page_size (9);
m_lookup_table.show_cursor ();
update_lookup_table (m_lookup_table);
show_lookup_table ();
hangul_update_aux_string ();
hanja_list_delete(list);
}
if (m_lookup_table.number_of_candidates() <= 0) {
delete_candidates();
}
}
void
StandardIMInstance::imm_update_property (const IME_InputContext *ic,
const IME_Property *property)
{
if (ic && ic->id >= 0 && property) {
StandardIMInstance *inst = __global->find_instance (ic->id);
if (inst) {
Property prop;
prop.set_key (String (property->key));
prop.set_icon (String (property->icon));
prop.set_label (utf8_wcstombs (inst->m_factory->convert_string (String (property->label))));
prop.set_tip (utf8_wcstombs (inst->m_factory->convert_string (String (property->tip))));
prop.set_active ((property->state & IME_PROPERTY_ACTIVE) != 0);
prop.show ((property->state & IME_PROPERTY_VISIBLE) != 0);
inst->update_property (prop);
}
}
}
/**
* @brief Load all ISEs to initialize.
*
* @param type The loading ISE type.
* @param config The config pointer for loading keyboard ISE.
* @param uuids The ISE uuid list.
* @param names The ISE name list.
* @param module_names The ISE module name list.
* @param langs The ISE language list.
* @param icons The ISE icon list.
* @param modes The ISE type list.
* @param options The ISE option list.
* @param ise_list The already loaded ISE list.
*/
void isf_get_factory_list (LOAD_ISE_TYPE type,
const ConfigPointer &config,
std::vector<String> &uuids,
std::vector<String> &names,
std::vector<String> &module_names,
std::vector<String> &langs,
std::vector<String> &icons,
std::vector<TOOLBAR_MODE_T> &modes,
std::vector<uint32> &options,
const std::vector<String> &ise_list)
{
uuids.clear ();
names.clear ();
module_names.clear ();
langs.clear ();
icons.clear ();
modes.clear ();
options.clear ();
_groups.clear ();
if (type != HELPER_ONLY) {
/* Add "English/Keyboard" factory first. */
IMEngineFactoryPointer factory = new ComposeKeyFactory ();
uuids.push_back (factory->get_uuid ());
names.push_back (utf8_wcstombs (factory->get_name ()));
module_names.push_back (ENGLISH_KEYBOARD_MODULE);
langs.push_back (isf_get_normalized_language (factory->get_language ()));
icons.push_back (factory->get_icon_file ());
modes.push_back (TOOLBAR_KEYBOARD_MODE);
options.push_back (0);
factory.reset ();
}
String user_file_name = String (USER_ENGINE_FILE_NAME);
FILE *engine_list_file = fopen (user_file_name.c_str (), "r");
if (engine_list_file == NULL) {
std::cerr << user_file_name << " doesn't exist.\n";
return;
}
char buf[MAXLINE];
while (fgets (buf, MAXLINE, engine_list_file) != NULL) {
ISEINFO info;
isf_get_ise_info_from_string (buf, info);
if (info.mode == TOOLBAR_HELPER_MODE || type != HELPER_ONLY) {
names.push_back (info.name);
uuids.push_back (info.uuid);
module_names.push_back (info.module);
langs.push_back (info.language);
icons.push_back (info.icon);
modes.push_back (info.mode);
options.push_back (info.option);
}
}
fclose (engine_list_file);
}
static void fcopy_send_data(void)
{
struct hv_start_fcopy *smsg_out = &fcopy_transaction.message;
int operation = fcopy_transaction.fcopy_msg->operation;
struct hv_start_fcopy *smsg_in;
/*
* The strings sent from the host are encoded in
* in utf16; convert it to utf8 strings.
* The host assures us that the utf16 strings will not exceed
* the max lengths specified. We will however, reserve room
* for the string terminating character - in the utf16s_utf8s()
* function we limit the size of the buffer where the converted
* string is placed to W_MAX_PATH -1 to guarantee
* that the strings can be properly terminated!
*/
switch (operation) {
case START_FILE_COPY:
memset(smsg_out, 0, sizeof(struct hv_start_fcopy));
smsg_out->hdr.operation = operation;
smsg_in = (struct hv_start_fcopy *)fcopy_transaction.fcopy_msg;
utf8_wcstombs((__u8 *)smsg_out->file_name,
(wchar_t *)smsg_in->file_name,
W_MAX_PATH - 1);
utf8_wcstombs((__u8 *)smsg_out->path_name,
(wchar_t *)smsg_in->path_name,
W_MAX_PATH - 1);
smsg_out->copy_flags = smsg_in->copy_flags;
smsg_out->file_size = smsg_in->file_size;
break;
default:
break;
}
up(&fcopy_transaction.read_sema);
return;
}
std::ostream& utf8_write_phase_string(std::ostream& os,PhraseString& str)
{
std::vector<__u8> s;
int size=str.size()*4;
s.reserve(size); //utf8
ucs4_t*p=&str[0];
int len=utf8_wcstombs(&s[0],p,size);
for(int i=0;i<len;i++){
os<<s[i];
}
return os;
}
void
StandardIMInstance::imm_register_properties (const IME_InputContext *ic,
const IME_PropertiesList *properties)
{
if (ic && ic->id >= 0 && properties) {
StandardIMInstance *inst = __global->find_instance (ic->id);
if (inst) {
PropertyList prop_list;
if (properties->nr_properties > 0 && properties->properties) {
Property prop;
for (int i = 0; i < properties->nr_properties; ++i) {
prop.set_key (String (properties->properties [i].key));
prop.set_icon (String (properties->properties [i].icon));
prop.set_label (utf8_wcstombs (inst->m_factory->convert_string (String (properties->properties [i].label))));
prop.set_tip (utf8_wcstombs (inst->m_factory->convert_string (String (properties->properties [i].tip))));
prop.set_active ((properties->properties [i].state & IME_PROPERTY_ACTIVE) != 0);
prop.show ((properties->properties [i].state & IME_PROPERTY_VISIBLE) != 0);
prop_list.push_back (prop);
}
}
inst->register_properties (prop_list);
}
}
}
void
CannaJRKanji::set_mode_line (void)
{
if (m_enabled) {
int max_mode_len = jrKanjiControl(m_context_id,
KC_QUERYMAXMODESTR, 0);
unsigned char current_mode[max_mode_len];
jrKanjiControl(m_context_id, KC_QUERYMODE, (char *) current_mode);
WideString dest;
m_iconv.convert (dest, (const char *) current_mode);
m_properties[0].set_label (utf8_wcstombs(dest).c_str());
m_canna->register_properties (m_properties);
} else {
m_properties[0].set_label (_("[Off]"));
m_canna->register_properties (m_properties);
}
}
void ISFSetupWin::create_ise_option_main (const char *str)
{
if (!_setup_ui)
_setup_ui = new SetupUI (_config);
if (!_setup_ui)
return;
String setup_module_name;
setup_module_name = utf8_wcstombs (utf8_mbstowcs (str)) + String ("-imengine-setup");
SetupModule *setup_module = new SetupModule (setup_module_name);
if (setup_module) {
_setup_ui->add_module (setup_module);
delete setup_module;
}
}
void
PinyinPhraseLib::create_pinyin_index ()
{
if (!m_pinyin_table || !m_pinyin_table->size()) return;
clear_phrase_index ();
uint32 pinyin_offset = 0;
WideString content;
Phrase phrase;
for (uint32 i=0; i<m_phrase_lib.number_of_phrases (); i++) {
phrase = m_phrase_lib.get_phrase_by_index (i);
content = phrase.get_content ();
std::vector<PinyinKeyVector> key_vv;
m_pinyin_table->find_key_strings (key_vv, content);
for (uint32 j=0; j<key_vv.size(); j++) {
for (uint32 k=0; k<key_vv[j].size(); k++)
m_pinyin_lib.push_back (key_vv[j][k]);
insert_pinyin_phrase_into_index (phrase.get_phrase_offset (), pinyin_offset);
pinyin_offset = m_pinyin_lib.size ();
}
#if 0
if (key_vv.size () > 1 && content.length () > 1) {
for (uint32 x=0; x<key_vv.size (); x++) {
std::cerr << phrase.frequency () << "\t| " <<
utf8_wcstombs (content) << " =";
for (uint32 y=0; y<key_vv[x].size (); y++)
std::cerr << " " << key_vv[x][y];
std::cerr << "\n";
}
}
#endif
std::cout << "." << std::flush;
}
sort_phrase_tables ();
std::cout << "Phrase Number = " << count_phrase_number () << "\n";
}
String
HangulInstance::get_candidate_string()
{
int cursor = 0;
if (m_surrounding_text.empty())
get_surrounding_text(m_surrounding_text, cursor, 10, 0);
int i;
for (i = m_surrounding_text.length() - 1; i >= 0; i--) {
if (!hangul_is_syllable(m_surrounding_text[i]))
break;
}
if (i >= 0)
m_surrounding_text.erase(0, i + 1);
return utf8_wcstombs(m_surrounding_text + get_preedit_string());
}
static void test_nls_base(void) {
wchar_t p=0x20;
__u8 s=0x01;
int n=2;
struct nls_table nls;
char charset[20]="David";
load_nls_default();
register_nls(&nls);
unload_nls(&nls);
load_nls(charset);
unregister_nls(&nls);
utf8_mbtowc(&p, &s, n);
utf8_mbstowcs(&p, &s, n);
n=20;
utf8_wctomb(&s, p, n);
utf8_wcstombs(&s, &p, n);
}
static M4Err IS_ProcessData(SceneDecoder *plug, unsigned char *inBuffer, u32 inBufferLength,
u16 ES_ID, u32 AU_time, u32 mmlevel)
{
u32 i, j, count;
Double scene_time;
BitStream *bs;
ISPriv *priv = plug->privateStack;
M4Err e = M4OK;
/*decode data frame except if local stringSensor*/
bs = NewBitStream(inBuffer, inBufferLength, BS_READ);
for (i=0; i<ChainGetCount(priv->ddf); i++) {
FieldInfo *field = ChainGetEntry(priv->ddf, i);
/*store present flag in eventIn for command skip - this is an ugly hack but it works since DDF don't have event types*/
field->eventType = BS_ReadInt(bs, 1);
/*parse val ourselves (we don't want to depend on bifs codec)*/
if (field->eventType) {
switch (field->fieldType) {
case FT_SFBool: * ((SFBool *) field->far_ptr) = (SFBool) BS_ReadInt(bs, 1); break;
case FT_SFFloat: *((SFFloat *)field->far_ptr) = BS_ReadFloat(bs); break;
case FT_SFInt32: *((SFInt32 *)field->far_ptr) = (s32) BS_ReadInt(bs, 32); break;
case FT_SFTime: *((SFTime *)field->far_ptr) = BS_ReadDouble(bs); break;
case FT_SFVec2f:
((SFVec2f *)field->far_ptr)->x = BS_ReadFloat(bs);
((SFVec2f *)field->far_ptr)->y = BS_ReadFloat(bs);
break;
case FT_SFVec3f:
((SFVec3f *)field->far_ptr)->x = BS_ReadFloat(bs);
((SFVec3f *)field->far_ptr)->y = BS_ReadFloat(bs);
((SFVec3f *)field->far_ptr)->z = BS_ReadFloat(bs);
break;
case FT_SFColor:
((SFColor *)field->far_ptr)->red = BS_ReadFloat(bs);;
((SFColor *)field->far_ptr)->green = BS_ReadFloat(bs);
((SFColor *)field->far_ptr)->blue = BS_ReadFloat(bs);
break;
case FT_SFRotation:
((SFRotation *)field->far_ptr)->xAxis = BS_ReadFloat(bs);
((SFRotation *)field->far_ptr)->yAxis = BS_ReadFloat(bs);
((SFRotation *)field->far_ptr)->zAxis = BS_ReadFloat(bs);
((SFRotation *)field->far_ptr)->angle = BS_ReadFloat(bs);
break;
case FT_SFString:
{
u32 size, length;
size = BS_ReadInt(bs, 5);
length = BS_ReadInt(bs, size);
if (BS_Available(bs) < length) return M4NonCompliantBitStream;
if ( ((SFString *)field->far_ptr)->buffer ) free( ((SFString *)field->far_ptr)->buffer);
((SFString *)field->far_ptr)->buffer = malloc(sizeof(char)*(length+1));
memset(((SFString *)field->far_ptr)->buffer , 0, length+1);
for (j=0; j<length; j++) {
((SFString *)field->far_ptr)->buffer[j] = BS_ReadInt(bs, 8);
}
}
break;
}
}
}
DeleteBitStream(bs);
/*special case for StringSensor in local mode: lookup for special chars*/
if ((priv->type == IS_StringSensor) && priv->is_local) {
char tmp_utf8[5000];
const unsigned short *ptr;
u32 len;
FieldInfo *field1 = ChainGetEntry(priv->ddf, 0);
FieldInfo *field2 = ChainGetEntry(priv->ddf, 1);
SFString *inText = (SFString *) field1->far_ptr;
SFString *outText = (SFString *) field2->far_ptr;
field1->eventType = field2->eventType = 0;
priv->enteredText[priv->text_len] = (short) '\0';
len = utf8_wcslen(priv->enteredText);
if (len && (priv->enteredText[len-1] == priv->termChar)) {
ptr = priv->enteredText;
len = utf8_wcstombs(tmp_utf8, 5000, &ptr);
if (outText->buffer) free(outText->buffer);
outText->buffer = malloc(sizeof(char) * (len+1));
memcpy(outText->buffer, tmp_utf8, sizeof(char) * len);
outText->buffer[len] = 0;
if (inText->buffer) free(inText->buffer);
inText->buffer = NULL;
priv->text_len = 0;
field1->eventType = field2->eventType = 1;
} else {
if (priv->delChar) {
/*remove chars*/
if (len && (priv->enteredText[len-1] == priv->delChar)) {
priv->enteredText[len-1] = (short) '\0';
len--;
if (len) {
priv->enteredText[len-1] = (short) '\0';
len--;
}
}
}
priv->text_len = len;
ptr = priv->enteredText;
len = utf8_wcstombs(tmp_utf8, 5000, &ptr);
if (inText->buffer) free(inText->buffer);
inText->buffer = malloc(sizeof(char) * (len+1));
memcpy(inText->buffer, tmp_utf8, sizeof(char) * len);
inText->buffer[len] = 0;
field1->eventType = 1;
}
}
/*apply it*/
for (i=0; i<ChainGetCount(priv->is_nodes); i++) {
ISStack *st = ChainGetEntry(priv->is_nodes, i);
assert(st->is);
assert(st->is_dec);
if (!st->is->enabled) continue;
count = ChainGetCount(st->is->buffer.commandList);
scene_time = IS_GetSceneTime(priv->scene);
for (j=0; j<count; j++) {
SGCommand *com = ChainGetEntry(st->is->buffer.commandList, j);
FieldInfo *field = ChainGetEntry(priv->ddf, j);
CommandFieldInfo *info = ChainGetEntry(com->command_fields, 0);
if (info && field && field->eventType) {
VRML_FieldCopy(info->field_ptr, field->far_ptr, field->fieldType);
SG_ApplyCommand(priv->scene->graph, com, scene_time);
}
}
}
return e;
}
void
asusnls_c2u(char *name)
{
#ifdef CONFIG_NLS
char *codepage;
char *xfrstr;
struct nls_table *nls;
int ret;
strcpy(codebuf, name);
codepage=codebuf+strlen(NLS_NVRAM_C2U);
if((xfrstr=strchr(codepage, '_')))
{
*xfrstr=NULL;
xfrstr++;
/* debug message, start */
/*
printk("%s, xfr from %s to utf8\n", xfrstr, codepage);
printk("local: %d, ", strlen(xfrstr));
int j;
for (j=0;j<strlen(xfrstr);j++)
printk("%X ", (unsigned char)xfrstr[j]);
printk("\n");
printk("local: %s\n", xfrstr);
*/
/* debug message, end */
strcpy(name, "");
nls=load_nls(codepage);
if(!nls)
{
printk("NLS table is null!!\n");
}
else
{
int charlen;
int i;
int len = strlen(xfrstr);
for (i = 0; len && *xfrstr; i++, xfrstr += charlen, len -= charlen) { /* string to unicode */
charlen = nls->char2uni(xfrstr, len, &unibuf[i]);
if (charlen < 1) {
//unibuf[i] = 0x003f; /* a question mark */
//charlen = 1;
strcpy(name ,"");
unload_nls(nls);
return;
}
}
unibuf[i] = 0;
ret=utf8_wcstombs(name, unibuf, 1024); /* unicode to utf-8, 1024 is size of array unibuf */
name[ret]=0;
unload_nls(nls);
/* debug message, start */
/*
int k;
printk("unicode: %d, ", i);
for(k=0;k<i;k++)
printk("%X ", unibuf[k]);
printk("\n");
printk("utf-8: %s, %d, ", name, strlen(name));
for (i=0;i<strlen(name);i++)
printk("%X ", (unsigned char)name[i]);
printk("\n");
*/
/* debug message, end */
if(!ret)
{
printk("can not xfr from %s to utf8\n", codepage);
strcpy(name, "");
}
}
}
else
{
strcpy(name, "");
}
#endif
}
SocketFactory::SocketFactory (const String &peer_uuid)
: m_name (utf8_mbstowcs (_("Unknown"))),
m_language (String ("")),
m_peer_uuid (peer_uuid),
m_icon_file (String ("")),
m_ok (false)
{
String locales;
String iconfile;
int cmd;
bool m_name_ok = false;
bool m_locale_ok = false;
Transaction trans;
SCIM_DEBUG_IMENGINE(1) << "Create SocketFactory " << peer_uuid << ".\n";
// Get factory name.
global->init_transaction (trans);
trans.put_command (SCIM_TRANS_CMD_GET_FACTORY_NAME);
trans.put_data (m_peer_uuid);
if (global->send_transaction (trans)) {
if (global->receive_transaction (trans) &&
trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_REPLY &&
trans.get_data (m_name) &&
trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_OK) {
SCIM_DEBUG_IMENGINE(2) << " Name (" << utf8_wcstombs (m_name) << ")\n";
m_name_ok = true;
} else {
m_name = utf8_mbstowcs (_("Unknown"));
}
}
// Get factory locales
global->init_transaction (trans);
trans.put_command (SCIM_TRANS_CMD_GET_FACTORY_LOCALES);
trans.put_data (m_peer_uuid);
if (global->send_transaction (trans)) {
if (global->receive_transaction (trans) &&
trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_REPLY &&
trans.get_data (locales) &&
trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_OK) {
SCIM_DEBUG_IMENGINE(2) << " Locales (" << locales << ")\n";
set_locales (locales);
m_locale_ok = true;
}
}
// Get factory language
global->init_transaction (trans);
trans.put_command (SCIM_TRANS_CMD_GET_FACTORY_LANGUAGE);
trans.put_data (m_peer_uuid);
if (global->send_transaction (trans)) {
if (global->receive_transaction (trans) &&
trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_REPLY &&
trans.get_data (m_language) &&
trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_OK) {
SCIM_DEBUG_IMENGINE(2) << " Language (" << m_language << ")\n";
} else {
m_language.clear ();
}
}
// Get icon file.
global->init_transaction (trans);
trans.put_command (SCIM_TRANS_CMD_GET_FACTORY_ICON_FILE);
trans.put_data (m_peer_uuid);
if (global->send_transaction (trans)) {
if (global->receive_transaction (trans) &&
trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_REPLY &&
trans.get_data (iconfile) &&
trans.get_command (cmd) && cmd == SCIM_TRANS_CMD_OK) {
m_icon_file = global->load_icon (iconfile);
}
}
m_ok = (m_name_ok && m_locale_ok);
}
void M4T_StringInput(MPEG4CLIENT term, u32 character)
{
u32 i;
BitStream *bs;
SLHeader slh;
unsigned char *buf;
u32 buf_size;
if (!character || !term) return;
if (!ChainGetCount(term->input_streams) && !ChainGetCount(term->x3d_sensors)) return;
memset(&slh, 0, sizeof(SLHeader));
slh.accessUnitStartFlag = slh.accessUnitEndFlag = 1;
slh.compositionTimeStampFlag = 1;
/*cf above*/
slh.compositionTimeStamp = 0;
/*get all IS StringSensor decoders and send frame*/
for (i=0; i<ChainGetCount(term->input_streams); i++) {
GenericCodec *cod = ChainGetEntry(term->input_streams, i);
ISPriv *is = cod->decio->privateStack;
if (is->type==IS_StringSensor) {
Channel *ch = ChainGetEntry(cod->inChannels, 0);
is->enteredText[is->text_len] = character;
is->text_len += 1;
/*write empty DDF*/
bs = NewBitStream(NULL, 0, BS_WRITE);
BS_WriteInt(bs, 0, 1);
BS_WriteInt(bs, 0, 1);
BS_Align(bs);
BS_GetContent(bs, &buf, &buf_size);
DeleteBitStream(bs);
Channel_RecieveSLP(ch->service, ch, buf, buf_size, &slh, M4OK);
free(buf);
}
}
/*get all X3D StringSensors*/
for (i=0; i<ChainGetCount(term->x3d_sensors); i++) {
StringSensorStack *st;
char szStr[5000];
const unsigned short *ptr;
u32 len;
X_StringSensor *n = ChainGetEntry(term->x3d_sensors, i);
if (Node_GetTag((SFNode *)n) != TAG_X3D_StringSensor) continue;
if (!n->enabled) continue;
st = (StringSensorStack *) Node_GetPrivate((SFNode *)n);
if (character=='\b') {
if (n->deletionAllowed && st->text_len) {
st->text_len -= 1;
st->enteredText[st->text_len] = 0;
ptr = st->enteredText;
len = utf8_wcstombs(szStr, 10, &ptr);
if (n->enteredText.buffer) free(n->enteredText.buffer);
szStr[len] = 0;
n->enteredText.buffer = strdup(szStr);
Node_OnEventOutSTR((SFNode *)n, "enteredText");
}
} else if (character=='\r') {
if (n->finalText.buffer) free(n->finalText.buffer);
n->finalText.buffer = n->enteredText.buffer;
n->enteredText.buffer = strdup("");
st->text_len = 0;
Node_OnEventOutSTR((SFNode *)n, "enteredText");
Node_OnEventOutSTR((SFNode *)n, "finalText");
} else {
st->enteredText[st->text_len] = character;
st->text_len += 1;
st->enteredText[st->text_len] = 0;
ptr = st->enteredText;
len = utf8_wcstombs(szStr, 10, &ptr);
if (n->enteredText.buffer) free(n->enteredText.buffer);
szStr[len] = 0;
n->enteredText.buffer = strdup(szStr);
Node_OnEventOutSTR((SFNode *)n, "enteredText");
}
}
}
// Convert a UTF-16 std::wstring into a multibyte UTF-8 string
std::string SharedUtil::UTF16ToMbUTF8 (const std::wstring& input)
{
return utf8_wcstombs (input);
}
/**
* @brief Load one keyboard ISE module.
*
* @param module_name The keboard ISE module name.
* @param config The config pointer for loading keyboard ISE.
*
* @return true if load module is successful, otherwise return false.
*/
static bool add_keyboard_ise_module (const String module_name, const ConfigPointer &config)
{
if (module_name.length () <= 0 || module_name == "socket")
return false;
IMEngineFactoryPointer factory;
IMEngineModule ime_module;
String filename = String (USER_ENGINE_FILE_NAME);
FILE *engine_list_file = fopen (filename.c_str (), "a");
if (engine_list_file == NULL) {
std::cerr << "failed to open " << filename << "\n";
return false;
}
ime_module.load (module_name, config);
if (ime_module.valid ()) {
for (size_t j = 0; j < ime_module.number_of_factories (); ++j) {
try {
factory = ime_module.create_factory (j);
} catch (...) {
factory.reset ();
}
if (!factory.null ()) {
if (std::find (_uuids.begin (), _uuids.end (), factory->get_uuid ()) == _uuids.end ()) {
String uuid = factory->get_uuid ();
String name = utf8_wcstombs (factory->get_name ());
String language = isf_get_normalized_language (factory->get_language ());
String icon = factory->get_icon_file ();
char mode[12];
char option[12];
_uuids.push_back (uuid);
_names.push_back (name);
_module_names.push_back (module_name);
_langs.push_back (language);
_icons.push_back (icon);
_modes.push_back (TOOLBAR_KEYBOARD_MODE);
_options.push_back (0);
snprintf (mode, sizeof (mode), "%d", (int)TOOLBAR_KEYBOARD_MODE);
snprintf (option, sizeof (option), "%d", 0);
String line = isf_combine_ise_info_string (name, uuid, module_name, language,
icon, String (mode), String (option), factory->get_locales ());
if (fputs (line.c_str (), engine_list_file) < 0) {
std::cerr << "write to ise cache file failed:" << line << "\n";
break;
}
}
factory.reset ();
}
}
ime_module.unload ();
}
fclose (engine_list_file);
return true;
}
void M4T_KeyboardInput(MPEG4CLIENT term, s32 keyPressed, s32 keyReleased, s32 actionKeyPressed, s32 actionKeyReleased, u32 shiftKeyDown, u32 controlKeyDown, u32 altKeyDown)
{
u32 i;
BitStream *bs;
SLHeader slh;
unsigned char *buf;
u32 buf_size;
if (!term || (!ChainGetCount(term->input_streams) && !ChainGetCount(term->x3d_sensors)) ) return;
memset(&slh, 0, sizeof(SLHeader));
slh.accessUnitStartFlag = slh.accessUnitEndFlag = 1;
slh.compositionTimeStampFlag = 1;
/*cf above*/
slh.compositionTimeStamp = 0;
bs = NewBitStream(NULL, 0, BS_WRITE);
BS_WriteInt(bs, keyPressed ? 1 : 0, 1);
if (keyPressed) BS_WriteInt(bs, keyPressed, 32);
BS_WriteInt(bs, keyReleased ? 1 : 0, 1);
if (keyReleased) BS_WriteInt(bs, keyReleased, 32);
BS_WriteInt(bs, actionKeyPressed ? 1 : 0, 1);
if (actionKeyPressed) BS_WriteInt(bs, actionKeyPressed, 32);
BS_WriteInt(bs, actionKeyReleased ? 1 : 0, 1);
if (actionKeyReleased) BS_WriteInt(bs, actionKeyReleased, 32);
BS_WriteInt(bs, shiftKeyDown ? 1 : 0 , 1);
if (shiftKeyDown) BS_WriteInt(bs, shiftKeyDown-1, 1);
BS_WriteInt(bs, controlKeyDown ? 1 : 0 , 1);
if (controlKeyDown) BS_WriteInt(bs, controlKeyDown-1, 1);
BS_WriteInt(bs, altKeyDown ? 1 : 0 , 1);
if (altKeyDown) BS_WriteInt(bs, altKeyDown, 1);
BS_Align(bs);
BS_GetContent(bs, &buf, &buf_size);
DeleteBitStream(bs);
/*get all IS keySensor decoders and send frame*/
for (i=0; i<ChainGetCount(term->input_streams); i++) {
GenericCodec *cod = ChainGetEntry(term->input_streams, i);
ISPriv *is = cod->decio->privateStack;
if (is->type==IS_KeySensor) {
Channel *ch = ChainGetEntry(cod->inChannels, 0);
Channel_RecieveSLP(ch->service, ch, buf, buf_size, &slh, M4OK);
}
}
free(buf);
for (i=0; i<ChainGetCount(term->x3d_sensors); i++) {
u16 tc[2];
u32 len;
char szStr[10];
const unsigned short *ptr;
X_KeySensor *n = ChainGetEntry(term->x3d_sensors, i);
if (Node_GetTag((SFNode *)n) != TAG_X3D_KeySensor) continue;
if (!n->enabled) return;
if (keyPressed) {
if (n->keyPress.buffer) free(n->keyPress.buffer);
tc[0] = keyPressed; tc[1] = 0;
ptr = tc;
len = utf8_wcstombs(szStr, 10, &ptr);
n->keyPress.buffer = malloc(sizeof(char) * (len+1));
memcpy(n->keyPress.buffer, szStr, sizeof(char) * len);
n->keyPress.buffer[len] = 0;
Node_OnEventOutSTR((SFNode *)n, "keyPress");
}
if (keyReleased) {
if (n->keyRelease.buffer) free(n->keyRelease.buffer);
tc[0] = keyReleased; tc[1] = 0;
ptr = tc;
len = utf8_wcstombs(szStr, 10, &ptr);
n->keyRelease.buffer = malloc(sizeof(char) * (len+1));
memcpy(n->keyRelease.buffer, szStr, sizeof(char) * len);
n->keyRelease.buffer[len] = 0;
Node_OnEventOutSTR((SFNode *)n, "keyRelease");
}
if (actionKeyPressed) {
n->actionKeyPress = actionKeyPressed;
Node_OnEventOutSTR((SFNode *)n, "actionKeyPress");
}
if (actionKeyReleased) {
n->actionKeyRelease = actionKeyReleased;
Node_OnEventOutSTR((SFNode *)n, "actionKeyRelease");
}
if (shiftKeyDown) {
n->shiftKey = (shiftKeyDown-1) ? 1 : 0;
Node_OnEventOutSTR((SFNode *)n, "shiftKey");
}
if (controlKeyDown) {
n->controlKey = (controlKeyDown-1) ? 1 : 0;
Node_OnEventOutSTR((SFNode *)n, "controlKey");
}
if (altKeyDown) {
n->altKey= (altKeyDown-1) ? 1 : 0;
Node_OnEventOutSTR((SFNode *)n, "altKey");
}
if (keyPressed || actionKeyPressed || (shiftKeyDown-1) || (controlKeyDown-1) || (altKeyDown-1)) {
if (!n->isActive) {
n->isActive = 1;
Node_OnEventOutSTR((SFNode *)n, "isActive");
}
} else if (n->isActive) {
n->isActive = 0;
Node_OnEventOutSTR((SFNode *)n, "isActive");
}
}
}
