scim_chewing_imengine_setup.cpp

scim 修改过的可以在手机上运行的代码

	}
	
	gtk_combo_set_popdown_strings (GTK_COMBO (__widget_selKey_type), selKey_type_list);
	g_list_free(selKey_type_list);
	gtk_combo_set_use_arrows (GTK_COMBO (__widget_selKey_type), TRUE);
	gtk_editable_set_editable (GTK_EDITABLE (GTK_ENTRY (GTK_COMBO (__widget_selKey_type)->entry)), FALSE);
	label = gtk_label_new (_("Customized Selection Keys:"));
	gtk_widget_show (label);
	gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
	gtk_misc_set_padding (GTK_MISC (label), 4, 0);
	gtk_table_attach (GTK_TABLE (table), label, 0, 1, i, i+1,
			(GtkAttachOptions) (GTK_FILL),
			(GtkAttachOptions) (GTK_FILL), 4, 4);
	gtk_table_attach (GTK_TABLE (table), __widget_selKey_type, 1, 2, i, i+1,
			(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
			(GtkAttachOptions) (GTK_FILL), 4, 4);
	gtk_tooltips_set_tip (__widget_tooltips, GTK_COMBO (__widget_selKey_type)->entry,
			_("Change the default selection keys"), NULL);
	g_signal_connect(
		(gpointer) GTK_ENTRY(GTK_COMBO(__widget_selKey_type)->entry), 
		"changed",
		G_CALLBACK (on_default_editable_changed),
		&(__config_selKey_type_data));

	// Setup selKey_num combo box
	__widget_selKey_num = gtk_combo_new();
	gtk_widget_show (__widget_selKey_num);

	for (i = 0; 
	     i < (sizeof(builtin_selectkeys_num) / sizeof(builtin_selectkeys_num[0])); 
	     i++) {
		selKey_num_list = g_list_append(
				selKey_num_list,
				(void *) builtin_selectkeys_num[ i ] );
	}
	
	gtk_combo_set_popdown_strings (GTK_COMBO (__widget_selKey_num), selKey_num_list);
	g_list_free(selKey_num_list);
	gtk_combo_set_use_arrows (GTK_COMBO (__widget_selKey_num), TRUE);
	gtk_editable_set_editable (GTK_EDITABLE (GTK_ENTRY (GTK_COMBO (__widget_selKey_num)->entry)), FALSE);
	label = gtk_label_new (_("Number of Selection Keys :"));
	gtk_widget_show (label);
	gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
	gtk_misc_set_padding (GTK_MISC (label), 4, 0);
	gtk_table_attach (GTK_TABLE (table), label, 0, 1, i, i+1,
			(GtkAttachOptions) (GTK_FILL),
			(GtkAttachOptions) (GTK_FILL), 4, 4);
	gtk_table_attach (GTK_TABLE (table), __widget_selKey_num, 1, 2, i, i+1,
			(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
			(GtkAttachOptions) (GTK_FILL), 4, 4);
	gtk_tooltips_set_tip (__widget_tooltips, GTK_COMBO (__widget_selKey_num)->entry,
			_("Change the default number of selection keys"), NULL);
	g_signal_connect(
		(gpointer) GTK_ENTRY(GTK_COMBO(__widget_selKey_num)->entry), 
		"changed",
		G_CALLBACK (on_default_editable_changed),
		&(__config_selKey_num_data));

	// keyboard: trigger keys
	for (i = 0; __config_keyboards [i].key; ++ i) {
		g_signal_connect ((gpointer) __config_keyboards [i].button, "clicked",
				G_CALLBACK (on_default_key_selection_clicked),
				&(__config_keyboards [i]));
		g_signal_connect ((gpointer) __config_keyboards [i].entry, "changed",
				G_CALLBACK (on_default_editable_changed),
				&(__config_keyboards [i].data));
	}

	for (i = 0; __config_keyboards [i].key; ++ i) {
		gtk_tooltips_set_tip (__widget_tooltips, __config_keyboards [i].entry,
				_(__config_keyboards [i].tooltip), NULL);
	}

	return table;
}

static GtkWidget *create_color_button_page()
{               
	GtkWidget *widget;
	GtkWidget *hbox;
	GtkWidget *table;
	char color_button_name_string[64] = { 0 };
	table = gtk_table_new (4, 5, FALSE);
	gtk_widget_show (table);

	for (int i = 0; i < SCIM_CONFIG_IMENGINE_CHEWING_PREEDIT_BGCOLOR_NUM; i++) {
		hbox = gtk_hbox_new (FALSE, 0);
		gtk_widget_show (hbox);
		sprintf(color_button_name_string, 
			SCIM_CONFIG_IMENGINE_CHEWING_PREEDIT_BGCOLOR_ "_%d", i + 1);
		widget = create_color_button (color_button_name_string);
		gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
		gtk_table_attach (GTK_TABLE (table), hbox, 4, 5, i, i + 1,
				(GtkAttachOptions) (GTK_FILL),
				(GtkAttachOptions) (GTK_FILL), 5, 5);
	}

	return table;
}

static GtkWidget *create_setup_window()
{
	static GtkWidget *window = 0;

	if (!window) {
		GtkWidget *notebook;
		GtkWidget *label;
		GtkWidget *page;

		__widget_tooltips = gtk_tooltips_new ();

		// Create the Notebook.
		notebook = gtk_notebook_new ();
		gtk_widget_show (notebook);

		// Create the first page.
		page = create_options_page ();
		gtk_container_add (GTK_CONTAINER (notebook), page);

		// Create the label for this note page.
		label = gtk_label_new (_("Options"));
		gtk_widget_show (label);
		gtk_notebook_set_tab_label(
			GTK_NOTEBOOK( notebook ),
			gtk_notebook_get_nth_page( GTK_NOTEBOOK( notebook ), 0 ), 
			label );

		// Create the second page.
		page = create_keyboard_page ();

		// Create the label for this note page.
		label = gtk_label_new (_("Keyboard"));
		gtk_widget_show (label);
		gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, label);

		// Create the third page.
		page = create_color_button_page ();

		// Create the label for this note page.
		label = gtk_label_new (_("Decorative Color"));
		gtk_widget_show (label);
		gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, label);

		window = notebook;

		setup_widget_value ();
	}

	return window;
}

