CannaJRKanji::~CannaJRKanji ()
{
    jrKanjiControl (m_context_id, KC_CLOSEUICONTEXT, (char *) &m_ksv);

    if (n_instance != 0) {
        n_instance--;
        if (n_instance == 0)
            jrKanjiControl (0, KC_FINALIZE, NULL);
    }
}
CannaJRKanji::CannaJRKanji (CannaInstance *ci)
    : m_canna (ci),
      m_enabled (false),
      m_context_id (last_created_context_id++),
      m_preediting (false),
      m_aux_string_visible (false)
{
    char **warn = NULL, **p;

    if (m_canna->m_factory->m_on_off == "On") {
        m_enabled = true;
    } else if (m_canna->m_factory->m_on_off == "Off") {
        m_enabled = false;
    } else {
        m_enabled = false;
    }

    m_iconv.set_encoding ("EUC-JP");

    // initialize canna library
    if (n_instance == 0) {
        if (m_canna->m_factory->m_specify_init_file_name) {
            const char *file = m_canna->m_factory->m_init_file_name.c_str();
            jrKanjiControl (0, KC_SETINITFILENAME, (char *) file);
        }

        if (m_canna->m_factory->m_specify_server_name) {
            const char *server = m_canna->m_factory->m_server_name.c_str();
            jrKanjiControl (0, KC_SETSERVERNAME, (char *) server);
        }

        jrKanjiControl (0, KC_INITIALIZE, (char *) &warn);

        for (p = warn; warn && *p; p++) {
            // error
        }

        jrKanjiControl (0, KC_SETAPPNAME, "scim-canna");
    }

    // initialize canna context
    m_workbuf[0]       = '\0';
    m_ksv.ks           = &m_ks;
    m_ksv.buffer       = m_workbuf;
    m_ksv.bytes_buffer = CANNA_MAX_SIZE;
    m_ksv.val          = CANNA_MODE_HenkanMode;
    jrKanjiControl (m_context_id, KC_CHANGEMODE, (char *) &m_ksv);

    n_instance++;

    // set mode line
    install_properties ();
    set_mode_line ();
}
Beispiel #3
0
int main() {
  char** warning = NULL;
  int res = jrKanjiControl(0, KC_INITIALIZE, (char*)&warning);

  if( res != 0 ) {
    exit(-1);
  } else if( warning ) {
    exit(-1);
  }

  jrKanjiControl(0, KC_FINALIZE, 0);
  return 0;
}
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
CannaJRKanji::trigger_property (const String &property)
{
    int val = m_ksv.val;

    if (property == SCIM_PROP_INPUT_MODE_OFF) {
        m_enabled = false;
        set_mode_line ();
    } else if (property == SCIM_PROP_INPUT_MODE_HIRAGANA) {
        m_enabled = true;
        m_ksv.val = CANNA_MODE_ZenHiraHenkanMode;

    } else if (property == SCIM_PROP_INPUT_MODE_KATAKANA) {
        m_enabled = true;
        m_ksv.val = CANNA_MODE_ZenKataHenkanMode;

    } else if (property == SCIM_PROP_INPUT_MODE_HALF_KATAKANA) {
        m_enabled = true;
        m_ksv.val = CANNA_MODE_HanKataHenkanMode;

    } else if (property == SCIM_PROP_INPUT_MODE_ALPHABET) {
        m_enabled = true;
        m_ksv.val = CANNA_MODE_HanAlphaHenkanMode;

    } else if (property == SCIM_PROP_INPUT_MODE_WIDE_ALPHABET) {
        m_enabled = true;
        m_ksv.val = CANNA_MODE_ZenAlphaHenkanMode;

    } else if (property == SCIM_PROP_INPUT_MODE_KIGO) {
        m_enabled = true;
        m_ksv.val = CANNA_MODE_KigoMode;

    } else if (property == SCIM_PROP_INPUT_MODE_HEX) {
        m_enabled = true;
        m_ksv.val = CANNA_MODE_HexMode;

    } else if (property == SCIM_PROP_INPUT_MODE_BUSHU) {
        m_enabled = true;
        m_ksv.val = CANNA_MODE_BushuMode;
    }

    if (val != m_ksv.val) {
        jrKanjiControl (m_context_id, KC_CHANGEMODE, (char *) &m_ksv);
        set_mode_line ();
        set_guide_line ();
    }
}
void
CannaJRKanji::reset (void)
{
    jrKanjiControl (m_context_id, KC_KILL, (char *) &m_ksv);
}