/* * display the initial menu to setup global options * at startup. */ static void gtkui_setup(void) { GtkTextIter iter; GtkWidget *item, *vbox, *scroll, *vpaned, *logo; GtkItemFactory *item_factory; GClosure *closure = NULL; GdkModifierType mods; gint keyval, width, height, left, top; char *path = NULL; GtkItemFactoryEntry file_menu[] = { { "/_File", "<shift>F", NULL, 0, "<Branch>" }, { "/File/_Open", "<control>O", gtkui_file_open, 0, "<StockItem>", GTK_STOCK_OPEN }, { "/File/_Save", "<control>S", gtkui_file_write, 0, "<StockItem>", GTK_STOCK_SAVE }, { "/File/sep1", NULL, NULL, 0, "<Separator>" }, { "/File/E_xit", "<control>x", gtkui_exit, 0, "<StockItem>", GTK_STOCK_QUIT }, { "/_Sniff", "<shift>S", NULL, 0, "<Branch>" }, { "/Sniff/Unified sniffing...", "<shift>U", gtkui_unified_sniff, 0, "<StockItem>", GTK_STOCK_DND }, { "/Sniff/Bridged sniffing...", "<shift>B", gtkui_bridged_sniff, 0, "<StockItem>", GTK_STOCK_DND_MULTIPLE }, { "/Sniff/sep2", NULL, NULL, 0, "<Separator>" }, { "/Sniff/Set pcap filter...", "p", gtkui_pcap_filter, 0, "<StockItem>", GTK_STOCK_PREFERENCES }, { "/_Options", "<shift>O", NULL, 0, "<Branch>" }, { "/Options/Unoffensive", NULL, toggle_unoffensive, 0, "<ToggleItem>" }, { "/Options/Promisc mode", NULL, toggle_nopromisc, 0, "<ToggleItem>" }, { "/Options/Set netmask", "n", gtkui_set_netmask, 0, "<Item>"} #ifndef OS_WINDOWS ,{"/_?", NULL, NULL, 0, "<Branch>" }, {"/?/Contents", " ", gtkui_help, 0, "<StockItem>", GTK_STOCK_HELP } #endif }; gint nmenu_items = sizeof (file_menu) / sizeof (file_menu[0]); DEBUG_MSG("gtkui_setup"); width = gtkui_conf_get("window_width"); height = gtkui_conf_get("window_height"); left = gtkui_conf_get("window_left"); top = gtkui_conf_get("window_top"); /* create menu window */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW (window), EC_PROGRAM" "EC_VERSION); gtk_window_set_default_size(GTK_WINDOW (window), width, height); if(left > 0 || top > 0) gtk_window_move(GTK_WINDOW(window), left, top); g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (gtkui_exit), NULL); accel_group = gtk_accel_group_new (); item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group); gtk_item_factory_create_items (item_factory, nmenu_items, file_menu, NULL); /* hidden shortcut to start Unified Sniffing with default interface */ closure = g_cclosure_new(G_CALLBACK(gtkui_unified_sniff_default), NULL, NULL); gtk_accelerator_parse ("u", &keyval, &mods); gtk_accel_group_connect(accel_group, keyval, mods, 0, closure); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER (window), vbox); gtk_widget_show(vbox); main_menu = gtk_item_factory_get_widget (item_factory, "<main>"); gtk_box_pack_start(GTK_BOX(vbox), main_menu, FALSE, FALSE, 0); gtk_window_add_accel_group (GTK_WINDOW (window), accel_group); gtk_widget_show(main_menu); if(GBL_PCAP->promisc) { /* setting the menu item active will toggle this setting */ /* it will be TRUE after the menu is updated */ GBL_PCAP->promisc = 0; item = gtk_item_factory_get_item(item_factory, "/Options/Promisc mode"); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM (item), TRUE); } if(GBL_OPTIONS->unoffensive) { GBL_OPTIONS->unoffensive = 0; item = gtk_item_factory_get_item(item_factory, "/Options/Unoffensive"); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM (item), TRUE); } vpaned = gtk_vpaned_new(); /* notebook for MDI pages */ notebook_frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME (notebook_frame), GTK_SHADOW_IN); gtk_paned_pack1(GTK_PANED(vpaned), notebook_frame, TRUE, TRUE); gtk_widget_show(notebook_frame); path = INSTALL_DATADIR "/" EC_PROGRAM "/" LOGO_FILE; if(g_file_test(path, G_FILE_TEST_EXISTS)) logo = gtk_image_new_from_file(path); else /* if neither path is valid gtk will use a broken image icon */ logo = gtk_image_new_from_file("./share/" LOGO_FILE); gtk_misc_set_alignment (GTK_MISC (logo), 0.5, 0.5); gtk_container_add(GTK_CONTAINER (notebook_frame), logo); gtk_widget_show(logo); /* messages */ scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (scroll), GTK_SHADOW_IN); gtk_paned_pack2(GTK_PANED (vpaned), scroll, FALSE, TRUE); gtk_widget_show(scroll); textview = gtk_text_view_new(); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW (textview), GTK_WRAP_WORD_CHAR); gtk_text_view_set_editable(GTK_TEXT_VIEW (textview), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW (textview), FALSE); gtk_widget_set_size_request(textview, -1, 140); gtk_container_add(GTK_CONTAINER (scroll), textview); gtk_widget_show(textview); msgbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW (textview)); gtk_text_buffer_get_end_iter(msgbuffer, &iter); endmark = gtk_text_buffer_create_mark(msgbuffer, "end", &iter, FALSE); gtk_box_pack_end(GTK_BOX(vbox), vpaned, TRUE, TRUE, 0); gtk_widget_show(vpaned); gtk_widget_show(window); DEBUG_MSG("gtk_setup: end"); }
bool wxRadioBox::Create( wxWindow *parent, wxWindowID id, const wxString& title, const wxPoint &pos, const wxSize &size, int n, const wxString choices[], int majorDim, long style, const wxValidator& validator, const wxString &name ) { if (!PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, validator, name )) { wxFAIL_MSG( wxT("wxRadioBox creation failed") ); return false; } m_widget = gtk_frame_new(NULL); SetLabel(title); if ( HasFlag(wxNO_BORDER) ) { // If we don't do this here, the wxNO_BORDER style is ignored in Show() gtk_frame_set_shadow_type(GTK_FRAME(m_widget), GTK_SHADOW_NONE); } // majorDim may be 0 if all trailing parameters were omitted, so don't // assert here but just use the correct value for it SetMajorDim(majorDim == 0 ? n : majorDim, style); unsigned int num_of_cols = GetColumnCount(); unsigned int num_of_rows = GetRowCount(); GtkRadioButton *m_radio = (GtkRadioButton*) NULL; GtkWidget *table = gtk_table_new( num_of_rows, num_of_cols, FALSE ); gtk_table_set_col_spacings( GTK_TABLE(table), 1 ); gtk_table_set_row_spacings( GTK_TABLE(table), 1 ); gtk_widget_show( table ); gtk_container_add( GTK_CONTAINER(m_widget), table ); wxString label; GSList *radio_button_group = (GSList *) NULL; for (int i = 0; i < n; i++) { if ( i != 0 ) radio_button_group = gtk_radio_button_group( GTK_RADIO_BUTTON(m_radio) ); label.Empty(); for ( const wxChar *pc = choices[i]; *pc; pc++ ) { if ( *pc != wxT('&') ) label += *pc; } m_radio = GTK_RADIO_BUTTON( gtk_radio_button_new_with_label( radio_button_group, wxGTK_CONV( label ) ) ); gtk_widget_show( GTK_WIDGET(m_radio) ); gtk_signal_connect( GTK_OBJECT(m_radio), "key_press_event", GTK_SIGNAL_FUNC(gtk_radiobox_keypress_callback), (gpointer)this ); m_boxes.Append( (wxObject*) m_radio ); if (HasFlag(wxRA_SPECIFY_COLS)) { int left = i%num_of_cols; int right = (i%num_of_cols) + 1; int top = i/num_of_cols; int bottom = (i/num_of_cols)+1; gtk_table_attach( GTK_TABLE(table), GTK_WIDGET(m_radio), left, right, top, bottom, GTK_FILL, GTK_FILL, 1, 1 ); } else { int left = i/num_of_rows; int right = (i/num_of_rows) + 1; int top = i%num_of_rows; int bottom = (i%num_of_rows)+1; gtk_table_attach( GTK_TABLE(table), GTK_WIDGET(m_radio), left, right, top, bottom, GTK_FILL, GTK_FILL, 1, 1 ); } ConnectWidget( GTK_WIDGET(m_radio) ); if (!i) gtk_toggle_button_set_state( GTK_TOGGLE_BUTTON(m_radio), TRUE ); gtk_signal_connect( GTK_OBJECT(m_radio), "clicked", GTK_SIGNAL_FUNC(gtk_radiobutton_clicked_callback), (gpointer*)this ); gtk_signal_connect( GTK_OBJECT(m_radio), "focus_in_event", GTK_SIGNAL_FUNC(gtk_radiobutton_focus_in), (gpointer)this ); gtk_signal_connect( GTK_OBJECT(m_radio), "focus_out_event", GTK_SIGNAL_FUNC(gtk_radiobutton_focus_out), (gpointer)this ); } m_parent->DoAddChild( this ); PostCreation(size); return true; }
GtkWidget *dt_lib_gui_get_expander(dt_lib_module_t *module) { /* check if module is expandable */ if(!module->expandable(module)) { module->expander = NULL; return NULL; } int bs = DT_PIXEL_APPLY_DPI(12); GtkWidget *header = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); GtkWidget *expander = dtgtk_expander_new(header, module->widget); GtkWidget *header_evb = dtgtk_expander_get_header_event_box(DTGTK_EXPANDER(expander)); GtkWidget *pluginui_frame = dtgtk_expander_get_frame(DTGTK_EXPANDER(expander)); /* setup the header box */ g_signal_connect(G_OBJECT(header_evb), "button-press-event", G_CALLBACK(_lib_plugin_header_button_press), module); /* setup plugin content frame */ gtk_frame_set_shadow_type(GTK_FRAME(pluginui_frame), GTK_SHADOW_IN); /* * initialize the header widgets */ int idx = 0; GtkWidget *hw[5] = { NULL, NULL, NULL, NULL, NULL }; /* add the expand indicator icon */ hw[idx] = dtgtk_icon_new(dtgtk_cairo_paint_solid_arrow, CPF_DIRECTION_LEFT); gtk_widget_set_size_request(GTK_WIDGET(hw[idx++]), bs, bs); /* add module label */ char label[128]; g_snprintf(label, sizeof(label), "<span size=\"larger\">%s</span>", module->name(module)); hw[idx] = gtk_label_new(""); gtk_widget_set_name(hw[idx], "panel_label"); gtk_label_set_markup(GTK_LABEL(hw[idx]), label); gtk_widget_set_tooltip_text(hw[idx], module->name(module)); gtk_label_set_ellipsize(GTK_LABEL(hw[idx++]), PANGO_ELLIPSIZE_MIDDLE); /* add reset button if module has implementation */ if(module->gui_reset) { hw[idx] = dtgtk_button_new(dtgtk_cairo_paint_reset, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER); module->reset_button = GTK_WIDGET(hw[idx]); gtk_widget_set_tooltip_text(hw[idx], _("reset parameters")); g_signal_connect(G_OBJECT(hw[idx]), "clicked", G_CALLBACK(dt_lib_gui_reset_callback), module); } else hw[idx] = gtk_fixed_new(); gtk_widget_set_size_request(GTK_WIDGET(hw[idx++]), bs, bs); /* add preset button if module has implementation */ if(module->get_params) { hw[idx] = dtgtk_button_new(dtgtk_cairo_paint_presets, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER); module->presets_button = GTK_WIDGET(hw[idx]); gtk_widget_set_tooltip_text(hw[idx], _("presets")); g_signal_connect(G_OBJECT(hw[idx]), "clicked", G_CALLBACK(popup_callback), module); } else hw[idx] = gtk_fixed_new(); gtk_widget_set_size_request(GTK_WIDGET(hw[idx++]), bs, bs); /* add a spacer to align buttons with iop buttons (enabled button) */ hw[idx] = gtk_fixed_new(); gtk_widget_set_size_request(GTK_WIDGET(hw[idx++]), bs, bs); /* lets order header elements depending on left/right side panel placement */ int c = module->container(module); if((c == DT_UI_CONTAINER_PANEL_LEFT_TOP) || (c == DT_UI_CONTAINER_PANEL_LEFT_CENTER) || (c == DT_UI_CONTAINER_PANEL_LEFT_BOTTOM)) { for(int i = 0; i <= 4; i++) if(hw[i]) gtk_box_pack_start(GTK_BOX(header), hw[i], i == 1 ? TRUE : FALSE, i == 1 ? TRUE : FALSE, 2); gtk_widget_set_halign(hw[1], GTK_ALIGN_START); dtgtk_icon_set_paint(hw[0], dtgtk_cairo_paint_solid_arrow, CPF_DIRECTION_RIGHT); } else { for(int i = 4; i >= 0; i--) if(hw[i]) gtk_box_pack_start(GTK_BOX(header), hw[i], i == 1 ? TRUE : FALSE, i == 1 ? TRUE : FALSE, 2); gtk_widget_set_halign(hw[1], GTK_ALIGN_END); dtgtk_icon_set_paint(hw[0], dtgtk_cairo_paint_solid_arrow, CPF_DIRECTION_LEFT); } /* add empty space around widget */ gtk_widget_set_margin_start(module->widget, DT_PIXEL_APPLY_DPI(8)); gtk_widget_set_margin_end(module->widget, DT_PIXEL_APPLY_DPI(8)); gtk_widget_set_margin_top(module->widget, DT_PIXEL_APPLY_DPI(8)); gtk_widget_set_margin_bottom(module->widget, DT_PIXEL_APPLY_DPI(8)); gtk_widget_show_all(module->widget); gtk_widget_set_name(pluginui_frame, "lib-plugin-ui"); module->expander = expander; gtk_widget_set_hexpand(module->widget, FALSE); gtk_widget_set_vexpand(module->widget, FALSE); return module->expander; }
/* ----------------------------------------------------------------------------*/ GtkWidget* buildBandUI() { GtkWidget* label; bandFrame=gtk_frame_new("Band"); gtk_widget_modify_bg(bandFrame,GTK_STATE_NORMAL,&background); gtk_widget_modify_fg(gtk_frame_get_label_widget(GTK_FRAME(bandFrame)),GTK_STATE_NORMAL,&white); bandTable=gtk_table_new(4,4,TRUE); // band selection buttonBand1 = gtk_button_new_with_label ("160"); gtk_widget_modify_bg(buttonBand1, GTK_STATE_NORMAL, &bandButtonBackground); label=gtk_bin_get_child((GtkBin*)buttonBand1); gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black); gtk_widget_set_size_request(GTK_WIDGET(buttonBand1),50,25); g_signal_connect(G_OBJECT(buttonBand1),"clicked",G_CALLBACK(bandCallback),NULL); gtk_widget_show(buttonBand1); gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand1,0,1,0,1); buttonBand2 = gtk_button_new_with_label ("80"); gtk_widget_modify_bg(buttonBand2, GTK_STATE_NORMAL, &bandButtonBackground); label=gtk_bin_get_child((GtkBin*)buttonBand2); gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black); gtk_widget_set_size_request(GTK_WIDGET(buttonBand2),50,25); g_signal_connect(G_OBJECT(buttonBand2),"clicked",G_CALLBACK(bandCallback),NULL); gtk_widget_show(buttonBand2); gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand2,1,2,0,1); buttonBand3 = gtk_button_new_with_label ("60"); gtk_widget_modify_bg(buttonBand3, GTK_STATE_NORMAL, &bandButtonBackground); label=gtk_bin_get_child((GtkBin*)buttonBand3); gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black); gtk_widget_set_size_request(GTK_WIDGET(buttonBand3),50,25); g_signal_connect(G_OBJECT(buttonBand3),"clicked",G_CALLBACK(bandCallback),NULL); gtk_widget_show(buttonBand3); gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand3,2,3,0,1); buttonBand4 = gtk_button_new_with_label ("40"); gtk_widget_modify_bg(buttonBand4, GTK_STATE_NORMAL, &bandButtonBackground); label=gtk_bin_get_child((GtkBin*)buttonBand4); gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black); gtk_widget_set_size_request(GTK_WIDGET(buttonBand4),50,25); g_signal_connect(G_OBJECT(buttonBand4),"clicked",G_CALLBACK(bandCallback),NULL); gtk_widget_show(buttonBand4); gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand4,3,4,0,1); buttonBand5 = gtk_button_new_with_label ("30"); gtk_widget_modify_bg(buttonBand5, GTK_STATE_NORMAL, &bandButtonBackground); label=gtk_bin_get_child((GtkBin*)buttonBand5); gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black); gtk_widget_set_size_request(GTK_WIDGET(buttonBand5),50,25); g_signal_connect(G_OBJECT(buttonBand5),"clicked",G_CALLBACK(bandCallback),NULL); gtk_widget_show(buttonBand5); gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand5,0,1,1,2); buttonBand6 = gtk_button_new_with_label ("20"); gtk_widget_modify_bg(buttonBand6, GTK_STATE_NORMAL, &bandButtonBackground); label=gtk_bin_get_child((GtkBin*)buttonBand6); gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black); gtk_widget_set_size_request(GTK_WIDGET(buttonBand6),50,25); g_signal_connect(G_OBJECT(buttonBand6),"clicked",G_CALLBACK(bandCallback),NULL); gtk_widget_show(buttonBand6); gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand6,1,2,1,2); buttonBand7 = gtk_button_new_with_label ("17"); gtk_widget_modify_bg(buttonBand7, GTK_STATE_NORMAL, &bandButtonBackground); label=gtk_bin_get_child((GtkBin*)buttonBand7); gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black); gtk_widget_set_size_request(GTK_WIDGET(buttonBand7),50,25); g_signal_connect(G_OBJECT(buttonBand7),"clicked",G_CALLBACK(bandCallback),NULL); gtk_widget_show(buttonBand7); gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand7,2,3,1,2); buttonBand8 = gtk_button_new_with_label ("15"); gtk_widget_modify_bg(buttonBand8, GTK_STATE_NORMAL, &bandButtonBackground); label=gtk_bin_get_child((GtkBin*)buttonBand8); gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black); gtk_widget_set_size_request(GTK_WIDGET(buttonBand8),50,25); g_signal_connect(G_OBJECT(buttonBand8),"clicked",G_CALLBACK(bandCallback),NULL); gtk_widget_show(buttonBand8); gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand8,3,4,1,2); buttonBand9 = gtk_button_new_with_label ("12"); gtk_widget_modify_bg(buttonBand9, GTK_STATE_NORMAL, &bandButtonBackground); label=gtk_bin_get_child((GtkBin*)buttonBand9); gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black); gtk_widget_set_size_request(GTK_WIDGET(buttonBand9),50,25); g_signal_connect(G_OBJECT(buttonBand9),"clicked",G_CALLBACK(bandCallback),NULL); gtk_widget_show(buttonBand9); gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand9,0,1,2,3); buttonBand10 = gtk_button_new_with_label ("10"); gtk_widget_modify_bg(buttonBand10, GTK_STATE_NORMAL, &bandButtonBackground); label=gtk_bin_get_child((GtkBin*)buttonBand10); gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black); gtk_widget_set_size_request(GTK_WIDGET(buttonBand10),50,25); g_signal_connect(G_OBJECT(buttonBand10),"clicked",G_CALLBACK(bandCallback),NULL); gtk_widget_show(buttonBand10); gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand10,1,2,2,3); buttonBand11 = gtk_button_new_with_label ("6"); gtk_widget_modify_bg(buttonBand11, GTK_STATE_NORMAL, &bandButtonBackground); label=gtk_bin_get_child((GtkBin*)buttonBand11); gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black); gtk_widget_set_size_request(GTK_WIDGET(buttonBand11),50,25); g_signal_connect(G_OBJECT(buttonBand11),"clicked",G_CALLBACK(bandCallback),NULL); gtk_widget_show(buttonBand11); gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand11,2,3,2,3); buttonBand12 = gtk_button_new_with_label ("GEN"); gtk_widget_modify_bg(buttonBand12, GTK_STATE_NORMAL, &bandButtonBackground); label=gtk_bin_get_child((GtkBin*)buttonBand12); gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black); gtk_widget_set_size_request(GTK_WIDGET(buttonBand12),50,25); g_signal_connect(G_OBJECT(buttonBand12),"clicked",G_CALLBACK(bandCallback),NULL); gtk_widget_show(buttonBand12); gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand12,3,4,2,3); buttonBand13 = gtk_button_new_with_label ("WWV"); gtk_widget_modify_bg(buttonBand13, GTK_STATE_NORMAL, &bandButtonBackground); label=gtk_bin_get_child((GtkBin*)buttonBand13); gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black); gtk_widget_set_size_request(GTK_WIDGET(buttonBand13),50,25); g_signal_connect(G_OBJECT(buttonBand13),"clicked",G_CALLBACK(bandCallback),NULL); gtk_widget_show(buttonBand13); gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand13,0,1,3,4); buttonBand14 = gtk_button_new_with_label ("XVTR"); gtk_widget_modify_bg(buttonBand14, GTK_STATE_NORMAL, &bandButtonBackground); label=gtk_bin_get_child((GtkBin*)buttonBand14); gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black); gtk_widget_set_size_request(GTK_WIDGET(buttonBand14),50,25); g_signal_connect(G_OBJECT(buttonBand14),"clicked",G_CALLBACK(bandCallback),NULL); gtk_widget_show(buttonBand14); gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand14,1,2,3,4); configureXVTRButton(); if(!displayHF) { setXVTRTitles(); } gtk_container_add(GTK_CONTAINER(bandFrame),bandTable); gtk_widget_show(bandTable); gtk_widget_show(bandFrame); return bandFrame; }
static gboolean avatar_image_button_press_event (GtkWidget *widget, GdkEventButton *event) { EmpathyAvatarImagePriv *priv; GtkWidget *popup; GtkWidget *frame; GtkWidget *image; gint x, y; gint popup_width, popup_height; gint width, height; GdkPixbuf *pixbuf; priv = GET_PRIV (widget); if (priv->popup) { gtk_widget_destroy (priv->popup); priv->popup = NULL; } if (event->button != 1 || event->type != GDK_BUTTON_PRESS || !priv->pixbuf) { return FALSE; } popup_width = gdk_pixbuf_get_width (priv->pixbuf); popup_height = gdk_pixbuf_get_height (priv->pixbuf); width = priv->image->allocation.width; height = priv->image->allocation.height; /* Don't show a popup if the popup is smaller then the currently avatar * image. */ if (popup_height <= height && popup_width <= width) { return TRUE; } pixbuf = empathy_pixbuf_scale_down_if_necessary (priv->pixbuf, MAX_LARGE); popup_width = gdk_pixbuf_get_width (pixbuf); popup_height = gdk_pixbuf_get_height (pixbuf); popup = gtk_window_new (GTK_WINDOW_POPUP); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT); gtk_container_add (GTK_CONTAINER (popup), frame); image = gtk_image_new (); gtk_container_add (GTK_CONTAINER (frame), image); gtk_image_set_from_pixbuf (GTK_IMAGE (image), pixbuf); g_object_unref (pixbuf); gdk_window_get_origin (gtk_widget_get_window (priv->image), &x, &y); x = x - (popup_width - width) / 2; y = y - (popup_height - height) / 2; gtk_window_move (GTK_WINDOW (popup), x, y); priv->popup = popup; gtk_widget_show_all (popup); return TRUE; }
GtkWidget * convert_type_dialog_new (GimpImage *image, GimpContext *context, GtkWidget *parent, GimpProgress *progress) { IndexedDialog *dialog; GtkWidget *button; GtkWidget *main_vbox; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *label; GtkObject *adjustment; GtkWidget *spinbutton; GtkWidget *frame; GtkWidget *toggle; GtkWidget *palette_box; GtkWidget *combo; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); g_return_val_if_fail (GTK_IS_WIDGET (parent), NULL); g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL); dialog = g_slice_new0 (IndexedDialog); dialog->image = image; dialog->progress = progress; dialog->dither_type = saved_dither_type; dialog->alpha_dither = saved_alpha_dither; dialog->remove_dups = saved_remove_dups; dialog->num_colors = saved_num_colors; dialog->palette_type = saved_palette_type; dialog->dialog = gimp_viewable_dialog_new (GIMP_VIEWABLE (image), context, _("Indexed Color Conversion"), "gimp-image-convert-indexed", GIMP_STOCK_CONVERT_INDEXED, _("Convert Image to Indexed Colors"), parent, gimp_standard_help_func, GIMP_HELP_IMAGE_CONVERT_INDEXED, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); button = gtk_dialog_add_button (GTK_DIALOG (dialog->dialog), _("C_onvert"), GTK_RESPONSE_OK); gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_stock (GIMP_STOCK_CONVERT_INDEXED, GTK_ICON_SIZE_BUTTON)); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog->dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gtk_window_set_resizable (GTK_WINDOW (dialog->dialog), FALSE); g_object_weak_ref (G_OBJECT (dialog->dialog), (GWeakNotify) convert_dialog_free, dialog); g_signal_connect (dialog->dialog, "response", G_CALLBACK (convert_dialog_response), dialog); palette_box = convert_dialog_palette_box (dialog); main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog->dialog))), main_vbox, TRUE, TRUE, 0); gtk_widget_show (main_vbox); /* palette */ frame = gimp_enum_radio_frame_new_with_range (GIMP_TYPE_CONVERT_PALETTE_TYPE, GIMP_MAKE_PALETTE, (palette_box ? GIMP_CUSTOM_PALETTE : GIMP_MONO_PALETTE), gtk_label_new (_("Colormap")), G_CALLBACK (gimp_radio_button_update), &dialog->palette_type, &button); gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (button), dialog->palette_type); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); /* max n_colors */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gimp_enum_radio_frame_add (GTK_FRAME (frame), hbox, GIMP_MAKE_PALETTE, TRUE); gtk_widget_show (hbox); label = gtk_label_new_with_mnemonic (_("_Maximum number of colors:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); if (dialog->num_colors == 256 && gimp_image_has_alpha (image)) dialog->num_colors = 255; spinbutton = gimp_spin_button_new (&adjustment, dialog->num_colors, 2, 256, 1, 8, 0, 1, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); g_signal_connect (adjustment, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &dialog->num_colors); /* custom palette */ if (palette_box) { gimp_enum_radio_frame_add (GTK_FRAME (frame), palette_box, GIMP_CUSTOM_PALETTE, TRUE); gtk_widget_show (palette_box); } vbox = gtk_bin_get_child (GTK_BIN (frame)); toggle = gtk_check_button_new_with_mnemonic (_("_Remove unused colors " "from colormap")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), dialog->remove_dups); gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 3); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &dialog->remove_dups); g_object_bind_property (button, "active", toggle, "sensitive", G_BINDING_SYNC_CREATE | G_BINDING_INVERT_BOOLEAN); /* dithering */ frame = gimp_frame_new (_("Dithering")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new_with_mnemonic (_("Color _dithering:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); combo = gimp_enum_combo_box_new (GIMP_TYPE_CONVERT_DITHER_TYPE); gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo); gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0); gtk_widget_show (combo); gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), dialog->dither_type, G_CALLBACK (gimp_int_combo_box_get_active), &dialog->dither_type); toggle = gtk_check_button_new_with_mnemonic (_("Enable dithering of _transparency")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), dialog->alpha_dither); gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &dialog->alpha_dither); return dialog->dialog; }
/** Create contents of the accept dialog in here. @return 0 if success, -1 on errors. */ int nhdlg_create_content(void) { /* Variables. */ GtkWidget *window = (GtkWidget *)widget(ID_NHDLG); GtkWidget *frame, *w, *vb, *vb1, *vb2, *sw, *hb, *hp, *exp; gtk_container_set_border_width(GTK_CONTAINER(window), 1); /* Create remote HIT info. */ frame = gtk_frame_new(NULL); gtk_frame_set_label(GTK_FRAME(frame), lang_get("nhdlg-newinfo")); gtk_frame_set_label_align(GTK_FRAME(frame), 0.0, 0.0); gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_OUT); gtk_container_set_border_width(GTK_CONTAINER(frame), 5); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox), frame, TRUE, TRUE, 3); gtk_widget_show(GTK_WIDGET(frame)); /* This box is for adding everything inside previous frame. */ vb = gtk_vbox_new(FALSE, 1); gtk_container_add(GTK_CONTAINER(frame), vb); gtk_widget_show(GTK_WIDGET(vb)); /* Now create basic information. */ hb = gtk_hbox_new(FALSE, 1); gtk_box_pack_start(GTK_BOX(vb), hb, FALSE, FALSE, 3); gtk_widget_show(GTK_WIDGET(hb)); w = gtk_label_new(lang_get("nhdlg-newhit")); gtk_box_pack_start(GTK_BOX(hb), w, FALSE, FALSE, 3); gtk_widget_show(GTK_WIDGET(w)); w = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(hb), w, TRUE, TRUE, 3); gtk_widget_show(GTK_WIDGET(w)); widget_set(ID_NH_HIT, w); gtk_tooltips_set_tip(widget(ID_TOOLTIPS), w, lang_get("nhdlg-tt-hit"), lang_get("nhdlg-tt-hit-priv")); hb = gtk_hbox_new(FALSE, 1); gtk_box_pack_start(GTK_BOX(vb), hb, FALSE, FALSE, 3); gtk_widget_show(GTK_WIDGET(hb)); w = gtk_label_new(lang_get("nhdlg-name")); gtk_box_pack_start(GTK_BOX(hb), w, FALSE, FALSE, 3); gtk_widget_show(GTK_WIDGET(w)); w = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(w), ""); gtk_box_pack_start(GTK_BOX(hb), w, TRUE, TRUE, 3); gtk_entry_set_activates_default(GTK_ENTRY(w), TRUE); gtk_entry_set_max_length(GTK_ENTRY(w), MAX_NAME_LEN); gtk_widget_show(GTK_WIDGET(w)); widget_set(ID_NH_NAME, w); w = gtk_label_new(lang_get("nhdlg-group")); gtk_box_pack_start(GTK_BOX(hb), w, FALSE, FALSE, 3); gtk_widget_show(GTK_WIDGET(w)); w = gtk_combo_box_new_text(); g_signal_connect(w, "changed", G_CALLBACK(button_event), (gpointer)IDB_NH_RGROUPS); widget_set(ID_NH_RGROUP, w); gtk_box_pack_start(GTK_BOX(hb), w, TRUE, TRUE, 3); gtk_widget_show(GTK_WIDGET(w)); /* Separator between basic and advanced. */ w = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(vb), w, FALSE, FALSE, 2); gtk_widget_show(GTK_WIDGET(w)); /* Advanced information. */ exp = gtk_expander_new(lang_get("nhdlg-advanced")); gtk_box_pack_start(GTK_BOX(vb), exp, FALSE, TRUE, 2); gtk_widget_show(GTK_WIDGET(exp)); widget_set(ID_NH_EXPANDER, exp); g_signal_connect(exp, "activate", G_CALLBACK(button_event), (gpointer)IDB_NH_EXPANDER); g_signal_connect(exp, "check-resize", G_CALLBACK(button_event), (gpointer)IDB_NH_EXPANDER); vb2 = gtk_vbox_new(FALSE, 2); gtk_container_add(GTK_CONTAINER(exp), vb2); gtk_widget_show(GTK_WIDGET(vb2)); hb = gtk_hbox_new(FALSE, 1); gtk_box_pack_start(GTK_BOX(vb2), hb, FALSE, FALSE, 1); gtk_widget_show(GTK_WIDGET(hb)); /* w = gtk_label_new(lang_get("nhdlg-url")); gtk_box_pack_start(GTK_BOX(hb), w, FALSE, FALSE, 5); gtk_widget_show(GTK_WIDGET(w)); w = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(w), ""); gtk_box_pack_start(GTK_BOX(hb), w, TRUE, TRUE, 5); gtk_entry_set_max_length(GTK_ENTRY(w), MAX_URL_LEN); gtk_entry_set_activates_default(GTK_ENTRY(w), TRUE); gtk_widget_show(GTK_WIDGET(w)); widget_set(ID_NH_URL, w);*/ /* w = gtk_label_new(lang_get("nhdlg-port")); gtk_box_pack_start(GTK_BOX(hb), w, FALSE, FALSE, 5); gtk_widget_show(GTK_WIDGET(w)); w = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(w), "0"); gtk_box_pack_start(GTK_BOX(hb), w, FALSE, TRUE, 5); gtk_widget_set_size_request(GTK_WIDGET(w), 70, -1); gtk_entry_set_max_length(GTK_ENTRY(w), 8); gtk_entry_set_activates_default(GTK_ENTRY(w), TRUE); gtk_widget_show(GTK_WIDGET(w)); widget_set(ID_NH_PORT, w);*/ frame = gtk_frame_new(NULL); gtk_frame_set_label(GTK_FRAME(frame), lang_get("nhdlg-g-info")); gtk_frame_set_label_align(GTK_FRAME(frame), 0.0, 0.0); gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_OUT); gtk_container_set_border_width(GTK_CONTAINER(frame), 5); gtk_box_pack_start(GTK_BOX(vb2), frame, FALSE, FALSE, 1); gtk_widget_show(GTK_WIDGET(frame)); vb2 = gtk_vbox_new(FALSE, 2); gtk_container_add(GTK_CONTAINER(frame), vb2); gtk_widget_show(GTK_WIDGET(vb2)); hb = gtk_hbox_new(FALSE, 1); gtk_box_pack_start(GTK_BOX(vb2), hb, FALSE, FALSE, 1); gtk_widget_show(GTK_WIDGET(hb)); w = gtk_label_new(lang_get("nhdlg-g-localhit")); gtk_box_pack_start(GTK_BOX(hb), w, FALSE, FALSE, 5); gtk_widget_show(GTK_WIDGET(w)); w = gtk_combo_box_new_text(); gtk_box_pack_start(GTK_BOX(hb), w, TRUE, TRUE, 1); gtk_widget_set_sensitive(GTK_WIDGET(w), FALSE); gtk_widget_show(GTK_WIDGET(w)); widget_set(ID_NH_LOCAL, w); hb = gtk_hbox_new(FALSE, 1); gtk_box_pack_start(GTK_BOX(vb2), hb, FALSE, FALSE, 1); gtk_widget_show(GTK_WIDGET(hb)); w = gtk_label_new(lang_get("nhdlg-g-type")); gtk_box_pack_start(GTK_BOX(hb), w, FALSE, FALSE, 5); gtk_widget_show(GTK_WIDGET(w)); w = gtk_combo_box_new_text(); gtk_combo_box_append_text(GTK_COMBO_BOX(w), lang_get("group-type-accept")); gtk_combo_box_append_text(GTK_COMBO_BOX(w), lang_get("group-type-deny")); gtk_combo_box_set_active(GTK_COMBO_BOX(w), 0); gtk_box_pack_start(GTK_BOX(hb), w, TRUE, TRUE, 1); gtk_widget_set_sensitive(GTK_WIDGET(w), FALSE); gtk_widget_show(GTK_WIDGET(w)); widget_set(ID_NH_TYPE1, w); w = gtk_label_new(lang_get("nhdlg-g-lightweight")); gtk_box_pack_start(GTK_BOX(hb), w, FALSE, FALSE, 5); gtk_widget_show(GTK_WIDGET(w)); w = gtk_combo_box_new_text(); gtk_combo_box_append_text(GTK_COMBO_BOX(w), lang_get("group-type2-normal")); gtk_combo_box_append_text(GTK_COMBO_BOX(w), lang_get("group-type2-lightweight")); gtk_combo_box_set_active(GTK_COMBO_BOX(w), 0); gtk_box_pack_start(GTK_BOX(hb), w, TRUE, TRUE, 1); gtk_widget_set_sensitive(GTK_WIDGET(w), FALSE); gtk_widget_show(GTK_WIDGET(w)); widget_set(ID_NH_TYPE2, w); return (0); }
GtkWidget *plugin_configure(GtkDialog *dialog) { GtkWidget *label_language, *label_dir, *vbox; GtkWidget *combo, *check_type, *check_on_open, *check_msgwin, *check_toolbar; GtkWidget *frame_editor_menu, *check_editor_menu; GtkWidget *check_editor_menu_sub_menu, *align_editor_menu_sub_menu; GtkWidget *vbox_interface, *frame_interface, *label_interface; GtkWidget *vbox_behavior, *frame_behavior, *label_behavior; #ifdef HAVE_ENCHANT_1_5 GtkWidget *entry_dir, *hbox, *button, *image; #endif vbox = gtk_vbox_new(FALSE, 6); check_toolbar = gtk_check_button_new_with_label( _("Show toolbar item to toggle spell checking")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_toolbar), sc_info->show_toolbar_item); check_editor_menu = gtk_check_button_new_with_label( _("Show editor menu item to show spelling suggestions")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_editor_menu), sc_info->show_editor_menu_item); check_editor_menu_sub_menu = gtk_check_button_new_with_label( _("Show suggestions in a sub menu of the editor menu")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_editor_menu_sub_menu), sc_info->show_editor_menu_item_sub_menu); align_editor_menu_sub_menu = gtk_alignment_new(0.5, 0.5, 1, 1); gtk_alignment_set_padding(GTK_ALIGNMENT(align_editor_menu_sub_menu), 0, 0, 9, 0); gtk_container_add(GTK_CONTAINER(align_editor_menu_sub_menu), check_editor_menu_sub_menu); frame_editor_menu = gtk_frame_new(NULL); gtk_frame_set_label_widget(GTK_FRAME(frame_editor_menu), check_editor_menu); gtk_container_set_border_width(GTK_CONTAINER(frame_editor_menu), 3); gtk_container_add(GTK_CONTAINER(frame_editor_menu), align_editor_menu_sub_menu); g_signal_connect(check_editor_menu, "toggled", G_CALLBACK(configure_frame_editor_menu_toggled_cb), dialog); check_msgwin = gtk_check_button_new_with_label( _("Print misspelled words and suggestions in the messages window")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_msgwin), sc_info->use_msgwin); vbox_interface = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_interface), check_toolbar, FALSE, FALSE, 3); gtk_box_pack_start(GTK_BOX(vbox_interface), frame_editor_menu, TRUE, TRUE, 3); gtk_box_pack_start(GTK_BOX(vbox_interface), check_msgwin, TRUE, TRUE, 3); label_interface = gtk_label_new(NULL); gtk_label_set_use_markup(GTK_LABEL(label_interface), TRUE); gtk_label_set_markup(GTK_LABEL(label_interface), _("<b>Interface</b>")); frame_interface = gtk_frame_new(NULL); gtk_frame_set_label_widget(GTK_FRAME(frame_interface), label_interface); gtk_container_add(GTK_CONTAINER(frame_interface), vbox_interface); gtk_box_pack_start(GTK_BOX(vbox), frame_interface, FALSE, FALSE, 3); check_type = gtk_check_button_new_with_label(_("Check spelling while typing")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_type), sc_info->check_while_typing); check_on_open = gtk_check_button_new_with_label(_("Check spelling when opening a document")); gtk_widget_set_tooltip_text(check_on_open, _("Enabling this option will check every document after it is opened in Geany. " "Reloading a document will also trigger a re-check.")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_on_open), sc_info->check_on_document_open); label_language = gtk_label_new(_("Language to use for the spell check:")); gtk_misc_set_alignment(GTK_MISC(label_language), 0, 0.5); combo = gtk_combo_box_text_new(); populate_dict_combo(GTK_COMBO_BOX(combo)); if (sc_info->dicts->len > 20) gtk_combo_box_set_wrap_width(GTK_COMBO_BOX(combo), 3); else if (sc_info->dicts->len > 10) gtk_combo_box_set_wrap_width(GTK_COMBO_BOX(combo), 2); #ifdef HAVE_ENCHANT_1_5 label_dir = gtk_label_new_with_mnemonic(_("_Directory to look for dictionary files:")); gtk_misc_set_alignment(GTK_MISC(label_dir), 0, 0.5); entry_dir = gtk_entry_new(); ui_entry_add_clear_icon(GTK_ENTRY(entry_dir)); gtk_label_set_mnemonic_widget(GTK_LABEL(label_dir), entry_dir); gtk_widget_set_tooltip_text(entry_dir, _("Read additional dictionary files from this directory. " "For now, this only works with myspell dictionaries.")); if (! EMPTY(sc_info->dictionary_dir)) gtk_entry_set_text(GTK_ENTRY(entry_dir), sc_info->dictionary_dir); button = gtk_button_new(); g_signal_connect(button, "clicked", G_CALLBACK(dictionary_dir_button_clicked_cb), entry_dir); image = gtk_image_new_from_stock("gtk-open", GTK_ICON_SIZE_BUTTON); gtk_container_add(GTK_CONTAINER(button), image); hbox = gtk_hbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(hbox), entry_dir, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); g_object_set_data(G_OBJECT(dialog), "dict_dir", entry_dir); #endif vbox_behavior = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_behavior), check_type, FALSE, FALSE, 3); gtk_box_pack_start(GTK_BOX(vbox_behavior), check_on_open, TRUE, TRUE, 3); gtk_box_pack_start(GTK_BOX(vbox_behavior), label_language, TRUE, TRUE, 3); gtk_box_pack_start(GTK_BOX(vbox_behavior), combo, TRUE, TRUE, 3); #ifdef HAVE_ENCHANT_1_5 gtk_box_pack_start(GTK_BOX(vbox_behavior), label_dir, TRUE, TRUE, 3); gtk_box_pack_start(GTK_BOX(vbox_behavior), hbox, TRUE, TRUE, 3); #endif label_behavior = gtk_label_new(NULL); gtk_label_set_use_markup(GTK_LABEL(label_behavior), TRUE); gtk_label_set_markup(GTK_LABEL(label_behavior), _("<b>Behavior</b>")); frame_behavior = gtk_frame_new(NULL); gtk_frame_set_label_widget(GTK_FRAME(frame_behavior), label_behavior); gtk_container_add(GTK_CONTAINER(frame_behavior), vbox_behavior); gtk_box_pack_start(GTK_BOX(vbox), frame_behavior, FALSE, FALSE, 3); g_object_set_data(G_OBJECT(dialog), "combo", combo); g_object_set_data(G_OBJECT(dialog), "check_type", check_type); g_object_set_data(G_OBJECT(dialog), "check_on_open", check_on_open); g_object_set_data(G_OBJECT(dialog), "check_msgwin", check_msgwin); g_object_set_data(G_OBJECT(dialog), "check_toolbar", check_toolbar); g_object_set_data(G_OBJECT(dialog), "check_editor_menu", check_editor_menu); g_object_set_data(G_OBJECT(dialog), "check_editor_menu_sub_menu", check_editor_menu_sub_menu); g_signal_connect(dialog, "response", G_CALLBACK(configure_response_cb), NULL); configure_frame_editor_menu_toggled_cb(GTK_TOGGLE_BUTTON(check_editor_menu), dialog); gtk_widget_show_all(vbox); return vbox; }
/* * init debug related GUI (watch tree view) * arguments: */ void debug_init() { /* create watch page */ wtree = wtree_init(on_watch_expanded_callback, on_watch_dragged_callback, on_watch_key_pressed_callback, on_watch_changed, on_watch_button_pressed_callback); wmodel = gtk_tree_view_get_model(GTK_TREE_VIEW(wtree)); wstore = GTK_TREE_STORE(wmodel); tab_watch = gtk_scrolled_window_new( gtk_tree_view_get_hadjustment(GTK_TREE_VIEW(wtree)), gtk_tree_view_get_vadjustment(GTK_TREE_VIEW(wtree)) ); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(tab_watch), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(tab_watch), wtree); /* create autos page */ atree = atree_init(on_watch_expanded_callback, on_watch_button_pressed_callback); tab_autos = gtk_scrolled_window_new( gtk_tree_view_get_hadjustment(GTK_TREE_VIEW(atree)), gtk_tree_view_get_vadjustment(GTK_TREE_VIEW(atree)) ); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(tab_autos), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(tab_autos), atree); /* create stack trace page */ stree = stree_init(editor_open_position, on_select_frame); tab_call_stack = gtk_scrolled_window_new( gtk_tree_view_get_hadjustment(GTK_TREE_VIEW(stree )), gtk_tree_view_get_vadjustment(GTK_TREE_VIEW(stree )) ); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(tab_call_stack), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(tab_call_stack), stree); /* create debug terminal page */ terminal = vte_terminal_new(); /* create PTY */ openpty(&pty_master, &pty_slave, NULL, NULL, NULL); grantpt(pty_master); unlockpt(pty_master); vte_terminal_set_pty(VTE_TERMINAL(terminal), pty_master); GtkWidget *scrollbar = gtk_vscrollbar_new(GTK_ADJUSTMENT(VTE_TERMINAL(terminal)->adjustment)); GTK_WIDGET_UNSET_FLAGS(scrollbar, GTK_CAN_FOCUS); tab_terminal = gtk_frame_new(NULL); gtk_frame_set_shadow_type (GTK_FRAME(tab_terminal), GTK_SHADOW_NONE); GtkWidget *hbox = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(tab_terminal), hbox); gtk_box_pack_start(GTK_BOX(hbox), terminal, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), scrollbar, FALSE, FALSE, 0); /* set the default widget size first to prevent VTE expanding too much, * sometimes causing the hscrollbar to be too big or out of view. */ gtk_widget_set_size_request(GTK_WIDGET(terminal), 10, 10); vte_terminal_set_size(VTE_TERMINAL(terminal), 30, 1); /* set terminal font. */ GKeyFile *config = g_key_file_new(); gchar *configfile = g_strconcat(geany_data->app->configdir, G_DIR_SEPARATOR_S, "geany.conf", NULL); g_key_file_load_from_file(config, configfile, G_KEY_FILE_NONE, NULL); gchar *font = utils_get_setting_string(config, "VTE", "font", "Monospace 10"); vte_terminal_set_font_from_string (VTE_TERMINAL(terminal), font); /* debug messages page */ tab_messages = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(tab_messages), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); hadj = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(tab_messages)); vadj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(tab_messages)); debugger_messages_textview = gtk_text_view_new(); gtk_text_view_set_editable (GTK_TEXT_VIEW (debugger_messages_textview), FALSE); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(tab_messages), debugger_messages_textview); /* create tex tags */ GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(debugger_messages_textview)); gtk_text_buffer_create_tag(buffer, "black", "foreground", "#000000", NULL); gtk_text_buffer_create_tag(buffer, "grey", "foreground", "#AAAAAA", NULL); gtk_text_buffer_create_tag(buffer, "red", "foreground", "#FF0000", NULL); gtk_text_buffer_create_tag(buffer, "green", "foreground", "#00FF00", NULL); gtk_text_buffer_create_tag(buffer, "blue", "foreground", "#0000FF", NULL); gtk_text_buffer_create_tag(buffer, "yellow", "foreground", "#FFFF00", NULL); gtk_text_buffer_create_tag(buffer, "brown", "foreground", "#BB8915", NULL); gtk_text_buffer_create_tag(buffer, "rose", "foreground", "#BA92B7", NULL); }
GtkWidget * create_canvas_features (void) { GtkWidget *vbox; GtkWidget *w; GtkWidget *frame; GtkWidget *canvas; GooCanvasItemModel *root, *item; GooCanvasItemModel *parent1; GooCanvasItemModel *parent2; GooCanvasItemModel *group; vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4); g_object_set (vbox, "margin", 4, NULL); gtk_widget_show (vbox); /* Instructions */ w = gtk_label_new ("Reparent test: click on the items to switch them between parents"); gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE); gtk_widget_show (w); /* Frame and canvas */ frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE); gtk_widget_show (frame); g_object_set (frame, "halign", GTK_ALIGN_CENTER, "valign", GTK_ALIGN_CENTER, NULL); canvas = goo_canvas_new (); g_signal_connect (canvas, "item_created", G_CALLBACK (on_item_created), NULL); root = goo_canvas_group_model_new (NULL, NULL); gtk_widget_set_size_request (canvas, 400, 200); goo_canvas_set_bounds (GOO_CANVAS (canvas), 0, 0, 400, 200); gtk_container_add (GTK_CONTAINER (frame), canvas); gtk_widget_show (canvas); /* First parent and box */ parent1 = goo_canvas_group_model_new (root, NULL); goo_canvas_rect_model_new (parent1, 0, 0, 200, 200, "fill_color", "tan", NULL); /* Second parent and box */ parent2 = goo_canvas_group_model_new (root, NULL); goo_canvas_item_model_translate (parent2, 200, 0); goo_canvas_rect_model_new (parent2, 0, 0, 200, 200, "fill_color", "#204060", NULL); /* Big circle to be reparented */ item = goo_canvas_ellipse_model_new (parent1, 100, 100, 90, 90, "stroke_color", "black", "fill_color", "mediumseagreen", "line-width", 3.0, NULL); g_object_set_data (G_OBJECT (item), "parent1", parent1); g_object_set_data (G_OBJECT (item), "parent2", parent2); #if 0 g_signal_connect (G_OBJECT (item), "event", G_CALLBACK (item_event), NULL); #endif /* A group to be reparented */ group = goo_canvas_group_model_new (parent2, NULL); goo_canvas_item_model_translate (group, 100, 100); goo_canvas_ellipse_model_new (group, 0, 0, 50, 50, "stroke_color", "black", "fill_color", "wheat", "line_width", 3.0, NULL); goo_canvas_ellipse_model_new (group, 0, 0, 25, 25, "fill_color", "steelblue", NULL); g_object_set_data (G_OBJECT (group), "parent1", parent1); g_object_set_data (G_OBJECT (group), "parent2", parent2); #if 0 g_signal_connect (G_OBJECT (group), "event", G_CALLBACK (item_event), NULL); #endif goo_canvas_set_root_item_model (GOO_CANVAS (canvas), root); g_object_unref (root); /* Done */ return vbox; }
GtkWidget * do_images (GtkWidget *do_widget) { GtkWidget *frame; GtkWidget *vbox; GtkWidget *image; GtkWidget *label; GtkWidget *align; GtkWidget *button; GdkPixbuf *pixbuf; GError *error = NULL; char *filename; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (do_widget)); gtk_window_set_title (GTK_WINDOW (window), "Images"); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); g_signal_connect (window, "destroy", G_CALLBACK (cleanup_callback), NULL); gtk_container_set_border_width (GTK_CONTAINER (window), 8); vbox = gtk_vbox_new (FALSE, 8); gtk_container_set_border_width (GTK_CONTAINER (vbox), 8); gtk_container_add (GTK_CONTAINER (window), vbox); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Image loaded from a file</u>"); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); /* The alignment keeps the frame from growing when users resize * the window */ align = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_container_add (GTK_CONTAINER (align), frame); gtk_box_pack_start (GTK_BOX (vbox), align, FALSE, FALSE, 0); /* demo_find_file() looks in the the current directory first, * so you can run gtk-demo without installing GTK, then looks * in the location where the file is installed. */ pixbuf = NULL; filename = demo_find_file ("gtk-logo-rgb.gif", &error); if (filename) { pixbuf = gdk_pixbuf_new_from_file (filename, &error); g_free (filename); } if (error) { /* This code shows off error handling. You can just use * gtk_image_new_from_file() instead if you don't want to report * errors to the user. If the file doesn't load when using * gtk_image_new_from_file(), a "missing image" icon will * be displayed instead. */ GtkWidget *dialog; dialog = gtk_message_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Unable to open image file 'gtk-logo-rgb.gif': %s", error->message); g_error_free (error); g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); gtk_widget_show (dialog); } image = gtk_image_new_from_pixbuf (pixbuf); gtk_container_add (GTK_CONTAINER (frame), image); /* Animation */ label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Animation loaded from a file</u>"); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); /* The alignment keeps the frame from growing when users resize * the window */ align = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_container_add (GTK_CONTAINER (align), frame); gtk_box_pack_start (GTK_BOX (vbox), align, FALSE, FALSE, 0); filename = demo_find_file ("floppybuddy.gif", NULL); image = gtk_image_new_from_file (filename); g_free (filename); gtk_container_add (GTK_CONTAINER (frame), image); /* Progressive */ label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Progressive image loading</u>"); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); /* The alignment keeps the frame from growing when users resize * the window */ align = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_container_add (GTK_CONTAINER (align), frame); gtk_box_pack_start (GTK_BOX (vbox), align, FALSE, FALSE, 0); /* Create an empty image for now; the progressive loader * will create the pixbuf and fill it in. */ image = gtk_image_new_from_pixbuf (NULL); gtk_container_add (GTK_CONTAINER (frame), image); start_progressive_loading (image); /* Sensitivity control */ button = gtk_toggle_button_new_with_mnemonic ("_Insensitive"); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); g_signal_connect (button, "toggled", G_CALLBACK (toggle_sensitivity_callback), vbox); } if (!GTK_WIDGET_VISIBLE (window)) { gtk_widget_show_all (window); } else { gtk_widget_destroy (window); window = NULL; } return window; }
void splash_create (gboolean be_verbose) { GtkWidget *frame; GtkWidget *vbox; GdkPixbufAnimation *pixbuf; GdkScreen *screen; g_return_if_fail (splash == NULL); pixbuf = splash_image_load (be_verbose); if (! pixbuf) return; splash = g_slice_new0 (GimpSplash); splash->window = g_object_new (GTK_TYPE_WINDOW, "type", GTK_WINDOW_TOPLEVEL, "type-hint", GDK_WINDOW_TYPE_HINT_SPLASHSCREEN, "title", _("GIMP Startup"), "role", "gimp-startup", "window-position", GTK_WIN_POS_CENTER, "resizable", FALSE, NULL); g_signal_connect_swapped (splash->window, "delete-event", G_CALLBACK (exit), GINT_TO_POINTER (0)); screen = gtk_widget_get_screen (splash->window); splash->width = MIN (gdk_pixbuf_animation_get_width (pixbuf), gdk_screen_get_width (screen)); splash->height = MIN (gdk_pixbuf_animation_get_height (pixbuf), gdk_screen_get_height (screen)); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT); gtk_container_add (GTK_CONTAINER (splash->window), frame); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); /* If the splash image is static, we use a drawing area and set the * image as back pixmap, otherwise a GtkImage is being used. */ if (gdk_pixbuf_animation_is_static_image (pixbuf)) { splash->area = gtk_drawing_area_new (); } else { splash->area = gtk_image_new_from_animation (pixbuf); } gtk_box_pack_start (GTK_BOX (vbox), splash->area, TRUE, TRUE, 0); gtk_widget_show (splash->area); gtk_widget_set_size_request (splash->area, splash->width, splash->height); /* create the pango layouts */ splash->upper = gtk_widget_create_pango_layout (splash->area, ""); splash->lower = gtk_widget_create_pango_layout (splash->area, ""); gimp_pango_layout_set_scale (splash->lower, PANGO_SCALE_SMALL); /* this sets the initial layout positions */ splash_position_layouts (splash, "", "", NULL); splash_average_text_area (splash, gdk_pixbuf_animation_get_static_image (pixbuf), &splash->color); gtk_widget_realize (splash->area); if (gdk_pixbuf_animation_is_static_image (pixbuf)) { GdkPixbuf *static_pixbuf = gdk_pixbuf_animation_get_static_image (pixbuf); GdkPixmap *pixmap; cairo_t *cr; pixmap = gdk_pixmap_new (gtk_widget_get_window (splash->area), splash->width, splash->height, -1); cr = gdk_cairo_create (pixmap); gdk_cairo_set_source_pixbuf (cr, static_pixbuf, 0.0, 0.0); cairo_paint (cr); cairo_destroy (cr); gdk_window_set_back_pixmap (gtk_widget_get_window (splash->area), pixmap, FALSE); g_object_unref (pixmap); } g_object_unref (pixbuf); g_signal_connect_after (splash->area, "expose-event", G_CALLBACK (splash_area_expose), splash); /* add a progress bar */ splash->progress = gtk_progress_bar_new (); gtk_box_pack_end (GTK_BOX (vbox), splash->progress, FALSE, FALSE, 0); gtk_widget_show (splash->progress); gtk_widget_show_now (splash->window); #ifdef STARTUP_TIMER splash->timer = g_timer_new (); #endif }
GtkWidget *load_gtk_widget() { GtkWidget *pVBox, *pFrame, *pHBoxFrame, *pVBoxFrame, *phboxtemp, *labeltemp; GtkWidget *hboxview; GtkWidget *labelinfo, *labeldesc; GtkWidget *info; GtkListStore *store; GtkTreeModel *model; GtkTreeViewColumn *col; GtkCellRenderer *renderer; pVBoxFrame = gtk_vbox_new(FALSE, 0); pHBoxFrame = gtk_hbox_new(FALSE, 0); pVBox = gtk_vbox_new(FALSE, 0); hboxview = gtk_hbox_new(FALSE, 0); info = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(info), _("<span face=\"Courier New\"><b>You can configure all network interfaces you need</b></span>")); gtk_box_pack_start(GTK_BOX(pVBox), info, FALSE, FALSE, 5); gtk_box_pack_start (GTK_BOX (pVBox), info, FALSE, FALSE, 5); store = gtk_list_store_new(6, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); model = GTK_TREE_MODEL(store); viewif = gtk_tree_view_new_with_model(model); g_object_unref (model); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(viewif), TRUE); renderer = gtk_cell_renderer_pixbuf_new(); col = gtk_tree_view_column_new_with_attributes ("", renderer, "pixbuf", COLUMN_NET_IMAGE, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(viewif), col); renderer = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes (_("Device"), renderer, "text", COLUMN_NET_NAME, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(viewif), col); renderer = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes (_("Ip Address"), renderer, "text", COLUMN_NET_IP, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(viewif), col); renderer = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes (_("Netmask"), renderer, "text", COLUMN_NET_NETMASK, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(viewif), col); renderer = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes (_("Gateway"), renderer, "text", COLUMN_NET_GATEWAY, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(viewif), col); renderer = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes (_("DHCP Nameserver"), renderer, "text", COLUMN_NET_NAMESERV, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(viewif), col); gtk_box_pack_start(GTK_BOX(hboxview), viewif, TRUE, TRUE, 10); gtk_box_pack_start(GTK_BOX(pVBox), hboxview, TRUE, TRUE, 5); pFrame = gtk_frame_new(_("Network configuration")); gtk_container_add(GTK_CONTAINER(pFrame), pVBoxFrame); gtk_box_pack_start(GTK_BOX(pVBox), pFrame, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(pVBoxFrame), pHBoxFrame, FALSE, FALSE, 12); labeldesc = gtk_label_new(_("Interface :")); gtk_box_pack_start(GTK_BOX(pHBoxFrame), labeldesc, FALSE, FALSE, 5); intercombo = gtk_combo_box_new_text(); gtk_box_pack_start(GTK_BOX(pHBoxFrame), intercombo, TRUE, TRUE, 5); labelinfo = gtk_label_new(""); gtk_box_pack_start(GTK_BOX(pHBoxFrame), labelinfo, TRUE, TRUE, 0); phboxtemp = gtk_hbox_new(FALSE, 0); labeltemp = gtk_label_new(_("Network configuration : ")); gtk_box_pack_start(GTK_BOX(phboxtemp), labeltemp, FALSE, FALSE, 5); GtkWidget *btnsave = gtk_button_new_from_stock (GTK_STOCK_ADD); gtk_box_pack_start(GTK_BOX(phboxtemp), btnsave, FALSE, FALSE, 10); GtkWidget *btndel = gtk_button_new_from_stock (GTK_STOCK_REMOVE); gtk_box_pack_start(GTK_BOX(phboxtemp), btndel, FALSE, FALSE, 10); gtk_frame_set_label_widget(GTK_FRAME(pFrame), phboxtemp); g_signal_connect(G_OBJECT(intercombo), "changed", G_CALLBACK(change_interface), labelinfo); g_signal_connect(G_OBJECT(btnsave), "clicked", G_CALLBACK(add_interface), viewif); g_signal_connect(G_OBJECT(btndel), "clicked", G_CALLBACK(del_interface), viewif); return pVBox; }
Selection_t* make_selection(ObjectList_t *object_list) { Selection_t *data = g_new(Selection_t, 1); GtkWidget *swin, *frame, *hbox; GtkWidget *toolbar; GtkWidget *list; GtkCellRenderer *renderer; GtkTreeViewColumn *column; data->object_list = object_list; data->selected_child = NULL; data->is_visible = TRUE; data->nr_rows = 0; data->select_lock = FALSE; data->doubleclick = FALSE; data->container = frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN); gtk_widget_show(frame); hbox = gtk_hbox_new(FALSE, 6); gtk_container_add(GTK_CONTAINER(frame), hbox); gtk_widget_show(hbox); toolbar = make_selection_toolbar(); gtk_container_add(GTK_CONTAINER(hbox), toolbar); /* Create selection */ frame = gimp_frame_new(_("Selection")); gtk_container_add(GTK_CONTAINER(hbox), frame); gtk_widget_show(frame); data->store = gtk_list_store_new (1, G_TYPE_POINTER); data->list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (data->store)); list = data->list; g_object_unref (data->store); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (N_("#"), renderer, NULL); gtk_tree_view_column_set_cell_data_func (column, renderer, render_nr, data, NULL); gtk_tree_view_column_set_min_width (column, 16); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_alignment (column, 0.5); gtk_tree_view_append_column (GTK_TREE_VIEW (list), column); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("URL")); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func (column, renderer, render_image, data, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_cell_data_func (column, renderer, render_url, data, NULL); gtk_tree_view_column_set_min_width (column, 80); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_alignment (column, 0.5); gtk_tree_view_append_column (GTK_TREE_VIEW (list), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("ALT Text"), renderer, NULL); gtk_tree_view_column_set_cell_data_func (column, renderer, render_comment, data, NULL); gtk_tree_view_column_set_min_width (column, 64); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_alignment (column, 0.5); gtk_tree_view_append_column (GTK_TREE_VIEW (list), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Target"), renderer, NULL); gtk_tree_view_column_set_cell_data_func (column, renderer, render_target, data, NULL); gtk_tree_view_column_set_min_width (column, 64); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_alignment (column, 0.5); gtk_tree_view_append_column (GTK_TREE_VIEW (list), column); /* Create scrollable window */ swin = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_size_request (swin, 16 + 80 + 2 * 64 + 16, -1); gtk_container_add (GTK_CONTAINER(frame), swin); gtk_widget_show (swin); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW(swin), list); gtk_widget_show (list); /* Drop support */ gtk_drag_dest_set (list, GTK_DEST_DEFAULT_ALL, target_table, 2, GDK_ACTION_COPY); g_signal_connect (list, "drag-data-received", G_CALLBACK(handle_drop), NULL); /* For handling doubleclick */ g_signal_connect (list, "button-press-event", G_CALLBACK(button_press_cb), data); g_signal_connect (list, "button-release-event", G_CALLBACK(button_release_cb), data); /* Callbacks we are interested in */ data->selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (list)); gtk_tree_selection_set_mode (data->selection, GTK_SELECTION_MULTIPLE); g_signal_connect (data->selection, "changed", G_CALLBACK(changed_cb), data); set_buttons (data); /* Set object list callbacks we're interested in */ object_list_add_add_cb (object_list, object_added_cb, data); object_list_add_update_cb (object_list, object_updated_cb, data); object_list_add_remove_cb (object_list, object_removed_cb, data); object_list_add_select_cb (object_list, object_selected_cb, data); object_list_add_move_cb (object_list, object_moved_cb, data); return data; }
static gint sobel_dialog () { GtkWidget *dlg; GtkWidget *button; GtkWidget *toggle; GtkWidget *frame; GtkWidget *vbox; GtkWidget *hbox; gchar **argv; gint argc; argc = 1; argv = g_new (gchar *, 1); argv[0] = g_strdup ("sobel"); gtk_init (&argc, &argv); gtk_rc_parse (gimp_gtkrc ()); dlg = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dlg), _("Sobel Edge Detection")); gtk_window_position (GTK_WINDOW (dlg), GTK_WIN_POS_MOUSE); gtk_signal_connect (GTK_OBJECT (dlg), "destroy", (GtkSignalFunc) sobel_close_callback, NULL); /* Action area */ button = gtk_button_new_with_label (_("OK")); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) sobel_ok_callback, dlg); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->action_area), button, TRUE, TRUE, 0); gtk_widget_grab_default (button); gtk_widget_show (button); button = gtk_button_new_with_label (_("Cancel")); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_signal_connect_object (GTK_OBJECT (button), "clicked", (GtkSignalFunc) gtk_widget_destroy, GTK_OBJECT (dlg)); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->action_area), button, TRUE, TRUE, 0); gtk_widget_show (button); /* parameter settings */ frame = gtk_frame_new (_("Parameter Settings")); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN); gtk_container_border_width (GTK_CONTAINER (frame), 10); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0); vbox = gtk_vbox_new (FALSE, 5); gtk_container_border_width (GTK_CONTAINER (vbox), 10); gtk_container_add (GTK_CONTAINER (frame), vbox); toggle = gtk_check_button_new_with_label (_("Sobel Horizontally")); gtk_box_pack_start (GTK_BOX (vbox), toggle, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (toggle), "toggled", (GtkSignalFunc) sobel_toggle_update, &bvals.horizontal); gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (toggle), bvals.horizontal); gtk_widget_show (toggle); toggle = gtk_check_button_new_with_label (_("Sobel Vertically")); gtk_box_pack_start (GTK_BOX (vbox), toggle, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (toggle), "toggled", (GtkSignalFunc) sobel_toggle_update, &bvals.vertical); gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (toggle), bvals.vertical); gtk_widget_show (toggle); toggle = gtk_check_button_new_with_label (_("Keep sign of result (one direction only)")); gtk_box_pack_start (GTK_BOX (vbox), toggle, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT (toggle), "toggled", (GtkSignalFunc) sobel_toggle_update, &bvals.keep_sign); gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (toggle), bvals.vertical); gtk_widget_show (toggle); hbox = gtk_hbox_new (FALSE, 5); gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); gtk_widget_show (vbox); gtk_widget_show (frame); gtk_widget_show (dlg); gtk_main (); gdk_flush (); return bint.run; }
int mc_show_history (GtkWidget *widget, MCData *mc) { GtkWidget *window; GtkWidget *frame; GtkWidget *scrolled_window; GtkListStore *store; GtkTreeIter iter; GtkTreeModel *model; GtkWidget *treeview; GtkCellRenderer *cell_renderer; GtkTreeViewColumn *column; GtkRequisition req; gchar *command_list[1]; int i, j; gint x, y, width, height, screen_width, screen_height; /* count commands stored in history list */ for(i = 0, j = 0; i < MC_HISTORY_LIST_LENGTH; i++) if(exists_history_entry(i)) j++; window = gtk_window_new(GTK_WINDOW_POPUP); gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (GTK_WIDGET (mc->applet))); gtk_window_set_resizable(GTK_WINDOW(window), FALSE); gtk_window_set_type_hint(GTK_WINDOW(window), GDK_WINDOW_TYPE_HINT_COMBO); /* cb */ g_signal_connect_after(GTK_OBJECT(window), "button_press_event", G_CALLBACK(history_popup_clicked_cb), NULL); g_signal_connect_after (G_OBJECT (window), "key_press_event", G_CALLBACK (history_key_press_cb), NULL); /* size */ gtk_widget_set_size_request(GTK_WIDGET(window), 200, 350); /* frame */ frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT); gtk_widget_show(frame); gtk_container_add(GTK_CONTAINER(window), frame); /* scrollbars */ /* create scrolled window to put the Gtk_list widget inside */ scrolled_window=gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); g_signal_connect(GTK_OBJECT(scrolled_window), "button_press_event", G_CALLBACK(history_popup_clicked_inside_cb), NULL); gtk_container_add(GTK_CONTAINER(frame), scrolled_window); gtk_container_set_border_width (GTK_CONTAINER(scrolled_window), 2); gtk_widget_show(scrolled_window); store = gtk_list_store_new (1, G_TYPE_STRING); /* add history entries to list */ if (j == 0) { gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter,0, _("No items in history"), -1); } else { for(i = 0; i < MC_HISTORY_LIST_LENGTH; i++) { if(exists_history_entry(i)) { command_list[0] = get_history_entry(i); gtk_list_store_prepend (store, &iter); gtk_list_store_set (store, &iter,0,command_list[0],-1); } } } model = GTK_TREE_MODEL(store); treeview = gtk_tree_view_new_with_model (model); g_object_set_data (G_OBJECT (mc->applet), "tree", treeview); cell_renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (NULL, cell_renderer, "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE); if (j == 0) { gtk_tree_selection_set_mode( (GtkTreeSelection *)gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)), GTK_SELECTION_NONE); } else { gtk_tree_selection_set_mode( (GtkTreeSelection *)gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)), GTK_SELECTION_SINGLE); g_signal_connect (G_OBJECT (treeview), "button_press_event", G_CALLBACK (history_list_button_press_cb), mc); g_signal_connect (G_OBJECT (treeview), "key_press_event", G_CALLBACK (history_list_key_press_cb), mc); } g_object_unref (G_OBJECT (model)); gtk_container_add(GTK_CONTAINER(scrolled_window),treeview); gtk_widget_show (treeview); gtk_widget_size_request (window, &req); gdk_window_get_origin (GTK_WIDGET (mc->applet)->window, &x, &y); gdk_window_get_geometry (GTK_WIDGET (mc->applet)->window, NULL, NULL, &width, &height, NULL); switch (mate_panel_applet_get_orient (mc->applet)) { case MATE_PANEL_APPLET_ORIENT_DOWN: y += height; break; case MATE_PANEL_APPLET_ORIENT_UP: y -= req.height; break; case MATE_PANEL_APPLET_ORIENT_LEFT: x -= req.width; break; case MATE_PANEL_APPLET_ORIENT_RIGHT: x += width; break; } screen_width = gdk_screen_width (); screen_height = gdk_screen_height (); x = CLAMP (x - 2, 0, MAX (0, screen_width - req.width)); y = CLAMP (y - 2, 0, MAX (0, screen_height - req.height)); gtk_window_move (GTK_WINDOW (window), x, y); gtk_widget_show(window); /* grab focus */ gdk_pointer_grab (window->window, TRUE, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_POINTER_MOTION_MASK, NULL, NULL, GDK_CURRENT_TIME); gdk_keyboard_grab (window->window, TRUE, GDK_CURRENT_TIME); gtk_grab_add(window); gtk_widget_grab_focus (treeview); return FALSE; }
bool partMover::entry_update(partMover *currentPart) { GdkColor color_grey; GdkColor color_yellow; GdkColor color_green; GdkColor color_red; GdkColor color_pink; GdkColor color_indaco; GdkColor color_white; GdkColor color_blue; color_pink.red=219*255; color_pink.green=166*255; color_pink.blue=171*255; color_red.red=255*255; color_red.green=100*255; color_red.blue=100*255; color_grey.red=220*255; color_grey.green=220*255; color_grey.blue=220*255; color_white.red=250*255; color_white.green=250*255; color_white.blue=250*255; color_green.red=149*255; color_green.green=221*255; color_green.blue=186*255; color_blue.red=150*255; color_blue.green=190*255; color_blue.blue=255*255; color_indaco.red=220*255; color_indaco.green=190*255; color_indaco.blue=220*255; color_yellow.red=249*255; color_yellow.green=236*255; color_yellow.blue=141*255; GdkColor* pColor= &color_grey; static int slowSwitcher = 0; IControlMode *ictrl = currentPart->ctrlmode; IPositionControl *ipos = currentPart->pos; IVelocityControl *ivel = currentPart->iVel; IEncoders *iiencs = currentPart->iencs; ITorqueControl *itrq = currentPart->trq; IAmplifierControl *iamp = currentPart->amp; GtkEntry * *pos_entry = (GtkEntry **) currentPart->currPosArray; GtkEntry **trq_entry = (GtkEntry **) currentPart->currTrqArray; GtkEntry **speed_entry = (GtkEntry **) currentPart->currSpeedArray; GtkEntry **inEntry = (GtkEntry **) currentPart->inPosArray; GtkWidget **colorback = (GtkWidget **) currentPart->frameColorBack; GtkWidget **sliderAry = currentPart->sliderArray; bool *POS_UPDATE = currentPart->CURRENT_POS_UPDATE; char buffer[40] = {'i', 'n', 'i', 't'}; char frame_title [255]; double positions[MAX_NUMBER_OF_JOINTS]; double torques[MAX_NUMBER_OF_JOINTS]; double speeds[MAX_NUMBER_OF_JOINTS]; double max_torques[MAX_NUMBER_OF_JOINTS]; double min_torques[MAX_NUMBER_OF_JOINTS]; static int controlModes[MAX_NUMBER_OF_JOINTS]; static int controlModesOld[MAX_NUMBER_OF_JOINTS]; int k; int NUMBER_OF_JOINTS=0; bool done = false; bool ret = false; ipos->getAxes(&NUMBER_OF_JOINTS); if (NUMBER_OF_JOINTS == 0) { fprintf(stderr,"Lost connection with iCubInterface. You should save and restart.\n" ); Time::delay(0.1); pColor=&color_grey; strcpy(frame_title,"DISCONNECTED"); for (k = 0; k < MAX_NUMBER_OF_JOINTS; k++) { if (currentPart->framesArray[k]!=0) { gtk_frame_set_label (GTK_FRAME(currentPart->framesArray[k]),frame_title); gtk_widget_modify_bg (colorback[k], GTK_STATE_NORMAL, pColor); } } return true; } for (k = 0; k < NUMBER_OF_JOINTS; k++) { max_torques[k]=0; min_torques[k]=0; torques[k]=0; } if (!iiencs->getEncoders(positions)) return true; itrq->getTorques(torques); iiencs->getEncoderSpeeds(speeds); //update all joints positions for (k = 0; k < NUMBER_OF_JOINTS; k++) { sprintf(buffer, "%.1f", positions[k]); gtk_entry_set_text((GtkEntry*) pos_entry[k], buffer); sprintf(buffer, "%.3f", torques[k]); gtk_entry_set_text((GtkEntry*) trq_entry[k], buffer); sprintf(buffer, "%.1f", speeds[k]); gtk_entry_set_text((GtkEntry*) speed_entry[k], buffer); } //update all joint sliders for (k = 0; k < NUMBER_OF_JOINTS; k++) if(POS_UPDATE[k]) gtk_range_set_value((GtkRange*)sliderAry[k], positions[k]); // *** update the checkMotionDone box section *** // (only one at a time in order to save badwidth) k = slowSwitcher%NUMBER_OF_JOINTS; slowSwitcher++; #if DEBUG_GUI gtk_entry_set_text((GtkEntry*) inEntry[k], "off"); #else ipos->checkMotionDone(k, &done); if (!done) gtk_entry_set_text((GtkEntry*) inEntry[k], " "); else gtk_entry_set_text((GtkEntry*) inEntry[k], "@"); #endif // *** update the controlMode section *** // the new icubinterface does not increase the bandwidth consumption // ret = true; useless guys! ret=ictrl->getControlModes(controlModes); if (ret==false) fprintf(stderr,"ictrl->getControlMode failed\n" ); for (k = 0; k < NUMBER_OF_JOINTS; k++) { if (currentPart->first_time==false && controlModes[k] == controlModesOld[k]) continue; controlModesOld[k]=controlModes[k]; sprintf(frame_title,"Joint %d ",k ); switch (controlModes[k]) { case VOCAB_CM_IDLE: pColor=&color_yellow; strcat(frame_title," (IDLE)"); gtk_frame_set_label (GTK_FRAME(currentPart->framesArray[k]),frame_title); gtk_widget_modify_bg (colorback[k], GTK_STATE_NORMAL, pColor); break; case VOCAB_CM_POSITION: pColor=&color_green; strcat(frame_title," (POSITION)"); gtk_frame_set_label (GTK_FRAME(currentPart->framesArray[k]),frame_title); gtk_frame_set_label (GTK_FRAME(currentPart->frame_slider1[k]),"Position:"); gtk_frame_set_label (GTK_FRAME(currentPart->frame_slider2[k]),"Velocity:"); gtk_widget_modify_bg (colorback[k], GTK_STATE_NORMAL, pColor); break; case VOCAB_CM_VELOCITY: pColor=&color_blue; strcat(frame_title," (VELOCITY)"); gtk_frame_set_label (GTK_FRAME(currentPart->framesArray[k]),frame_title); gtk_widget_modify_bg (colorback[k], GTK_STATE_NORMAL, pColor); break; case VOCAB_CM_TORQUE: pColor=&color_pink; strcat(frame_title," (TORQUE)"); gtk_frame_set_label (GTK_FRAME(currentPart->framesArray[k]),frame_title); gtk_frame_set_label (GTK_FRAME(currentPart->frame_slider1[k]),"Torque:"); gtk_frame_set_label (GTK_FRAME(currentPart->frame_slider2[k]),"Torque2:"); gtk_widget_modify_bg (colorback[k], GTK_STATE_NORMAL, pColor); break; case VOCAB_CM_IMPEDANCE_POS: pColor=&color_indaco; strcat(frame_title," (IMPEDANCE POS)"); gtk_frame_set_label (GTK_FRAME(currentPart->framesArray[k]),frame_title); gtk_widget_modify_bg (colorback[k], GTK_STATE_NORMAL, pColor); break; case VOCAB_CM_IMPEDANCE_VEL: pColor=&color_indaco; strcat(frame_title," (IMPEDANCE VEL)"); gtk_frame_set_label (GTK_FRAME(currentPart->framesArray[k]),frame_title); gtk_widget_modify_bg (colorback[k], GTK_STATE_NORMAL, pColor); break; case VOCAB_CM_OPENLOOP: pColor=&color_white; strcat(frame_title," (OPENLOOP)"); gtk_frame_set_label (GTK_FRAME(currentPart->framesArray[k]),frame_title); gtk_widget_modify_bg (colorback[k], GTK_STATE_NORMAL, pColor); break; default: case VOCAB_CM_UNKNOWN: pColor=&color_grey; //strcat(frame_title," (UNKNOWN)"); gtk_frame_set_label (GTK_FRAME(currentPart->framesArray[k]),frame_title); gtk_widget_modify_bg (colorback[k], GTK_STATE_NORMAL, pColor); break; } // pColor=&color_blue; // gtk_widget_modify_bg (colorback[k], GTK_STATE_NORMAL, pColor); int curr_amp_status=0; int amp_status[60]; //fix this!!! for (int i=0; i<60; i++) amp_status[i]=0; //fix this!!! iamp->getAmpStatus(amp_status); //fix this!!! curr_amp_status=amp_status[k]; //fix this!!! #if 0 if ((amp_status[k] & 0xFF)!=0) { //fprintf(stderr, "FAULT DETECTED: %x\n", curr_amp_status); //pColor=&color_red; //strcat(frame_title," (FAULT)"); //gtk_frame_set_label (GTK_FRAME(currentPart->framesArray[k]),frame_title); //gtk_widget_modify_bg (colorback[k], GTK_STATE_NORMAL, pColor); } #endif } currentPart->first_time =false; return true; }
GtkWidget* create_dialog1 (void) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *vbox1; GtkWidget *frame1; GtkWidget *table1; GtkWidget *buttonSelect; GtkWidget *labelVobsub; GtkWidget *label4; GtkWidget *optionmenu1; GtkWidget *label2; GtkWidget *frame2; GtkWidget *table2; GtkWidget *label6; GtkObject *spinbutton1_adj; GtkWidget *spinbutton1; GtkWidget *label7; GtkWidget *entryShift; GtkWidget *label5; GtkWidget *dialog_action_area1; GtkWidget *cancelbutton1; GtkWidget *okbutton1; dialog1 = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("VobSub Settings")); dialog_vbox1 = GTK_DIALOG (dialog1)->vbox; gtk_widget_show (dialog_vbox1); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0); frame1 = gtk_frame_new (NULL); gtk_widget_show (frame1); gtk_box_pack_start (GTK_BOX (vbox1), frame1, TRUE, TRUE, 0); table1 = gtk_table_new (2, 2, FALSE); gtk_widget_show (table1); gtk_container_add (GTK_CONTAINER (frame1), table1); buttonSelect = gtk_button_new_with_mnemonic (QT_TR_NOOP("Select .idx")); gtk_widget_show (buttonSelect); gtk_table_attach (GTK_TABLE (table1), buttonSelect, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); labelVobsub = gtk_label_new (QT_TR_NOOP("None")); gtk_widget_show (labelVobsub); gtk_table_attach (GTK_TABLE (table1), labelVobsub, 0, 1, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (labelVobsub), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (labelVobsub), 0, 0.5); label4 = gtk_label_new (QT_TR_NOOP("Select Language :")); gtk_widget_show (label4); gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5); optionmenu1 = gtk_option_menu_new (); gtk_widget_show (optionmenu1); gtk_table_attach (GTK_TABLE (table1), optionmenu1, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); label2 = gtk_label_new (QT_TR_NOOP("Select Sub")); gtk_widget_show (label2); gtk_frame_set_label_widget (GTK_FRAME (frame1), label2); gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT); frame2 = gtk_frame_new (NULL); gtk_widget_show (frame2); gtk_box_pack_start (GTK_BOX (vbox1), frame2, TRUE, TRUE, 0); table2 = gtk_table_new (2, 2, FALSE); gtk_widget_show (table2); gtk_container_add (GTK_CONTAINER (frame2), table2); label6 = gtk_label_new (QT_TR_NOOP("Extra Shrink Factor :")); gtk_widget_show (label6); gtk_table_attach (GTK_TABLE (table2), label6, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label6), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5); spinbutton1_adj = gtk_adjustment_new (1, 1, 2, 0.1, 0.2, 0); spinbutton1 = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton1_adj), 1, 0); gtk_widget_show (spinbutton1); gtk_table_attach (GTK_TABLE (table2), spinbutton1, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); label7 = gtk_label_new (QT_TR_NOOP("Shift (ms) :")); gtk_widget_show (label7); gtk_table_attach (GTK_TABLE (table2), label7, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label7), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5); entryShift = gtk_entry_new (); gtk_widget_show (entryShift); gtk_table_attach (GTK_TABLE (table2), entryShift, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); label5 = gtk_label_new (QT_TR_NOOP("Extra Settings")); gtk_widget_show (label5); gtk_frame_set_label_widget (GTK_FRAME (frame2), label5); gtk_label_set_justify (GTK_LABEL (label5), GTK_JUSTIFY_LEFT); dialog_action_area1 = GTK_DIALOG (dialog1)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (cancelbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT); okbutton1 = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT (dialog1, frame1, "frame1"); GLADE_HOOKUP_OBJECT (dialog1, table1, "table1"); GLADE_HOOKUP_OBJECT (dialog1, buttonSelect, "buttonSelect"); GLADE_HOOKUP_OBJECT (dialog1, labelVobsub, "labelVobsub"); GLADE_HOOKUP_OBJECT (dialog1, label4, "label4"); GLADE_HOOKUP_OBJECT (dialog1, optionmenu1, "optionmenu1"); GLADE_HOOKUP_OBJECT (dialog1, label2, "label2"); GLADE_HOOKUP_OBJECT (dialog1, frame2, "frame2"); GLADE_HOOKUP_OBJECT (dialog1, table2, "table2"); GLADE_HOOKUP_OBJECT (dialog1, label6, "label6"); GLADE_HOOKUP_OBJECT (dialog1, spinbutton1, "spinbutton1"); GLADE_HOOKUP_OBJECT (dialog1, label7, "label7"); GLADE_HOOKUP_OBJECT (dialog1, entryShift, "entryShift"); GLADE_HOOKUP_OBJECT (dialog1, label5, "label5"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1"); GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1"); return dialog1; }
static void dma_sparse_view_goto_activate (GtkWidget *menu_item, DmaSparseView *view) { GtkWidget *toplevel; GtkWidget *frame; GtkWidget *vbox; GtkWindowGroup *toplevel_group, *goto_window_group; toplevel = gtk_widget_get_toplevel (GTK_WIDGET (view)); toplevel_group = gtk_window_get_group (GTK_WINDOW (toplevel)); if (view->priv->goto_window != NULL) { goto_window_group = gtk_window_get_group (GTK_WINDOW (view->priv->goto_window)); if (toplevel_group) gtk_window_group_add_window (toplevel_group, GTK_WINDOW (view->priv->goto_window)); else if (goto_window_group) gtk_window_group_remove_window (goto_window_group, GTK_WINDOW (view->priv->goto_window)); } else { view->priv->goto_window = gtk_window_new (GTK_WINDOW_POPUP); if (toplevel_group) gtk_window_group_add_window (toplevel_group, GTK_WINDOW (view->priv->goto_window)); gtk_window_set_modal (GTK_WINDOW (view->priv->goto_window), TRUE); g_signal_connect (view->priv->goto_window, "delete_event", G_CALLBACK (dma_sparse_view_goto_delete_event), view); g_signal_connect (view->priv->goto_window, "key_press_event", G_CALLBACK (dma_sparse_view_goto_key_press_event), view); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN); gtk_widget_show (frame); gtk_container_add (GTK_CONTAINER (view->priv->goto_window), frame); vbox = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_container_set_border_width (GTK_CONTAINER (vbox), 3); /* add entry */ view->priv->goto_entry = gtk_entry_new (); gtk_entry_set_icon_from_stock (GTK_ENTRY (view->priv->goto_entry), GTK_ENTRY_ICON_PRIMARY, GTK_STOCK_JUMP_TO); gtk_widget_show (view->priv->goto_entry); gtk_container_add (GTK_CONTAINER (vbox), view->priv->goto_entry); gtk_widget_realize (view->priv->goto_entry); } dma_sparse_view_goto_position_func (view); gtk_entry_set_text (GTK_ENTRY (view->priv->goto_entry), "0x"); gtk_widget_show (view->priv->goto_window); gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (view), FALSE); gtk_widget_grab_focus (view->priv->goto_entry); send_focus_change (view->priv->goto_entry, TRUE); gtk_editable_set_position (GTK_EDITABLE (view->priv->goto_entry), -1); }
int main (int argc, char *argv[]) { GtkWidget *win, *vbox, *frame, *alignment, *group_box; GtkWidget *hbox, *label, *chooser, *button; GtkSizeGroup *label_group; GOptionContext *context; gchar *cwd; context = g_option_context_new ("- test GtkFileChooserButton widget"); g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE); g_option_context_add_group (context, gtk_get_option_group (TRUE)); g_option_context_parse (context, &argc, &argv, NULL); g_option_context_free (context); gtk_init (&argc, &argv); /* to test rtl layout, use "--right-to-left" */ if (rtl) gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL); cwd = g_get_current_dir(); gtk_src_dir = g_path_get_dirname (cwd); g_free (cwd); win = gtk_dialog_new_with_buttons ("TestFileChooserButton", NULL, 0, "_Quit", GTK_RESPONSE_CLOSE, NULL); g_signal_connect (win, "style-set", G_CALLBACK (win_style_set_cb), NULL); g_signal_connect (win, "response", G_CALLBACK (gtk_main_quit), NULL); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18); gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (win))), vbox); frame = gtk_frame_new ("<b>GtkFileChooserButton</b>"); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); gtk_label_set_use_markup (GTK_LABEL (gtk_frame_get_label_widget (GTK_FRAME (frame))), TRUE); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); alignment = gtk_alignment_new (0.0, 0.0, 1.0, 1.0); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 6, 0, 12, 0); gtk_container_add (GTK_CONTAINER (frame), alignment); label_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); group_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (alignment), group_box); /* OPEN */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (group_box), hbox, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic ("_Open:"); gtk_size_group_add_widget (GTK_SIZE_GROUP (label_group), label); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); chooser = gtk_file_chooser_button_new ("Select A File - testfilechooserbutton", GTK_FILE_CHOOSER_ACTION_OPEN); gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL); gtk_file_chooser_remove_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL); gtk_label_set_mnemonic_widget (GTK_LABEL (label), chooser); g_signal_connect (chooser, "current-folder-changed", G_CALLBACK (chooser_current_folder_changed_cb), NULL); g_signal_connect (chooser, "selection-changed", G_CALLBACK (chooser_selection_changed_cb), NULL); g_signal_connect (chooser, "file-activated", G_CALLBACK (chooser_file_activated_cb), NULL); g_signal_connect (chooser, "update-preview", G_CALLBACK (chooser_update_preview_cb), NULL); gtk_box_pack_start (GTK_BOX (hbox), chooser, TRUE, TRUE, 0); button = gtk_button_new_with_label ("Properties"); g_signal_connect (button, "clicked", G_CALLBACK (properties_button_clicked_cb), chooser); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); button = gtk_button_new_with_label ("Tests"); g_signal_connect (button, "clicked", G_CALLBACK (tests_button_clicked_cb), chooser); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); /* SELECT_FOLDER */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (group_box), hbox, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic ("Select _Folder:"); gtk_size_group_add_widget (GTK_SIZE_GROUP (label_group), label); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); chooser = gtk_file_chooser_button_new ("Select A Folder - testfilechooserbutton", GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL); gtk_file_chooser_remove_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL); gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL); gtk_label_set_mnemonic_widget (GTK_LABEL (label), chooser); g_signal_connect (chooser, "current-folder-changed", G_CALLBACK (chooser_current_folder_changed_cb), NULL); g_signal_connect (chooser, "selection-changed", G_CALLBACK (chooser_selection_changed_cb), NULL); g_signal_connect (chooser, "file-activated", G_CALLBACK (chooser_file_activated_cb), NULL); g_signal_connect (chooser, "update-preview", G_CALLBACK (chooser_update_preview_cb), NULL); gtk_box_pack_start (GTK_BOX (hbox), chooser, TRUE, TRUE, 0); button = gtk_button_new_with_label ("Properties"); g_signal_connect (button, "clicked", G_CALLBACK (properties_button_clicked_cb), chooser); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); button = gtk_button_new_with_label ("Tests"); g_signal_connect (button, "clicked", G_CALLBACK (tests_button_clicked_cb), chooser); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); g_object_unref (label_group); gtk_widget_show_all (win); gtk_window_present (GTK_WINDOW (win)); gtk_main (); return 0; }
GtkWidget* create_particle_dialog (void) { GtkWidget *particle_dialog; GtkWidget *dialogVbox; GtkWidget *dialogHbox; GtkWidget *allButButtonsHbox; GtkWidget *settingsOuterHbox; GtkWidget *settingsOuterVbox; GtkWidget *minAreaHbox; GtkWidget *minAreaLabel; GtkObject *minAreaSpinButton_adj; GtkWidget *minAreaSpinButton; GtkWidget *maxAreaHbox; GtkWidget *maxAreaLabel; GtkObject *maxAreaSpinButton_adj; GtkWidget *maxAreaSpinButton; GtkWidget *aboveCropSeparator; GtkWidget *leftCropHbox; GtkWidget *leftCropLabel; GtkObject *leftCropSpinButton_adj; GtkWidget *leftCropSpinButton; GtkWidget *rightCropHbox; GtkWidget *rightCropLabel; GtkObject *rightCropSpinButton_adj; GtkWidget *rightCropSpinButton; GtkWidget *topCropHbox; GtkWidget *topCropLabel; GtkObject *topCropSpinButton_adj; GtkWidget *topCropSpinButton; GtkWidget *bottomCropHbox; GtkWidget *bottomCropLabel; GtkObject *bottomCropSpinButton_adj; GtkWidget *bottomCropSpinButton; GtkWidget *belowCropSeparator; GtkWidget *outputFormatHbox; GtkWidget *outputFormatLabel; GtkWidget *outputFormatMenu; GtkWidget *outputFileHbox; GtkWidget *outputFileLabel; GtkWidget *outputFileEntry; GtkWidget *outputFileBrowseButton; GtkWidget *cameraNumberHbox; GtkWidget *cameraNumberLabel; GtkObject *cameraNumberSpinButton_adj; GtkWidget *cameraNumberSpinButton; GtkWidget *debugHbox; GtkWidget *debugLabel; GtkObject *debugSpinButton_adj; GtkWidget *debugSpinButton; GtkWidget *previewVboxOuter; GtkWidget *previewFrame; GtkWidget *previewAlignment; GtkWidget *previewVbox; GtkWidget *previewControlHbox; GtkWidget *previewOutputMenu; GtkWidget *previewSlider; GtkWidget *previewVideo; GtkWidget *previewLabel; GtkWidget *dialogButtonBox; GtkWidget *cancelButton; GtkWidget *okButton; particle_dialog = gtk_dialog_new (); // NO NEED TO "FIX" THAT _("...")!! // see handy macro near top of file. gtk_window_set_title (GTK_WINDOW (particle_dialog), _("Particle Detection")); gtk_window_set_type_hint (GTK_WINDOW (particle_dialog), GDK_WINDOW_TYPE_HINT_DIALOG); dialogVbox = GTK_DIALOG (particle_dialog)->vbox; gtk_widget_show (dialogVbox); dialogHbox = gtk_hbox_new (FALSE, 0); gtk_widget_show (dialogHbox); gtk_box_pack_start (GTK_BOX (dialogVbox), dialogHbox, TRUE, TRUE, 0); allButButtonsHbox = gtk_hbox_new (FALSE, 12); gtk_widget_show (allButButtonsHbox); gtk_box_pack_start (GTK_BOX (dialogHbox), allButButtonsHbox, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (allButButtonsHbox), 8); settingsOuterHbox = gtk_hbox_new (FALSE, 0); gtk_widget_show (settingsOuterHbox); gtk_box_pack_start (GTK_BOX (allButButtonsHbox), settingsOuterHbox, FALSE, TRUE, 0); settingsOuterVbox = gtk_vbox_new (FALSE, 12); gtk_widget_show (settingsOuterVbox); gtk_box_pack_start (GTK_BOX (settingsOuterHbox), settingsOuterVbox, FALSE, TRUE, 0); minAreaHbox = gtk_hbox_new (FALSE, 0); gtk_widget_show (minAreaHbox); gtk_box_pack_start (GTK_BOX (settingsOuterVbox), minAreaHbox, FALSE, TRUE, 0); minAreaLabel = gtk_label_new_with_mnemonic (_("Mi_nimum area for a particle to be detected: ")); gtk_widget_show (minAreaLabel); gtk_box_pack_start (GTK_BOX (minAreaHbox), minAreaLabel, FALSE, FALSE, 0); minAreaSpinButton_adj = gtk_adjustment_new (5, 1, 999999, 1, 1, 0); minAreaSpinButton = gtk_spin_button_new (GTK_ADJUSTMENT (minAreaSpinButton_adj), 1, 0); gtk_widget_show (minAreaSpinButton); gtk_box_pack_start (GTK_BOX (minAreaHbox), minAreaSpinButton, TRUE, TRUE, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (minAreaSpinButton), TRUE); maxAreaHbox = gtk_hbox_new (FALSE, 0); gtk_widget_show (maxAreaHbox); gtk_box_pack_start (GTK_BOX (settingsOuterVbox), maxAreaHbox, FALSE, TRUE, 0); maxAreaLabel = gtk_label_new_with_mnemonic (_("Ma_ximum area for a particle to be detected: ")); gtk_widget_show (maxAreaLabel); gtk_box_pack_start (GTK_BOX (maxAreaHbox), maxAreaLabel, FALSE, FALSE, 0); maxAreaSpinButton_adj = gtk_adjustment_new (50000, 1, 999999, 1, 1, 0); maxAreaSpinButton = gtk_spin_button_new (GTK_ADJUSTMENT (maxAreaSpinButton_adj), 1, 0); gtk_widget_show (maxAreaSpinButton); gtk_box_pack_start (GTK_BOX (maxAreaHbox), maxAreaSpinButton, TRUE, TRUE, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (maxAreaSpinButton), TRUE); aboveCropSeparator = gtk_hseparator_new (); gtk_widget_show (aboveCropSeparator); gtk_box_pack_start (GTK_BOX (settingsOuterVbox), aboveCropSeparator, FALSE, TRUE, 0); leftCropHbox = gtk_hbox_new (FALSE, 0); gtk_widget_show (leftCropHbox); gtk_box_pack_start (GTK_BOX (settingsOuterVbox), leftCropHbox, FALSE, TRUE, 0); leftCropLabel = gtk_label_new_with_mnemonic (_("_Left side crop (ignore this many pixels on the left): ")); gtk_widget_show (leftCropLabel); gtk_box_pack_start (GTK_BOX (leftCropHbox), leftCropLabel, FALSE, FALSE, 0); leftCropSpinButton_adj = gtk_adjustment_new (0, 0, 2048, 1, 1, 0); leftCropSpinButton = gtk_spin_button_new (GTK_ADJUSTMENT (leftCropSpinButton_adj), 1, 0); gtk_widget_show (leftCropSpinButton); gtk_box_pack_start (GTK_BOX (leftCropHbox), leftCropSpinButton, TRUE, TRUE, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (leftCropSpinButton), TRUE); rightCropHbox = gtk_hbox_new (FALSE, 0); gtk_widget_show (rightCropHbox); gtk_box_pack_start (GTK_BOX (settingsOuterVbox), rightCropHbox, FALSE, TRUE, 0); rightCropLabel = gtk_label_new_with_mnemonic (_("_Right side crop (ignore this many pixels on the right): ")); gtk_widget_show (rightCropLabel); gtk_box_pack_start (GTK_BOX (rightCropHbox), rightCropLabel, FALSE, FALSE, 0); rightCropSpinButton_adj = gtk_adjustment_new (0, 0, 2048, 1, 1, 0); rightCropSpinButton = gtk_spin_button_new (GTK_ADJUSTMENT (rightCropSpinButton_adj), 1, 0); gtk_widget_show (rightCropSpinButton); gtk_box_pack_start (GTK_BOX (rightCropHbox), rightCropSpinButton, TRUE, TRUE, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (rightCropSpinButton), TRUE); topCropHbox = gtk_hbox_new (FALSE, 0); gtk_widget_show (topCropHbox); gtk_box_pack_start (GTK_BOX (settingsOuterVbox), topCropHbox, FALSE, TRUE, 0); topCropLabel = gtk_label_new_with_mnemonic (_("_Top crop (ignore this many pixels on the top): ")); gtk_widget_show (topCropLabel); gtk_box_pack_start (GTK_BOX (topCropHbox), topCropLabel, FALSE, FALSE, 0); topCropSpinButton_adj = gtk_adjustment_new (0, 0, 2048, 1, 1, 0); topCropSpinButton = gtk_spin_button_new (GTK_ADJUSTMENT (topCropSpinButton_adj), 1, 0); gtk_widget_show (topCropSpinButton); gtk_box_pack_start (GTK_BOX (topCropHbox), topCropSpinButton, TRUE, TRUE, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (topCropSpinButton), TRUE); bottomCropHbox = gtk_hbox_new (FALSE, 0); gtk_widget_show (bottomCropHbox); gtk_box_pack_start (GTK_BOX (settingsOuterVbox), bottomCropHbox, FALSE, TRUE, 0); bottomCropLabel = gtk_label_new_with_mnemonic (_("_Bottom crop (ignore this many pixels on the bottom): ")); gtk_widget_show (bottomCropLabel); gtk_box_pack_start (GTK_BOX (bottomCropHbox), bottomCropLabel, FALSE, FALSE, 0); bottomCropSpinButton_adj = gtk_adjustment_new (0, 0, 2048, 1, 1, 0); bottomCropSpinButton = gtk_spin_button_new (GTK_ADJUSTMENT (bottomCropSpinButton_adj), 1, 0); gtk_widget_show (bottomCropSpinButton); gtk_box_pack_start (GTK_BOX (bottomCropHbox), bottomCropSpinButton, TRUE, TRUE, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (bottomCropSpinButton), TRUE); belowCropSeparator = gtk_hseparator_new (); gtk_widget_show (belowCropSeparator); gtk_box_pack_start (GTK_BOX (settingsOuterVbox), belowCropSeparator, FALSE, TRUE, 0); outputFormatHbox = gtk_hbox_new (FALSE, 0); gtk_widget_show (outputFormatHbox); gtk_box_pack_start (GTK_BOX (settingsOuterVbox), outputFormatHbox, FALSE, TRUE, 0); outputFormatLabel = gtk_label_new_with_mnemonic (_("Output _Format: ")); gtk_widget_show (outputFormatLabel); gtk_box_pack_start (GTK_BOX (outputFormatHbox), outputFormatLabel, FALSE, FALSE, 0); outputFormatMenu = gtk_combo_box_new_text (); gtk_widget_show (outputFormatMenu); gtk_box_pack_start (GTK_BOX (outputFormatHbox), outputFormatMenu, TRUE, TRUE, 0); outputFileHbox = gtk_hbox_new (FALSE, 5); gtk_widget_show (outputFileHbox); gtk_box_pack_start (GTK_BOX (settingsOuterVbox), outputFileHbox, FALSE, TRUE, 0); outputFileLabel = gtk_label_new_with_mnemonic (_("_Output File:")); gtk_widget_show (outputFileLabel); gtk_box_pack_start (GTK_BOX (outputFileHbox), outputFileLabel, FALSE, FALSE, 0); outputFileEntry = gtk_entry_new (); gtk_widget_show (outputFileEntry); gtk_box_pack_start (GTK_BOX (outputFileHbox), outputFileEntry, TRUE, TRUE, 0); gtk_entry_set_invisible_char (GTK_ENTRY (outputFileEntry), 8226); gtk_entry_set_width_chars (GTK_ENTRY (outputFileEntry), 40); outputFileBrowseButton = gtk_button_new_with_mnemonic (_("_Browse...")); gtk_widget_show (outputFileBrowseButton); gtk_box_pack_start (GTK_BOX (outputFileHbox), outputFileBrowseButton, FALSE, FALSE, 0); cameraNumberHbox = gtk_hbox_new (FALSE, 0); gtk_widget_show (cameraNumberHbox); gtk_box_pack_start (GTK_BOX (settingsOuterVbox), cameraNumberHbox, FALSE, TRUE, 0); cameraNumberLabel = gtk_label_new_with_mnemonic (_("_Camera Number for output file: ")); gtk_widget_show (cameraNumberLabel); gtk_box_pack_start (GTK_BOX (cameraNumberHbox), cameraNumberLabel, FALSE, FALSE, 0); cameraNumberSpinButton_adj = gtk_adjustment_new (1, 0, 99999, 1, 1, 0); cameraNumberSpinButton = gtk_spin_button_new (GTK_ADJUSTMENT (cameraNumberSpinButton_adj), 1, 0); gtk_widget_show (cameraNumberSpinButton); gtk_box_pack_start (GTK_BOX (cameraNumberHbox), cameraNumberSpinButton, TRUE, TRUE, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (cameraNumberSpinButton), TRUE); debugHbox = gtk_hbox_new (FALSE, 0); gtk_widget_show (debugHbox); gtk_box_pack_start (GTK_BOX (settingsOuterVbox), debugHbox, FALSE, TRUE, 0); debugLabel = gtk_label_new_with_mnemonic (_("_Debugging settings (bits): ")); gtk_widget_show (debugLabel); gtk_box_pack_start (GTK_BOX (debugHbox), debugLabel, FALSE, FALSE, 0); debugSpinButton_adj = gtk_adjustment_new (0, 0, 16777215, 1, 10, 0); debugSpinButton = gtk_spin_button_new (GTK_ADJUSTMENT (debugSpinButton_adj), 1, 0); gtk_widget_show (debugSpinButton); gtk_box_pack_start (GTK_BOX (debugHbox), debugSpinButton, TRUE, TRUE, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (debugSpinButton), TRUE); previewVboxOuter = gtk_vbox_new (FALSE, 0); gtk_widget_show (previewVboxOuter); gtk_box_pack_start (GTK_BOX (allButButtonsHbox), previewVboxOuter, TRUE, TRUE, 0); previewFrame = gtk_frame_new (NULL); gtk_widget_show (previewFrame); gtk_box_pack_start (GTK_BOX (previewVboxOuter), previewFrame, FALSE, TRUE, 0); previewAlignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (previewAlignment); gtk_container_add (GTK_CONTAINER (previewFrame), previewAlignment); gtk_alignment_set_padding (GTK_ALIGNMENT (previewAlignment), 0, 8, 6, 8); previewVbox = gtk_vbox_new (FALSE, 5); gtk_widget_show (previewVbox); gtk_container_add (GTK_CONTAINER (previewAlignment), previewVbox); previewControlHbox = gtk_hbox_new (FALSE, 5); gtk_widget_show (previewControlHbox); gtk_box_pack_start (GTK_BOX (previewVbox), previewControlHbox, TRUE, TRUE, 0); previewOutputMenu = gtk_combo_box_new_text (); gtk_widget_show (previewOutputMenu); gtk_box_pack_start (GTK_BOX (previewControlHbox), previewOutputMenu, FALSE, TRUE, 0); previewSlider = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 99, 1, 1, 0))); gtk_widget_show (previewSlider); gtk_box_pack_start (GTK_BOX (previewControlHbox), previewSlider, TRUE, TRUE, 0); gtk_scale_set_digits (GTK_SCALE (previewSlider), 0); previewVideo = gtk_drawing_area_new (); gtk_widget_show (previewVideo); gtk_box_pack_start (GTK_BOX (previewVbox), previewVideo, TRUE, TRUE, 0); gtk_widget_set_size_request (previewVideo, 30, 30); gtk_widget_set_events (previewVideo, GDK_BUTTON1_MOTION_MASK | GDK_BUTTON_PRESS_MASK); previewLabel = gtk_label_new (_("Preview")); gtk_widget_show (previewLabel); gtk_frame_set_label_widget (GTK_FRAME (previewFrame), previewLabel); dialogButtonBox = GTK_DIALOG (particle_dialog)->action_area; gtk_widget_show (dialogButtonBox); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialogButtonBox), GTK_BUTTONBOX_END); cancelButton = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (cancelButton); gtk_dialog_add_action_widget (GTK_DIALOG (particle_dialog), cancelButton, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelButton, GTK_CAN_DEFAULT); okButton = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (okButton); gtk_dialog_add_action_widget (GTK_DIALOG (particle_dialog), okButton, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (okButton, GTK_CAN_DEFAULT); gtk_label_set_mnemonic_widget (GTK_LABEL (minAreaLabel), minAreaSpinButton); gtk_label_set_mnemonic_widget (GTK_LABEL (maxAreaLabel), maxAreaSpinButton); gtk_label_set_mnemonic_widget (GTK_LABEL (leftCropLabel), leftCropSpinButton); gtk_label_set_mnemonic_widget (GTK_LABEL (rightCropLabel), rightCropSpinButton); gtk_label_set_mnemonic_widget (GTK_LABEL (topCropLabel), topCropSpinButton); gtk_label_set_mnemonic_widget (GTK_LABEL (bottomCropLabel), bottomCropSpinButton); gtk_label_set_mnemonic_widget (GTK_LABEL (outputFileLabel), outputFileEntry); gtk_label_set_mnemonic_widget (GTK_LABEL (cameraNumberLabel), cameraNumberSpinButton); gtk_label_set_mnemonic_widget (GTK_LABEL (debugLabel), debugSpinButton); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (particle_dialog, particle_dialog, "particle_dialog"); GLADE_HOOKUP_OBJECT_NO_REF (particle_dialog, dialogVbox, "dialogVbox"); GLADE_HOOKUP_OBJECT (particle_dialog, dialogHbox, "dialogHbox"); GLADE_HOOKUP_OBJECT (particle_dialog, allButButtonsHbox, "allButButtonsHbox"); GLADE_HOOKUP_OBJECT (particle_dialog, settingsOuterHbox, "settingsOuterHbox"); GLADE_HOOKUP_OBJECT (particle_dialog, settingsOuterVbox, "settingsOuterVbox"); GLADE_HOOKUP_OBJECT (particle_dialog, minAreaHbox, "minAreaHbox"); GLADE_HOOKUP_OBJECT (particle_dialog, minAreaLabel, "minAreaLabel"); GLADE_HOOKUP_OBJECT (particle_dialog, minAreaSpinButton, "minAreaSpinButton"); GLADE_HOOKUP_OBJECT (particle_dialog, maxAreaHbox, "maxAreaHbox"); GLADE_HOOKUP_OBJECT (particle_dialog, maxAreaLabel, "maxAreaLabel"); GLADE_HOOKUP_OBJECT (particle_dialog, maxAreaSpinButton, "maxAreaSpinButton"); GLADE_HOOKUP_OBJECT (particle_dialog, aboveCropSeparator, "aboveCropSeparator"); GLADE_HOOKUP_OBJECT (particle_dialog, leftCropHbox, "leftCropHbox"); GLADE_HOOKUP_OBJECT (particle_dialog, leftCropLabel, "leftCropLabel"); GLADE_HOOKUP_OBJECT (particle_dialog, leftCropSpinButton, "leftCropSpinButton"); GLADE_HOOKUP_OBJECT (particle_dialog, rightCropHbox, "rightCropHbox"); GLADE_HOOKUP_OBJECT (particle_dialog, rightCropLabel, "rightCropLabel"); GLADE_HOOKUP_OBJECT (particle_dialog, rightCropSpinButton, "rightCropSpinButton"); GLADE_HOOKUP_OBJECT (particle_dialog, topCropHbox, "topCropHbox"); GLADE_HOOKUP_OBJECT (particle_dialog, topCropLabel, "topCropLabel"); GLADE_HOOKUP_OBJECT (particle_dialog, topCropSpinButton, "topCropSpinButton"); GLADE_HOOKUP_OBJECT (particle_dialog, bottomCropHbox, "bottomCropHbox"); GLADE_HOOKUP_OBJECT (particle_dialog, bottomCropLabel, "bottomCropLabel"); GLADE_HOOKUP_OBJECT (particle_dialog, bottomCropSpinButton, "bottomCropSpinButton"); GLADE_HOOKUP_OBJECT (particle_dialog, belowCropSeparator, "belowCropSeparator"); GLADE_HOOKUP_OBJECT (particle_dialog, outputFormatHbox, "outputFormatHbox"); GLADE_HOOKUP_OBJECT (particle_dialog, outputFormatLabel, "outputFormatLabel"); GLADE_HOOKUP_OBJECT (particle_dialog, outputFormatMenu, "outputFormatMenu"); GLADE_HOOKUP_OBJECT (particle_dialog, outputFileHbox, "outputFileHbox"); GLADE_HOOKUP_OBJECT (particle_dialog, outputFileLabel, "outputFileLabel"); GLADE_HOOKUP_OBJECT (particle_dialog, outputFileEntry, "outputFileEntry"); GLADE_HOOKUP_OBJECT (particle_dialog, outputFileBrowseButton, "outputFileBrowseButton"); GLADE_HOOKUP_OBJECT (particle_dialog, cameraNumberHbox, "cameraNumberHbox"); GLADE_HOOKUP_OBJECT (particle_dialog, cameraNumberLabel, "cameraNumberLabel"); GLADE_HOOKUP_OBJECT (particle_dialog, cameraNumberSpinButton, "cameraNumberSpinButton"); GLADE_HOOKUP_OBJECT (particle_dialog, debugHbox, "debugHbox"); GLADE_HOOKUP_OBJECT (particle_dialog, debugLabel, "debugLabel"); GLADE_HOOKUP_OBJECT (particle_dialog, debugSpinButton, "debugSpinButton"); GLADE_HOOKUP_OBJECT (particle_dialog, previewVboxOuter, "previewVboxOuter"); GLADE_HOOKUP_OBJECT (particle_dialog, previewFrame, "previewFrame"); GLADE_HOOKUP_OBJECT (particle_dialog, previewAlignment, "previewAlignment"); GLADE_HOOKUP_OBJECT (particle_dialog, previewVbox, "previewVbox"); GLADE_HOOKUP_OBJECT (particle_dialog, previewControlHbox, "previewControlHbox"); GLADE_HOOKUP_OBJECT (particle_dialog, previewOutputMenu, "previewOutputMenu"); GLADE_HOOKUP_OBJECT (particle_dialog, previewSlider, "previewSlider"); GLADE_HOOKUP_OBJECT (particle_dialog, previewVideo, "previewVideo"); GLADE_HOOKUP_OBJECT (particle_dialog, previewLabel, "previewLabel"); GLADE_HOOKUP_OBJECT_NO_REF (particle_dialog, dialogButtonBox, "dialogButtonBox"); GLADE_HOOKUP_OBJECT (particle_dialog, cancelButton, "cancelButton"); GLADE_HOOKUP_OBJECT (particle_dialog, okButton, "okButton"); return particle_dialog; }
MetaTabPopup* meta_ui_tab_popup_new (const MetaTabEntry *entries, int screen_number, int entry_count, int width, gboolean outline) { MetaTabPopup *popup; int i, left, right, top, bottom; int height; GtkWidget *table; GtkWidget *vbox; GtkWidget *align; GList *tmp; GtkWidget *frame; int max_label_width; /* the actual max width of the labels we create */ AtkObject *obj; GdkScreen *screen; int screen_width; popup = g_new (MetaTabPopup, 1); popup->outline_window = gtk_window_new (GTK_WINDOW_POPUP); screen = gdk_display_get_screen (gdk_display_get_default (), screen_number); gtk_window_set_screen (GTK_WINDOW (popup->outline_window), screen); gtk_widget_set_app_paintable (popup->outline_window, TRUE); gtk_widget_realize (popup->outline_window); g_signal_connect (G_OBJECT (popup->outline_window), "draw", G_CALLBACK (outline_window_draw), popup); popup->window = gtk_window_new (GTK_WINDOW_POPUP); gtk_window_set_screen (GTK_WINDOW (popup->window), screen); gtk_window_set_position (GTK_WINDOW (popup->window), GTK_WIN_POS_CENTER_ALWAYS); /* enable resizing, to get never-shrink behavior */ gtk_window_set_resizable (GTK_WINDOW (popup->window), TRUE); popup->current = NULL; popup->entries = NULL; popup->current_selected_entry = NULL; popup->outline = outline; screen_width = gdk_screen_get_width (screen); for (i = 0; i < entry_count; ++i) { TabEntry* new_entry = tab_entry_new (&entries[i], screen_width, outline); popup->entries = g_list_prepend (popup->entries, new_entry); } popup->entries = g_list_reverse (popup->entries); g_assert (width > 0); height = i / width; if (i % width) height += 1; table = gtk_table_new (height, width, FALSE); vbox = gtk_vbox_new (FALSE, 0); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT); gtk_container_set_border_width (GTK_CONTAINER (table), 1); gtk_container_add (GTK_CONTAINER (popup->window), frame); gtk_container_add (GTK_CONTAINER (frame), vbox); align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); gtk_box_pack_start (GTK_BOX (vbox), align, TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER (align), table); popup->label = gtk_label_new (""); /* Set the accessible role of the label to a status bar so it * will emit name changed events that can be used by screen * readers. */ obj = gtk_widget_get_accessible (popup->label); atk_object_set_role (obj, ATK_ROLE_STATUSBAR); gtk_misc_set_padding (GTK_MISC (popup->label), 3, 3); gtk_box_pack_end (GTK_BOX (vbox), popup->label, FALSE, FALSE, 0); max_label_width = 0; top = 0; bottom = 1; tmp = popup->entries; while (tmp && top < height) { left = 0; right = 1; while (tmp && left < width) { GtkWidget *image; GtkRequisition req; TabEntry *te; te = tmp->data; if (te->blank) { /* just stick a widget here to avoid special cases */ image = gtk_alignment_new (0.0, 0.0, 0.0, 0.0); } else if (outline) { if (te->dimmed_icon) { image = selectable_image_new (te->dimmed_icon); } else { image = selectable_image_new (te->icon); } gtk_misc_set_padding (GTK_MISC (image), INSIDE_SELECT_RECT + OUTSIDE_SELECT_RECT + 1, INSIDE_SELECT_RECT + OUTSIDE_SELECT_RECT + 1); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.5); } else { image = selectable_workspace_new ((MetaWorkspace *) te->key); } te->widget = image; gtk_table_attach (GTK_TABLE (table), te->widget, left, right, top, bottom, 0, 0, 0, 0); /* Efficiency rules! */ gtk_label_set_markup (GTK_LABEL (popup->label), te->title); gtk_widget_size_request (popup->label, &req); max_label_width = MAX (max_label_width, req.width); tmp = tmp->next; ++left; ++right; } ++top; ++bottom; } /* remove all the temporary text */ gtk_label_set_text (GTK_LABEL (popup->label), ""); /* Make it so that we ellipsize if the text is too long */ gtk_label_set_ellipsize (GTK_LABEL (popup->label), PANGO_ELLIPSIZE_END); /* Limit the window size to no bigger than screen_width/4 */ if (max_label_width>(screen_width/4)) { max_label_width = screen_width/4; } max_label_width += 20; /* add random padding */ gtk_window_set_default_size (GTK_WINDOW (popup->window), max_label_width, -1); return popup; }
int main(int argc, char ** argv) { GtkWidget * vbox; GtkWidget * hpaned; GtkWidget * sc_win, * sc_buffer; GtkWidget * menu_bar; GtkWidget * file_menu, * file_item; GtkWidget * generate_menu, * generate_item; GtkWidget * settings_menu, * settings_item; GtkWidget * zoom_box, * zoom_button; int i; //init general colors = (color_t *)malloc(NUM_COLORS * sizeof(color_t)); oldcolors = (color_t *)malloc(OLD_NUM_COLORS * sizeof(color_t)); memset(mdata, 0, BUFFER_COUNT * sizeof(unsigned char *)); memset(icons, 0, BUFFER_COUNT * sizeof(GtkWidget *)); memset(icon_event_boxes, 0, BUFFER_COUNT * sizeof(GtkWidget *)); mdata[current_buffer] = (unsigned char *)malloc(128 * 128); load_colors_plain(colors, "colors"); load_colors_plain(oldcolors, "oldcolors"); newcolors = colors; //save_colors(colors, "colors.bin"); //load_colors(colors, "colors.bin"); srand(time(NULL)); config = config_new(); //init gtk gtk_init(&argc, &argv); //window window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), "ImageToMap X v" VERSION_NUMBER); g_signal_connect(window, "delete_event", G_CALLBACK(kill_window), NULL); //vbox #ifdef GTK2 vbox = gtk_vbox_new(FALSE, 0); #else vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); #endif gtk_frame_set_shadow_type(GTK_FRAME(vbox), GTK_SHADOW_IN); gtk_container_add(GTK_CONTAINER (window), vbox); gtk_widget_show(vbox); //////menu_bar menu_bar = gtk_menu_bar_new(); gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, TRUE, 0); gtk_widget_show(menu_bar); ////////file_menu file_menu = gtk_menu_new(); //////////file_menu items construct_tool_bar_add(file_menu, "Open", ITEM_SIGNAL_OPEN); construct_tool_bar_add(file_menu, "Open Grid Image", ITEM_SIGNAL_OPEN_GRID_IMAGE); construct_tool_bar_add(file_menu, "Save", ITEM_SIGNAL_SAVE); construct_tool_bar_add(file_menu, "Save Increment", ITEM_SIGNAL_SAVE_INCREMENT); construct_tool_bar_add(file_menu, "Save All", ITEM_SIGNAL_SAVE_ALL); construct_tool_bar_add(file_menu, "Save Raw Map", ITEM_SIGNAL_SAVE_RM); construct_tool_bar_add(file_menu, "Export Image", ITEM_SIGNAL_EXPORT_IMAGE); /* construct_tool_bar_add_deactivate(file_menu, "Render World", ITEM_SIGNAL_WORLD_RENDER_ITEM); */ construct_tool_bar_add(file_menu, "Render World", ITEM_SIGNAL_WORLD_RENDER_ITEM); construct_tool_bar_add(file_menu, "Clean Buffer List", ITEM_SIGNAL_CLEAN); construct_tool_bar_add(file_menu, "Quit", ITEM_SIGNAL_QUIT); /////////file_item file_item = gtk_menu_item_new_with_label("File"); gtk_widget_show(file_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(file_item), file_menu); gtk_menu_shell_append((GtkMenuShell *)menu_bar, file_item); ////////generate_menu generate_menu = gtk_menu_new(); //////////generate_menu items construct_tool_bar_add(generate_menu, "Mandelbrot", ITEM_SIGNAL_GENERATE_MANDELBROT); construct_tool_bar_add(generate_menu, "Julia", ITEM_SIGNAL_GENERATE_JULIA); construct_tool_bar_add(generate_menu, "Palette", ITEM_SIGNAL_GENERATE_PALETTE); construct_tool_bar_add(generate_menu, "Random Noise", ITEM_SIGNAL_GENERATE_RANDOM_NOISE); construct_tool_bar_add(generate_menu, "From Clipboard", ITEM_SIGNAL_GENERATE_FROM_CLIPBOARD); /////////generate_item generate_item = gtk_menu_item_new_with_label("Generate"); gtk_widget_show(generate_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(generate_item), generate_menu); gtk_menu_shell_append((GtkMenuShell *)menu_bar, generate_item); ////////settings_menu settings_menu = gtk_menu_new(); ////////settings_item settings_item = gtk_menu_item_new_with_label("Settings"); gtk_widget_show(settings_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(settings_item), settings_menu); gtk_menu_shell_append((GtkMenuShell *)menu_bar, settings_item); //////////FSD_checkbox FSD_checkbox = gtk_check_menu_item_new_with_label("Floyd–Steinberg dithering"); gtk_menu_shell_append(GTK_MENU_SHELL(settings_menu), FSD_checkbox); gtk_widget_show(FSD_checkbox); //////////YUV_checkbox YUV_checkbox = gtk_check_menu_item_new_with_label("YUV color conversion"); gtk_menu_shell_append(GTK_MENU_SHELL(settings_menu), YUV_checkbox); gtk_widget_show(YUV_checkbox); //////////old_colors_checkbox old_colors_checkbox = gtk_check_menu_item_new_with_label("Old Colors"); gtk_menu_shell_append(GTK_MENU_SHELL(settings_menu), old_colors_checkbox); gtk_widget_show(old_colors_checkbox); g_signal_connect_swapped(old_colors_checkbox, "toggled", G_CALLBACK(old_colors_checkbox_toggle), 0); //drop_down_menu init_drop_down_menu(); //hpaned #ifdef GTK2 hpaned = gtk_hpaned_new(); #else hpaned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL); #endif gtk_widget_set_size_request (hpaned, 220, -1); gtk_box_pack_start(GTK_BOX(vbox), hpaned, TRUE, TRUE, 0); gtk_widget_show(hpaned); ////sc_buffer sc_buffer = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sc_buffer), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); #ifdef GTK2 gtk_widget_set_size_request(sc_buffer, 128 + 32, 512); #else gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(sc_buffer), 128 + 32); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sc_buffer), 512); #endif gtk_paned_pack2(GTK_PANED(hpaned), sc_buffer, FALSE, FALSE); gtk_widget_show(sc_buffer); //////list_vbox #ifdef GTK2 list_vbox = gtk_vbox_new(FALSE, 0); #else list_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); #endif #ifdef GTK2 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sc_buffer), list_vbox); #else gtk_container_add(GTK_CONTAINER(sc_buffer), list_vbox); #endif gtk_widget_show(list_vbox); ////sc_win sc_win = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sc_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); #ifdef GTK2 gtk_widget_set_size_request(sc_win, 128 * 4, 128 * 4); gtk_window_resize(GTK_WINDOW(window), 128 * 4 + 200, 128 * 4 + 70); #else gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(sc_win), 128 * 4); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sc_win), 128 * 4); #endif gtk_paned_pack1(GTK_PANED(hpaned), sc_win, TRUE, FALSE); gtk_widget_show(sc_win); //////image dimage = gdk_pixbuf_new_from_file("start.png", NULL); image = gtk_image_new(); gtk_image_set_from_pixbuf(GTK_IMAGE(image), dimage); #ifdef GTK2 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sc_win), image); #else gtk_container_add(GTK_CONTAINER(sc_win), image); #endif gtk_widget_show(image); ////zoom_box #ifdef GTK2 zoom_box = gtk_hbox_new(FALSE, 0); #else zoom_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); #endif gtk_box_pack_start(GTK_BOX(vbox), zoom_box, FALSE, FALSE, 0); gtk_widget_show(zoom_box); //////zoom_button (+) zoom_button = gtk_button_new_with_label("+"); gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2); g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoomp"); gtk_widget_show(zoom_button); //////zoom_button (|) zoom_button = gtk_button_new_with_label("|"); gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2); g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoome"); gtk_widget_show(zoom_button); //////zoom_button (-) zoom_button = gtk_button_new_with_label("-"); gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2); g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoomm"); gtk_widget_show(zoom_button); //icon gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("imagetomap.ico")); //Drag and drop gtk_drag_dest_set(window, GTK_DEST_DEFAULT_ALL, targets, sizeof(targets)/sizeof(*targets), GDK_ACTION_COPY); gtk_drag_dest_add_uri_targets(window); g_signal_connect(window, "drag-drop", G_CALLBACK(drag_drop), NULL); g_signal_connect(window, "drag-motion", G_CALLBACK(drag_motion), NULL); g_signal_connect(window, "drag-data-received", G_CALLBACK(drag_received), NULL); g_signal_connect(window, "drag-leave", G_CALLBACK(drag_leave), NULL); //display window gtk_widget_show (window); gtk_main(); //clean up free(colors); for(i = 0; i < BUFFER_COUNT; i++) free(mdata[i]); config_free(config); return 0; }
/** * @brief Build Transmit User Interface * * @return GtkWidget pointer */ GtkWidget* buildSubRxUI() { GtkWidget* label; subrxFrame=gtk_frame_new("Sub RX"); gtk_widget_modify_bg(subrxFrame,GTK_STATE_NORMAL,&background); gtk_widget_modify_fg(gtk_frame_get_label_widget(GTK_FRAME(subrxFrame)),GTK_STATE_NORMAL,&white); #ifdef NETBOOK subrxTable=gtk_table_new(1,9,TRUE); #else subrxTable=gtk_table_new(2,8,TRUE); #endif // subrx settings subrxFrequencyDisplay=gtk_drawing_area_new(); //gtk_widget_set_size_request(GTK_WIDGET(subrxFrequencyDisplay),250,35); g_signal_connect(G_OBJECT (subrxFrequencyDisplay),"configure_event",G_CALLBACK(subrxFrequencyDisplayConfigure),NULL); g_signal_connect(G_OBJECT (subrxFrequencyDisplay),"expose_event",G_CALLBACK(subrxFrequencyDisplayExpose),NULL); g_signal_connect(G_OBJECT(subrxFrequencyDisplay),"scroll_event",G_CALLBACK(subrx_frequency_scroll_event),NULL); gtk_widget_set_events(subrxFrequencyDisplay,GDK_EXPOSURE_MASK|GDK_SCROLL_MASK); gtk_widget_show(subrxFrequencyDisplay); #ifdef NETBOOK gtk_table_attach_defaults(GTK_TABLE(subrxTable),subrxFrequencyDisplay,5,9,0,1); #else gtk_table_attach_defaults(GTK_TABLE(subrxTable),subrxFrequencyDisplay,1,8,0,1); #endif subrxEnabled = gtk_button_new_with_label ("SubRX"); gtk_widget_modify_bg(subrxEnabled, GTK_STATE_NORMAL, &buttonBackground); label=gtk_bin_get_child((GtkBin*)subrxEnabled); if(subrx) { gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &buttonSelected); gtk_widget_modify_fg(label, GTK_STATE_PRELIGHT, &buttonSelected); } else { gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white); gtk_widget_modify_fg(label, GTK_STATE_PRELIGHT, &black); } gtk_widget_set_size_request(GTK_WIDGET(subrxEnabled),BUTTON_WIDTH,BUTTON_HEIGHT); g_signal_connect(G_OBJECT(subrxEnabled),"clicked",G_CALLBACK(subrxEnabledButtonCallback),NULL); gtk_widget_show(subrxEnabled); gtk_table_attach_defaults(GTK_TABLE(subrxTable),subrxEnabled,0,1,0,1); // subrx gain subrxGainFrame=gtk_frame_new("AF Gain"); gtk_widget_modify_bg(subrxGainFrame,GTK_STATE_NORMAL,&background); gtk_widget_modify_fg(gtk_frame_get_label_widget(GTK_FRAME(subrxGainFrame)),GTK_STATE_NORMAL,&white); subrxGainScale=gtk_hscale_new_with_range(0.0,100.0,10.0); g_signal_connect(G_OBJECT(subrxGainScale),"value-changed",G_CALLBACK(subrxGainChanged),NULL); gtk_range_set_value((GtkRange*)subrxGainScale,subrxGain); #ifdef NETBOOK gtk_widget_set_size_request(GTK_WIDGET(subrxGainScale),80,37); #else gtk_widget_set_size_request(GTK_WIDGET(subrxGainScale),150,30); #endif gtk_widget_show(subrxGainScale); gtk_container_add(GTK_CONTAINER(subrxGainFrame),subrxGainScale); gtk_widget_show(subrxGainFrame); #ifdef NETBOOK gtk_table_attach_defaults(GTK_TABLE(subrxTable),subrxGainFrame,1,3,0,1); #else gtk_table_attach_defaults(GTK_TABLE(subrxTable),subrxGainFrame,0,4,1,2); #endif // subrx pan subrxPanFrame=gtk_frame_new("AF Pan"); gtk_widget_modify_bg(subrxPanFrame,GTK_STATE_NORMAL,&background); gtk_widget_modify_fg(gtk_frame_get_label_widget(GTK_FRAME(subrxPanFrame)),GTK_STATE_NORMAL,&white); subrxPanScale=gtk_hscale_new_with_range(0.0,1.0,0.1); g_signal_connect(G_OBJECT(subrxPanScale),"value-changed",G_CALLBACK(subrxPanChanged),NULL); gtk_range_set_value((GtkRange*)subrxPanScale,subrxPan); #ifdef NETBOOK gtk_widget_set_size_request(GTK_WIDGET(subrxPanScale),80,37); #else gtk_widget_set_size_request(GTK_WIDGET(subrxPanScale),150,30); #endif gtk_widget_show(subrxPanScale); gtk_container_add(GTK_CONTAINER(subrxPanFrame),subrxPanScale); gtk_widget_show(subrxPanFrame); #ifdef NETBOOK gtk_table_attach_defaults(GTK_TABLE(subrxTable),subrxPanFrame,3,5,0,1); #else gtk_table_attach_defaults(GTK_TABLE(subrxTable),subrxPanFrame,4,8,1,2); #endif if(running) { SetRXAPanelPan(CHANNEL_SUBRX, 1.0-subrxPan); } gtk_container_add(GTK_CONTAINER(subrxFrame),subrxTable); gtk_widget_show(subrxTable); gtk_widget_show(subrxFrame); return subrxFrame; }
Frame::Frame(const char *label) : Frame(GTK_FRAME(gtk_frame_new(label))) {}
/* * inject interactively with the user */ static void gtkui_connection_inject(void) { GtkWidget *dialog, *text, *label, *vbox, *frame; GtkWidget *button1, *button2, *hbox; GtkTextBuffer *buf; GtkTextIter start, end; char tmp[MAX_ASCII_ADDR_LEN]; gint response = 0; DEBUG_MSG("gtk_connection_inject"); if(curr_conn == NULL) return; dialog = gtk_dialog_new_with_buttons("Character Injection", GTK_WINDOW (window), GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); gtk_window_set_default_size(GTK_WINDOW (dialog), 400, 200); gtk_dialog_set_has_separator(GTK_DIALOG (dialog), FALSE); gtk_container_set_border_width(GTK_CONTAINER (dialog), 5); vbox = GTK_DIALOG (dialog)->vbox; label = gtk_label_new ("Packet destination:"); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show(label); hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show(hbox); button1 = gtk_radio_button_new_with_label(NULL, ip_addr_ntoa(&curr_conn->L3_addr2, tmp)); gtk_box_pack_start(GTK_BOX(hbox), button1, FALSE, FALSE, 0); gtk_widget_show(button1); button2 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON (button1), ip_addr_ntoa(&curr_conn->L3_addr1, tmp)); gtk_box_pack_start(GTK_BOX(hbox), button2, FALSE, FALSE, 0); gtk_widget_show(button2); label = gtk_label_new ("Characters to be injected:"); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show(label); frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX (vbox), frame, TRUE, TRUE, 5); gtk_widget_show(frame); text = gtk_text_view_new(); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW (text), GTK_WRAP_CHAR); gtk_container_add(GTK_CONTAINER (frame), text); gtk_widget_show(text); response = gtk_dialog_run(GTK_DIALOG(dialog)); if(response == GTK_RESPONSE_OK) { gtk_widget_hide(dialog); SAFE_REALLOC(injectbuf, 501 * sizeof(char)); memset(injectbuf, 0, 501); buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW (text)); /* initialize iters for get text */ gtk_text_buffer_get_start_iter(buf, &start); gtk_text_buffer_get_start_iter(buf, &end); /* advance end iter to end of text, 500 char max */ gtk_text_iter_forward_chars(&end, 500); strncpy(injectbuf, gtk_text_buffer_get_text(buf, &start, &end, FALSE), 501); if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (button1))) gtkui_inject_user(1); else if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (button2))) gtkui_inject_user(2); } gtk_widget_destroy(dialog); }
void wxRadioBox::SetLabel( const wxString& label ) { wxCHECK_RET( m_widget != NULL, wxT("invalid radiobox") ); GTKSetLabelForFrame(GTK_FRAME(m_widget), label); }
void gui_create_search_sidebar(void) { GtkWidget *vbox1; GtkWidget *vbox90; GtkWidget *vbox5; GtkWidget *frame2; GtkWidget *vbox2; GtkWidget *frame3; GtkWidget *vbox3; GtkWidget *frame4; GtkWidget *vbox4; GtkWidget *table1; GtkWidget *label1; GtkWidget *label2; GtkWidget *scrolledwindow_search; GtkWidget *viewport_search; gchar *header; //GtkListStore *store; //ss = &sss; scrolledwindow_search = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow_search); gtk_container_add(GTK_CONTAINER(widgets.notebook_sidebar), scrolledwindow_search); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow_search), settings.shadow_type); gtk_container_set_border_width(GTK_CONTAINER(scrolledwindow_search), 2); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow_search), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); viewport_search = gtk_viewport_new(NULL, NULL); gtk_widget_show(viewport_search); gtk_container_add(GTK_CONTAINER(scrolledwindow_search), viewport_search); UI_VBOX(vbox1, FALSE, 4); gtk_widget_show(vbox1); gtk_container_add(GTK_CONTAINER(viewport_search), vbox1); UI_VBOX(vbox5, FALSE, 0); gtk_widget_show(vbox5); gtk_box_pack_start(GTK_BOX(vbox1), vbox5, FALSE, TRUE, 0); /* text entry */ ss.entrySearch = gtk_entry_new(); gtk_widget_show(ss.entrySearch); gtk_box_pack_start(GTK_BOX(vbox5), ss.entrySearch, TRUE, TRUE, 0); gtk_widget_set_size_request(ss.entrySearch, 130, -1); ; /* find button */ #ifdef HAVE_GTK_310 remember_search = gtk_button_new_from_icon_name("edit-find-symbolic", GTK_ICON_SIZE_BUTTON); #else remember_search = gtk_button_new_from_stock(GTK_STOCK_FIND); #endif gtk_widget_show(remember_search); gtk_box_pack_start(GTK_BOX(vbox5), remember_search, TRUE, FALSE, 0); gtk_widget_set_tooltip_text(remember_search, _("This is an inclusive (\"AND\") search:\nFind matches showing all words.")); gtk_button_set_relief(GTK_BUTTON(remember_search), GTK_RELIEF_HALF); /* progress bar */ ss.progressbar_search = gtk_progress_bar_new(); gtk_widget_show(ss.progressbar_search); gtk_box_pack_start(GTK_BOX(vbox5), ss.progressbar_search, FALSE, TRUE, 0); /* button to open advanced search */ ss.advanced_search = gtk_button_new_with_mnemonic(_("_Open Advanced Search")); gtk_widget_show(ss.advanced_search); gtk_box_pack_start(GTK_BOX(vbox5), ss.advanced_search, TRUE, FALSE, 0); gtk_widget_set_tooltip_text(ss.advanced_search, _("Open the separate Advanced Search dialog.")); gtk_button_set_relief(GTK_BUTTON(ss.advanced_search), GTK_RELIEF_HALF); ss.frame_module = gtk_frame_new(NULL); gtk_widget_show(ss.frame_module); gtk_box_pack_start(GTK_BOX(vbox1), ss.frame_module, FALSE, FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(ss.frame_module), 2); gtk_frame_set_shadow_type(GTK_FRAME(ss.frame_module), GTK_SHADOW_NONE); label1 = gtk_label_new(NULL); header = g_strdup_printf("<span weight=\"bold\">%s</span>", _("Search Module")); gtk_label_set_markup(GTK_LABEL(label1), header); g_free(header); gtk_widget_show(label1); gtk_frame_set_label_widget(GTK_FRAME(ss.frame_module), label1); UI_VBOX(vbox90, FALSE, 0); gtk_widget_show(vbox90); gtk_container_add(GTK_CONTAINER(ss.frame_module), vbox90); gtk_container_set_border_width(GTK_CONTAINER(vbox90), 4); ss.radiobutton_search_text = gtk_radio_button_new_with_label(NULL, _("Bible")); gtk_widget_show(ss.radiobutton_search_text); gtk_widget_set_size_request(ss.radiobutton_search_text, -1, 20); gtk_box_pack_start(GTK_BOX(vbox90), ss.radiobutton_search_text, FALSE, FALSE, 0); ss.radiobutton_search_comm = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(ss.radiobutton_search_text), _("Commentary")); gtk_widget_show(ss.radiobutton_search_comm); gtk_widget_set_size_request(ss.radiobutton_search_comm, -1, 20); gtk_box_pack_start(GTK_BOX(vbox90), ss.radiobutton_search_comm, FALSE, FALSE, 0); frame2 = gtk_frame_new(NULL); gtk_widget_show(frame2); gtk_box_pack_start(GTK_BOX(vbox1), frame2, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(frame2), 2); gtk_frame_set_shadow_type(GTK_FRAME(frame2), GTK_SHADOW_NONE); label1 = gtk_label_new(NULL); header = g_strdup_printf("<span weight=\"bold\">%s</span>", _("Search Type")); gtk_label_set_markup(GTK_LABEL(label1), header); g_free(header); gtk_widget_show(label1); gtk_frame_set_label_widget(GTK_FRAME(frame2), label1); UI_VBOX(vbox2, TRUE, 0); gtk_widget_show(vbox2); gtk_container_add(GTK_CONTAINER(frame2), vbox2); gtk_container_set_border_width(GTK_CONTAINER(vbox2), 4); ss.rbMultiword = gtk_radio_button_new_with_label(NULL, _("Multi word")); gtk_widget_show(ss.rbMultiword); gtk_box_pack_start(GTK_BOX(vbox2), ss.rbMultiword, FALSE, FALSE, 0); gtk_widget_set_size_request(ss.rbMultiword, -1, 20); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ss.rbMultiword), TRUE); ss.rbRegExp = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(ss.rbMultiword), _("Regular expression")); gtk_widget_show(ss.rbRegExp); gtk_box_pack_start(GTK_BOX(vbox2), ss.rbRegExp, FALSE, FALSE, 0); gtk_widget_set_size_request(ss.rbRegExp, -1, 20); ss.rbPhraseSearch = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(ss.rbMultiword), _("Exact phrase")); gtk_widget_show(ss.rbPhraseSearch); gtk_box_pack_start(GTK_BOX(vbox2), ss.rbPhraseSearch, FALSE, FALSE, 0); gtk_widget_set_size_request(ss.rbPhraseSearch, -1, 20); frame3 = gtk_frame_new(NULL); gtk_widget_show(frame3); gtk_box_pack_start(GTK_BOX(vbox1), frame3, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(frame3), 2); gtk_frame_set_shadow_type(GTK_FRAME(frame3), GTK_SHADOW_NONE); label1 = gtk_label_new(NULL); header = g_strdup_printf("<span weight=\"bold\">%s</span>", _("Search Options")); gtk_label_set_markup(GTK_LABEL(label1), header); g_free(header); gtk_widget_show(label1); gtk_frame_set_label_widget(GTK_FRAME(frame3), label1); UI_VBOX(vbox3, FALSE, 0); gtk_widget_show(vbox3); gtk_container_add(GTK_CONTAINER(frame3), vbox3); gtk_container_set_border_width(GTK_CONTAINER(vbox3), 4); ss.ckbCaseSensitive = gtk_check_button_new_with_label(_("Match case")); gtk_widget_show(ss.ckbCaseSensitive); gtk_box_pack_start(GTK_BOX(vbox3), ss.ckbCaseSensitive, FALSE, FALSE, 0); gtk_widget_set_size_request(ss.ckbCaseSensitive, -1, 20); frame4 = gtk_frame_new(NULL); gtk_widget_show(frame4); gtk_box_pack_start(GTK_BOX(vbox1), frame4, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(frame4), 2); gtk_frame_set_shadow_type(GTK_FRAME(frame4), GTK_SHADOW_NONE); label1 = gtk_label_new(NULL); header = g_strdup_printf("<span weight=\"bold\">%s</span>", _("Search Scope")); gtk_label_set_markup(GTK_LABEL(label1), header); g_free(header); gtk_widget_show(label1); gtk_frame_set_label_widget(GTK_FRAME(frame4), label1); UI_VBOX(vbox4, TRUE, 0); gtk_widget_show(vbox4); gtk_container_add(GTK_CONTAINER(frame4), vbox4); gtk_container_set_border_width(GTK_CONTAINER(vbox4), 4); ss.rbNoScope = gtk_radio_button_new_with_label(NULL, _("No scope")); gtk_widget_show(ss.rbNoScope); gtk_box_pack_start(GTK_BOX(vbox4), ss.rbNoScope, FALSE, FALSE, 0); gtk_widget_set_size_request(ss.rbNoScope, -1, 20); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ss.rbNoScope), TRUE); ss.rrbUseBounds = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(ss.rbNoScope), _("Use bounds")); gtk_widget_show(ss.rrbUseBounds); gtk_box_pack_start(GTK_BOX(vbox4), ss.rrbUseBounds, FALSE, FALSE, 0); gtk_widget_set_size_request(ss.rrbUseBounds, -1, 20); ss.rbLastSearch = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(ss.rbNoScope), _("Last search")); gtk_widget_show(ss.rbLastSearch); gtk_box_pack_start(GTK_BOX(vbox4), ss.rbLastSearch, FALSE, FALSE, 0); gtk_widget_set_size_request(ss.rbLastSearch, -1, 20); ss.frame5 = gtk_frame_new(NULL); gtk_widget_show(ss.frame5); gtk_box_pack_start(GTK_BOX(vbox1), ss.frame5, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(ss.frame5), 2); gtk_widget_hide(ss.frame5); gtk_frame_set_shadow_type(GTK_FRAME(ss.frame5), GTK_SHADOW_NONE); label1 = gtk_label_new(NULL); header = g_strdup_printf("<span weight=\"bold\">%s</span>", _("Bounds")); gtk_label_set_markup(GTK_LABEL(label1), header); g_free(header); gtk_widget_show(label1); gtk_frame_set_label_widget(GTK_FRAME(ss.frame5), label1); #ifdef HAVE_GTK_34 table1 = gtk_grid_new(); gtk_widget_show(table1); gtk_container_add(GTK_CONTAINER(ss.frame5), table1); gtk_grid_set_row_spacing(GTK_GRID(table1), 3); gtk_grid_set_column_spacing(GTK_GRID(table1), 3); gtk_container_set_border_width(GTK_CONTAINER(table1), 8); label1 = gtk_label_new(_("Lower")); gtk_widget_show(label1); gtk_grid_attach(GTK_GRID(table1), label1, 0, 0, 1, 1); #ifndef HAVE_GTK_310 gtk_misc_set_alignment(GTK_MISC(label1), 1.0, 0.5); #endif ss.entryLower = gtk_combo_box_text_new_with_entry(); gtk_widget_show(ss.entryLower); gtk_grid_attach(GTK_GRID(table1), ss.entryLower, 1, 0, 1, 1); gtk_widget_set_size_request(ss.entryLower, 114, 22); label2 = gtk_label_new(_("Upper")); gtk_widget_show(label2); gtk_grid_attach(GTK_GRID(table1), label2, 0, 1, 1, 1); #ifndef HAVE_GTK_310 gtk_misc_set_alignment(GTK_MISC(label2), 1.0, 0.5); #endif ss.entryUpper = gtk_combo_box_text_new_with_entry(); gtk_widget_show(ss.entryUpper); gtk_grid_attach(GTK_GRID(table1), ss.entryUpper, 1, 1, 1, 1); gtk_widget_set_size_request(ss.entryUpper, 114, 22); #else table1 = gtk_table_new(2, 2, FALSE); gtk_widget_show(table1); gtk_container_add(GTK_CONTAINER(ss.frame5), table1); gtk_table_set_row_spacings(GTK_TABLE(table1), 3); gtk_table_set_col_spacings(GTK_TABLE(table1), 3); gtk_container_set_border_width(GTK_CONTAINER(table1), 8); label1 = gtk_label_new(_("Lower")); gtk_widget_show(label1); gtk_table_attach(GTK_TABLE(table1), label1, 0, 1, 0, 1, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); gtk_misc_set_alignment(GTK_MISC(label1), 1.0, 0.5); label2 = gtk_label_new(_("Upper")); gtk_widget_show(label2); gtk_table_attach(GTK_TABLE(table1), label2, 0, 1, 1, 2, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); gtk_misc_set_alignment(GTK_MISC(label2), 1.0, 0.5); #ifdef HAVE_GTK_224 ss.entryLower = gtk_combo_box_text_new_with_entry(); #else ss.entryLower = gtk_combo_box_entry_new_text(); #endif gtk_widget_show(ss.entryLower); gtk_table_attach(GTK_TABLE(table1), ss.entryLower, 1, 2, 0, 1, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); gtk_widget_set_size_request(ss.entryLower, 114, 22); #ifdef HAVE_GTK_224 ss.entryUpper = gtk_combo_box_text_new_with_entry(); #else ss.entryUpper = gtk_combo_box_entry_new_text(); #endif gtk_widget_show(ss.entryUpper); gtk_table_attach(GTK_TABLE(table1), ss.entryUpper, 1, 2, 1, 2, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0); gtk_widget_set_size_request(ss.entryUpper, 114, 22); #endif g_signal_connect(G_OBJECT(ss.rrbUseBounds), "toggled", G_CALLBACK(on_rrbUseBounds_toggled), NULL); g_signal_connect(G_OBJECT(remember_search), "clicked", G_CALLBACK(on_search_button_clicked), NULL); g_signal_connect(G_OBJECT(ss.entrySearch), "activate", G_CALLBACK(on_search_button_clicked), NULL); g_signal_connect(G_OBJECT(ss.advanced_search), "clicked", G_CALLBACK(main_open_search_dialog), NULL); }
static void gtk_color_button_init (GtkColorButton *color_button) { GtkWidget *alignment; GtkWidget *frame; PangoLayout *layout; PangoRectangle rect; /* Create the widgets */ color_button->priv = GTK_COLOR_BUTTON_GET_PRIVATE (color_button); gtk_widget_push_composite_child (); alignment = gtk_alignment_new (0.5, 0.5, 0.5, 1.0); gtk_container_set_border_width (GTK_CONTAINER (alignment), 1); gtk_container_add (GTK_CONTAINER (color_button), alignment); gtk_widget_show (alignment); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_OUT); gtk_container_add (GTK_CONTAINER (alignment), frame); gtk_widget_show (frame); /* Just some widget we can hook to expose-event on */ color_button->priv->draw_area = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); layout = gtk_widget_create_pango_layout (GTK_WIDGET (color_button), "Black"); pango_layout_get_pixel_extents (layout, NULL, &rect); g_object_unref (layout); gtk_widget_set_size_request (color_button->priv->draw_area, rect.width - 2, rect.height - 2); g_signal_connect (color_button->priv->draw_area, "expose-event", G_CALLBACK (expose_event), color_button); gtk_container_add (GTK_CONTAINER (frame), color_button->priv->draw_area); gtk_widget_show (color_button->priv->draw_area); color_button->priv->title = g_strdup (_("Pick a Color")); /* default title */ /* Start with opaque black, alpha disabled */ color_button->priv->color.red = 0; color_button->priv->color.green = 0; color_button->priv->color.blue = 0; color_button->priv->alpha = 65535; color_button->priv->use_alpha = FALSE; gtk_drag_dest_set (GTK_WIDGET (color_button), GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, drop_types, 1, GDK_ACTION_COPY); gtk_drag_source_set (GTK_WIDGET(color_button), GDK_BUTTON1_MASK|GDK_BUTTON3_MASK, drop_types, 1, GDK_ACTION_COPY); g_signal_connect (color_button, "drag-begin", G_CALLBACK (gtk_color_button_drag_begin), color_button); g_signal_connect (color_button, "drag-data-received", G_CALLBACK (gtk_color_button_drag_data_received), color_button); g_signal_connect (color_button, "drag-data-get", G_CALLBACK (gtk_color_button_drag_data_get), color_button); gtk_widget_pop_composite_child (); }
/* returns a parent widget to pack the contents of the page into */ GtkWidget *gtkui_page_new(char *title, void (*callback)(void), void (*detacher)(GtkWidget *)) { GtkWidget *parent, *label; GtkWidget *hbox, *button, *image; /* a container to hold the close button and tab label */ hbox = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox); /* the label for the tab title */ label = gtk_label_new(title); gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0); gtk_widget_show(label); /* the close button */ button = gtk_button_new(); gtk_button_set_relief(GTK_BUTTON (button), GTK_RELIEF_NONE); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); gtk_widget_set_size_request(button, 20, 20); gtk_widget_show(button); /* an image for the button */ image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU); gtk_container_add(GTK_CONTAINER (button), image); gtk_widget_show(image); /* a parent to pack the contents into */ parent = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME(parent), GTK_SHADOW_NONE); gtk_widget_show(parent); if(!notebook && notebook_frame) { gtk_container_remove(GTK_CONTAINER (notebook_frame), gtk_bin_get_child(GTK_BIN (notebook_frame))); notebook = gtk_notebook_new(); gtk_notebook_set_tab_pos(GTK_NOTEBOOK (notebook), GTK_POS_TOP); gtk_notebook_set_scrollable(GTK_NOTEBOOK (notebook), TRUE); gtk_container_add(GTK_CONTAINER (notebook_frame), notebook); gtk_widget_show(notebook); #if GTK_MINOR_VERSION == 2 g_signal_connect(G_OBJECT (notebook), "switch-page", G_CALLBACK(gtkui_page_defocus_tabs), NULL); #endif gtkui_create_tab_menu(); } gtk_notebook_append_page(GTK_NOTEBOOK(notebook), parent, hbox); /* attach callback to destroy the tab/page */ g_signal_connect(G_OBJECT (button), "clicked", G_CALLBACK(gtkui_page_close), parent); /* attach callback to do specific clean-up */ if(callback) g_object_set_data(G_OBJECT (parent), "destroy", callback); if(detacher) g_object_set_data(G_OBJECT (parent), "detach", detacher); gtkui_page_present(parent); return(parent); }