void setup_widget_value()
{
	if ( __widget_add_phrase_forward ) {
		gtk_toggle_button_set_active(
				GTK_TOGGLE_BUTTON( __widget_add_phrase_forward ),
				__config_add_phrase_forward);
	}

	if ( __widget_space_as_selection ) {
		gtk_toggle_button_set_active(
				GTK_TOGGLE_BUTTON( __widget_space_as_selection ),
				__config_space_as_selection );
	}
	
	for (int i = 0; __config_keyboards [i].key; ++ i) {
		if (__config_keyboards [i].entry) {
			gtk_entry_set_text (
					GTK_ENTRY (__config_keyboards [i].entry),
					__config_keyboards [i].data.c_str ());
		}
	}

	for (unsigned int i = 0; config_color_common[i].bg_key; i++) {
		ColorConfigData &entry = config_color_common[i];
		if (entry.widget) {
			scim_color_button_set_colors (
				SCIM_COLOR_BUTTON (entry.widget),
				entry.fg_value, 
				entry.bg_value);
		}
	}

	/* KB_TYPE */
	int index_keymap = (sizeof(builtin_keymaps) / sizeof(_builtin_keymap)) - 1;
	for ( ; index_keymap >= 0;  index_keymap--) {
		if ( __config_kb_type_data == builtin_keymaps[index_keymap].entry ) {
			break;
		}
	}
	if (index_keymap < 0)
		index_keymap = 0;
	
	gtk_entry_set_text (
			GTK_ENTRY(GTK_COMBO(__widget_kb_type)->entry),
			builtin_keymaps[index_keymap].translated_name.c_str()
	);

	/* selKey */
	int index_selectkeys = sizeof(builtin_selectkeys) / sizeof(builtin_selectkeys[0]) - 1;
	for ( ; index_selectkeys >= 0;  index_selectkeys--) {
		if ( __config_selKey_type_data ==
		     builtin_selectkeys[index_selectkeys]) {
			break;
		}
	}
	if (index_selectkeys < 0)
		index_selectkeys = 0;
	
	gtk_entry_set_text (
		GTK_ENTRY(GTK_COMBO(__widget_selKey_type)->entry),
		builtin_selectkeys[index_selectkeys]
	);

	/* selKey_num */
	int index_selectkeys_num =
		sizeof(builtin_selectkeys_num) / sizeof(builtin_selectkeys_num[0]) - 1;
	for ( ; index_selectkeys_num >= 0;  index_selectkeys_num--) {
		if ( __config_selKey_num_data ==
			builtin_selectkeys_num[index_selectkeys_num]) {
			break;
		}
	}
	if (index_selectkeys_num < 0)
		index_selectkeys_num = 0;
	
	gtk_entry_set_text (
		GTK_ENTRY(GTK_COMBO(__widget_selKey_num)->entry),
		builtin_selectkeys_num[index_selectkeys_num]
	);
}

