/*
* Sets the properties of the widget. This is used for both applying the
* properties changed in the property editor, and also for loading.
*/
static void
gb_combo_set_properties (GtkWidget * widget, GbWidgetSetArgData * data)
{
gboolean value_in_list, ok_if_empty, case_sensitive, arrows, arrows_always;
gchar *items;
GList *item_list = NULL;
value_in_list = gb_widget_input_bool (data, ValueInList);
if (data->apply)
{
gtk_object_set_data (GTK_OBJECT (widget), ValueInList,
value_in_list ? "TRUE" : NULL);
}
ok_if_empty = gb_widget_input_bool (data, OKIfEmpty);
if (data->apply)
{
gtk_object_set_data (GTK_OBJECT (widget), OKIfEmpty,
ok_if_empty ? "TRUE" : NULL);
}
case_sensitive = gb_widget_input_bool (data, Case);
if (data->apply)
gtk_combo_set_case_sensitive (GTK_COMBO (widget), case_sensitive);
arrows = gb_widget_input_bool (data, Arrows);
if (data->apply)
gtk_combo_set_use_arrows (GTK_COMBO (widget), arrows);
arrows_always = gb_widget_input_bool (data, Always);
if (data->apply)
gtk_combo_set_use_arrows_always (GTK_COMBO (widget), arrows_always);
items = gb_widget_input_text (data, Items);
if (data->apply)
{
gchar *pos = items;
gchar *items_end = &items[strlen (items)];
while (pos < items_end)
{
gchar *item_end = strchr (pos, '\n');
if (item_end == NULL)
item_end = items_end;
*item_end = '\0';
item_list = g_list_append (item_list, pos);
pos = item_end + 1;
}
if (item_list)
gtk_combo_set_popdown_strings (GTK_COMBO (widget), item_list);
else
gtk_list_clear_items (GTK_LIST (GTK_COMBO (widget)->list), 0, -1);
g_list_free (item_list);
}
if (data->action == GB_APPLYING)
g_free (items);
}
/* up/down arrows change value if current value not in list */
int
clip_GTK_COMBOSETUSEARROWSALWAYS(ClipMachine * ClipMachineMemory)
{
C_widget *ccmb = _fetch_cw_arg(ClipMachineMemory);
gint use_arrows = _clip_parl(ClipMachineMemory, 2);
CHECKCWID(ccmb, GTK_IS_COMBO);
CHECKOPT(2, LOGICAL_type_of_ClipVarType);
if (_clip_parinfo(ClipMachineMemory, 2) == UNDEF_type_of_ClipVarType)
use_arrows = TRUE;
gtk_combo_set_use_arrows_always(GTK_COMBO(ccmb->widget), use_arrows);
return 0;
err:
return 1;
}
GtkWidget* CreateFileCombo(const char* entryText)
{
GList* list = NULL;
list = g_list_append(list, strdup(entryText));
for (int i = 0; i < NUM_FILE_HISTORY; i++) {
const char* fileName =
MyConfig->GetStringValue(CONFIG_APP_FILE_0 + i);
if (fileName == NULL || fileName[0] == '\0'
|| !strcmp(fileName, entryText)) {
continue;
}
list = g_list_append(list, strdup(fileName));
}
GtkWidget* combo = gtk_combo_new();
gtk_combo_set_popdown_strings(GTK_COMBO(combo), list);
gtk_combo_set_use_arrows_always(GTK_COMBO(combo), 1);
GtkWidget* entry = GTK_COMBO(combo)->entry;
gtk_entry_set_text(GTK_ENTRY(entry), entryText);
return combo;
}
GtkWidget *
create_file_view(FileView *view)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *menu_bar;
GtkWidget *button;
GtkWidget *pixmapwid;
GdkPixmap *pixmap;
GdkBitmap *mask;
GtkStyle *style;
GdkFont *font;
GtkWidget *sw;
gint i;
/* Top Pane */
vbox = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox);
menu_bar = create_filelist_menu_bar(view);
gtk_widget_show(menu_bar);
gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox);
/* Show/Hide Button */
if (view == &app.right_view)
button = gtk_button_new_with_label("<");
else
button = gtk_button_new_with_label(">");
GTK_WIDGET_UNSET_FLAGS(button, GTK_CAN_FOCUS);
gtk_signal_connect(GTK_OBJECT(button), "button_press_event",
GTK_SIGNAL_FUNC(show_hide_file_view_cb), view);
gtk_tooltips_set_tip(GTK_TOOLTIPS(app.tooltips), button,
_("Left Click: Maximize/Minimize File View\n"
"Right Click: Sync Dirs"), NULL);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
/* Hidden files toggle button */
view->hidden_toggle = gtk_toggle_button_new_with_label("H");
GTK_WIDGET_UNSET_FLAGS(view->hidden_toggle, GTK_CAN_FOCUS);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(view->hidden_toggle),
view->show_hidden);
gtk_signal_connect(GTK_OBJECT(view->hidden_toggle), "toggled",
GTK_SIGNAL_FUNC(toggle_show_hidden_cb), view);
gtk_tooltips_set_tip(GTK_TOOLTIPS(app.tooltips), view->hidden_toggle,
_("Show/Hide hidden files"), NULL);
gtk_box_pack_start(GTK_BOX(hbox), view->hidden_toggle, FALSE, FALSE, 0);
gtk_widget_show(view->hidden_toggle);
/* Dir Entry Combo */
view->dir_entry = gtk_combo_new();
gtk_combo_disable_activate(GTK_COMBO(view->dir_entry));
gtk_combo_set_use_arrows_always(GTK_COMBO(view->dir_entry), TRUE);
gtk_combo_set_case_sensitive(GTK_COMBO(view->dir_entry), TRUE);
gtk_signal_connect(GTK_OBJECT(GTK_COMBO(view->dir_entry)->entry),
"activate", GTK_SIGNAL_FUNC(dir_entry_cb), view);
gtk_signal_connect(GTK_OBJECT(GTK_COMBO(view->dir_entry)->popwin),
"hide", GTK_SIGNAL_FUNC(dir_popwin_cb), view);
gtk_box_pack_start(GTK_BOX(hbox), view->dir_entry, TRUE, TRUE, 0);
gtk_widget_show(view->dir_entry);
/* Up Dir Button */
button = gtk_button_new();
GTK_WIDGET_UNSET_FLAGS(button, GTK_CAN_FOCUS);
gtk_signal_connect(GTK_OBJECT(button), "button_press_event",
GTK_SIGNAL_FUNC(updir_click_cb), view);
gtk_tooltips_set_tip(GTK_TOOLTIPS(app.tooltips), button,
_("Left Click: Up Dir Right Click: Home"), NULL);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
style = gtk_widget_get_style(app.main_window);
pixmap = gdk_pixmap_create_from_xpm_d(app.main_window->window, &mask,
&style->bg[GTK_STATE_NORMAL],
icon_dirparent_xpm);
pixmapwid = gtk_pixmap_new(pixmap, mask);
gtk_container_add(GTK_CONTAINER(button), pixmapwid);
gtk_widget_show(pixmapwid);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_placement(GTK_SCROLLED_WINDOW(sw), cfg.scrollbar_pos);
gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
gtk_widget_show(sw);
/* File List */
view->clist = gtk_clist_new(MAX_COLUMNS);
for (i = 0; i < MAX_COLUMNS; i++)
{
GtkWidget *hbox = gtk_hbox_new(FALSE, 0);
GtkWidget *label = gtk_label_new(all_columns[i].title);
view->sort_arrows[i] = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(hbox), view->sort_arrows[i], FALSE, TRUE, 0);
gtk_widget_show(label);
gtk_widget_show(hbox);
gtk_clist_set_column_widget(GTK_CLIST(view->clist), i, hbox);
GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(view->clist)->column[i].button,
GTK_CAN_FOCUS);
}
gtk_clist_column_titles_show(GTK_CLIST(view->clist));
gtk_clist_set_shadow_type(GTK_CLIST(view->clist), GTK_SHADOW_ETCHED_IN);
gtk_clist_set_selection_mode(GTK_CLIST(view->clist), GTK_SELECTION_EXTENDED);
gtk_clist_set_use_drag_icons(GTK_CLIST(view->clist), TRUE);
gtk_clist_set_row_height(GTK_CLIST(view->clist), 0);
font = gdk_font_load(cfg.list_font);
if (font != NULL)
{
style = gtk_style_copy(gtk_widget_get_style(view->clist));
style->font = font;
gtk_widget_set_style(view->clist, style);
}
for (i = 0; i < MAX_COLUMNS; i++)
{
gtk_clist_set_column_width(GTK_CLIST(view->clist), i, all_columns[i].size);
gtk_clist_set_column_visibility(GTK_CLIST(view->clist), i,
all_columns[i].is_visible);
}
gtk_signal_connect(GTK_OBJECT(view->clist), "select_row",
GTK_SIGNAL_FUNC(select_row_cb), view);
gtk_signal_connect(GTK_OBJECT(view->clist), "button_press_event",
GTK_SIGNAL_FUNC(mouse_click_cb), view);
gtk_signal_connect(GTK_OBJECT(view->clist), "key_press_event",
GTK_SIGNAL_FUNC(file_list_key_press_cb), view);
gtk_signal_connect(GTK_OBJECT(view->clist), "click_column",
GTK_SIGNAL_FUNC(column_button_cb), view);
gtk_signal_connect(GTK_OBJECT(view->clist), "drag_data_get",
GTK_SIGNAL_FUNC(clist_drag_data_get), view);
gtk_signal_connect(GTK_OBJECT(view->clist), "drag_motion",
GTK_SIGNAL_FUNC(clist_drag_motion), view);
gtk_signal_connect(GTK_OBJECT(view->clist), "drag_leave",
GTK_SIGNAL_FUNC(clist_drag_leave), view);
gtk_signal_connect(GTK_OBJECT(view->clist), "drag_data_received",
GTK_SIGNAL_FUNC(clist_drag_data_received), view);
gtk_drag_dest_set(view->clist, GTK_DEST_DEFAULT_MOTION |
GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, target_table,
n_targets, GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK |
GDK_ACTION_ASK);
gtk_container_add(GTK_CONTAINER(sw), view->clist);
gtk_widget_show(view->clist);
/* Set the CLIST_COLOR for resetting from the DRAG_HILIGHT color */
{
GtkStyle *style = gtk_widget_get_style(view->clist);
CLIST_COLOR.red = style->base[GTK_STATE_NORMAL].red;
CLIST_COLOR.green = style->base[GTK_STATE_NORMAL].green;
CLIST_COLOR.blue = style->base[GTK_STATE_NORMAL].blue;
}
return vbox;
}
bool wxComboBox::Create( wxWindow *parent, wxWindowID id, const wxString& value,
const wxPoint& pos, const wxSize& size,
int n, const wxString choices[],
long style, const wxValidator& validator,
const wxString& name )
{
m_ignoreNextUpdate = false;
m_needParent = true;
m_acceptsFocus = true;
m_prevSelection = 0;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxComboBox creation failed") );
return false;
}
m_widget = gtk_combo_new();
GtkCombo *combo = GTK_COMBO(m_widget);
// Disable GTK's broken events ...
gtk_signal_disconnect( GTK_OBJECT(combo->entry), combo->entry_change_id );
// ... and add surrogate handler.
combo->entry_change_id = gtk_signal_connect (GTK_OBJECT (combo->entry), "changed",
(GtkSignalFunc) gtk_dummy_callback, combo);
// make it more useable
gtk_combo_set_use_arrows_always( GTK_COMBO(m_widget), TRUE );
// and case-sensitive
gtk_combo_set_case_sensitive( GTK_COMBO(m_widget), TRUE );
GtkWidget *list = GTK_COMBO(m_widget)->list;
// gtk_list_set_selection_mode( GTK_LIST(list), GTK_SELECTION_MULTIPLE );
for (int i = 0; i < n; i++)
{
GtkWidget *list_item = gtk_list_item_new_with_label( wxGTK_CONV( choices[i] ) );
m_clientDataList.Append( (wxObject*)NULL );
m_clientObjectList.Append( (wxObject*)NULL );
gtk_container_add( GTK_CONTAINER(list), list_item );
gtk_widget_show( list_item );
}
m_parent->DoAddChild( this );
m_focusWidget = combo->entry;
PostCreation(size);
ConnectWidget( combo->button );
// MSW's combo box shows the value and the selection is -1
gtk_entry_set_text( GTK_ENTRY(combo->entry), wxGTK_CONV(value) );
gtk_list_unselect_all( GTK_LIST(combo->list) );
if (style & wxCB_READONLY)
gtk_entry_set_editable( GTK_ENTRY( combo->entry ), FALSE );
// "show" and "hide" events are generated when user click on the combobox button which popups a list
// this list is the "popwin" gtk widget
gtk_signal_connect( GTK_OBJECT(GTK_COMBO(combo)->popwin), "hide",
GTK_SIGNAL_FUNC(gtk_popup_hide_callback), (gpointer)this );
gtk_signal_connect( GTK_OBJECT(GTK_COMBO(combo)->popwin), "show",
GTK_SIGNAL_FUNC(gtk_popup_show_callback), (gpointer)this );
gtk_signal_connect_after( GTK_OBJECT(combo->entry), "changed",
GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this );
gtk_signal_connect_after( GTK_OBJECT(combo->list), "select-child",
GTK_SIGNAL_FUNC(gtk_combo_select_child_callback), (gpointer)this );
SetInitialSize(size); // need this too because this is a wxControlWithItems
// This is required for tool bar support
// wxSize setsize = GetSize();
// gtk_widget_set_usize( m_widget, setsize.x, setsize.y );
return true;
}
static GtkWidget *
create_midi_note(void)
{
GtkWidget *vbox;
GtkWidget *button;
GtkWidget *enable_button;
GtkWidget *mimpi_button;
GtkWidget *label;
GtkWidget *combo;
GtkWidget *entry;
GtkWidget *hbox;
static midi_init_item_t mii;
GList *items;
int i;
vbox = gtk_vbox_new(FALSE, 4);
hbox = gtk_hbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
enable_button = gtk_check_button_new_with_label(
"Enable MIDI");
gtk_container_set_border_width(GTK_CONTAINER(enable_button), 5);
gtk_box_pack_start(GTK_BOX(hbox), enable_button, FALSE, FALSE, 0);
gtk_widget_show(enable_button);
mii.init_combo = combo = gtk_combo_new();
gtk_container_set_border_width(GTK_CONTAINER(combo), 5);
gtk_combo_set_value_in_list(GTK_COMBO(combo), TRUE, TRUE);
gtk_combo_set_use_arrows_always(GTK_COMBO(combo), TRUE);
for (items = 0, i = 0; i < NELEMENTS(MIDI_TYPE_NAME); ++i)
items = g_list_append(items, (gpointer)MIDI_TYPE_NAME[i]);
gtk_combo_set_popdown_strings(GTK_COMBO(combo), items);
g_list_free(items);
gtk_box_pack_end(GTK_BOX(hbox), combo, FALSE, FALSE, 0);
gtk_widget_show(combo);
entry = GTK_COMBO(combo)->entry;
gtk_entry_set_editable(GTK_ENTRY(entry), FALSE);
gtk_signal_connect(GTK_OBJECT(entry), "changed",
GTK_SIGNAL_FUNC(midi_init_entry_changed), 0);
gtk_widget_show(entry);
mii.init_label = label = gtk_label_new(
"- MIDI initialized method:");
gtk_box_pack_end(GTK_BOX(hbox), label, TRUE, TRUE, 0);
gtk_widget_show(label);
mii.reset_button = button = gtk_check_button_new_with_label(
"Send initialize command when X68k is reseted");
gtk_container_set_border_width(GTK_CONTAINER(button), 5);
gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(midi_send_reset_button_clicked), 0);
gtk_widget_show(button);
if (Config.MIDI_Reset)
gtk_signal_emit_by_name(GTK_OBJECT(button), "clicked");
mii.mimpi_button = mimpi_button = gtk_check_button_new_with_label(
"Use MIMPI tone map");
gtk_container_set_border_width(GTK_CONTAINER(mimpi_button), 5);
gtk_box_pack_start(GTK_BOX(vbox), mimpi_button, FALSE, FALSE, 0);
gtk_widget_show(mimpi_button);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
mii.mimpi_entry = entry = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(entry), MAX_PATH - 1);
gtk_entry_set_editable(GTK_ENTRY(entry), FALSE);
gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 10);
gtk_widget_show(entry);
mii.mimpi_browse_button = button = gtk_button_new_with_label(
"Browse...");
gtk_container_set_border_width(GTK_CONTAINER(button), 5);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(midi_mimpi_browse_button_clicked),
(gpointer)&mii);
gtk_widget_show(button);
/* MIMPI ToneMap */
gtk_signal_connect(GTK_OBJECT(mimpi_button), "clicked",
GTK_SIGNAL_FUNC(midi_mimpi_button_clicked),
(gpointer)&mii);
if (!Config.ToneMap)
gtk_signal_emit_by_name(GTK_OBJECT(mimpi_button), "clicked");
gtk_signal_emit_by_name(GTK_OBJECT(mimpi_button), "clicked");
/* Enable MIDI */
gtk_signal_connect(GTK_OBJECT(enable_button), "clicked",
GTK_SIGNAL_FUNC(midi_enable_button_clicked),
(gpointer)&mii);
if (!Config.MIDI_SW)
gtk_signal_emit_by_name(GTK_OBJECT(enable_button), "clicked");
gtk_signal_emit_by_name(GTK_OBJECT(enable_button), "clicked");
return vbox;
}
static GtkWidget *
create_others_note(void)
{
static const char *sasi_drive_str[16] = {
"0", "1", "2", "3", "4", "5", "6", "7", "8",
"9", "10", "11", "12", "13", "14", "15",
};
static sasi_hdd_t sasi_hdd = { 0, 0 };
GtkWidget *w;
GtkWidget *frame;
GtkWidget *align;
GtkWidget *table;
GtkWidget *label;
GtkWidget *combo;
GtkWidget *entry;
GtkWidget *button;
GList *items;
int i;
w = gtk_vbox_new(FALSE, 3);
frame = gtk_frame_new("HDD (SASI) Drive");
gtk_box_pack_start(GTK_BOX(w), frame, FALSE, FALSE, 0);
gtk_widget_show(frame);
align = gtk_alignment_new(0.5, 0.5, 0.9, 0.9);
gtk_container_add(GTK_CONTAINER(frame), align);
gtk_widget_show(align);
table = gtk_table_new(2, 5, FALSE);
gtk_container_add(GTK_CONTAINER(align), table);
gtk_widget_show(table);
label = gtk_label_new("Drive #:");
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1);
gtk_widget_show(label);
combo = gtk_combo_new();
gtk_combo_set_value_in_list(GTK_COMBO(combo), TRUE, TRUE);
gtk_combo_set_use_arrows_always(GTK_COMBO(combo), TRUE);
for (items = 0, i = 0; i < NELEMENTS(sasi_drive_str); ++i)
items = g_list_append(items, (gpointer)sasi_drive_str[i]);
gtk_combo_set_popdown_strings(GTK_COMBO(combo), items);
g_list_free(items);
gtk_table_attach_defaults(GTK_TABLE(table), combo, 1, 2, 0, 1);
gtk_widget_show(combo);
entry = GTK_COMBO(combo)->entry;
gtk_entry_set_editable(GTK_ENTRY(entry), FALSE);
gtk_signal_connect(GTK_OBJECT(entry), "changed",
GTK_SIGNAL_FUNC(others_sasi_hdd_index_entry_changed),
&sasi_hdd);
gtk_widget_show(entry);
button = gtk_button_new_with_label("Remove");
gtk_container_set_border_width(GTK_CONTAINER(button), 5);
gtk_table_attach_defaults(GTK_TABLE(table), button, 3, 4, 0, 1);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(others_sasi_hdd_remove_button_clicked),
&sasi_hdd);
gtk_widget_show(button);
button = gtk_button_new_with_label("New");
gtk_container_set_border_width(GTK_CONTAINER(button), 5);
gtk_table_attach_defaults(GTK_TABLE(table), button, 4, 5, 0, 1);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(others_sasi_hdd_new_button_clicked),
&sasi_hdd);
#if 1
gtk_widget_set_sensitive(button, FALSE);
#endif
gtk_widget_show(button);
label = gtk_label_new("Filename:");
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2);
gtk_widget_show(label);
sasi_hdd.entry = entry = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(entry), MAX_PATH - 1);
gtk_entry_set_editable(GTK_ENTRY(entry), FALSE);
gtk_table_attach_defaults(GTK_TABLE(table), entry, 1, 4, 1, 2);
gtk_widget_show(entry);
gtk_entry_set_text(GTK_ENTRY(entry), Config.HDImage[0]);
button = gtk_button_new_with_label("Browse...");
gtk_container_set_border_width(GTK_CONTAINER(button), 5);
gtk_table_attach_defaults(GTK_TABLE(table), button, 4, 5, 1, 2);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(others_sasi_hdd_browse_button_clicked),
&sasi_hdd);
gtk_widget_show(button);
button = gtk_check_button_new_with_label("Show FDD status");
gtk_container_set_border_width(GTK_CONTAINER(button), 5);
gtk_box_pack_start(GTK_BOX(w), button, FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(others_show_fdd_status_button_clicked), 0);
#if 1
gtk_widget_set_sensitive(button, FALSE);
#else
if (Config.WindowFDDStat)
gtk_signal_emit_by_name(GTK_OBJECT(button), "clicked");
#endif
gtk_widget_show(button);
button = gtk_check_button_new_with_label("Enable SRAM virus warning");
gtk_container_set_border_width(GTK_CONTAINER(button), 5);
gtk_box_pack_start(GTK_BOX(w), button, FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(others_enable_virus_button_clicked), 0);
if (Config.SRAMWarning)
gtk_signal_emit_by_name(GTK_OBJECT(button), "clicked");
gtk_widget_show(button);
return w;
}
GtkWidget * gw_notebook_managment_create ( GtkWindow * window)
{
GtkWidget *vb_tabbed_pane = NULL;
GtkWidget *hb_control;
GtkWidget *frm_new_disk_control;
GtkWidget *vb_new_disk_control;
GtkWidget *hb_disk_selection;
GtkWidget *lbl_disk_selection;
GtkWidget *cmb_disk_selection;
GtkWidget *entry_cmb_disk_selection;
GtkWidget *hseparator;
GtkWidget *hb_number_archive;
GtkWidget *lbl_number_archive;
GtkWidget *entry_number_archive;
GtkWidget *hb_disk_name;
GtkWidget *lbl_disk_name;
GtkWidget *entry_disk_name;
GtkHBox *cmb_categories;
GtkWidget *hb_device_file;
GtkWidget *lbl_device_file;
GtkWidget *hb_device_type;
GtkWidget *lbl_device_type;
#ifdef HAVE_MOUNT_SYSTEM
GtkWidget *hb_device_ismounted;
GtkWidget *lbl_device_ismounted;
#endif
GtkWidget *hb_device_volume_name;
GtkWidget *lbl_device_volume_name;
GtkWidget *hb_device_serial_number;
GtkWidget *lbl_device_serial_number;
GtkWidget *hb_device_capacity;
GtkWidget *lbl_device_capacity;
GtkWidget *hb_device_free_space;
GtkWidget *lbl_device_free_space;
GtkWidget *frm_options;
GtkWidget *vb_options;
GtkWidget *chk_display_device_info;
#ifdef HAVE_MOUNT_SYSTEM
GtkWidget *chk_automount_device;
#endif
GtkWidget *chk_explore_tree_structure;
GtkWidget *chk_explore_archive_files;
GtkWidget *chk_auto_eject_device;
GtkWidget *chk_category_recursively;
GtkWidget *chk_auto_make_description;
GtkWidget *chk_use_disk_label;
GtkWidget *chk_use_pattern;
GtkWidget *bt_start_device_scan;
GtkTooltips *tooltips_group;
GtkCTree *tree = NULL;
GtkCTreeNode *root = NULL;
gchar *text_utf8 = NULL;
#ifdef GW_DEBUG_GUI_COMPONENT
g_print ( "*** GW - %s (%d) :: %s()\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
#endif
if ( window != NULL )
{
tree = gw_gui_manager_main_interface_get_tree ( );
root = gw_gui_manager_main_interface_get_tree_root ( );
/* Inits tooltips group */
tooltips_group = gtk_tooltips_new ( );
/* Vertical box of the managment tabbed pane. */
vb_tabbed_pane = gtk_vbox_new ( FALSE, 0);
/* Horizontal box for controls (text field, checks buttons, ...). */
hb_control = gtk_hbox_new ( TRUE, 0);
gtk_box_pack_start ( GTK_BOX ( vb_tabbed_pane), hb_control, TRUE, TRUE, 0);
/* Frame of new disk control */
g_strdup_to_gtk_text ( _( "New disk"), text_utf8);
frm_new_disk_control = gtk_frame_new ( text_utf8);
g_free ( text_utf8);
gtk_container_set_border_width ( GTK_CONTAINER ( frm_new_disk_control), 10);
gtk_box_pack_start ( GTK_BOX ( hb_control), frm_new_disk_control, FALSE, TRUE, 0);
/* Vertical box for new disk control */
vb_new_disk_control = gtk_vbox_new ( FALSE, 0);
gtk_container_add ( GTK_CONTAINER ( frm_new_disk_control), vb_new_disk_control);
/* Horizontal box for media selection */
hb_disk_selection = gtk_hbox_new ( FALSE, 0);
gtk_container_set_border_width ( GTK_CONTAINER ( hb_disk_selection), 10);
gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hb_disk_selection, TRUE, TRUE, 0);
g_strdup_to_gtk_text ( _( "Select the media that will be added as a disk to your catalog."), text_utf8);
gtk_tooltips_set_tip ( tooltips_group, hb_disk_selection, text_utf8, NULL);
g_free ( text_utf8);
/* Label for media selection */
g_strdup_to_gtk_text ( _( "Select media : "), text_utf8);
lbl_disk_selection = gtk_label_new ( text_utf8);
g_free ( text_utf8);
gtk_box_pack_start ( GTK_BOX ( hb_disk_selection), lbl_disk_selection, FALSE, FALSE, 0);
/* ComboBox to select media */
cmb_disk_selection = gtk_combo_new ( );
gtk_widget_ref ( cmb_disk_selection);
gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_COMBO_BOX_DEVICE, cmb_disk_selection, (GtkDestroyNotify) gtk_widget_unref);
gtk_combo_set_use_arrows_always ( GTK_COMBO ( cmb_disk_selection), TRUE);
gtk_entry_set_editable ( GTK_ENTRY ( GTK_COMBO ( cmb_disk_selection)->entry), FALSE);
/* Loads the list of devices */
gw_notebook_managment_load_device_list ( window);
/* To fix : when user click on combo's button, the first item of the list is selected
automaticaly. This emits the "changed" event!!
*/
gtk_signal_connect_after ( GTK_OBJECT ( GTK_ENTRY ( GTK_COMBO ( cmb_disk_selection)->entry)), "changed", GTK_SIGNAL_FUNC ( gw_notebook_managment_select_device), GTK_WINDOW ( window));
gtk_box_pack_start ( GTK_BOX ( hb_disk_selection), cmb_disk_selection, TRUE, TRUE, 0);
/* Entry of ComboBox to select disk */
entry_cmb_disk_selection = GTK_COMBO ( cmb_disk_selection)->entry;
gtk_widget_ref ( entry_cmb_disk_selection);
gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_COMBO_BOX_ENTRY_DEVICE_DIR, entry_cmb_disk_selection, (GtkDestroyNotify) gtk_widget_unref);
/* Horizontal separator */
hseparator = gtk_hseparator_new ( );
gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hseparator, TRUE, TRUE, 0);
/* Horizontal box for number archive */
hb_number_archive = gtk_hbox_new ( FALSE, 0);
gtk_container_set_border_width ( GTK_CONTAINER ( hb_number_archive), 10);
gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hb_number_archive, TRUE, TRUE, 0);
g_strdup_to_gtk_text ( _( "Enter the number of the new disk. This number can help you with the history of your catalog."), text_utf8);
gtk_tooltips_set_tip ( tooltips_group, hb_number_archive, text_utf8, NULL);
g_free ( text_utf8);
/* Label for number archive */
g_strdup_to_gtk_text ( _( "Archive N# : "), text_utf8);
lbl_number_archive = gtk_label_new ( text_utf8);
g_free ( text_utf8);
gtk_box_pack_start ( GTK_BOX ( hb_number_archive), lbl_number_archive, FALSE, FALSE, 0);
/* Entry for number archive */
entry_number_archive = gtk_entry_new ( );
gtk_widget_ref ( entry_number_archive);
gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_ENTRY_DEVICE_NUMBER_ARCHIVE, entry_number_archive, (GtkDestroyNotify) gtk_widget_unref);
gtk_box_pack_start ( GTK_BOX ( hb_number_archive), entry_number_archive, TRUE, TRUE, 0);
/* Horizontal box for disk name */
hb_disk_name = gtk_hbox_new ( FALSE, 0);
gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hb_disk_name, TRUE, TRUE, 0);
gtk_container_set_border_width ( GTK_CONTAINER ( hb_disk_name), 10);
g_strdup_to_gtk_text ( _( "Enter the name of the new disk to identify it in your catalog."), text_utf8);
gtk_tooltips_set_tip ( tooltips_group, hb_disk_name, text_utf8, NULL);
g_free ( text_utf8);
/* Label for disk name */
g_strdup_to_gtk_text ( _( "Name : "), text_utf8);
lbl_disk_name = gtk_label_new ( text_utf8);
g_free ( text_utf8);
gtk_box_pack_start ( GTK_BOX ( hb_disk_name), lbl_disk_name, FALSE, FALSE, 0);
/* Entry for disk name */
entry_disk_name = gtk_entry_new ( );
gtk_widget_ref ( entry_disk_name);
gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_ENTRY_DEVICE_NAME, entry_disk_name, (GtkDestroyNotify) gtk_widget_unref);
gtk_box_pack_start ( GTK_BOX ( hb_disk_name), entry_disk_name, TRUE, TRUE, 0);
gtk_signal_connect ( GTK_OBJECT ( entry_disk_name), "activate", GTK_SIGNAL_FUNC ( gw_notebook_managment_scan_click), window);
/* Horizontal separator */
hseparator = gtk_hseparator_new ( );
gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hseparator, TRUE, TRUE, 0);
/* ComboBox for category selection */
/* It's not mandatory to encode to UTF-8 because gw_combo_box_categories_create() encodes itself. */
cmb_categories = gw_combo_box_categories_create ( window, _( "Category : "), gtk_ctree_node_get_row_data ( tree, root));
gtk_widget_ref ( GTK_WIDGET ( cmb_categories));
gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_COMBO_BOX_CATEGORY, GTK_WIDGET ( cmb_categories), (GtkDestroyNotify) gtk_widget_unref);
gw_combo_box_categories_load ( cmb_categories);
gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), GTK_WIDGET ( cmb_categories), TRUE, TRUE, 0);
gtk_container_set_border_width ( GTK_CONTAINER ( cmb_categories), 10);
g_strdup_to_gtk_text ( _( "Select the category to apply to the disk which will be added (even if the option is selected)."), text_utf8);
gtk_tooltips_set_tip ( tooltips_group, GTK_WIDGET ( cmb_categories), text_utf8, NULL);
g_free ( text_utf8);
/* Horizontal separator */
hseparator = gtk_hseparator_new ( );
gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hseparator, TRUE, TRUE, 0);
/* Horizontal box for device file information */
hb_device_file = gtk_hbox_new ( FALSE, 0);
gtk_container_set_border_width ( GTK_CONTAINER ( hb_device_file), 5);
gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hb_device_file, TRUE, TRUE, 0);
g_strdup_to_gtk_text ( _( "Give the device file of the selected media."), text_utf8);
gtk_tooltips_set_tip ( tooltips_group, hb_device_file, text_utf8, NULL);
g_free ( text_utf8);
/* Device file information label */
g_strdup_to_gtk_text ( _( "Info : "), text_utf8);
lbl_device_file = gtk_label_new ( text_utf8);
g_free ( text_utf8);
gtk_widget_ref ( lbl_device_file);
gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_LABEL_DISPLAY_INFO_INFO, lbl_device_file, (GtkDestroyNotify) gtk_widget_unref);
gtk_box_pack_start ( GTK_BOX ( hb_device_file), lbl_device_file, FALSE, FALSE, 0);
/* Horizontal box for device type information */
hb_device_type = gtk_hbox_new ( FALSE, 0);
gtk_widget_show ( hb_device_type);
gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hb_device_type, TRUE, TRUE, 0);
gtk_container_set_border_width ( GTK_CONTAINER ( hb_device_type), 5);
g_strdup_to_gtk_text ( _( "Give the type of the selected media (ex : ext2, ext3, vfat, ntfs, ...)."), text_utf8);
gtk_tooltips_set_tip ( tooltips_group, hb_device_type, text_utf8, NULL);
g_free ( text_utf8);
/* Device type information label */
g_strdup_to_gtk_text ( _( "Type : "), text_utf8);
lbl_device_type = gtk_label_new ( text_utf8);
g_free ( text_utf8);
gtk_widget_ref ( lbl_device_type);
gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_LABEL_DISPLAY_INFO_TYPE, lbl_device_type, (GtkDestroyNotify) gtk_widget_unref);
gtk_box_pack_start ( GTK_BOX ( hb_device_type), lbl_device_type, FALSE, FALSE, 0);
#ifdef HAVE_MOUNT_SYSTEM
/* Horizontal box for media mount state information */
hb_device_ismounted = gtk_hbox_new ( FALSE, 0);
gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hb_device_ismounted, TRUE, TRUE, 0);
gtk_container_set_border_width ( GTK_CONTAINER ( hb_device_ismounted), 5);
g_strdup_to_gtk_text ( _( "Display if the selected media is mounted or no."), text_utf8);
gtk_tooltips_set_tip ( tooltips_group, hb_device_ismounted, text_utf8, NULL);
g_free ( text_utf8);
/* Media mount state information label */
g_strdup_to_gtk_text ( _( "Mounted : "), text_utf8);
lbl_device_ismounted = gtk_label_new ( text_utf8);
g_free ( text_utf8);
gtk_widget_ref ( lbl_device_ismounted);
gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_LABEL_DISPLAY_INFO_MOUNTED, lbl_device_ismounted, (GtkDestroyNotify) gtk_widget_unref);
gtk_box_pack_start ( GTK_BOX ( hb_device_ismounted), lbl_device_ismounted, FALSE, FALSE, 0);
#endif
/* Horizontal box for media volume name information */
hb_device_volume_name = gtk_hbox_new ( FALSE, 0);
gtk_container_set_border_width ( GTK_CONTAINER ( hb_device_volume_name), 5);
gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hb_device_volume_name, TRUE, TRUE, 0);
g_strdup_to_gtk_text ( _( "Give the volume name of the selected media (only if is mounted)."), text_utf8);
gtk_tooltips_set_tip ( tooltips_group, hb_device_volume_name, text_utf8, NULL);
g_free ( text_utf8);
/* Media volume information label */
g_strdup_to_gtk_text ( _( "Volume : "), text_utf8);
lbl_device_volume_name = gtk_label_new ( text_utf8);
g_free ( text_utf8);
gtk_widget_ref ( lbl_device_volume_name);
gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_LABEL_DISPLAY_INFO_VOLUME, lbl_device_volume_name, (GtkDestroyNotify) gtk_widget_unref);
gtk_box_pack_start ( GTK_BOX ( hb_device_volume_name), lbl_device_volume_name, FALSE, FALSE, 0);
/* Horizontal box for media serial number information */
hb_device_serial_number = gtk_hbox_new ( FALSE, 0);
gtk_container_set_border_width ( GTK_CONTAINER ( hb_device_serial_number), 5);
gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hb_device_serial_number, TRUE, TRUE, 0);
g_strdup_to_gtk_text ( _( "Give the serial number of the selected media (only if is mounted). This number is a manufacture number."), text_utf8);
gtk_tooltips_set_tip ( tooltips_group, hb_device_serial_number, text_utf8, NULL);
g_free ( text_utf8);
/* Media serial number information label */
g_strdup_to_gtk_text ( _( "Serial N# : "), text_utf8);
lbl_device_serial_number = gtk_label_new ( text_utf8);
g_free ( text_utf8);
gtk_widget_ref ( lbl_device_serial_number);
gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_LABEL_DISPLAY_INFO_SERIAL_NUMBER, lbl_device_serial_number, (GtkDestroyNotify) gtk_widget_unref);
gtk_box_pack_start ( GTK_BOX ( hb_device_serial_number), lbl_device_serial_number, FALSE, FALSE, 0);
/* Horizontal box for media capacity information */
hb_device_capacity = gtk_hbox_new ( FALSE, 0);
gtk_container_set_border_width ( GTK_CONTAINER ( hb_device_capacity), 5);
gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hb_device_capacity, TRUE, TRUE, 0);
g_strdup_to_gtk_text ( _( "Give the full space of the selected media (only if is mounted)."), text_utf8);
gtk_tooltips_set_tip ( tooltips_group, hb_device_capacity, text_utf8, NULL);
g_free ( text_utf8);
/* Media capacity information label */
g_strdup_to_gtk_text ( _( "Capacity : "), text_utf8);
lbl_device_capacity = gtk_label_new ( text_utf8);
g_free ( text_utf8);
gtk_widget_ref ( lbl_device_capacity);
gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_LABEL_DISPLAY_INFO_CAPACITY, lbl_device_capacity, (GtkDestroyNotify) gtk_widget_unref);
gtk_box_pack_start ( GTK_BOX ( hb_device_capacity), lbl_device_capacity, FALSE, FALSE, 0);
/* Horizontal box for media free space information */
hb_device_free_space = gtk_hbox_new ( FALSE, 0);
gtk_container_set_border_width ( GTK_CONTAINER ( hb_device_free_space), 5);
gtk_box_pack_start ( GTK_BOX ( vb_new_disk_control), hb_device_free_space, TRUE, TRUE, 0);
g_strdup_to_gtk_text ( _( "Give the free space of the selected media (only if is mounted)."), text_utf8);
gtk_tooltips_set_tip ( tooltips_group, hb_device_free_space, text_utf8, NULL);
g_free ( text_utf8);
/* Media free space information label */
g_strdup_to_gtk_text ( _( "Free space : "), text_utf8);
lbl_device_free_space = gtk_label_new ( text_utf8);
g_free ( text_utf8);
gtk_widget_ref ( lbl_device_free_space);
gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_LABEL_DISPLAY_INFO_FREE_SPACE, lbl_device_free_space, (GtkDestroyNotify) gtk_widget_unref);
gtk_box_pack_start ( GTK_BOX ( hb_device_free_space), lbl_device_free_space, FALSE, FALSE, 0);
/* Frame for scan options */
g_strdup_to_gtk_text ( _( "Options"), text_utf8);
frm_options = gtk_frame_new ( text_utf8);
g_free ( text_utf8);
gtk_container_set_border_width ( GTK_CONTAINER ( frm_options), 10);
gtk_box_pack_start ( GTK_BOX ( hb_control), frm_options, TRUE, TRUE, 0);
/* Vertical box of the frame options */
vb_options = gtk_vbox_new ( FALSE, 0);
gtk_container_add ( GTK_CONTAINER ( frm_options), vb_options);
/* Check button for the displaying of media information */
g_strdup_to_gtk_text ( _( "Display info"), text_utf8);
chk_display_device_info = gtk_check_button_new_with_label ( text_utf8);
g_free ( text_utf8);
gtk_widget_ref ( chk_display_device_info);
gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_CHECK_DISPLAY_INFO, chk_display_device_info, (GtkDestroyNotify) gtk_widget_unref);
gtk_signal_connect ( GTK_OBJECT ( chk_display_device_info), "clicked", GTK_SIGNAL_FUNC ( gw_notebook_managment_refresh_info), window);
gtk_container_set_border_width ( GTK_CONTAINER ( chk_display_device_info), 5);
gtk_box_pack_start ( GTK_BOX ( vb_options), chk_display_device_info, FALSE, FALSE, 0);
g_strdup_to_gtk_text ( _( "Display information about the selected media, such as path, capacity, free space, label,..."), text_utf8);
gtk_tooltips_set_tip ( tooltips_group, chk_display_device_info, text_utf8, NULL);
g_free ( text_utf8);
#ifdef HAVE_MOUNT_SYSTEM
/* Check button for the automount */
g_strdup_to_gtk_text ( _("Automount"), text_utf8);
chk_automount_device = gtk_check_button_new_with_label ( text_utf8);
g_free ( text_utf8);
gtk_widget_ref ( chk_automount_device);
gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_CHECK_AUTO_MOUNT, chk_automount_device, (GtkDestroyNotify) gtk_widget_unref);
gtk_signal_connect ( GTK_OBJECT ( chk_automount_device), "clicked", GTK_SIGNAL_FUNC (gw_notebook_managment_option_automount_click), window);
gtk_container_set_border_width ( GTK_CONTAINER ( chk_automount_device), 5);
gtk_box_pack_start ( GTK_BOX ( vb_options), chk_automount_device, FALSE, FALSE, 0);
g_strdup_to_gtk_text ( _( "Mount the media if it isn't already mounted. And unmount after scanning the media, even if it was mounted before the scan."), text_utf8);
gtk_tooltips_set_tip ( tooltips_group, chk_automount_device, text_utf8, NULL);
g_free ( text_utf8);
#endif
/* Check button for the exploring of tree structure */
g_strdup_to_gtk_text ( _( "Explore tree structure of the media."), text_utf8);
chk_explore_tree_structure = gtk_check_button_new_with_label ( text_utf8);
g_free ( text_utf8);
gtk_widget_ref ( chk_explore_tree_structure);
gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_CHECK_EXPLORE_TREE_STRUCTURE, chk_explore_tree_structure, (GtkDestroyNotify) gtk_widget_unref);
gtk_signal_connect ( GTK_OBJECT ( chk_explore_tree_structure), "clicked", GTK_SIGNAL_FUNC (gw_notebook_managment_option_explore_tree_structure_click), window);
gtk_container_set_border_width ( GTK_CONTAINER ( chk_explore_tree_structure), 5);
gtk_box_pack_start ( GTK_BOX ( vb_options), chk_explore_tree_structure, FALSE, FALSE, 0);
g_strdup_to_gtk_text ( _( "Keep this option selected to scan all folders and files informations."), text_utf8);
gtk_tooltips_set_tip ( tooltips_group, chk_explore_tree_structure, text_utf8, NULL);
g_free ( text_utf8);
/* Check button for the exploring of archive files */
g_strdup_to_gtk_text ( _( "Explore archive files (.tar, .gz, .zip, ...)"), text_utf8);
chk_explore_archive_files = gtk_check_button_new_with_label ( text_utf8);
g_free ( text_utf8);
gtk_widget_ref ( chk_explore_archive_files);
gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_CHECK_EXPLORE_ARCHIVE, chk_explore_archive_files, (GtkDestroyNotify) gtk_widget_unref);
gtk_signal_connect ( GTK_OBJECT ( chk_explore_archive_files), "clicked", GTK_SIGNAL_FUNC (gw_notebook_managment_option_explore_archive_click), window);
gtk_container_set_border_width ( GTK_CONTAINER ( chk_explore_archive_files), 5);
gtk_box_pack_start ( GTK_BOX ( vb_options), chk_explore_archive_files, FALSE, FALSE, 0);
g_strdup_to_gtk_text ( _( "Not yet implemented!!\nExplore archives as if they were directories. Archives are tarred or gzipped files."), text_utf8);
gtk_tooltips_set_tip ( tooltips_group, chk_explore_archive_files, text_utf8, NULL);
g_free ( text_utf8);
/* Check button for the auto eject */
g_strdup_to_gtk_text ( _( "Eject media if possible"), text_utf8);
chk_auto_eject_device = gtk_check_button_new_with_label ( text_utf8);
g_free ( text_utf8);
gtk_widget_ref ( chk_auto_eject_device);
gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_CHECK_EJECT, chk_auto_eject_device, (GtkDestroyNotify) gtk_widget_unref);
gtk_signal_connect ( GTK_OBJECT ( chk_auto_eject_device), "clicked", GTK_SIGNAL_FUNC (gw_notebook_managment_option_eject_click), window);
gtk_container_set_border_width ( GTK_CONTAINER ( chk_auto_eject_device), 5);
gtk_box_pack_start ( GTK_BOX ( vb_options), chk_auto_eject_device, FALSE, FALSE, 0);
g_strdup_to_gtk_text ( _( "Eject the media if possible (CD-ROM...), even if the tray was closed. This is possible only if automount is enabled!!"), text_utf8);
gtk_tooltips_set_tip ( tooltips_group, chk_auto_eject_device, text_utf8, NULL);
g_free ( text_utf8);
/* Check button for setting category recursively */
g_strdup_to_gtk_text ( _( "Sets category recursive"), text_utf8);
chk_category_recursively = gtk_check_button_new_with_label ( text_utf8);
g_free ( text_utf8);
gtk_widget_ref ( chk_category_recursively);
gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_CHECK_CATEGORY_RECURSIVE, chk_category_recursively, (GtkDestroyNotify) gtk_widget_unref);
gtk_signal_connect ( GTK_OBJECT ( chk_category_recursively), "clicked", GTK_SIGNAL_FUNC (gw_notebook_managment_option_category_click), window);
gtk_container_set_border_width ( GTK_CONTAINER ( chk_category_recursively), 5);
gtk_box_pack_start ( GTK_BOX ( vb_options), chk_category_recursively, FALSE, FALSE, 0);
g_strdup_to_gtk_text ( _( "Apply selected category to all items in the disk (disk, folders and files)."), text_utf8);
gtk_tooltips_set_tip ( tooltips_group, chk_category_recursively, text_utf8, NULL);
g_free ( text_utf8);
/* Check button for the auto make description */
g_strdup_to_gtk_text ( _( "Auto make description"), text_utf8);
chk_auto_make_description = gtk_check_button_new_with_label ( text_utf8);
g_free ( text_utf8);
gtk_widget_ref ( chk_auto_make_description);
gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_CHECK_MAKE_DESCRIPTION, chk_auto_make_description, (GtkDestroyNotify) gtk_widget_unref);
gtk_signal_connect ( GTK_OBJECT ( chk_auto_make_description), "clicked", GTK_SIGNAL_FUNC (gw_notebook_managment_option_description_click), window);
gtk_container_set_border_width ( GTK_CONTAINER ( chk_auto_make_description), 5);
gtk_box_pack_start ( GTK_BOX ( vb_options), chk_auto_make_description, FALSE, FALSE, 0);
g_strdup_to_gtk_text ( _( "Make auto description of file (file format description, image size for xmp or jpg, etc...)."), text_utf8);
gtk_tooltips_set_tip ( tooltips_group, chk_auto_make_description, text_utf8, NULL);
g_free ( text_utf8);
/* Check button for the using a pattern to generate disk name */
g_strdup_to_gtk_text ( _( "Use an advanced pattern to generate disk name"), text_utf8);
chk_use_pattern = gtk_check_button_new_with_label ( text_utf8);
g_free ( text_utf8);
gtk_widget_ref ( chk_use_pattern);
gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_CHECK_USE_PATTERN, chk_use_pattern, (GtkDestroyNotify) gtk_widget_unref);
gtk_signal_connect ( GTK_OBJECT ( chk_use_pattern), "clicked", GTK_SIGNAL_FUNC (gw_notebook_managment_option_use_pattern_click), window);
gtk_container_set_border_width ( GTK_CONTAINER ( chk_use_pattern), 5);
gtk_box_pack_start ( GTK_BOX ( vb_options), chk_use_pattern, FALSE, FALSE, 0);
g_strdup_to_gtk_text ( _( "You can fill extra tags to generate a disk name with disk information :\n- %% : %\n- %n : number archive (can use prefix to prefixed by 0 : %.4n give 0001, 0002, 0003, ..., 0091, ...\n- %l : media volume label\n- %t : media type\n- %s : serial number"), text_utf8);
gtk_tooltips_set_tip ( tooltips_group, chk_use_pattern, text_utf8, NULL);
g_free ( text_utf8);
/* Check button for the using media label */
g_strdup_to_gtk_text ( _( "Use media volume name as disk name (only when disk name is empty)"), text_utf8);
chk_use_disk_label = gtk_check_button_new_with_label ( text_utf8);
g_free ( text_utf8);
gtk_widget_ref ( chk_use_disk_label);
gtk_object_set_data_full ( GTK_OBJECT ( window), REF_GW_GUI_NOTEBOOK_MANAGMENT_CHECK_USE_DISK_LABEL, chk_use_disk_label, (GtkDestroyNotify) gtk_widget_unref);
gtk_signal_connect ( GTK_OBJECT ( chk_use_disk_label), "clicked", GTK_SIGNAL_FUNC (gw_notebook_managment_option_use_disk_label_click), window);
gtk_container_set_border_width ( GTK_CONTAINER ( chk_use_disk_label), 5);
gtk_box_pack_start ( GTK_BOX ( vb_options), chk_use_disk_label, FALSE, FALSE, 0);
g_strdup_to_gtk_text ( _( "If you didn't enter disk name and if your selected media has a volume name, the media volume name will be applied as disk name."), text_utf8);
gtk_tooltips_set_tip ( tooltips_group, chk_use_disk_label, text_utf8, NULL);
g_free ( text_utf8);
/* The add disk button to start the media scanning */
g_strdup_to_gtk_text ( _( "Add disk"), text_utf8);
bt_start_device_scan = gtk_button_new_with_label ( text_utf8);
g_free ( text_utf8);
gtk_signal_connect ( GTK_OBJECT ( bt_start_device_scan), "clicked", GTK_SIGNAL_FUNC ( gw_notebook_managment_scan_click), window);
gtk_container_set_border_width ( GTK_CONTAINER ( bt_start_device_scan), 5);
gtk_box_pack_start ( GTK_BOX ( vb_tabbed_pane), bt_start_device_scan, FALSE, FALSE, 0);
/* Loads the list of devices */
/* Do not still load device info at time.
gw_notebook_managment_load_device_list ( window);
*/
/* Loads the list of categories */
gw_combo_box_categories_load ( cmb_categories);
/* Fills the pattern to use for disk name */
if ( gw_am_get_settings_tol ( GW_VALUE_APP_DISK_SCAN_USE_PATTERN) == 1)
{
gw_notebook_managment_set_device_name ( window, gw_am_get_settings ( GW_VALUE_APP_DISK_SCAN_PATTERN));
}
}
return vb_tabbed_pane;
}
void
sp_text_edit_dialog (void)
{
if (!dlg) {
GtkWidget *mainvb, *nb, *vb, *hb, *txt, *fontsel, *preview, *f, *tbl, *l, *px, *c, *b, *hs;
GtkTextBuffer *tb;
GList *sl;
int i;
gchar title[500];
sp_ui_dialog_title_string (SP_VERB_DIALOG_TEXT, title);
dlg = sp_window_new (title, TRUE);
if (x == -1000 || y == -1000) {
x = prefs_get_int_attribute (prefs_path, "x", 0);
y = prefs_get_int_attribute (prefs_path, "y", 0);
}
if (w ==0 || h == 0) {
w = prefs_get_int_attribute (prefs_path, "w", 0);
h = prefs_get_int_attribute (prefs_path, "h", 0);
}
if (x != 0 || y != 0)
gtk_window_move ((GtkWindow *) dlg, x, y);
else
gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER);
if (w && h) gtk_window_resize ((GtkWindow *) dlg, w, h);
sp_transientize (dlg);
wd.win = dlg;
wd.stop = 0;
g_signal_connect (G_OBJECT (INKSCAPE), "activate_desktop", G_CALLBACK (sp_transientize_callback), &wd);
gtk_signal_connect (GTK_OBJECT (dlg), "event", GTK_SIGNAL_FUNC (sp_dialog_event_handler), dlg);
gtk_signal_connect (GTK_OBJECT (dlg), "destroy", G_CALLBACK (sp_text_edit_dialog_destroy), dlg);
gtk_signal_connect (GTK_OBJECT (dlg), "delete_event", G_CALLBACK (sp_text_edit_dialog_delete), dlg);
g_signal_connect (G_OBJECT (INKSCAPE), "shut_down", G_CALLBACK (sp_text_edit_dialog_delete), dlg);
gtk_window_set_policy (GTK_WINDOW (dlg), TRUE, TRUE, FALSE);
mainvb = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (dlg), mainvb);
nb = gtk_notebook_new ();
gtk_container_set_border_width (GTK_CONTAINER (nb), 4);
gtk_box_pack_start (GTK_BOX (mainvb), nb, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (dlg), "notebook", nb);
/* Vbox inside notebook */
vb = gtk_vbox_new (FALSE, 0);
/* Textview */
f = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (f), GTK_SHADOW_IN);
tb = gtk_text_buffer_new (NULL);
txt = gtk_text_view_new_with_buffer (tb);
gtk_widget_set_size_request (txt, -1, 64);
gtk_text_view_set_editable (GTK_TEXT_VIEW (txt), TRUE);
gtk_container_add (GTK_CONTAINER (f), txt);
gtk_box_pack_start (GTK_BOX (vb), f, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (tb), "changed", G_CALLBACK (sp_text_edit_dialog_text_changed), dlg);
g_object_set_data (G_OBJECT (dlg), "text", tb);
g_object_set_data (G_OBJECT (dlg), "textw", txt);
/* HBox containing font selection and layout */
hb = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vb), hb, TRUE, TRUE, 0);
fontsel = sp_font_selector_new ();
g_signal_connect (G_OBJECT (fontsel), "font_set", G_CALLBACK (sp_text_edit_dialog_font_changed), dlg);
gtk_box_pack_start (GTK_BOX (hb), fontsel, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (dlg), "fontsel", fontsel);
/* Layout */
f = gtk_frame_new (_("Layout"));
gtk_box_pack_start (GTK_BOX (hb), f, FALSE, FALSE, 4);
tbl = gtk_table_new (3, 4, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (tbl), 4);
gtk_table_set_col_spacings (GTK_TABLE (tbl), 4);
gtk_container_add (GTK_CONTAINER (f), tbl);
l = gtk_label_new (_("Alignment:"));
gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (tbl), l, 0, 1, 0, 1, (GtkAttachOptions)0, (GtkAttachOptions)0, 4, 0);
px = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_LEFT, GTK_ICON_SIZE_LARGE_TOOLBAR);
b = gtk_radio_button_new (NULL);
g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_table_attach (GTK_TABLE (tbl), b, 1, 2, 0, 1, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0);
g_object_set_data (G_OBJECT (dlg), "text_anchor_start", b);
px = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_CENTER, GTK_ICON_SIZE_LARGE_TOOLBAR);
b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (b)));
g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_table_attach (GTK_TABLE (tbl), b, 2, 3, 0, 1, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0);
g_object_set_data (G_OBJECT (dlg), "text_anchor_middle", b);
px = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_RIGHT, GTK_ICON_SIZE_LARGE_TOOLBAR);
b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (b)));
g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_table_attach (GTK_TABLE (tbl), b, 3, 4, 0, 1, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0);
g_object_set_data (G_OBJECT (dlg), "text_anchor_end", b);
l = gtk_label_new (_("Orientation:"));
gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (tbl), l, 0, 1, 1, 2, (GtkAttachOptions)0, (GtkAttachOptions)0, 4, 0);
px = gtk_image_new_from_stock (INKSCAPE_STOCK_WRITING_MODE_LR, GTK_ICON_SIZE_LARGE_TOOLBAR);
b = gtk_radio_button_new (NULL);
g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_table_attach (GTK_TABLE (tbl), b, 1, 2, 1, 2, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0);
g_object_set_data (G_OBJECT (dlg), "writing_mode_lr", b);
px = gtk_image_new_from_stock (INKSCAPE_STOCK_WRITING_MODE_TB, GTK_ICON_SIZE_LARGE_TOOLBAR);
b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (b)));
g_signal_connect (G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_table_attach (GTK_TABLE (tbl), b, 2, 3, 1, 2, (GtkAttachOptions)0, (GtkAttachOptions)0, 0, 0);
g_object_set_data (G_OBJECT (dlg), "writing_mode_tb", b);
l = gtk_label_new (_("Line spacing:"));
gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (tbl), l, 0, 1, 2, 3, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)0, 4, 0);
c = gtk_combo_new ();
gtk_combo_set_value_in_list ((GtkCombo *) c, FALSE, FALSE);
gtk_combo_set_use_arrows ((GtkCombo *) c, TRUE);
gtk_combo_set_use_arrows_always ((GtkCombo *) c, TRUE);
gtk_widget_set_size_request (c, 64, -1);
/* Setup strings */
sl = NULL;
for (i = 0; spacings[i]; i++) {
sl = g_list_prepend (sl, (void *) spacings[i]);
}
sl = g_list_reverse (sl);
gtk_combo_set_popdown_strings ((GtkCombo *) c, sl);
g_list_free (sl);
g_signal_connect ((GObject *) ((GtkCombo *) c)->entry, "changed", (GCallback) sp_text_edit_dialog_line_spacing_changed, dlg);
gtk_table_attach (GTK_TABLE (tbl), c, 1, 4, 2, 3, (GtkAttachOptions)0, (GtkAttachOptions)0, 4, 0);
g_object_set_data (G_OBJECT (dlg), "line_spacing", c);
/* Font preview */
preview = sp_font_preview_new ();
gtk_box_pack_start (GTK_BOX (vb), preview, TRUE, TRUE, 4);
g_object_set_data (G_OBJECT (dlg), "preview", preview);
l = gtk_label_new (_("Text and font"));
gtk_notebook_append_page (GTK_NOTEBOOK (nb), vb, l);
/* Buttons */
hs = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (mainvb), hs, FALSE, FALSE, 0);
hb = gtk_hbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (hb), 4);
gtk_box_pack_start (GTK_BOX (mainvb), hb, FALSE, FALSE, 0);
b = gtk_button_new_with_label (_("Set as default"));
g_signal_connect (G_OBJECT (b), "clicked", G_CALLBACK (sp_text_edit_dialog_set_default), dlg);
gtk_box_pack_start (GTK_BOX (hb), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), "default", b);
b = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
g_signal_connect (G_OBJECT (b), "clicked", G_CALLBACK (sp_text_edit_dialog_close), dlg);
gtk_box_pack_end (GTK_BOX (hb), b, FALSE, FALSE, 0);
b = gtk_button_new_from_stock (GTK_STOCK_APPLY);
g_signal_connect (G_OBJECT (b), "clicked", G_CALLBACK (sp_text_edit_dialog_apply), dlg);
gtk_box_pack_end (GTK_BOX (hb), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), "apply", b);
g_signal_connect (G_OBJECT (INKSCAPE), "modify_selection", G_CALLBACK (sp_text_edit_dialog_modify_selection), dlg);
g_signal_connect (G_OBJECT (INKSCAPE), "change_selection", G_CALLBACK (sp_text_edit_dialog_change_selection), dlg);
sp_text_edit_dialog_read_selection (dlg, TRUE, TRUE);
gtk_widget_show_all (dlg);
}
gtk_window_present ((GtkWindow *) dlg);
}
static GtkWidget* create_script_option_widget(Script* script, ScriptOption* opt) {
GtkWidget* ret = NULL;
opt->widget = NULL;
switch(opt->type) {
case SCRIPT_OPTION_TYPE_STRING:
case SCRIPT_OPTION_TYPE_INT:
{
GtkWidget* hbox = ret = gtk_hbox_new(FALSE, 0);
GtkWidget* label = gtk_label_new(opt->name);
GtkWidget* entry = opt->widget = gtk_entry_new();
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 4);
gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 4);
if (opt->defval) {
gtk_entry_set_text(GTK_ENTRY(entry), opt->defval);
}
gtk_widget_show(hbox);
gtk_widget_show(label);
gtk_widget_show(entry);
}
break;
case SCRIPT_OPTION_TYPE_BOOL:
{
GtkWidget* button = ret = opt->widget = gtk_check_button_new_with_label(opt->name);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(button), opt->enable);
gtk_widget_show(button);
}
break;
case SCRIPT_OPTION_TYPE_LIST:
{
GtkWidget* hbox = ret = gtk_hbox_new(FALSE, 0);
GtkWidget* label = gtk_label_new(opt->name);
GtkWidget* combo = gtk_combo_new ();
GList* list = NULL;
unsigned i;
for (i = 0; i < opt->list->len; ++i) {
list = g_list_append(list, g_ptr_array_index(opt->list, i));
}
gtk_combo_set_popdown_strings(GTK_COMBO (combo), list);
g_list_free(list);
gtk_combo_set_use_arrows_always (GTK_COMBO (combo), TRUE);
gtk_list_set_selection_mode (GTK_LIST (GTK_COMBO (combo)->list), GTK_SELECTION_BROWSE);
if (opt->defval) {
gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (combo)->entry), opt->defval);
}
opt->widget = GTK_COMBO(combo)->entry;
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 4);
gtk_box_pack_start(GTK_BOX(hbox), combo, FALSE, FALSE, 4);
gtk_widget_show(combo);
gtk_widget_show(label);
gtk_widget_show(hbox);
}
break;
case SCRIPT_OPTION_TYPE_INVALID:
xqf_error("unreachable code");
break;
}
gtk_widget_ref(opt->widget);
return ret;
}
struct master *add_master_dialog (struct master *m) {
GtkWidget *window;
GtkWidget *main_vbox;
GtkWidget *table;
GtkWidget *option_menu;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *button;
GtkWidget *hseparator;
char *typestr;
enum master_query_type i;
struct master *master_to_edit;
char *windowtitle;
master_name_result = NULL;
master_addr_result = NULL;
current_master_query_type = MASTER_NATIVE;
master_to_edit = NULL;
master_to_add = NULL;
for (i=MASTER_NATIVE;i<MASTER_NUM_QUERY_TYPES;i++)
master_query_type_radios[i]=NULL;
master_to_edit = m;
if (master_to_edit) {
current_master_query_type = master_to_edit->master_type;
master_type = master_to_edit->type;
}
else {
// Get last game type added (stored in master_okbutton_callback)
typestr = config_get_string ("/" CONFIG_FILE "/Add Master/game");
if (typestr) {
master_type = id2type (typestr);
g_free (typestr);
}
else {
master_type = QW_SERVER;
}
}
if (master_to_edit) {
windowtitle=_("Rename Master");
}
else {
windowtitle=_("Add Master");
}
window = dialog_create_modal_transient_window(windowtitle, TRUE, FALSE, NULL);
main_vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), main_vbox);
table = gtk_table_new (2, 2, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_container_set_border_width (GTK_CONTAINER (table), 16);
gtk_box_pack_start (GTK_BOX (main_vbox), table, FALSE, FALSE, 0);
/* Master Name (Description) */
label = gtk_label_new (_("Master Name"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
hbox = gtk_hbox_new (FALSE, 4);
gtk_table_attach_defaults (GTK_TABLE (table), hbox, 1, 2, 0, 1);
master_name_combo = gtk_combo_new ();
gtk_widget_set_usize (master_name_combo, 200, -1);
gtk_box_pack_start (GTK_BOX (hbox), master_name_combo, TRUE, TRUE, 0);
gtk_entry_set_max_length (GTK_ENTRY (GTK_COMBO (master_name_combo)->entry), 256);
gtk_combo_set_case_sensitive (GTK_COMBO (master_name_combo), TRUE);
gtk_combo_set_use_arrows_always (GTK_COMBO (master_name_combo), TRUE);
gtk_combo_disable_activate (GTK_COMBO (master_name_combo));
gtk_signal_connect(
GTK_OBJECT (GTK_COMBO (master_name_combo)->entry), "activate",
GTK_SIGNAL_FUNC (master_okbutton_callback), GTK_OBJECT (window));
GTK_WIDGET_SET_FLAGS (GTK_COMBO (master_name_combo)->entry, GTK_CAN_FOCUS);
GTK_WIDGET_UNSET_FLAGS (GTK_COMBO (master_name_combo)->button, GTK_CAN_FOCUS);
gtk_widget_grab_focus (GTK_COMBO (master_name_combo)->entry);
gtk_widget_show (master_name_combo);
if (master_history_name->items)
combo_set_vals (master_name_combo, master_history_name->items, "");
if (master_to_edit) {
gtk_entry_set_text(GTK_ENTRY (GTK_COMBO (master_name_combo)->entry), master_to_edit->name);
}
/* Master Type Option Menu */
option_menu = create_server_type_menu (master_type, create_server_type_menu_filter_configured, GTK_SIGNAL_FUNC(select_master_type_callback));
gtk_box_pack_start (GTK_BOX (hbox), option_menu, FALSE, FALSE, 0);
if (master_to_edit) {
gtk_widget_set_state (option_menu, GTK_STATE_NORMAL);
gtk_widget_set_sensitive (GTK_WIDGET(option_menu),FALSE);
}
gtk_widget_show (option_menu);
gtk_widget_show (hbox);
/* Master Address */
label = gtk_label_new (_("Master Address"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
master_addr_combo = gtk_combo_new ();
gtk_table_attach_defaults (GTK_TABLE (table), master_addr_combo, 1, 2, 1, 2);
gtk_entry_set_max_length (GTK_ENTRY (GTK_COMBO (master_addr_combo)->entry), 4096);
gtk_combo_set_case_sensitive (GTK_COMBO (master_addr_combo), TRUE);
gtk_combo_set_use_arrows_always (GTK_COMBO (master_addr_combo), TRUE);
gtk_combo_disable_activate (GTK_COMBO (master_addr_combo));
gtk_signal_connect (
GTK_OBJECT (GTK_COMBO (master_addr_combo)->entry), "activate",
GTK_SIGNAL_FUNC (master_okbutton_callback), GTK_OBJECT (window));
gtk_signal_connect (
GTK_OBJECT (GTK_COMBO (master_addr_combo)->list),
"selection-changed",
GTK_SIGNAL_FUNC
(master_address_from_history_selected_callback),NULL);
GTK_WIDGET_SET_FLAGS (GTK_COMBO (master_addr_combo)->entry, GTK_CAN_FOCUS);
GTK_WIDGET_UNSET_FLAGS (GTK_COMBO (master_addr_combo)->button, GTK_CAN_FOCUS);
// gtk_widget_grab_focus (GTK_COMBO (master_addr_combo)->entry);
gtk_widget_show (master_addr_combo);
if (master_history_addr->items)
combo_set_vals (master_addr_combo, master_history_addr->items, "");
if (master_to_edit) {
char* url = master_to_url(master_to_edit);
gtk_entry_set_text(GTK_ENTRY (GTK_COMBO (master_addr_combo)->entry), url);
gtk_widget_set_state (master_addr_combo, GTK_STATE_NORMAL);
gtk_widget_set_sensitive (GTK_WIDGET(master_addr_combo),FALSE);
g_free(url);
}
gtk_widget_show (table);
/* query type */
hbox = gtk_hbox_new (TRUE, 8);
for (i=MASTER_NATIVE;i<MASTER_NUM_QUERY_TYPES;i++) {
master_query_type_radios[i] =
gtk_radio_button_new_with_label_from_widget(
i==MASTER_NATIVE?NULL:GTK_RADIO_BUTTON(master_query_type_radios[MASTER_NATIVE]),
_(master_designation[i]));
if (master_to_edit) {
gtk_widget_set_sensitive (GTK_WIDGET(master_query_type_radios[i]),FALSE);
}
gtk_signal_connect(GTK_OBJECT (master_query_type_radios[i]), "toggled",
GTK_SIGNAL_FUNC (master_type_radio_callback), (gpointer)i);
gtk_widget_show (master_query_type_radios[i]);
gtk_box_pack_start (GTK_BOX (hbox),master_query_type_radios[i], FALSE, FALSE, 0);
}
if (master_to_edit) {
master_activate_radio_for_type(current_master_query_type);
}
else if (!games[master_type].default_master_port &&
current_master_query_type == MASTER_NATIVE) {
gtk_widget_set_state (master_query_type_radios[MASTER_NATIVE], GTK_STATE_NORMAL);
gtk_widget_set_sensitive
(GTK_WIDGET(master_query_type_radios[MASTER_NATIVE]),FALSE);
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON(master_query_type_radios[MASTER_GAMESPY]),TRUE);
}
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
/* Separator */
hseparator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (main_vbox), hseparator, FALSE, FALSE, 0);
gtk_widget_show (hseparator);
/* Buttons */
hbox = gtk_hbox_new (FALSE, 8);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 8);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
/* Cancel Button */
button = gtk_button_new_with_label (_("Cancel"));
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_set_usize (button, 80, -1);
gtk_signal_connect_object (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (gtk_widget_destroy), GTK_OBJECT (window));
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_show (button);
/* OK Button */
button = gtk_button_new_with_label ("OK");
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_set_usize (button, 80, -1);
gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(master_okbutton_callback), window);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
gtk_widget_show (button);
gtk_widget_show (hbox);
gtk_widget_show (main_vbox);
gtk_widget_show (window);
gtk_main ();
unregister_window (window);
return master_to_add;
}
bool wxComboBox::Create( wxWindow *parent, wxWindowID id, const wxString& value,
const wxPoint& pos, const wxSize& size,
int n, const wxString choices[],
long style, const wxValidator& validator,
const wxString& name )
{
m_ignoreNextUpdate = false;
m_needParent = true;
m_acceptsFocus = true;
m_prevSelection = 0;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxComboBox creation failed") );
return false;
}
#ifdef __WXGTK24__
if (!gtk_check_version(2,4,0))
{
m_widget = gtk_combo_box_entry_new_text();
GtkComboBox* combobox = GTK_COMBO_BOX( m_widget );
gtk_entry_set_editable( GTK_ENTRY( GTK_BIN(m_widget)->child ), TRUE );
for (int i = 0; i < n; i++)
{
gtk_combo_box_append_text( combobox, wxGTK_CONV( choices[i] ) );
m_clientDataList.Append( (wxObject*)NULL );
m_clientObjectList.Append( (wxObject*)NULL );
}
}
else
#endif
{
m_widget = gtk_combo_new();
GtkCombo* combo = GTK_COMBO(m_widget);
// Disable GTK's broken events ...
g_signal_handler_disconnect (combo->entry, combo->entry_change_id);
// ... and add surrogate handler.
combo->entry_change_id = g_signal_connect (combo->entry, "changed",
G_CALLBACK (gtkcombo_dummy_callback),
combo);
// make it more useable
gtk_combo_set_use_arrows_always( GTK_COMBO(m_widget), TRUE );
// and case-sensitive
gtk_combo_set_case_sensitive( GTK_COMBO(m_widget), TRUE );
if (style & wxNO_BORDER)
g_object_set (combo->entry, "has-frame", FALSE, NULL );
GtkWidget *list = combo->list;
for (int i = 0; i < n; i++)
{
GtkWidget *list_item = gtk_list_item_new_with_label( wxGTK_CONV( choices[i] ) );
m_clientDataList.Append( (wxObject*)NULL );
m_clientObjectList.Append( (wxObject*)NULL );
gtk_container_add( GTK_CONTAINER(list), list_item );
gtk_widget_show( list_item );
}
}
m_parent->DoAddChild( this );
GtkEntry *entry = NULL;
#ifdef __WXGTK24__
if (!gtk_check_version(2,4,0))
entry = GTK_ENTRY( GTK_BIN(m_widget)->child );
else
#endif
entry = GTK_ENTRY( GTK_COMBO(m_widget)->entry );
m_focusWidget = GTK_WIDGET( entry );
PostCreation(size);
#ifdef __WXGTK24__
if (!gtk_check_version(2,4,0))
ConnectWidget( m_widget );
else
#endif
ConnectWidget( GTK_COMBO(m_widget)->button );
#ifdef __WXGTK24__
if (!gtk_check_version(2,4,0))
{
gtk_entry_set_text( entry, wxGTK_CONV(value) );
if (style & wxCB_READONLY)
gtk_entry_set_editable( entry, FALSE );
g_signal_connect_after (entry, "changed",
G_CALLBACK (gtkcombobox_text_changed_callback), this);
g_signal_connect_after (m_widget, "changed",
G_CALLBACK (gtkcombobox_changed_callback), this);
}
else
#endif
{
GtkCombo *combo = GTK_COMBO(m_widget);
// MSW's combo box shows the value and the selection is -1
gtk_entry_set_text( entry, wxGTK_CONV(value) );
gtk_list_unselect_all( GTK_LIST(combo->list) );
if (style & wxCB_READONLY)
gtk_entry_set_editable( entry, FALSE );
// "show" and "hide" events are generated when user click on the combobox button which popups a list
// this list is the "popwin" gtk widget
g_signal_connect (GTK_COMBO(combo)->popwin, "hide",
G_CALLBACK (gtkcombo_popup_hide_callback), this);
g_signal_connect (GTK_COMBO(combo)->popwin, "show",
G_CALLBACK (gtkcombo_popup_show_callback), this);
g_signal_connect_after (combo->list, "select-child",
G_CALLBACK (gtkcombo_combo_select_child_callback),
this);
g_signal_connect_after (entry, "changed",
G_CALLBACK (gtkcombo_text_changed_callback), this);
// This is required for tool bar support
// Doesn't currently work
// wxSize setsize = GetSize();
// gtk_widget_set_size_request( m_widget, setsize.x, setsize.y );
}
SetInitialSize(size); // need this too because this is a wxControlWithItems
return true;
}
GtkWidget*
create_app (void)
{
GtkWidget *app;
GtkWidget *dock1;
GtkWidget *toolbar1;
GtkWidget *tmp_toolbar_icon;
GtkWidget *button_new;
GtkWidget *button_open;
GtkWidget *button_save;
GtkWidget *button_save_as;
GtkWidget *hexentry;
GtkWidget *button_upload;
GtkWidget *radiobutton_spline;
GtkWidget *radiobutton_linear;
GtkWidget *radiobutton_free;
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *vbox2;
GtkWidget *table1;
GtkWidget *label1;
GtkWidget *label2;
GtkWidget *label3;
GtkWidget *label4;
GtkWidget *label5;
GtkWidget *label6;
GtkObject *minx_adj;
GtkWidget *minx;
GtkWidget *type;
GList *type_items = NULL;
GtkWidget *typeentry;
GtkObject *maxx_adj;
GtkWidget *maxx;
GtkObject *miny_adj;
GtkWidget *miny;
GtkObject *maxy_adj;
GtkWidget *maxy;
GtkObject *count_adj;
GtkWidget *count;
GtkWidget *label10;
GtkWidget *label11;
GtkWidget *label12;
GtkObject *scale_adj;
GtkWidget *scale;
GtkObject *base_adj;
GtkWidget *base;
GtkWidget *label13;
GtkWidget *scrolledwindow1;
GtkWidget *clist;
GtkWidget *label8;
GtkWidget *label9;
GtkWidget *toolbar2;
GtkWidget *list_open;
GtkWidget *list_save;
GtkWidget *list_add;
GtkWidget *list_remove;
GtkWidget *list_use;
GtkWidget *curve;
GtkWidget *appbar1;
app = gnome_app_new ("Curvegen", _("PSXDEV Curve Generator"));
gtk_object_set_data (GTK_OBJECT (app), "app", app);
dock1 = GNOME_APP (app)->dock;
gtk_widget_ref (dock1);
gtk_object_set_data_full (GTK_OBJECT (app), "dock1", dock1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (dock1);
gnome_app_create_menus (GNOME_APP (app), menubar1_uiinfo);
gtk_widget_ref (menubar1_uiinfo[0].widget);
gtk_object_set_data_full (GTK_OBJECT (app), "file1",
menubar1_uiinfo[0].widget,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_ref (file1_menu_uiinfo[0].widget);
gtk_object_set_data_full (GTK_OBJECT (app), "exit1",
file1_menu_uiinfo[0].widget,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_ref (menubar1_uiinfo[1].widget);
gtk_object_set_data_full (GTK_OBJECT (app), "help1",
menubar1_uiinfo[1].widget,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_ref (help1_menu_uiinfo[0].widget);
gtk_object_set_data_full (GTK_OBJECT (app), "about1",
help1_menu_uiinfo[0].widget,
(GtkDestroyNotify) gtk_widget_unref);
toolbar1 = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
gtk_widget_ref (toolbar1);
gtk_object_set_data_full (GTK_OBJECT (app), "toolbar1", toolbar1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (toolbar1);
gnome_app_add_toolbar (GNOME_APP (app), GTK_TOOLBAR (toolbar1), "toolbar1",
GNOME_DOCK_ITEM_BEH_EXCLUSIVE,
GNOME_DOCK_TOP, 1, 0, 0);
gtk_container_set_border_width (GTK_CONTAINER (toolbar1), 1);
gtk_toolbar_set_space_size (GTK_TOOLBAR (toolbar1), 16);
gtk_toolbar_set_space_style (GTK_TOOLBAR (toolbar1), GTK_TOOLBAR_SPACE_LINE);
gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar1), GTK_RELIEF_NONE);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_NEW);
button_new = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("New"),
_("New File"), NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (button_new);
gtk_object_set_data_full (GTK_OBJECT (app), "button_new", button_new,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_new);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_OPEN);
button_open = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Open"),
_("Open File"), NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (button_open);
gtk_object_set_data_full (GTK_OBJECT (app), "button_open", button_open,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_open);
gtk_widget_set_sensitive (button_open, FALSE);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_SAVE);
button_save = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Save"),
_("Save File"), NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (button_save);
gtk_object_set_data_full (GTK_OBJECT (app), "button_save", button_save,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_save);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_SAVE_AS);
button_save_as = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Save As"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (button_save_as);
gtk_object_set_data_full (GTK_OBJECT (app), "button_save_as", button_save_as,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_save_as);
hexentry = gtk_entry_new ();
gtk_widget_ref (hexentry);
gtk_object_set_data_full (GTK_OBJECT (app), "hexentry", hexentry,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hexentry);
gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar1), hexentry, _("Address of curve in PlayStation memory..."), NULL);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_MAIL_FWD);
button_upload = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Upload"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (button_upload);
gtk_object_set_data_full (GTK_OBJECT (app), "button_upload", button_upload,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_upload);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar1));
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_CONVERT);
radiobutton_spline = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1),
GTK_TOOLBAR_CHILD_RADIOBUTTON,
NULL,
_("SPLINE"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (radiobutton_spline);
gtk_object_set_data_full (GTK_OBJECT (app), "radiobutton_spline", radiobutton_spline,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (radiobutton_spline);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (radiobutton_spline), FALSE);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_CONVERT);
radiobutton_linear = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1),
GTK_TOOLBAR_CHILD_RADIOBUTTON,
radiobutton_spline,
_("LINEAR"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (radiobutton_linear);
gtk_object_set_data_full (GTK_OBJECT (app), "radiobutton_linear", radiobutton_linear,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (radiobutton_linear);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (radiobutton_linear), FALSE);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_CONVERT);
radiobutton_free = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1),
GTK_TOOLBAR_CHILD_RADIOBUTTON,
radiobutton_spline,
_("FREE"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (radiobutton_free);
gtk_object_set_data_full (GTK_OBJECT (app), "radiobutton_free", radiobutton_free,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (radiobutton_free);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (radiobutton_free), FALSE);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (vbox1);
gtk_object_set_data_full (GTK_OBJECT (app), "vbox1", vbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox1);
gnome_app_set_contents (GNOME_APP (app), vbox1);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox1);
gtk_object_set_data_full (GTK_OBJECT (app), "hbox1", hbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 0);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (vbox2);
gtk_object_set_data_full (GTK_OBJECT (app), "vbox2", vbox2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox2);
gtk_box_pack_start (GTK_BOX (hbox1), vbox2, FALSE, TRUE, 0);
table1 = gtk_table_new (10, 2, FALSE);
gtk_widget_ref (table1);
gtk_object_set_data_full (GTK_OBJECT (app), "table1", table1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (vbox2), table1, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (table1), 4);
gtk_table_set_row_spacings (GTK_TABLE (table1), 1);
gtk_table_set_col_spacings (GTK_TABLE (table1), 2);
label1 = gtk_label_new (_("Min X"));
gtk_widget_ref (label1);
gtk_object_set_data_full (GTK_OBJECT (app), "label1", label1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label1);
gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label1), 7.45058e-09, 0.5);
label2 = gtk_label_new (_("Max X"));
gtk_widget_ref (label2);
gtk_object_set_data_full (GTK_OBJECT (app), "label2", label2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label2);
gtk_table_attach (GTK_TABLE (table1), label2, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label2), 7.45058e-09, 0.5);
label3 = gtk_label_new (_("Min Y"));
gtk_widget_ref (label3);
gtk_object_set_data_full (GTK_OBJECT (app), "label3", label3,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label3);
gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label3), 7.45058e-09, 0.5);
label4 = gtk_label_new (_("Max Y"));
gtk_widget_ref (label4);
gtk_object_set_data_full (GTK_OBJECT (app), "label4", label4,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label4);
gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label4), 7.45058e-09, 0.5);
label5 = gtk_label_new (_("Count"));
gtk_widget_ref (label5);
gtk_object_set_data_full (GTK_OBJECT (app), "label5", label5,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label5);
gtk_table_attach (GTK_TABLE (table1), label5, 0, 1, 8, 9,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5);
label6 = gtk_label_new (_("Type"));
gtk_widget_ref (label6);
gtk_object_set_data_full (GTK_OBJECT (app), "label6", label6,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label6);
gtk_table_attach (GTK_TABLE (table1), label6, 0, 1, 9, 10,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5);
minx_adj = gtk_adjustment_new (0, -1e+13, 1e+13, 1, 10, 10);
minx = gtk_spin_button_new (GTK_ADJUSTMENT (minx_adj), 1, 4);
gtk_widget_ref (minx);
gtk_object_set_data_full (GTK_OBJECT (app), "minx", minx,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (minx);
gtk_table_attach (GTK_TABLE (table1), minx, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (minx), TRUE);
type = gtk_combo_new ();
gtk_widget_ref (type);
gtk_object_set_data_full (GTK_OBJECT (app), "type", type,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (type);
gtk_table_attach (GTK_TABLE (table1), type, 1, 2, 9, 10,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_combo_set_value_in_list (GTK_COMBO (type), TRUE, FALSE);
gtk_combo_set_use_arrows_always (GTK_COMBO (type), TRUE);
type_items = g_list_append (type_items, _("u_char"));
type_items = g_list_append (type_items, _("char"));
type_items = g_list_append (type_items, _("u_short"));
type_items = g_list_append (type_items, _("short"));
type_items = g_list_append (type_items, _("u_long"));
type_items = g_list_append (type_items, _("long"));
type_items = g_list_append (type_items, _("float"));
type_items = g_list_append (type_items, _("double"));
type_items = g_list_append (type_items, _("fixed (4+12)"));
gtk_combo_set_popdown_strings (GTK_COMBO (type), type_items);
g_list_free (type_items);
typeentry = GTK_COMBO (type)->entry;
gtk_widget_ref (typeentry);
gtk_object_set_data_full (GTK_OBJECT (app), "typeentry", typeentry,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (typeentry);
gtk_entry_set_editable (GTK_ENTRY (typeentry), FALSE);
gtk_entry_set_text (GTK_ENTRY (typeentry), _("u_char"));
maxx_adj = gtk_adjustment_new (1, -1e+13, 1e+13, 1, 10, 10);
maxx = gtk_spin_button_new (GTK_ADJUSTMENT (maxx_adj), 1, 4);
gtk_widget_ref (maxx);
gtk_object_set_data_full (GTK_OBJECT (app), "maxx", maxx,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (maxx);
gtk_table_attach (GTK_TABLE (table1), maxx, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (maxx), TRUE);
miny_adj = gtk_adjustment_new (0, -1e+13, 1e+13, 1, 10, 10);
miny = gtk_spin_button_new (GTK_ADJUSTMENT (miny_adj), 1, 4);
gtk_widget_ref (miny);
gtk_object_set_data_full (GTK_OBJECT (app), "miny", miny,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (miny);
gtk_table_attach (GTK_TABLE (table1), miny, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (miny), TRUE);
maxy_adj = gtk_adjustment_new (1, -1e+13, 1e+13, 1, 10, 10);
maxy = gtk_spin_button_new (GTK_ADJUSTMENT (maxy_adj), 1, 4);
gtk_widget_ref (maxy);
gtk_object_set_data_full (GTK_OBJECT (app), "maxy", maxy,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (maxy);
gtk_table_attach (GTK_TABLE (table1), maxy, 1, 2, 4, 5,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (maxy), TRUE);
count_adj = gtk_adjustment_new (1, 1, 1e+22, 1, 10, 10);
count = gtk_spin_button_new (GTK_ADJUSTMENT (count_adj), 1, 0);
gtk_widget_ref (count);
gtk_object_set_data_full (GTK_OBJECT (app), "count", count,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (count);
gtk_table_attach (GTK_TABLE (table1), count, 1, 2, 8, 9,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
label10 = gtk_label_new (_("Curve Interval:"));
gtk_widget_ref (label10);
gtk_object_set_data_full (GTK_OBJECT (app), "label10", label10,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label10);
gtk_table_attach (GTK_TABLE (table1), label10, 0, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label10), 7.45058e-09, 0.5);
label11 = gtk_label_new (_("Datatype:"));
gtk_widget_ref (label11);
gtk_object_set_data_full (GTK_OBJECT (app), "label11", label11,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label11);
gtk_table_attach (GTK_TABLE (table1), label11, 0, 2, 5, 6,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label11), 7.45058e-09, 0.5);
label12 = gtk_label_new (_("Scale"));
gtk_widget_ref (label12);
gtk_object_set_data_full (GTK_OBJECT (app), "label12", label12,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label12);
gtk_table_attach (GTK_TABLE (table1), label12, 0, 1, 6, 7,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label12), 0, 0.5);
scale_adj = gtk_adjustment_new (1, 1, 1e+22, 1, 10, 10);
scale = gtk_spin_button_new (GTK_ADJUSTMENT (scale_adj), 1, 0);
gtk_widget_ref (scale);
gtk_object_set_data_full (GTK_OBJECT (app), "scale", scale,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (scale);
gtk_table_attach (GTK_TABLE (table1), scale, 1, 2, 6, 7,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
base_adj = gtk_adjustment_new (0, 0, 1e+22, 1, 10, 10);
base = gtk_spin_button_new (GTK_ADJUSTMENT (base_adj), 1, 0);
gtk_widget_ref (base);
gtk_object_set_data_full (GTK_OBJECT (app), "base", base,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (base);
gtk_table_attach (GTK_TABLE (table1), base, 1, 2, 7, 8,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
label13 = gtk_label_new (_("Base"));
gtk_widget_ref (label13);
gtk_object_set_data_full (GTK_OBJECT (app), "label13", label13,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label13);
gtk_table_attach (GTK_TABLE (table1), label13, 0, 1, 7, 8,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label13), 0, 0.5);
scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_ref (scrolledwindow1);
gtk_object_set_data_full (GTK_OBJECT (app), "scrolledwindow1", scrolledwindow1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (scrolledwindow1);
gtk_box_pack_start (GTK_BOX (vbox2), scrolledwindow1, TRUE, TRUE, 0);
gtk_widget_set_sensitive (scrolledwindow1, FALSE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
clist = gtk_clist_new (2);
gtk_widget_ref (clist);
gtk_object_set_data_full (GTK_OBJECT (app), "clist", clist,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (clist);
gtk_container_add (GTK_CONTAINER (scrolledwindow1), clist);
gtk_clist_set_column_width (GTK_CLIST (clist), 0, 28);
gtk_clist_set_column_width (GTK_CLIST (clist), 1, 80);
gtk_clist_column_titles_show (GTK_CLIST (clist));
label8 = gtk_label_new (_("Type"));
gtk_widget_ref (label8);
gtk_object_set_data_full (GTK_OBJECT (app), "label8", label8,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label8);
gtk_clist_set_column_widget (GTK_CLIST (clist), 0, label8);
label9 = gtk_label_new (_("Name"));
gtk_widget_ref (label9);
gtk_object_set_data_full (GTK_OBJECT (app), "label9", label9,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label9);
gtk_clist_set_column_widget (GTK_CLIST (clist), 1, label9);
toolbar2 = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH);
gtk_widget_ref (toolbar2);
gtk_object_set_data_full (GTK_OBJECT (app), "toolbar2", toolbar2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (toolbar2);
gtk_box_pack_start (GTK_BOX (vbox2), toolbar2, FALSE, FALSE, 0);
gtk_widget_set_sensitive (toolbar2, FALSE);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_OPEN);
list_open = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar2),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Open"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (list_open);
gtk_object_set_data_full (GTK_OBJECT (app), "list_open", list_open,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (list_open);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_SAVE);
list_save = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar2),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Save"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (list_save);
gtk_object_set_data_full (GTK_OBJECT (app), "list_save", list_save,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (list_save);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_ADD);
list_add = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar2),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Add"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (list_add);
gtk_object_set_data_full (GTK_OBJECT (app), "list_add", list_add,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (list_add);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_REMOVE);
list_remove = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar2),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Remove"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (list_remove);
gtk_object_set_data_full (GTK_OBJECT (app), "list_remove", list_remove,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (list_remove);
tmp_toolbar_icon = gnome_stock_pixmap_widget (app, GNOME_STOCK_PIXMAP_EXEC);
list_use = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar2),
GTK_TOOLBAR_CHILD_BUTTON,
NULL,
_("Use"),
NULL, NULL,
tmp_toolbar_icon, NULL, NULL);
gtk_widget_ref (list_use);
gtk_object_set_data_full (GTK_OBJECT (app), "list_use", list_use,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (list_use);
curve = gtk_curve_new ();
gtk_widget_ref (curve);
gtk_object_set_data_full (GTK_OBJECT (app), "curve", curve,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (curve);
gtk_box_pack_start (GTK_BOX (hbox1), curve, TRUE, TRUE, 0);
gtk_widget_set_usize (curve, 256, 256);
gtk_curve_set_range (GTK_CURVE (curve), 0, 1, 0, 1);
appbar1 = gnome_appbar_new (FALSE, TRUE, GNOME_PREFERENCES_NEVER);
gtk_widget_ref (appbar1);
gtk_object_set_data_full (GTK_OBJECT (app), "appbar1", appbar1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (appbar1);
gnome_app_set_statusbar (GNOME_APP (app), appbar1);
gtk_signal_connect (GTK_OBJECT (app), "delete_event",
GTK_SIGNAL_FUNC (on_app_delete_event),
NULL);
gtk_signal_connect (GTK_OBJECT (button_new), "clicked",
GTK_SIGNAL_FUNC (on_button_new_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (button_open), "clicked",
GTK_SIGNAL_FUNC (on_button_open_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (button_save), "clicked",
GTK_SIGNAL_FUNC (on_button_save_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (button_save_as), "clicked",
GTK_SIGNAL_FUNC (on_button_save_as_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (button_upload), "clicked",
GTK_SIGNAL_FUNC (on_button_upload_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (radiobutton_spline), "clicked",
GTK_SIGNAL_FUNC (on_radiobutton_spline_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (radiobutton_linear), "clicked",
GTK_SIGNAL_FUNC (on_radiobutton_linear_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (radiobutton_free), "clicked",
GTK_SIGNAL_FUNC (on_radiobutton_free_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (minx), "changed",
GTK_SIGNAL_FUNC (on_minx_changed),
NULL);
gtk_signal_connect (GTK_OBJECT (maxx), "changed",
GTK_SIGNAL_FUNC (on_maxx_changed),
NULL);
gtk_signal_connect (GTK_OBJECT (miny), "changed",
GTK_SIGNAL_FUNC (on_miny_changed),
NULL);
gtk_signal_connect (GTK_OBJECT (maxy), "changed",
GTK_SIGNAL_FUNC (on_maxy_changed),
NULL);
gtk_signal_connect (GTK_OBJECT (list_open), "clicked",
GTK_SIGNAL_FUNC (on_list_open_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (list_save), "clicked",
GTK_SIGNAL_FUNC (on_list_save_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (list_add), "clicked",
GTK_SIGNAL_FUNC (on_list_add_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (list_remove), "clicked",
GTK_SIGNAL_FUNC (on_list_remove_clicked),
NULL);
gtk_signal_connect (GTK_OBJECT (list_use), "clicked",
GTK_SIGNAL_FUNC (on_list_use_clicked),
NULL);
return app;
}
void
sp_text_edit_dialog (void)
{
if (!dlg) {
gchar title[500];
sp_ui_dialog_title_string (Inkscape::Verb::get(SP_VERB_DIALOG_TEXT), title);
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
dlg = sp_window_new (title, TRUE);
if (x == -1000 || y == -1000) {
x = prefs->getInt(prefs_path + "x", -1000);
y = prefs->getInt(prefs_path + "y", -1000);
}
if (w ==0 || h == 0) {
w = prefs->getInt(prefs_path + "w", 0);
h = prefs->getInt(prefs_path + "h", 0);
}
// if (x<0) x=0;
// if (y<0) y=0;
if (w && h)
gtk_window_resize ((GtkWindow *) dlg, w, h);
if (x >= 0 && y >= 0 && (x < (gdk_screen_width()-MIN_ONSCREEN_DISTANCE)) && (y < (gdk_screen_height()-MIN_ONSCREEN_DISTANCE))) {
gtk_window_move ((GtkWindow *) dlg, x, y);
} else {
gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER);
}
sp_transientize (dlg);
wd.win = dlg;
wd.stop = 0;
g_signal_connect ( G_OBJECT (INKSCAPE), "activate_desktop", G_CALLBACK (sp_transientize_callback), &wd );
gtk_signal_connect ( GTK_OBJECT (dlg), "event", GTK_SIGNAL_FUNC (sp_dialog_event_handler), dlg );
gtk_signal_connect ( GTK_OBJECT (dlg), "destroy", G_CALLBACK (sp_text_edit_dialog_destroy), dlg );
gtk_signal_connect ( GTK_OBJECT (dlg), "delete_event", G_CALLBACK (sp_text_edit_dialog_delete), dlg );
g_signal_connect ( G_OBJECT (INKSCAPE), "shut_down", G_CALLBACK (sp_text_edit_dialog_delete), dlg );
g_signal_connect ( G_OBJECT (INKSCAPE), "dialogs_hide", G_CALLBACK (sp_dialog_hide), dlg );
g_signal_connect ( G_OBJECT (INKSCAPE), "dialogs_unhide", G_CALLBACK (sp_dialog_unhide), dlg );
gtk_window_set_policy (GTK_WINDOW (dlg), TRUE, TRUE, FALSE);
GtkTooltips *tt = gtk_tooltips_new();
// box containing the notebook and the bottom buttons
GtkWidget *mainvb = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (dlg), mainvb);
// notebook
GtkWidget *nb = gtk_notebook_new ();
gtk_box_pack_start (GTK_BOX (mainvb), nb, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (dlg), "notebook", nb);
// Font tab
{
GtkWidget *l = gtk_label_new (_("Font"));
GtkWidget *vb = gtk_vbox_new (FALSE, VB_MARGIN);
gtk_container_set_border_width (GTK_CONTAINER (vb), VB_MARGIN);
gtk_notebook_append_page (GTK_NOTEBOOK (nb), vb, l);
/* HBox containing font selection and layout */
GtkWidget *hb = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vb), hb, TRUE, TRUE, 0);
// font and style selector
GtkWidget *fontsel = sp_font_selector_new ();
g_signal_connect ( G_OBJECT (fontsel), "font_set", G_CALLBACK (sp_text_edit_dialog_font_changed), dlg );
g_signal_connect_swapped ( G_OBJECT (g_object_get_data (G_OBJECT(fontsel), "family-treeview")),
"row-activated",
G_CALLBACK (gtk_window_activate_default),
dlg);
gtk_box_pack_start (GTK_BOX (hb), fontsel, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (dlg), "fontsel", fontsel);
// Layout
{
GtkWidget *f = gtk_frame_new (_("Layout"));
gtk_box_pack_start (GTK_BOX (hb), f, FALSE, FALSE, 4);
GtkWidget *l_vb = gtk_vbox_new (FALSE, VB_MARGIN);
gtk_container_add (GTK_CONTAINER (f), l_vb);
{
GtkWidget *row = gtk_hbox_new (FALSE, VB_MARGIN);
GtkWidget *group;
// align left
{
// TODO - replace with Inkscape-specific call
GtkWidget *px = gtk_image_new_from_stock ( GTK_STOCK_JUSTIFY_LEFT, GTK_ICON_SIZE_LARGE_TOOLBAR );
GtkWidget *b = group = gtk_radio_button_new (NULL);
gtk_tooltips_set_tip (tt, b, _("Align lines left"), NULL);
gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE );
gtk_container_add (GTK_CONTAINER (b), px);
gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), "text_anchor_start", b);
}
// align center
{
// TODO - replace with Inkscape-specific call
GtkWidget *px = gtk_image_new_from_stock ( GTK_STOCK_JUSTIFY_CENTER, GTK_ICON_SIZE_LARGE_TOOLBAR );
GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group)));
/* TRANSLATORS: `Center' here is a verb. */
gtk_tooltips_set_tip (tt, b, _("Center lines"), NULL);
gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg );
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), "text_anchor_middle", b);
}
// align right
{
// TODO - replace with Inkscape-specific call
GtkWidget *px = gtk_image_new_from_stock ( GTK_STOCK_JUSTIFY_RIGHT, GTK_ICON_SIZE_LARGE_TOOLBAR );
GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group)));
gtk_tooltips_set_tip (tt, b, _("Align lines right"), NULL);
gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg );
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), "text_anchor_end", b);
}
// align justify
{
// TODO - replace with Inkscape-specific call
GtkWidget *px = gtk_image_new_from_stock ( GTK_STOCK_JUSTIFY_FILL, GTK_ICON_SIZE_LARGE_TOOLBAR );
GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group)));
gtk_tooltips_set_tip (tt, b, _("Justify lines"), NULL);
gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg );
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), "text_anchor_justify", b);
}
gtk_box_pack_start (GTK_BOX (l_vb), row, FALSE, FALSE, 0);
}
{
GtkWidget *row = gtk_hbox_new (FALSE, VB_MARGIN);
GtkWidget *group;
// horizontal
{
GtkWidget *px = sp_icon_new( Inkscape::ICON_SIZE_LARGE_TOOLBAR,
INKSCAPE_STOCK_WRITING_MODE_LR );
GtkWidget *b = group = gtk_radio_button_new (NULL);
gtk_tooltips_set_tip (tt, b, _("Horizontal text"), NULL);
gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg );
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), INKSCAPE_STOCK_WRITING_MODE_LR, b);
}
// vertical
{
GtkWidget *px = sp_icon_new( Inkscape::ICON_SIZE_LARGE_TOOLBAR,
INKSCAPE_STOCK_WRITING_MODE_TB );
GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group)));
gtk_tooltips_set_tip (tt, b, _("Vertical text"), NULL);
gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg );
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), INKSCAPE_STOCK_WRITING_MODE_TB, b);
}
gtk_box_pack_start (GTK_BOX (l_vb), row, FALSE, FALSE, 0);
}
{
GtkWidget *row = gtk_hbox_new (FALSE, VB_MARGIN);
l = gtk_label_new (_("Line spacing:"));
gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
gtk_box_pack_start (GTK_BOX (row), l, FALSE, FALSE, VB_MARGIN);
gtk_box_pack_start (GTK_BOX (l_vb), row, FALSE, FALSE, 0);
}
{
GtkWidget *row = gtk_hbox_new (FALSE, VB_MARGIN);
GtkWidget *c = gtk_combo_new ();
gtk_combo_set_value_in_list ((GtkCombo *) c, FALSE, FALSE);
gtk_combo_set_use_arrows ((GtkCombo *) c, TRUE);
gtk_combo_set_use_arrows_always ((GtkCombo *) c, TRUE);
gtk_widget_set_size_request (c, 90, -1);
{ /* Setup strings */
GList *sl = NULL;
for (int i = 0; spacings[i]; i++) {
sl = g_list_prepend (sl, (void *) spacings[i]);
}
sl = g_list_reverse (sl);
gtk_combo_set_popdown_strings ((GtkCombo *) c, sl);
g_list_free (sl);
}
g_signal_connect ( (GObject *) ((GtkCombo *) c)->entry,
"changed",
(GCallback) sp_text_edit_dialog_line_spacing_changed,
dlg );
gtk_box_pack_start (GTK_BOX (row), c, FALSE, FALSE, VB_MARGIN);
g_object_set_data (G_OBJECT (dlg), "line_spacing", c);
gtk_box_pack_start (GTK_BOX (l_vb), row, FALSE, FALSE, VB_MARGIN);
}
}
/* Font preview */
GtkWidget *preview = sp_font_preview_new ();
gtk_box_pack_start (GTK_BOX (vb), preview, TRUE, TRUE, 4);
g_object_set_data (G_OBJECT (dlg), "preview", preview);
}
// Text tab
{
GtkWidget *l = gtk_label_new (_("Text"));
GtkWidget *vb = gtk_vbox_new (FALSE, VB_MARGIN);
gtk_container_set_border_width (GTK_CONTAINER (vb), VB_MARGIN);
gtk_notebook_append_page (GTK_NOTEBOOK (nb), vb, l);
GtkWidget *scroller = gtk_scrolled_window_new ( NULL, NULL );
gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW (scroller),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC );
gtk_scrolled_window_set_shadow_type ( GTK_SCROLLED_WINDOW(scroller), GTK_SHADOW_IN );
gtk_widget_show (scroller);
GtkTextBuffer *tb = gtk_text_buffer_new (NULL);
GtkWidget *txt = gtk_text_view_new_with_buffer (tb);
gtk_text_view_set_wrap_mode ((GtkTextView *) txt, GTK_WRAP_WORD);
#ifdef WITH_GTKSPELL
GError *error = NULL;
char *errortext = NULL;
/* todo: Use computed xml:lang attribute of relevant element, if present, to specify the
language (either as 2nd arg of gtkspell_new_attach, or with explicit
gtkspell_set_language call in; see advanced.c example in gtkspell docs).
sp_text_edit_dialog_read_selection looks like a suitable place. */
if (gtkspell_new_attach(GTK_TEXT_VIEW(txt), NULL, &error) == NULL) {
g_print("gtkspell error: %s\n", error->message);
errortext = g_strdup_printf("GtkSpell was unable to initialize.\n"
"%s", error->message);
g_error_free(error);
}
#endif
gtk_widget_set_size_request (txt, -1, 64);
gtk_text_view_set_editable (GTK_TEXT_VIEW (txt), TRUE);
gtk_container_add (GTK_CONTAINER (scroller), txt);
gtk_box_pack_start (GTK_BOX (vb), scroller, TRUE, TRUE, 0);
g_signal_connect ( G_OBJECT (tb), "changed",
G_CALLBACK (sp_text_edit_dialog_text_changed), dlg );
g_signal_connect (G_OBJECT (txt), "focus-in-event", G_CALLBACK (text_view_focus_in), dlg);
g_signal_connect (G_OBJECT (txt), "focus-out-event", G_CALLBACK (text_view_focus_out), dlg);
g_object_set_data (G_OBJECT (dlg), "text", tb);
g_object_set_data (G_OBJECT (dlg), "textw", txt);
}
/* Buttons */
GtkWidget *hb = gtk_hbox_new (FALSE, VB_MARGIN);
gtk_container_set_border_width (GTK_CONTAINER (hb), 4);
gtk_box_pack_start (GTK_BOX (mainvb), hb, FALSE, FALSE, 0);
{
GtkWidget *b = gtk_button_new_with_label (_("Set as default"));
g_signal_connect ( G_OBJECT (b), "clicked",
G_CALLBACK (sp_text_edit_dialog_set_default),
dlg );
gtk_box_pack_start (GTK_BOX (hb), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), "default", b);
}
{
GtkWidget *b = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
g_signal_connect ( G_OBJECT (b), "clicked",
G_CALLBACK (sp_text_edit_dialog_close), dlg );
gtk_box_pack_end (GTK_BOX (hb), b, FALSE, FALSE, 0);
}
{
GtkWidget *b = gtk_button_new_from_stock (GTK_STOCK_APPLY);
GTK_WIDGET_SET_FLAGS (b, GTK_CAN_DEFAULT | GTK_HAS_DEFAULT);
g_signal_connect ( G_OBJECT (b), "clicked",
G_CALLBACK (sp_text_edit_dialog_apply), dlg );
gtk_box_pack_end ( GTK_BOX (hb), b, FALSE, FALSE, 0 );
g_object_set_data (G_OBJECT (dlg), "apply", b);
}
g_signal_connect ( G_OBJECT (INKSCAPE), "modify_selection",
G_CALLBACK (sp_text_edit_dialog_selection_modified), dlg);
g_signal_connect ( G_OBJECT (INKSCAPE), "change_selection",
G_CALLBACK (sp_text_edit_dialog_selection_changed), dlg);
g_signal_connect (INKSCAPE, "change_subselection", G_CALLBACK (sp_text_edit_dialog_subselection_changed), dlg);
gtk_widget_show_all (dlg);
sp_text_edit_dialog_read_selection (dlg, TRUE, TRUE);
}
gtk_window_present ((GtkWindow *) dlg);
} // end of sp_text_edit_dialog()
