void
gnc_item_edit_paste_clipboard (GncItemEdit *item_edit)
{
gtk_editable_set_editable(GTK_EDITABLE(item_edit->editor), TRUE);
gtk_editable_paste_clipboard(GTK_EDITABLE(item_edit->editor));
gtk_editable_set_editable(GTK_EDITABLE(item_edit->editor), FALSE);
}
StatusBar_t*
make_statusbar(GtkWidget *main_vbox, GtkWidget *window)
{
StatusBar_t *statusbar = g_new(StatusBar_t, 1);
GtkWidget *hbox, *iconw;
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 1);
gtk_box_pack_start(GTK_BOX(main_vbox), hbox, FALSE, FALSE, 0);
/* Status info */
statusbar->status = gtk_statusbar_new();
statusbar->status_id = gtk_statusbar_get_context_id(
GTK_STATUSBAR(statusbar->status), "general_status");
gtk_box_pack_start(GTK_BOX(hbox), statusbar->status, TRUE, TRUE, 0);
gtk_widget_show(statusbar->status);
/* (x, y) coordinate */
iconw = gtk_image_new_from_stock(IMAP_STOCK_COORD,
GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_box_pack_start(GTK_BOX(hbox), iconw, FALSE, FALSE, 10);
gtk_widget_show(iconw);
statusbar->xy = gtk_entry_new();
gtk_widget_set_size_request(statusbar->xy, 96, -1);
gtk_editable_set_editable(GTK_EDITABLE(statusbar->xy), FALSE);
gtk_widget_set_can_focus (statusbar->xy, FALSE);
gtk_box_pack_start(GTK_BOX(hbox), statusbar->xy, FALSE, FALSE, 0);
gtk_widget_show(statusbar->xy);
/* Dimension info */
iconw = gtk_image_new_from_stock(IMAP_STOCK_DIMENSION,
GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_box_pack_start(GTK_BOX(hbox), iconw, FALSE, FALSE, 10);
gtk_widget_show(iconw);
statusbar->dimension = gtk_entry_new();
gtk_widget_set_size_request(statusbar->dimension, 96, -1);
gtk_editable_set_editable(GTK_EDITABLE(statusbar->dimension), FALSE);
gtk_widget_set_can_focus (statusbar->dimension, FALSE);
gtk_box_pack_start(GTK_BOX(hbox), statusbar->dimension, FALSE, FALSE, 0);
gtk_widget_show(statusbar->dimension);
/* Zoom info */
statusbar->zoom = gtk_statusbar_new();
gtk_widget_set_size_request(statusbar->zoom, 48, -1);
statusbar->zoom_id = gtk_statusbar_get_context_id(
GTK_STATUSBAR(statusbar->zoom), "zoom_status");
gtk_box_pack_start(GTK_BOX(hbox), statusbar->zoom, FALSE, FALSE, 5);
gtk_widget_show(statusbar->zoom);
gtk_widget_show(hbox);
return statusbar;
}
void fill_cmbo(GtkWidget *cmbo)
{
FILE *f;
int i = 0;
PangoFontDescription *pfd;
GtkWidget *entry1;
char buffer[1024]={0};
char buffer1[1024]={0};
char buffer2[1024]={0};
GtkCellRenderer *renderer = NULL;
renderer = gtk_cell_renderer_text_new();//gtk_cell_renderer_combo_new();
g_object_set (G_OBJECT(renderer), "font", "Simsun 16","foreground", "RED",NULL );
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), renderer, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo), renderer, "text", 0,NULL);
f=fopen("res/data.txt","rb");
if(f)
{
strncpy(g_context[g_context_item].id,"0000000000000000",17);
strncpy(g_context[g_context_item].name,"全部",60);
gtk_combo_box_text_append_text((GtkComboBoxText *)combo,g_context[g_context_item++].name);
while(fgets(buffer,1024,f))
{
if(strlen(buffer) > 0 && (buffer[strlen(buffer) - 1] == '\n' || buffer[strlen(buffer) - 1] == '\r'))
{
buffer[strlen(buffer) - 1] = 0;
}
if(strlen(buffer) > 0 && (buffer[strlen(buffer) - 1] == '\n' || buffer[strlen(buffer) - 1] == '\r'))
{
buffer[strlen(buffer) - 1] = 0;
}
i = sscanf(buffer,"%s %s",buffer1,buffer2);
if(i==2)
{
if(strlen(buffer1)==16)
{
strncpy(g_context[g_context_item].id,buffer1,16);
g_print("====>>[%s]\n",g_context[g_context_item].id);
strncpy(g_context[g_context_item].name,buffer2,60);
gtk_combo_box_text_append_text((GtkComboBoxText *)combo,
g_convert(g_context[g_context_item].name,-1,"UTF-8", "GBK", NULL, NULL, NULL));
g_context_item++;
if(g_context_item >= 30)
{
break;
}
}
}
}
fclose(f);
}
entry1 = gtk_bin_get_child((GtkBin *)combo);
gtk_editable_set_editable((GtkEditable *)entry1,FALSE);
gtk_entry_set_text((GtkEntry *)entry1,g_convert(g_context[0].name,-1,"UTF-8", "GBK", NULL, NULL, NULL));
pfd = pango_font_description_from_string("Simsun");
pango_font_description_set_size (pfd, 20 * PANGO_SCALE);
gtk_widget_modify_font(GTK_WIDGET(entry1),pfd);
pango_font_description_free(pfd);
}
GtkWidget *
make_families_menu ()
{
GtkWidget *combo;
int n_families;
PangoFontFamily **families;
GList *family_list = NULL;
int i;
pango_context_list_families (context, &families, &n_families);
qsort (families, n_families, sizeof(char *), cmp_families);
for (i=0; i<n_families; i++)
family_list = g_list_prepend (family_list, pango_font_family_get_name (families[i]));
family_list = g_list_reverse (family_list);
combo = gtk_combo_new ();
gtk_combo_set_popdown_strings (GTK_COMBO (combo), family_list);
gtk_combo_set_value_in_list (GTK_COMBO (combo), TRUE, FALSE);
gtk_editable_set_editable (GTK_EDITABLE (GTK_COMBO (combo)->entry), FALSE);
gtk_entry_set_text (GTK_ENTRY (GTK_COMBO (combo)->entry), pango_font_description_get_family(font_description));
gtk_signal_connect (GTK_OBJECT (GTK_COMBO (combo)->entry), "changed",
GTK_SIGNAL_FUNC (set_family), NULL);
g_list_free (family_list);
return combo;
}
static void menu_join(GtkWidget *wid, gpointer none) {
GtkWidget *hbox, *dialog, *entry, *label;
dialog = gtk_dialog_new_with_buttons(_("Join Channel"),
GTK_WINDOW(parent_window), 0,
_("Retrieve channel list..."), GTK_RESPONSE_HELP,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);
gtk_box_set_homogeneous(GTK_BOX(GTK_DIALOG(dialog)->vbox), TRUE);
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_MOUSE);
hbox = gtk_hbox_new(TRUE, 0);
entry = gtk_entry_new();
GTK_ENTRY(entry)->editable = 0; /* avoid auto-selection */
gtk_entry_set_text(GTK_ENTRY(entry), "#");
g_signal_connect(G_OBJECT(entry), "activate", G_CALLBACK(menu_join_entry_cb), dialog);
gtk_box_pack_end(GTK_BOX(hbox), entry, 0, 0, 0);
label = gtk_label_new(_("Enter Channel to Join:"));
gtk_box_pack_end(GTK_BOX(hbox), label, 0, 0, 0);
g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(menu_join_cb), entry);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), hbox);
gtk_widget_show_all(dialog);
gtk_editable_set_editable(GTK_EDITABLE(entry), TRUE);
gtk_editable_set_position(GTK_EDITABLE(entry), 1);
}
int main(int argc,char **argv)
{
GtkWidget *window,*vbox,*hbox,*label,*button,*entry;
void *data[3];
CURL *curl = curl_easy_init();
gtk_init(&argc,&argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window),"GtkUrlShortener");
gtk_window_set_default_size(GTK_WINDOW(window),300,100);
gtk_container_set_border_width(GTK_CONTAINER(window),5);
vbox = gtk_vbox_new(TRUE,2);
hbox = gtk_hbox_new(FALSE,2);
gtk_container_add(GTK_CONTAINER(window),vbox);
gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,TRUE,2);
label = gtk_label_new("Insert long URL");
gtk_box_pack_start(GTK_BOX(hbox),label,TRUE,TRUE,2);
entry = gtk_entry_new();
gtk_editable_set_editable(GTK_EDITABLE(entry),TRUE);
gtk_box_pack_start(GTK_BOX(hbox),entry,TRUE,TRUE,2);
hbox = gtk_hbox_new(TRUE,2);
gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,TRUE,2);
button = gtk_button_new_with_label("Make short URL!");
gtk_box_pack_start(GTK_BOX(hbox),button,TRUE,TRUE,2);
data[0] = window;
data[1] = entry;
data[2] = curl;
g_signal_connect(G_OBJECT(window),"delete_event",G_CALLBACK(gtk_main_quit),NULL);
g_signal_connect(G_OBJECT(button),"clicked",G_CALLBACK(MakeShortURL),data);
gtk_widget_show_all(window);
gtk_main();
curl_easy_cleanup(curl);
return 0;
}
static void
wbcg_edit_attach_guru_main (WBCGtk *wbcg, GtkWidget *guru)
{
WorkbookControl *wbc = GNM_WBC (wbcg);
g_return_if_fail (guru != NULL);
g_return_if_fail (GNM_IS_WBC_GTK (wbcg));
g_return_if_fail (wbcg->edit_line.guru == NULL);
/* Make sure we don't have anything anted.
* this protects against two anted regions showing up
*/
gnm_app_clipboard_unant ();
/* don't set end 'End' mode when a dialog comes up */
wbcg_set_end_mode (wbcg, FALSE);
wbcg->edit_line.guru = guru;
gtk_editable_set_editable (GTK_EDITABLE (wbcg_get_entry (wbcg)), FALSE);
wb_control_update_action_sensitivity (wbc);
wb_control_menu_state_update (wbc, MS_GURU_MENU_ITEMS);
g_signal_connect_object (guru, "destroy",
G_CALLBACK (wbc_gtk_detach_guru), wbcg, G_CONNECT_SWAPPED);
}
static GObject *constructor(GType gtype, guint n_properties, GObjectConstructParam *properties) {
GObject *object;
#if (GTK_CHECK_VERSION(2,24,0))
guint i;
gchar const *name;
GObjectConstructParam *property;
for (i = 0, property = properties; i < n_properties; ++i, ++property) {
name = g_param_spec_get_name(property->pspec);
if (!strcmp(name, "has-entry")) // is G_PARAM_CONSTRUCT_ONLY
g_value_set_boolean(property->value, TRUE);
}
#endif
object = G_OBJECT_CLASS(ryostklconfig_pro_dimness_selector_parent_class)->constructor(gtype, n_properties, properties);
#if (GTK_CHECK_VERSION(2,24,0))
g_object_set(object, "entry-text-column", TITLE_COLUMN, NULL);
#else
g_object_set(object, "text-column", TITLE_COLUMN, NULL);
#endif
gtk_editable_set_editable(GTK_EDITABLE(gtk_bin_get_child(GTK_BIN(object))), FALSE);
return object;
}
static void
palette_editor_entry_selected (GimpPaletteView *view,
GimpPaletteEntry *entry,
GimpPaletteEditor *editor)
{
GimpDataEditor *data_editor = GIMP_DATA_EDITOR (editor);
if (editor->color != entry)
{
editor->color = entry;
g_signal_handlers_block_by_func (editor->color_name,
palette_editor_color_name_changed,
editor);
gtk_entry_set_text (GTK_ENTRY (editor->color_name),
entry ? entry->name : _("Undefined"));
g_signal_handlers_unblock_by_func (editor->color_name,
palette_editor_color_name_changed,
editor);
gtk_editable_set_editable (GTK_EDITABLE (editor->color_name),
entry && data_editor->data_editable);
gimp_ui_manager_update (gimp_editor_get_ui_manager (GIMP_EDITOR (editor)),
gimp_editor_get_popup_data (GIMP_EDITOR (editor)));
}
}
void wxBitmapComboBox::GTKCreateComboBoxWidget()
{
GtkListStore *store;
store = gtk_list_store_new( 2, G_TYPE_OBJECT, G_TYPE_STRING );
if ( HasFlag(wxCB_READONLY) )
{
m_widget = gtk_combo_box_new_with_model( GTK_TREE_MODEL(store) );
}
else
{
m_widget = gtk_combo_box_entry_new_with_model( GTK_TREE_MODEL(store), m_stringCellIndex );
m_entry = GTK_ENTRY(gtk_bin_get_child(GTK_BIN(m_widget)));
gtk_editable_set_editable(GTK_EDITABLE(m_entry), true);
}
g_object_ref(m_widget);
// This must be called as gtk_combo_box_entry_new_with_model adds
// automatically adds one text column.
gtk_cell_layout_clear( GTK_CELL_LAYOUT(m_widget) );
GtkCellRenderer* imageRenderer = gtk_cell_renderer_pixbuf_new();
gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(m_widget),
imageRenderer, FALSE);
gtk_cell_layout_add_attribute( GTK_CELL_LAYOUT(m_widget),
imageRenderer, "pixbuf", 0);
GtkCellRenderer* textRenderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_end( GTK_CELL_LAYOUT(m_widget),
textRenderer, TRUE );
gtk_cell_layout_add_attribute( GTK_CELL_LAYOUT(m_widget),
textRenderer, "text", 1);
}
static struct gopt *gopt_new_str_store(struct gopt_job_view *gjv,
struct fio_option *o, const char *text,
unsigned int idx)
{
struct gopt_str *s;
GtkWidget *label;
s = calloc(1, sizeof(*s));
s->gopt.box = gtk_hbox_new(FALSE, 3);
if (!o->lname)
label = gtk_label_new(o->name);
else
label = gtk_label_new(o->lname);
s->entry = gtk_entry_new();
gopt_mark_index(gjv, &s->gopt, idx, GOPT_STR);
gtk_editable_set_editable(GTK_EDITABLE(s->entry), 1);
if (text)
gopt_str_store_set_val(s, text);
else if (o->def)
gopt_str_store_set_val(s, o->def);
s->gopt.sig_handler = g_signal_connect(G_OBJECT(s->entry), "changed", G_CALLBACK(gopt_str_changed), s);
g_signal_connect(G_OBJECT(s->entry), "destroy", G_CALLBACK(gopt_str_destroy), s);
gtk_box_pack_start(GTK_BOX(s->gopt.box), s->entry, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(s->gopt.box), label, FALSE, FALSE, 0);
return &s->gopt;
}
/*
* Creates the components needed to edit the extra properties of this widget.
*/
static void
gb_radio_tool_button_create_properties (GtkWidget * widget, GbWidgetCreateArgData * data)
{
GtkWidget *combo;
property_add_stock_item (StockButton, _("Stock Button:"),
_("The stock button to use"),
GTK_ICON_SIZE_LARGE_TOOLBAR);
property_add_text (Label, _("Label:"), _("The text to display"), 2);
property_add_icon (Icon, _("Icon:"),
_("The icon to display"),
GTK_ICON_SIZE_LARGE_TOOLBAR);
property_add_combo (Group, _("Group:"),
_("The radio tool button group (the default is all radio tool buttons in the toolbar)"),
NULL);
combo = property_get_value_widget (Group);
gtk_editable_set_editable (GTK_EDITABLE (GTK_COMBO (combo)->entry), FALSE);
property_add_bool (Active, _("Initially On:"),
_("If the radio button is initially on"));
property_add_bool (VisibleHorz, _("Show Horizontal:"),
_("If the item is visible when the toolbar is horizontal"));
property_add_bool (VisibleVert, _("Show Vertical:"),
_("If the item is visible when the toolbar is vertical"));
property_add_bool (IsImportant, _("Is Important:"),
_("If the item's text should be shown when the toolbar's mode is GTK_TOOLBAR_BOTH_HORIZ"));
}
ZLGtkSelectionDialog::ZLGtkSelectionDialog(const char *caption, ZLTreeHandler &handler) : ZLSelectionDialog(handler) {
myExitFlag = false;
myNodeSelected = false;
myDialog = createGtkDialog(caption);
std::string okString = gtkButtonName(ZLDialogManager::OK_BUTTON);
std::string cancelString = gtkButtonName(ZLDialogManager::CANCEL_BUTTON);
gtk_dialog_add_button(myDialog, okString.c_str(), GTK_RESPONSE_ACCEPT);
gtk_dialog_add_button(myDialog, cancelString.c_str(), GTK_RESPONSE_REJECT);
myStateLine = GTK_ENTRY(gtk_entry_new());
gtk_editable_set_editable(GTK_EDITABLE(myStateLine), !this->handler().isOpenHandler());
gtk_widget_set_sensitive(GTK_WIDGET(myStateLine), !this->handler().isOpenHandler());
gtk_box_pack_start(GTK_BOX(myDialog->vbox), GTK_WIDGET(myStateLine), false, false, 2);
gtk_widget_show(GTK_WIDGET(myStateLine));
myStore = gtk_list_store_new(3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT);
myView = GTK_TREE_VIEW(gtk_tree_view_new_with_model(GTK_TREE_MODEL(myStore)));
gtk_object_set_user_data(GTK_OBJECT(myView), this);
gtk_tree_view_set_headers_visible(myView, false);
GtkTreeSelection *selection = gtk_tree_view_get_selection(myView);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
// MSS: in case we do not want single click navigation, comment out the line below
g_signal_connect(myView, "button-press-event", G_CALLBACK(clickHandler), this);
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
column = gtk_tree_view_column_new();
gtk_tree_view_insert_column(myView, column, -1);
gtk_tree_view_column_set_resizable(column, true);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, false);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 0);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, true);
gtk_tree_view_column_add_attribute(column, renderer, "text", 1);
g_signal_connect(myView, "row-activated", G_CALLBACK(activatedHandler), 0);
GtkWidget *scrolledWindow = gtk_scrolled_window_new(0, 0);
gtk_container_add(GTK_CONTAINER(scrolledWindow), GTK_WIDGET(myView));
gtk_box_pack_start(GTK_BOX(myDialog->vbox), scrolledWindow, true, true, 2);
gtk_widget_show_all(scrolledWindow);
gtk_widget_grab_focus(GTK_WIDGET(myView));
gtk_window_resize(GTK_WINDOW(myDialog), 1000, 1000);
update();
}
static void cache_manager_render_dialog(GtkWidget *widget, const gchar *path)
{
CleanData *cd;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *button;
cd = g_new0(CleanData, 1);
cd->gd = generic_dialog_new(_("Create thumbnails"),
"create_thumbnails",
widget, FALSE,
NULL, cd);
gtk_window_set_default_size(GTK_WINDOW(cd->gd->dialog), PURGE_DIALOG_WIDTH, -1);
cd->gd->cancel_cb = cache_manager_render_close_cb;
cd->button_close = generic_dialog_add_button(cd->gd, GTK_STOCK_CLOSE, NULL,
cache_manager_render_close_cb, FALSE);
cd->button_start = generic_dialog_add_button(cd->gd, GTK_STOCK_OK, _("S_tart"),
cache_manager_render_start_cb, FALSE);
cd->button_stop = generic_dialog_add_button(cd->gd, GTK_STOCK_STOP, NULL,
cache_manager_render_stop_cb, FALSE);
gtk_widget_set_sensitive(cd->button_stop, FALSE);
generic_dialog_add_message(cd->gd, NULL, _("Create thumbnails"), NULL);
hbox = pref_box_new(cd->gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, 0);
pref_spacer(hbox, PREF_PAD_INDENT);
cd->group = pref_box_new(hbox, TRUE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
hbox = pref_box_new(cd->group, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
pref_label_new(hbox, _("Folder:"));
label = tab_completion_new(&cd->entry, path, NULL, NULL);
tab_completion_add_select_button(cd->entry,_("Select folder") , TRUE);
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
gtk_widget_show(label);
pref_checkbox_new_int(cd->group, _("Include subfolders"), FALSE, &cd->recurse);
button = pref_checkbox_new_int(cd->group, _("Store thumbnails local to source images"), FALSE, &cd->local);
gtk_widget_set_sensitive(button, options->thumbnails.spec_standard);
pref_line(cd->gd->vbox, PREF_PAD_SPACE);
hbox = pref_box_new(cd->gd->vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
cd->progress = gtk_entry_new();
GTK_WIDGET_UNSET_FLAGS(cd->progress, GTK_CAN_FOCUS);
gtk_editable_set_editable(GTK_EDITABLE(cd->progress), FALSE);
gtk_entry_set_text(GTK_ENTRY(cd->progress), _("click start to begin"));
gtk_box_pack_start(GTK_BOX(hbox), cd->progress, TRUE, TRUE, 0);
gtk_widget_show(cd->progress);
cd->spinner = spinner_new(NULL, -1);
gtk_box_pack_start(GTK_BOX(hbox), cd->spinner, FALSE, FALSE, 0);
gtk_widget_show(cd->spinner);
cd->list = NULL;
gtk_widget_show(cd->gd->dialog);
}
void
vol_create_gui(volume_t * vol) {
GtkWidget * label;
GtkWidget * vbox;
GtkWidget * hbox;
++vol_slot_count;
if (vol_window == NULL) {
create_volume_window();
}
vbox = gtk_bin_get_child(GTK_BIN(vol_window));
vol->slot = gtk_table_new(4, 3, FALSE);
gtk_box_pack_start(GTK_BOX(vbox), vol->slot, FALSE, FALSE, 0);
gtk_table_attach(GTK_TABLE(vol->slot), gtk_hseparator_new(), 0, 3, 0, 1,
GTK_FILL, GTK_FILL, 5, 5);
hbox = gtk_hbox_new(FALSE, 0);
label = gtk_label_new(_("File:"));
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_table_attach(GTK_TABLE(vol->slot), hbox, 0, 1, 1, 2,
GTK_FILL, GTK_FILL, 5, 5);
vol->file_entry = gtk_entry_new();
gtk_editable_set_editable(GTK_EDITABLE(vol->file_entry), FALSE);
gtk_table_attach(GTK_TABLE(vol->slot), vol->file_entry, 1, 2, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_FILL, 5, 5);
vol->pause_button = gtk_button_new_with_label(_("Pause"));
g_signal_connect(vol->pause_button, "clicked", G_CALLBACK(vol_pause_event), vol);
gtk_table_attach(GTK_TABLE(vol->slot), vol->pause_button, 2, 3, 1, 2,
GTK_FILL, GTK_FILL, 5, 5);
hbox = gtk_hbox_new(FALSE, 0);
label = gtk_label_new(_("Progress:"));
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_table_attach(GTK_TABLE(vol->slot), hbox, 0, 1, 2, 3,
GTK_FILL, GTK_FILL, 5, 5);
vol->progress = gtk_progress_bar_new();
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(vol->progress), 0.0f);
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(vol->progress), "0.0%");
gtk_table_attach(GTK_TABLE(vol->slot), vol->progress, 1, 2, 2, 3,
GTK_EXPAND | GTK_FILL, GTK_FILL, 5, 5);
vol->cancel_button = gui_stock_label_button (_("Abort"), GTK_STOCK_CANCEL);
g_signal_connect(vol->cancel_button, "clicked", G_CALLBACK(vol_cancel_event), vol);
gtk_table_attach(GTK_TABLE(vol->slot), vol->cancel_button, 2, 3, 2, 3,
GTK_FILL, GTK_FILL, 5, 5);
gtk_table_attach(GTK_TABLE(vol->slot), gtk_hseparator_new(), 0, 3, 3, 4,
GTK_FILL, GTK_FILL, 5, 5);
gtk_widget_show_all(vol->slot);
}
static void set_entry_str_from_field (GtkWidget * widget, const Tuple * tuple,
gint fieldn, gboolean editable)
{
const gchar * text = tuple_get_string (tuple, fieldn, NULL);
gtk_entry_set_text ((GtkEntry *) widget, text != NULL ? text : "");
gtk_editable_set_editable ((GtkEditable *) widget, editable);
}
static void gui_init_hash_funcs(void)
{
for (int i = 0; i < HASH_FUNCS_N; i++) {
// File/Text view func labels
char *label = g_strdup_printf("%s:", hash.funcs[i].name);
gui.hash_widgets[i].label = GTK_LABEL(gtk_label_new(label));
g_free(label);
gtk_container_add(GTK_CONTAINER(gui.vbox_outputlabels),
GTK_WIDGET(gui.hash_widgets[i].label));
gtk_misc_set_alignment(GTK_MISC(gui.hash_widgets[i].label),
// Left align
0.0, 0.5);
// File view digests
gui.hash_widgets[i].entry_file = GTK_ENTRY(gtk_entry_new());
gtk_container_add(GTK_CONTAINER(gui.vbox_digests_file),
GTK_WIDGET(gui.hash_widgets[i].entry_file));
gtk_editable_set_editable(GTK_EDITABLE(gui.hash_widgets[i].entry_file), false);
// Text view digests
gui.hash_widgets[i].entry_text = GTK_ENTRY(gtk_entry_new());
gtk_container_add(GTK_CONTAINER(gui.vbox_digests_text),
GTK_WIDGET(gui.hash_widgets[i].entry_text));
gtk_editable_set_editable(GTK_EDITABLE(gui.hash_widgets[i].entry_text), false);
// File list treeview popup menu
gui.hash_widgets[i].menuitem_treeview_copy =
GTK_MENU_ITEM(gtk_menu_item_new_with_label(hash.funcs[i].name));
gtk_menu_shell_append(GTK_MENU_SHELL(gui.menu_treeview_copy),
GTK_WIDGET(gui.hash_widgets[i].menuitem_treeview_copy));
// Dialog checkbuttons
gui.hash_widgets[i].button = GTK_TOGGLE_BUTTON(
gtk_check_button_new_with_label(hash.funcs[i].name));
gtk_widget_set_sensitive(GTK_WIDGET(gui.hash_widgets[i].button),
hash.funcs[i].supported);
gtk_table_attach_defaults(gui.dialog_table,
GTK_WIDGET(gui.hash_widgets[i].button),
// Sort checkbuttons into 2 columns
i % 2 ? 1 : 0,
i % 2 ? 2 : 1,
i / 2,
i / 2 + 1);
gtk_widget_show(GTK_WIDGET(gui.hash_widgets[i].button));
}
}
// Show the popup preferences dialog.
void show_pref_dialog() {
if (pref_dialog) {
return;
}
pref_dialog = gtk_dialog_new_with_buttons("gatotray Settings", NULL, 0,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, GTK_STOCK_SAVE,
GTK_RESPONSE_ACCEPT, NULL);
//~ gtk_window_set_icon_name(GTK_WINDOW(pref_dialog), GTK_STOCK_PREFERENCES);
g_signal_connect(G_OBJECT(pref_dialog), "response", G_CALLBACK(pref_response), NULL);
g_signal_connect(G_OBJECT(pref_dialog), "destroy", G_CALLBACK(pref_destroyed), NULL);
GtkWidget *vb = gtk_dialog_get_content_area(GTK_DIALOG(pref_dialog));
GtkWidget *hb = gtk_hbox_new(FALSE, 0);
GtkWidget *wb = gtk_hbox_new(FALSE, 0); // full width text entry for command.
gtk_container_add(GTK_CONTAINER(vb), hb);
gtk_container_add(GTK_CONTAINER(vb), wb); // add command to main container.
GtkWidget *frame = gtk_frame_new("Colors");
gtk_container_add(GTK_CONTAINER(hb), frame);
vb = gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(frame), vb);
// Add the color pickers to the color options frame.
for (PrefColor* c = pref_colors; c < pref_colors + G_N_ELEMENTS(pref_colors); c++) {
GtkWidget *hb = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(vb), hb);
gtk_container_add(GTK_CONTAINER(hb), gtk_label_new(c->description));
GtkWidget *cbutton = gtk_color_button_new_with_color(c->color);
g_signal_connect(G_OBJECT(cbutton), "color-set", G_CALLBACK(gtk_color_button_get_color), c->color);
g_signal_connect_after(G_OBJECT(cbutton), "color-set", G_CALLBACK(preferences_changed), c);
gtk_box_pack_start(GTK_BOX(hb), cbutton, FALSE, FALSE, 0);
}
frame = gtk_frame_new("Options");
gtk_container_add(GTK_CONTAINER(hb), frame);
vb = gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(frame), vb);
// Add the transparent background checkbox.
GtkWidget *cbutton = gtk_check_button_new_with_label("Transparent Background");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cbutton), pref_transparent);
g_signal_connect(G_OBJECT(cbutton), "toggled", G_CALLBACK(on_transparency_toggled), NULL);
gtk_box_pack_start(GTK_BOX(vb), cbutton, FALSE, FALSE, 0);
frame = gtk_frame_new("Command run when tray icon is clicked:"); // create command frame.
gtk_container_add(GTK_CONTAINER(wb), frame); // add command frame to full-width container.
vb = gtk_hbox_new(FALSE, 0); // create the text box for entering command.
gtk_container_add(GTK_CONTAINER(frame), vb); // add the command text box to the command frame.
GtkWidget *entry = gtk_entry_new_with_max_length(255); // new text entry widget.
gtk_entry_set_text(GTK_ENTRY(entry), pref_command); // set text to loaded value of command.
gtk_editable_set_editable(GTK_EDITABLE(entry), TRUE); // make it user editable.
gtk_entry_set_visibility(GTK_ENTRY(entry), TRUE); // make it visible.
g_signal_connect(G_OBJECT(entry), "changed", G_CALLBACK(on_command_changed), NULL);
gtk_box_pack_start(GTK_BOX(vb), entry, TRUE, TRUE, 0);
gtk_widget_show_all(GTK_WIDGET(pref_dialog));
}
/*!
\brief prevents a entry from being editable
\param widget is the pointer to Comboboxentry where we want to lock the entry
*/
G_MODULE_EXPORT void lock_entry(GtkWidget *widget)
{
GtkComboBox *box = GTK_COMBO_BOX(widget);
GtkEntry *entry = NULL;
entry = GTK_ENTRY (gtk_bin_get_child(GTK_BIN (box)));
if (GTK_IS_ENTRY(entry))
gtk_editable_set_editable(GTK_EDITABLE(entry),FALSE);
gtk_combo_box_set_active(GTK_COMBO_BOX(widget),0);
}
static int gtkListSetReadOnlyAttrib(Ihandle* ih, const char* value)
{
GtkEntry* entry;
if (!ih->data->has_editbox)
return 0;
entry = (GtkEntry*)iupAttribGet(ih, "_IUPGTK_ENTRY");
gtk_editable_set_editable(GTK_EDITABLE(entry), !iupStrBoolean(value));
return 0;
}
static void _check_combo_box (AtkObject *obj)
{
static gboolean done = FALSE;
static gboolean done_selection = FALSE;
AtkRole role;
role = atk_object_get_role (obj);
if (role == ATK_ROLE_FRAME)
{
AtkRole roles[NUM_VALID_ROLES];
AtkObject *combo_obj;
if (done_selection)
return;
roles[0] = ATK_ROLE_COMBO_BOX;
combo_obj = find_object_by_role (obj, roles, NUM_VALID_ROLES);
if (combo_obj)
{
if (!done_selection)
{
done_selection = TRUE;
}
if (g_getenv ("TEST_ACCESSIBLE_COMBO_NOEDIT") != NULL)
{
GtkWidget *combo;
GtkEntry *entry;
combo = gtk_accessible_get_widget (GTK_ACCESSIBLE (combo_obj));
entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (combo)));
gtk_editable_set_editable (GTK_EDITABLE (entry), FALSE);
}
_check_children (combo_obj);
_test_selection (combo_obj);
}
return;
}
if (role != ATK_ROLE_COMBO_BOX)
return;
g_print ("*** Start ComboBox ***\n");
_check_children (obj);
if (!done)
{
g_idle_add ((GSourceFunc)_open_combo_list, obj);
done = TRUE;
}
else
return;
g_print ("*** End ComboBox ***\n");
}
static char *mt_new_connection_dialog(multitracker_t *mt, int *port_num, int *error)
{
GtkWidget *dialog = gtk_dialog_new_with_buttons(
"Connect to a Veejay",
GTK_WINDOW( mt->main_window ),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
NULL );
GtkWidget *text_entry = gtk_entry_new();
gtk_entry_set_text( GTK_ENTRY(text_entry), "localhost" );
gtk_editable_set_editable( GTK_EDITABLE(text_entry), TRUE );
gtk_dialog_set_default_response( GTK_DIALOG(dialog), GTK_RESPONSE_REJECT );
gtk_window_set_resizable( GTK_WINDOW( dialog ), FALSE );
gint base = DEFAULT_PORT_NUM;
gint p = (1000 * (mt->selected)) + base;
GtkObject *adj = gtk_adjustment_new( p,1024,65535,5,10,0);
GtkWidget *num_entry = gtk_spin_button_new( GTK_ADJUSTMENT(adj), 5.0, 0 );
GtkWidget *text_label = gtk_label_new( "Hostname" );
GtkWidget *num_label = gtk_label_new( "Port" );
g_signal_connect( G_OBJECT(dialog), "response",
G_CALLBACK( gtk_widget_hide ), G_OBJECT( dialog ) );
GtkWidget *vbox = gtk_vbox_new( FALSE, 4 );
gtk_container_add( GTK_CONTAINER( vbox ), text_label );
gtk_container_add( GTK_CONTAINER( vbox ), text_entry );
gtk_container_add( GTK_CONTAINER( vbox ), num_label );
gtk_container_add( GTK_CONTAINER( vbox ), num_entry );
gtk_container_add( GTK_CONTAINER( GTK_DIALOG(dialog)->vbox), vbox );
gtk_widget_show_all( dialog );
gint res = gtk_dialog_run( GTK_DIALOG(dialog) );
if( res == GTK_RESPONSE_ACCEPT )
{
const char *host = gtk_entry_get_text( GTK_ENTRY( text_entry ) );
gint port = gtk_spin_button_get_value( GTK_SPIN_BUTTON(num_entry ));
*port_num = port;
*error = 0;
return strdup(host);
}
gtk_widget_destroy( dialog );
*error = res;
*port_num = 0;
return NULL;
}
void roadmap_main_add_status (void) {
RoadMapMainStatus = gtk_entry_new ();
gtk_editable_set_editable (GTK_EDITABLE(RoadMapMainStatus), FALSE);
gtk_entry_set_text (GTK_ENTRY(RoadMapMainStatus), "Initializing..");
gtk_box_pack_end (GTK_BOX(RoadMapMainBox),
RoadMapMainStatus, FALSE, FALSE, 0);
}
static void set_entry_str_from_field (GtkWidget * widget, const Tuple * tuple,
int fieldn, bool_t editable)
{
char * text = tuple_get_str (tuple, fieldn, NULL);
gtk_entry_set_text ((GtkEntry *) widget, text != NULL ? text : "");
gtk_editable_set_editable ((GtkEditable *) widget, editable);
str_unref (text);
}
static void
set_editable (GdauiEntryWrapper *mgwrap, gboolean editable)
{
GdauiEntryString *mgstr;
g_return_if_fail (GDAUI_IS_ENTRY_STRING (mgwrap));
mgstr = GDAUI_ENTRY_STRING (mgwrap);
GdauiEntryStringPrivate *priv = gdaui_entry_string_get_instance_private (mgstr);
gtk_editable_set_editable (GTK_EDITABLE (priv->entry), editable);
gtk_text_view_set_editable (GTK_TEXT_VIEW (priv->view), editable);
}
static void on_log_button_toggled (GtkWidget *widget, gpointer data) {
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) {
gtk_editable_set_editable( GTK_EDITABLE(mb_gui.entry_log), FALSE );
const gchar *log_file_name = gtk_entry_get_text (GTK_ENTRY (mb_gui.entry_log));
GError* my_err = NULL;
mb_state.log_channel = g_io_channel_new_file (log_file_name, "w", &my_err);
GString* static_name = g_string_sized_new(128);
g_string_printf(static_name,"%s%s", log_file_name, "_static");
mb_state.log_channel_static = g_io_channel_new_file (static_name->str, "w", &my_err);
g_string_free(static_name, TRUE);
}
else {
gtk_editable_set_editable( GTK_EDITABLE(mb_gui.entry_log), TRUE );
if (mb_state.log_channel) {
g_io_channel_close(mb_state.log_channel);
g_io_channel_close(mb_state.log_channel_static);
mb_state.log_channel = NULL;
mb_state.log_channel_static = NULL;
}
}
}
/*
* set the page readonly
*/
void tpage_set_readonly(gboolean readonly)
{
gtk_editable_set_editable (GTK_EDITABLE (targetname), !readonly);
gtk_text_view_set_editable (GTK_TEXT_VIEW (textview), !readonly);
g_object_set (renderer_name, "editable", !readonly, NULL);
gtk_widget_set_sensitive (loadbtn, tpage_have_config() && !readonly);
gtk_widget_set_sensitive (clearbtn, !readonly);
gtk_widget_set_sensitive (button_browse, !readonly);
gtk_widget_set_sensitive (cmb_debugger, !readonly);
page_read_only = readonly;
}
GtkWidget *snd_gtk_entry_label_new(const char *label, GdkColor *color)
{
GtkWidget *rlw;
rlw = gtk_entry_new();
gtk_entry_set_has_frame(GTK_ENTRY(rlw), false);
if (label) gtk_entry_set_text(GTK_ENTRY(rlw), label);
gtk_editable_set_editable(GTK_EDITABLE(rlw), false);
GTK_WIDGET_UNSET_FLAGS(GTK_WIDGET(rlw), GTK_CAN_FOCUS); /* turn off the $%#@$! blinking cursor */
gtk_widget_modify_base(rlw, GTK_STATE_NORMAL, color);
gtk_widget_modify_base(rlw, GTK_STATE_ACTIVE, color);
return(rlw);
}
static void
stlink_gui_set_connected (STlinkGUI *gui)
{
gchar *tmp_str;
GtkListStore *store;
GtkTreeIter iter;
gtk_statusbar_push (gui->statusbar,
gtk_statusbar_get_context_id (gui->statusbar, "conn"),
"Connected");
gtk_widget_set_sensitive (GTK_WIDGET (gui->device_frame), TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (gui->devmem_box), TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (gui->connect_button), FALSE);
if (gui->filename) {
gtk_widget_set_sensitive (GTK_WIDGET (gui->flash_button), TRUE);
}
tmp_str = dev_format_chip_id (gui->sl->chip_id);
gtk_label_set_text (gui->chip_id_label, tmp_str);
g_free (tmp_str);
tmp_str = g_strdup_printf ("0x%x", gui->sl->core_id);
gtk_label_set_text (gui->core_id_label, tmp_str);
g_free (tmp_str);
tmp_str = dev_format_mem_size (gui->sl->flash_size);
gtk_label_set_text (gui->flash_size_label, tmp_str);
g_free (tmp_str);
tmp_str = dev_format_mem_size (gui->sl->sram_size);
gtk_label_set_text (gui->ram_size_label, tmp_str);
g_free (tmp_str);
tmp_str = g_strdup_printf ("0x%08X", gui->sl->flash_base);
gtk_entry_set_text (gui->devmem_jmp_entry, tmp_str);
gtk_editable_set_editable (GTK_EDITABLE (gui->devmem_jmp_entry), TRUE);
g_free (tmp_str);
store = GTK_LIST_STORE (gtk_tree_view_get_model (gui->devmem_treeview));
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter)) {
gtk_list_store_clear (store);
}
stlink_gui_set_sensitivity (gui, FALSE);
gtk_notebook_set_current_page (gui->notebook, PAGE_DEVMEM);
gtk_widget_show (GTK_WIDGET (gui->progress.bar));
gtk_progress_bar_set_text (gui->progress.bar, "Reading memory");
g_thread_new ("devmem", (GThreadFunc) stlink_gui_populate_devmem_view, gui);
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// init_data
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
void init_data(void)
{
// Bring globals into scope
extern GladeXML * gui;
// Locals
int BUFFER_SIZE = 7;
// update splash screen status
splash_status("Initializing Data...");
// Local variables
char bs_buffer[BUFFER_SIZE];
char cc_buffer[BUFFER_SIZE];
char cp_buffer[BUFFER_SIZE];
char dp_buffer[BUFFER_SIZE];
char fs_buffer[BUFFER_SIZE];
// Load data into text buffers
g_snprintf(fs_buffer,BUFFER_SIZE,"%d",DEFAULT_FS);
g_snprintf(bs_buffer,BUFFER_SIZE,"%d",DEFAULT_BLOCKSIZE);
g_snprintf(cc_buffer,BUFFER_SIZE,"%d",NUMBER_OF_CHANNELS);
g_snprintf(cp_buffer,BUFFER_SIZE,"%d",DEFAULT_CP);
g_snprintf(dp_buffer,BUFFER_SIZE,"%d",DEFAULT_DP);
// Set amp indicator
gtk_image_set_from_file(GTK_IMAGE(glade_xml_get_widget(gui, "amp_indicator")), "../res/gui/img/noamp.jpg");
// Update GUI text boxes
gtk_entry_set_text(GTK_ENTRY(glade_xml_get_widget(gui, "Fs_view")),fs_buffer);
gtk_entry_set_text(GTK_ENTRY(glade_xml_get_widget(gui, "Bs_view")),bs_buffer);
gtk_entry_set_text(GTK_ENTRY(glade_xml_get_widget(gui, "number_of_channels_view")),cc_buffer);
gtk_entry_set_text(GTK_ENTRY(glade_xml_get_widget(gui, "sequence_filename")),"sequences.txt");
gtk_entry_set_text(GTK_ENTRY(glade_xml_get_widget(gui, "control_port_view")),cp_buffer);
gtk_entry_set_text(GTK_ENTRY(glade_xml_get_widget(gui, "data_port_view")),dp_buffer);
gtk_editable_set_editable(GTK_EDITABLE(glade_xml_get_widget(gui, "control_port_view")),FALSE);
gtk_editable_set_editable(GTK_EDITABLE(glade_xml_get_widget(gui, "data_port_view")),FALSE);
}
