/*
* 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);
}