void load_config( const ConfigPointer &config )
{
	if (!config.null ()) {
		__config_add_phrase_forward =
			config->read( String( SCIM_CONFIG_IMENGINE_CHEWING_ADD_PHRASE_FORWARD ),
					__config_add_phrase_forward );

		__config_esc_clean_all_buffer =
			config->read( String( SCIM_CONFIG_IMENGINE_CHEWING_ESC_CLEAN_ALL_BUFFER ),
					__config_esc_clean_all_buffer );

		__config_space_as_selection =
			config->read( String( SCIM_CONFIG_IMENGINE_CHEWING_SPACE_AS_SELECTION ),
					__config_space_as_selection );

		__config_kb_type_data = 
			config->read( String( SCIM_CONFIG_IMENGINE_CHEWING_USER_KB_TYPE ),
					__config_kb_type_data);

		__config_selKey_type_data =
			config->read( String( SCIM_CONFIG_IMENGINE_CHEWING_USER_SELECTION_KEYS ),
					__config_selKey_type_data);

		__config_selKey_num_data =
			config->read( String( SCIM_CHEWING_SELECTION_KEYS_NUM ),
					__config_selKey_num_data);

		for (int i = 0; __config_keyboards[ i ].key; ++ i) {
			__config_keyboards[ i ].data =
				config->read( String( __config_keyboards [ i ].key ),
						__config_keyboards[ i ].data);
		}

		for (unsigned int i = 0; config_color_common[i].bg_key; i++) {
			ColorConfigData &entry = config_color_common[i];
			entry.bg_value = config->read (String (entry.bg_key), entry.bg_value);
		}

		setup_widget_value ();

		__have_changed = false;
	}
}

void save_config( const ConfigPointer &config )
{
	if ( ! config.null() ) {
		config->write( String( SCIM_CONFIG_IMENGINE_CHEWING_ADD_PHRASE_FORWARD ),
				__config_add_phrase_forward );

		config->write( String( SCIM_CONFIG_IMENGINE_CHEWING_ESC_CLEAN_ALL_BUFFER ),
				__config_esc_clean_all_buffer );

		config->write( String( SCIM_CONFIG_IMENGINE_CHEWING_SPACE_AS_SELECTION ),
				__config_space_as_selection );

		// SCIM_CONFIG_IMENGINE_CHEWING_USER_KB_TYPE
		int index_keymap = 
			(sizeof(builtin_keymaps) / sizeof(_builtin_keymap)) - 1;
		for ( ; index_keymap >= 0;  index_keymap--) {
			if (__config_kb_type_data_translated == 
				builtin_keymaps[index_keymap].translated_name ) {
				break;
			}
		}
		if (index_keymap < 0)
			index_keymap = 0;
		__config_kb_type_data = builtin_keymaps[index_keymap].entry;

		config->write (String (SCIM_CONFIG_IMENGINE_CHEWING_USER_KB_TYPE),
				__config_kb_type_data);

		// SCIM_CONFIG_IMENGINE_CHEWING_USER_SELECTION_KEYS
		int index_selectkeys =
			sizeof(builtin_selectkeys) / sizeof(builtin_selectkeys[0]) - 1;
		for ( ; index_selectkeys >= 0; index_selectkeys--) {
			if (__config_selKey_type_data ==
			    builtin_selectkeys[index_selectkeys]) {
				break;
			}
		}
		if (index_selectkeys < 0)
			index_selectkeys = 0;
		__config_selKey_type_data =
			builtin_selectkeys[index_selectkeys];

		config->write (String (SCIM_CONFIG_IMENGINE_CHEWING_USER_SELECTION_KEYS),
				__config_selKey_type_data);

		// SCIM_CHEWING_SELECTION_KEYS_NUM
		int index_selectkeys_num =
			sizeof(builtin_selectkeys_num) / sizeof(builtin_selectkeys_num[0]) - 1;
		for ( ; index_selectkeys_num >= 0; index_selectkeys_num--) {
			if (__config_selKey_num_data ==
			    builtin_selectkeys_num[index_selectkeys_num]) {
				break;
			}
		}
		if (index_selectkeys_num < 0)
			index_selectkeys_num = 0;
		__config_selKey_num_data =
			builtin_selectkeys_num[index_selectkeys_num];

		config->write (String (SCIM_CHEWING_SELECTION_KEYS_NUM),
		               __config_selKey_num_data);

//		config->write (String (SCIM_CONFIG_IMENGINE_CHEWING_SHOW_CANDIDATE_COMMENT),
//				__config_show_candidate_comment);

		for (int i = 0; __config_keyboards [i].key; ++ i) {
			config->write (String (__config_keyboards [i].key),
					__config_keyboards [i].data);
		}

		for (unsigned int i = 0; config_color_common[i].bg_key; i++) {
			ColorConfigData &entry = config_color_common[i];
			if (entry.changed) {
				entry.bg_value = config->write (String (entry.bg_key),
						entry.bg_value);
			}
			entry.changed = false;
		}


		__have_changed = false;
	}
}

bool query_changed()
{
	return __have_changed;
}

static void on_default_editable_changed(
		GtkEditable *editable,
		gpointer user_data )
{
	String *str = static_cast< String * >( user_data );

	if ( str ) {
		*str = String( gtk_entry_get_text( GTK_ENTRY( editable ) ) );
		__have_changed = true;
	}
}

static void on_default_toggle_button_toggled(
		GtkToggleButton *togglebutton,
		gpointer user_data )
{
	bool *toggle = static_cast< bool * >( user_data );

	if ( toggle ) {
		*toggle = gtk_toggle_button_get_active( togglebutton );
		__have_changed = true;
	}
}

static void on_default_key_selection_clicked(
		GtkButton *button,
		gpointer user_data )
{
	KeyboardConfigData *data = static_cast< KeyboardConfigData * >( user_data );

	if ( data ) {
		GtkWidget *dialog = scim_key_selection_dialog_new (_(data->title));
		gint result;

		scim_key_selection_dialog_set_keys (
				SCIM_KEY_SELECTION_DIALOG( dialog ),
				gtk_entry_get_text( GTK_ENTRY( data->entry ) ) );

		result = gtk_dialog_run( GTK_DIALOG( dialog ) );

		if ( result == GTK_RESPONSE_OK ) {
			const gchar *keys = scim_key_selection_dialog_get_keys (
				SCIM_KEY_SELECTION_DIALOG( dialog ) );

			if ( ! keys )
				keys = "";

			if ( strcmp( keys, gtk_entry_get_text( GTK_ENTRY( data->entry ) ) ) != 0 )
				gtk_entry_set_text( GTK_ENTRY( data->entry ), keys );
		}

		gtk_widget_destroy( dialog );
	}
}

static ColorConfigData *find_color_config_entry (const char *config_key)
{
	if (!config_key)
		return NULL;

	for (unsigned int i = 0; config_color_common[i].bg_key; i++) {
		ColorConfigData *entry = &config_color_common[i];
		if (entry->fg_key && !strcmp (entry->bg_key, config_key))
			return entry;
	}

	return NULL;
}

static GtkWidget *create_color_button (const char *config_key)
{
	ColorConfigData *entry = find_color_config_entry (config_key);
	if (!entry)
		return NULL;

	GtkWidget *hbox = gtk_hbox_new (FALSE, 0);
	gtk_container_set_border_width (GTK_CONTAINER (hbox), 4);
	gtk_widget_show (hbox);

	GtkWidget *label = NULL;
	if (entry->label) {
		label = gtk_label_new_with_mnemonic (_(entry->label));
		gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
		gtk_widget_show (label);
	}

	entry->widget = scim_color_button_new ();
	gtk_widget_set_size_request (GTK_WIDGET (entry->widget), 32, 24);
	g_signal_connect (G_OBJECT (entry->widget), "color-changed",
			G_CALLBACK (on_color_button_changed),
			entry);
	gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (entry->widget),
			FALSE, FALSE, 2);
	gtk_widget_show (GTK_WIDGET (entry->widget));

	if (label) {
		gtk_label_set_mnemonic_widget (GTK_LABEL (label),
				GTK_WIDGET (entry->widget));

#if 0	/* XXX: not functioned. */
		gtk_tooltips_set_tip(
			__widget_tooltips,
			GTK_WIDGET (label),
			_( entry->title ), NULL);
#endif
	}

	return hbox;
}

static void on_color_button_changed(
	ScimColorButton *button,
	gpointer user_data)
{
	ColorConfigData *entry = static_cast <ColorConfigData*> (user_data);

	if (entry->widget) {
		scim_color_button_get_colors (button, &entry->fg_value, &entry->bg_value);
		entry->changed = true;
		__have_changed = true;
	}
}