コード例 #1
0
void text_export(struct _properties *properties, char *dataExport)
{
  properties->textExport = false;

  GtkWidget *window, *scrolled_win, *textview;
  GtkTextBuffer *buffer;

  time_t mytime;
  struct tm *my_tm;
    
  time(&mytime);
  my_tm=localtime(&mytime);

  char tstring[400] = { 0 };
  char windowTitle[400] = { 0 };
  strftime(tstring,sizeof(tstring),"%a %b %d %Y %H:%M:%S",my_tm);
  sprintf(windowTitle,"%s Export %s @ %s", PACKAGE_NAME, option_algorithms[properties->modeltype].des, tstring);
  
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title (GTK_WINDOW (window), windowTitle);
  gtk_container_set_border_width (GTK_CONTAINER (window), 10);
  gtk_widget_set_size_request (window, 1050, 300);

  gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("images/2.png"));
  
  textview = gtk_text_view_new ();
  buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (textview));
  
  gtk_text_buffer_set_text (buffer, dataExport, -1);
  
  scrolled_win = gtk_scrolled_window_new (NULL, NULL);
  gtk_container_add (GTK_CONTAINER (scrolled_win), textview);
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
                                  GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
  
  gtk_container_add (GTK_CONTAINER (window), scrolled_win);
  gtk_widget_show_all (window);
}
コード例 #2
0
static void
display_text (gchar *title, gchar *text, gboolean editable)
{
    GtkWidget *dialog, *scrolled_window, *text_view;
    GtkTextBuffer *buffer;
    GdkPixbuf *pixbuf;

    dialog = gtk_dialog_new_with_buttons (title, NULL, 0,
                                          GTK_STOCK_CLOSE, GTK_RESPONSE_NONE, NULL);

    gtk_window_set_default_size (GTK_WINDOW (dialog), 600, 450);
    g_signal_connect_swapped (dialog, "response", 
                              G_CALLBACK (gtk_widget_destroy), dialog);

    scrolled_window = gtk_scrolled_window_new (NULL, NULL);
    gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), scrolled_window);

    text_view = gtk_text_view_new ();
    gtk_text_view_set_editable (GTK_TEXT_VIEW (text_view), editable);
    gtk_text_view_set_left_margin (GTK_TEXT_VIEW (text_view), 8);
    gtk_text_view_set_right_margin (GTK_TEXT_VIEW (text_view), 8);
    gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), GTK_WRAP_WORD);
    gtk_container_add (GTK_CONTAINER (scrolled_window), text_view);
    
    buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
    gtk_text_buffer_set_text (buffer, text, strlen (text));

    pixbuf = gtk_widget_render_icon (dialog, 
                                     ICON_CLIPBOARD_DEFAULT, 
                                     (GtkIconSize)-1, 
                                     NULL);
                                     
    gtk_window_set_icon (GTK_WINDOW (dialog), pixbuf);
    
    g_object_unref(pixbuf);
    
    gtk_widget_show_all (dialog);
}
コード例 #3
0
void on_buttonCalendar_clicked( GtkWidget *widget, struct _properties *properties )
{
  g_print ("on_buttonCalendar_clicked():\n");

  gtk_window_set_title(GTK_WINDOW(properties->GtkInfo.dialogCalendar), "Select Date for Expr");
  gtk_window_set_icon(GTK_WINDOW(properties->GtkInfo.dialogCalendar), create_pixbuf("images/2.png"));

  int year;
  int month;
  int day;
  int hour;
  int minute;
  int seconds;

  properties->calendarSelected = 0;

  decimal_date_to_real_dates(properties->data.t[properties->calendarSelected], &year, &month, &day, &hour, &minute, &seconds);

  gtk_calendar_select_month(GTK_CALENDAR(properties->GtkInfo.calendar1), month, year);
  gtk_calendar_select_day(GTK_CALENDAR(properties->GtkInfo.calendar1), day);

  gtk_dialog_run(GTK_DIALOG(properties->GtkInfo.dialogCalendar));
}
コード例 #4
0
GtkWidget*
hybrid_create_window(const gchar *title, GdkPixbuf *icon,
                     GtkWindowPosition pos, gboolean resizable)
{
    GtkWidget *window;

    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

    if (!icon) {
        icon = hybrid_create_default_icon(0);
    } else {
        g_object_ref(icon);
    }

    gtk_window_set_icon(GTK_WINDOW(window), icon);

    gtk_window_set_resizable(GTK_WINDOW(window), resizable);
    gtk_window_set_title(GTK_WINDOW(window), title);
    gtk_window_set_position(GTK_WINDOW(window), pos);
    g_object_unref(icon);

    return window;
}
コード例 #5
0
ファイル: main.c プロジェクト: macrat/rusk
void onFaviconChange(WebKitWebView *webview, GParamSpec *param, RuskWindow *rusk)
{
	cairo_surface_t *favicon;
	int width, height;
	GdkPixbuf *pixbuf;

	if((favicon = webkit_web_view_get_favicon(rusk->webview)) == NULL)
	{
		return;
	}

	width = cairo_image_surface_get_width(favicon);
	height = cairo_image_surface_get_height(favicon);

	if(width <= 0 || height <= 0)
	{
		return;
	}

	pixbuf = gdk_pixbuf_get_from_surface(favicon, 0, 0, width, height);

	gtk_window_set_icon(rusk->window, pixbuf);
}
コード例 #6
0
ファイル: modulo_gui.c プロジェクト: Douglasbraga94/Megasenha
// initiate get name window
int initializeGetNameWindow(GtkWidget **window) {
    // initialize window
    *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

    // set title
    char buf[50];
    sprintf(buf, "megasenha - type your name");
    gtk_window_set_title(GTK_WINDOW(*window), buf);

    // set size and position and connects close window with destroy function
    gtk_window_set_default_size(GTK_WINDOW(*window), 397, 107);
    gtk_container_set_border_width (GTK_CONTAINER (*window), 10);
    gtk_window_move(GTK_WINDOW(*window), gdk_screen_width()/2 - 397/2, gdk_screen_height()*9/20);
//    gtk_signal_connect (GTK_OBJECT(*window), "destroy", GTK_SIGNAL_FUNC (destroy), (gpointer) "1");

    // sets and creates icons for windows and tell windows manager not to put them together
    gtk_window_set_icon(GTK_WINDOW(*window), createPixbuf("info.jpg"));
    gtk_window_set_wmclass(GTK_WINDOW (*window), "infoWindow", "megasenha"); 

    gtk_widget_show_all(*window);

    return 1;
}
コード例 #7
0
entry_win_t login_create()
{
    struct entry_win *c = calloc(1, sizeof(struct entry_win));
    if (!c) {
		perror("entry_win_create");
		return NULL;
	}

    /*---�����´���---*/
    c->win = gtk_window_new(GTK_WINDOW_TOPLEVEL);     
 
    /*---���ô��ڱ���---*/
    gtk_window_set_title(GTK_WINDOW(c->win), WIN_TITLE); 
    
    /*---���ô���ͼ��---*/              
    gtk_window_set_icon(GTK_WINDOW(c->win), gdk_pixbuf_new_from_file(WIN_ICON, NULL));
    
    /*---���ô���λ��---*/  
    gtk_window_set_position(GTK_WINDOW(c->win), GTK_WIN_POS_CENTER); 
    
    /*---���ô����Ƿ������---*/
    gtk_window_set_resizable(GTK_WINDOW(c->win), FALSE);    
    
    /*---���ô��ڱ߿���---*/
    gtk_container_set_border_width(GTK_CONTAINER(c->win), 0); 
    
    /*---�����˳��ź��봦����---*/
    g_signal_connect(GTK_OBJECT(c->win), "destroy", G_CALLBACK(gtk_main_quit), NULL);
    
    /*---���������ź��봦����---*/
    g_signal_connect(G_OBJECT(c->win), "key_press_event", G_CALLBACK(key_press_func), c);
	
    entry_win_draw_face(c);
	
    gtk_widget_show_all(c->win);
    return c;
}
コード例 #8
0
ファイル: main.c プロジェクト: Mohnish-SPU/DrumHero
int main( int   argc,
          char *argv[] )
{
	PROGRAM_NAME = "DrumHero";
	PROGRAM_VERSION = "0.03";
	page = 0;
	RecFlag = 0;
	PlayFlag = 0;
	duration = W;
	gtk_init (&argc, &argv);
	
	//Window here
	window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	
	gtk_widget_set_events(window,GDK_BUTTON_PRESS_MASK);
	
	gtk_signal_connect (GTK_OBJECT (window), "button_press_event",
		      (GtkSignalFunc) button_press_event, NULL);
	
	
	gtk_window_set_title (GTK_WINDOW (window), "Drum Studio");
	gtk_widget_set_size_request(window,1024,768);
	gtk_window_set_resizable(GTK_WINDOW(window),FALSE);
	gtk_window_set_icon(GTK_WINDOW(window),load_pixbuf_from_file("mohnish/OpCover.jpg"));
	g_signal_connect (window, "delete-event",
                      G_CALLBACK (delete_event), NULL);
	
	//pageOne();
	setWindow(window,"mohnish/OpCover.jpg");
	
	pageOne();
	pageTwo();
	gtk_widget_show (window);

    gtk_main();
    return 0;
}
コード例 #9
0
ファイル: calc.c プロジェクト: Arguggi/GTK_Calculator
int main(int argc, char **argv)
{
  GtkWidget *window, *vbox;

  gtk_init(&argc, &argv);

  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title(GTK_WINDOW(window),"Calc");
  gtk_container_set_border_width(GTK_CONTAINER(window),15);
  gtk_window_set_resizable(GTK_WINDOW(window),TRUE);
  gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("../img/calculator.png"));
  /*gtk_widget_set_size_request(window,430,200);*/
  g_signal_connect(G_OBJECT(window),"delete_event",G_CALLBACK(gtk_main_quit),NULL);

  vbox = create_table();

  gtk_container_add(GTK_CONTAINER(window),vbox);

  gtk_widget_show_all(window);

  gtk_main();

  return 0;
}
コード例 #10
0
ファイル: gui_dialogs.c プロジェクト: krzyzanowskim/GNUGadu
void gui_show_window_with_text(gpointer signal)
{
    GGaduSignal *sig = (GGaduSignal *) signal;
    GtkWidget *dialog = NULL;
    GtkWidget *gtv = NULL;
    GtkTextBuffer *buf = NULL;
    GtkWidget *sw = NULL;
    GdkPixbuf *windowicon = NULL;

    dialog = gtk_dialog_new_with_buttons("", NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
    gtk_window_resize(GTK_WINDOW(dialog), 400, 400);

    if ((windowicon = create_pixbuf(GGADU_DEFAULT_ICON_FILENAME)) != NULL)
    {
        gtk_window_set_icon(GTK_WINDOW(dialog), windowicon);
        gdk_pixbuf_unref(windowicon);
    }


    buf = gtk_text_buffer_new(NULL);
    gtk_text_buffer_set_text(buf, (gchar *) sig->data, -1);
    gtv = gtk_text_view_new_with_buffer(buf);

    gtk_text_view_set_editable(GTK_TEXT_VIEW(gtv), FALSE);
    gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(gtv), FALSE);

    sw = gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);

    gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), sw);
    gtk_container_add(GTK_CONTAINER(sw), gtv);

    g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(gtk_widget_destroy), dialog);
    gtk_widget_show_all(dialog);

}
コード例 #11
0
ファイル: about-dialog.c プロジェクト: iolo/liteamp
GtkWidget *about_dialog_new(void)
{
    const gchar *authors[] = {
	"Dongsu Jang <*****@*****.**>",
	"Jaeman Jang <*****@*****.**>",
	NULL
    };
    const gchar *documenters[] = { NULL };
    gchar *translators = _("translator_credits");

    GtkWidget *dialog;
    GdkPixbuf *logo_pixbuf;
    GdkPixbuf *icon_pixbuf;

    if (!strcmp(translators, "translator_credits"))
	translators = NULL;

    logo_pixbuf =
	gdk_pixbuf_new_from_file(PKGDATADIR "/pixmaps/liteamp-logo.png", NULL);

    dialog = gnome_about_new(PACKAGE, VERSION,
			     _("(C) 2002 Dongsu Jang"),
			     _("A Light-Weight Music Player for GNOME"),
			     authors, documenters, translators,
			     logo_pixbuf);

    icon_pixbuf =
	gdk_pixbuf_new_from_file(PKGDATADIR "/pixmaps/liteamp.png", NULL);

    if (icon_pixbuf) {
	gtk_window_set_icon(GTK_WINDOW(dialog), icon_pixbuf);
	gdk_pixbuf_unref(icon_pixbuf);
    }

    return dialog;
}
コード例 #12
0
ファイル: main.c プロジェクト: yetist/GtkShot
int main(int argc, char *argv[]) {
#ifdef ENABLE_NLS
	bindtextdomain(GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
	bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
	textdomain(GETTEXT_PACKAGE);
#endif

	gint pid = new_lock_file();

	if (pid > 0) {
		if (kill(pid, WAKE_UP_SIGNAL) == 0) {
			exit(0); // 进程确已存在,则退出新进程
		} else { // 否则,重新创建锁定文件
			remove_lock_file();
			new_lock_file();
		}
	}
	signal(WAKE_UP_SIGNAL, wake_up);
	signal(SIGINT, exit_clean);

	gtk_init(&argc, &argv);

	shot = gtk_shot_new();
	shot->quit = quit;
	shot->dblclick = save_to_clipboard;

	gtk_window_set_title(GTK_WINDOW(shot), GTK_SHOT_NAME);
	GdkPixbuf *icon = gdk_pixbuf_new_from_xpm_data((const char**)gtkshot_xpm);
	gtk_window_set_icon(GTK_WINDOW(shot), icon);
	g_object_unref(icon);

	gtk_shot_show(shot, TRUE);
	gtk_main();

	return 0;
}
コード例 #13
0
ファイル: scim_setup_ui.cpp プロジェクト: sillsdev/scim
void
SetupUI::create_main_ui ()
{
    GtkWidget *hpaned1;
    GtkWidget *scrolledwindow1;
    GtkWidget *vbox1;
    GtkWidget *vbox2;
    GtkWidget *frame1;
    GtkWidget *hbox1;
    GtkWidget *ok_button;
    GtkWidget *exit_button;
    GtkWidget *vseparator1;
    GdkPixbuf *icon;

    GtkCellRenderer *module_list_cell;
    GtkTreeViewColumn *module_list_column;

    // Create main window.
    m_main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title (GTK_WINDOW (m_main_window), _("SCIM Input Method Setup"));
    gtk_window_set_position (GTK_WINDOW (m_main_window), GTK_WIN_POS_CENTER);
    gtk_window_set_modal (GTK_WINDOW (m_main_window), TRUE);
    gtk_window_set_destroy_with_parent (GTK_WINDOW (m_main_window), TRUE);
    gtk_window_set_resizable (GTK_WINDOW (m_main_window), TRUE);
    
    // Set the window icon
    icon = gdk_pixbuf_new_from_file (SCIM_TRADEMARK_ICON_FILE, NULL);
    if (icon) {
        gtk_window_set_icon (GTK_WINDOW (m_main_window), icon);
        g_object_unref (icon);
    }

    vbox1 = gtk_vbox_new (FALSE, 0);
    gtk_widget_show (vbox1);
    gtk_container_add (GTK_CONTAINER (m_main_window), vbox1);

    // Create paned window.
    hpaned1 = gtk_hpaned_new ();
    gtk_widget_show (hpaned1);
    gtk_box_pack_start (GTK_BOX (vbox1), hpaned1, TRUE, TRUE, 0);
    gtk_container_set_border_width (GTK_CONTAINER (hpaned1), 4);

    // Create statusbar.
    m_status_bar = gtk_statusbar_new ();
    gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR (m_status_bar), TRUE);
    gtk_widget_show (m_status_bar);
    gtk_box_pack_start (GTK_BOX (vbox1), m_status_bar, FALSE, FALSE, 0);

    // Create scrollwindow for module list.
    scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
    gtk_widget_show (scrolledwindow1);
    gtk_paned_pack1 (GTK_PANED (hpaned1), scrolledwindow1, FALSE, FALSE);
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1),
                                    GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
    gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow1), 
                                         GTK_SHADOW_ETCHED_IN);

    // Create module list view.
    m_module_list_view = gtk_tree_view_new ();
    gtk_widget_show (m_module_list_view);
    gtk_container_add (GTK_CONTAINER (scrolledwindow1), m_module_list_view);
    gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (m_module_list_view), FALSE);
    gtk_tree_view_set_enable_search (GTK_TREE_VIEW (m_module_list_view), FALSE);

    // Get module list selection.
    m_module_list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (m_module_list_view));
    gtk_tree_selection_set_mode (m_module_list_selection, GTK_SELECTION_BROWSE);

    // Create module list column.
    module_list_cell = gtk_cell_renderer_text_new ();
    module_list_column = gtk_tree_view_column_new_with_attributes (
                            NULL, module_list_cell, "text", MODULE_LIST_LABEL, NULL);

    gtk_tree_view_append_column (GTK_TREE_VIEW (m_module_list_view), module_list_column);

    // Create vbox for work area and button area.
    vbox2 = gtk_vbox_new (FALSE, 0);
    gtk_widget_show (vbox2);
    gtk_paned_pack2 (GTK_PANED (hpaned1), vbox2, TRUE, FALSE);

    // Create frame for work area.
    frame1 = gtk_frame_new (NULL);
    gtk_widget_show (frame1);
    gtk_box_pack_start (GTK_BOX (vbox2), frame1, TRUE, TRUE, 0);

    m_work_area = gtk_vbox_new (FALSE, 0);
    gtk_widget_show (m_work_area);
    gtk_container_add (GTK_CONTAINER (frame1), m_work_area);

    // Create hbox for button area.
    hbox1 = gtk_hbox_new (FALSE, 0);
    gtk_widget_show (hbox1);
    gtk_box_pack_end (GTK_BOX (vbox2), hbox1, FALSE, FALSE, 8);

    ok_button = gtk_button_new_from_stock ("gtk-ok");
    gtk_widget_show (ok_button);
    gtk_box_pack_end (GTK_BOX (hbox1), ok_button, FALSE, FALSE, 4);

    exit_button = gtk_button_new_from_stock ("gtk-quit");
    gtk_widget_show (exit_button);
    gtk_box_pack_end (GTK_BOX (hbox1), exit_button, FALSE, FALSE, 4);

    vseparator1 = gtk_vseparator_new ();
    gtk_widget_show (vseparator1);
    gtk_box_pack_end (GTK_BOX (hbox1), vseparator1, FALSE, FALSE, 4);

    m_apply_button = gtk_button_new_from_stock ("gtk-apply");
    gtk_widget_show (m_apply_button);
    gtk_box_pack_end (GTK_BOX (hbox1), m_apply_button, FALSE, FALSE, 4);
    GTK_WIDGET_SET_FLAGS (m_apply_button, GTK_CAN_DEFAULT);
    gtk_widget_set_sensitive (m_apply_button, FALSE);

    m_restore_button = gtk_button_new_from_stock ("gtk-revert-to-saved");
    gtk_widget_show (m_restore_button);
    gtk_box_pack_end (GTK_BOX (hbox1), m_restore_button, FALSE, FALSE, 4);
    gtk_widget_set_sensitive (m_restore_button, FALSE);

    g_signal_connect ((gpointer) ok_button, "clicked",
                      G_CALLBACK (SetupUI::ok_button_clicked_callback),
                      this);
    g_signal_connect ((gpointer) exit_button, "clicked",
                      G_CALLBACK (SetupUI::exit_button_clicked_callback),
                      this);
    g_signal_connect ((gpointer) m_apply_button, "clicked",
                      G_CALLBACK (SetupUI::apply_button_clicked_callback),
                      this);
    g_signal_connect ((gpointer) m_restore_button, "clicked",
                      G_CALLBACK (SetupUI::restore_button_clicked_callback),
                      this);
    g_signal_connect (G_OBJECT (m_main_window), "delete_event",
                      G_CALLBACK (main_window_delete_callback),
                      this);

    g_signal_connect (G_OBJECT (m_module_list_selection), "changed",
                      G_CALLBACK (module_list_selection_changed_callback),
                      this);

    gtk_widget_grab_default (m_apply_button);
}
コード例 #14
0
ファイル: bccv7.c プロジェクト: jonnyniv/boost_converter
int main(int argc, char** argv)
{
	GtkWidget *window;
	GtkWidget *frame;
	GtkWidget *plus;
	GtkWidget *minus;
	GtkWidget *table;
	GtkWidget *label, *label1, *label2, *label3, *label4, *label5, *label6, *label7, *label8;	
	GtkWidget *scale;
	
	gtk_init(&argc, &argv);
	
	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
	gtk_window_set_default_size(GTK_WINDOW(window), 300,200);
	gtk_window_set_title(GTK_WINDOW(window), "Boost Converter Controller");
	gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("icon.png")); 
	//creates icon from file, has to be in the same directie as the exe also good if its a png
	
	gtk_container_set_border_width(GTK_CONTAINER(window), 5);
	
	table = gtk_table_new(5, 4, FALSE); //creates a 4x4 widget,  non homogenous 
	gtk_table_set_row_spacings(GTK_TABLE(table), 2);
	gtk_table_set_col_spacings(GTK_TABLE(table), 2);//sets spcaing between rows and columns
	
	
	label = gtk_label_new("Voltage Setpoint");
	gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1 );
	
	label1 = gtk_label_new("ADC Value");
	gtk_table_attach_defaults(GTK_TABLE(table), label1, 0, 1, 1, 2 );
	label2 = gtk_label_new("Output Voltage");
	gtk_table_attach_defaults(GTK_TABLE(table), label2, 0, 1, 2, 3 );
	label3 = gtk_label_new("Output Current");
	gtk_table_attach_defaults(GTK_TABLE(table), label3, 0, 1, 3, 4 );
	label4 = gtk_label_new("Input Voltage");
	gtk_table_attach_defaults(GTK_TABLE(table), label4, 0, 1, 4, 5 );
	
	scale = gtk_hscale_new_with_range( 0, 15, 0.1);
	gtk_table_attach_defaults(GTK_TABLE(table), scale, 1, 4, 0, 1 );
	
	sprintf(buff, "%3.1f", adc);
	gtk_label_set_text(GTK_LABEL(label), buff);
	label5 = gtk_label_new(buff);
	gtk_table_attach_defaults(GTK_TABLE(table), label5, 1, 4, 1, 2);
	v_out = adc *
	label6 = gtk_label_new(buff);
	gtk_table_attach_defaults(GTK_TABLE(table), label6, 1, 4, 1, 2);
	label7 = gtk_label_new(buff);
	gtk_table_attach_defaults(GTK_TABLE(table), label7, 1, 4, 1, 2);
	label8 = gtk_label_new(buff);
	gtk_table_attach_defaults(GTK_TABLE(table), label8, 1, 4, 1, 2);
	
	gtk_container_add(GTK_CONTAINER(window), table);
	
	gtk_widget_show_all(window);
	
	g_signal_connect (G_OBJECT(scale), "value-changed", G_CALLBACK (scale_mov), label5);
	
	g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
	
	
	gtk_main();
	
	return 0;
}
コード例 #15
0
ファイル: fx_proxy.c プロジェクト: amoblin/flyshion
void fx_proxy_initialize(FxProxy *fxproxy)
{
	GtkBox *vbox = NULL;
	GtkBox *action_area = NULL;
	GtkWidget *hostLabel = NULL;
	GtkWidget *portLabel = NULL;
	GtkWidget *userLabel = NULL;
	GtkWidget *passLabel = NULL;
	GtkWidget *fixed = NULL;
	GtkWidget *okBtn = NULL;
	GtkWidget *cancelBtn = NULL;
	GdkPixbuf *pb = NULL;
	char text[128];
	Proxy *proxy = fxproxy->fxlogin->proxy;

	fxproxy->dialog = gtk_dialog_new();

	gtk_widget_set_usize(fxproxy->dialog , 350 , 220);
	gtk_window_set_resizable(GTK_WINDOW(fxproxy->dialog) , FALSE);
	gtk_window_set_title(GTK_WINDOW(fxproxy->dialog) , _("Set HTTP Proxy"));
	pb = gdk_pixbuf_new_from_file(SKIN_DIR"proxy.png" , NULL);
	gtk_window_set_icon(GTK_WINDOW(fxproxy->dialog) , pb);

	vbox = GTK_BOX(GTK_DIALOG(fxproxy->dialog)->vbox);
	action_area = GTK_BOX(GTK_DIALOG(fxproxy->dialog)->action_area);

	fixed = gtk_fixed_new();

	fxproxy->enableBtn = gtk_check_button_new_with_label(_("Trun on HTTP proxy"));
	g_signal_connect(fxproxy->enableBtn , "toggled"
			, G_CALLBACK(fx_proxy_enable_toggled) , fxproxy);
	gtk_fixed_put(GTK_FIXED(fixed) , fxproxy->enableBtn , 20 , 20);

	fxproxy->errorLabel = gtk_label_new(NULL);
	gtk_fixed_put(GTK_FIXED(fixed) , fxproxy->errorLabel , 180 , 22);
	
	hostLabel = gtk_label_new(NULL);
	gtk_label_set_markup(GTK_LABEL(hostLabel) , _("<b>Proxy host</b>"));
	gtk_fixed_put(GTK_FIXED(fixed) , hostLabel , 20 , 55);

	portLabel = gtk_label_new(NULL);
	gtk_label_set_markup(GTK_LABEL(portLabel) , _("<b>Port</b>"));
	gtk_fixed_put(GTK_FIXED(fixed) , portLabel , 190 , 55);
	
	fxproxy->hostEntry = gtk_entry_new();
	gtk_widget_set_usize(fxproxy->hostEntry , 140 , 25);
	gtk_fixed_put(GTK_FIXED(fixed) , fxproxy->hostEntry , 20 , 75);

	fxproxy->portEntry = gtk_entry_new();
	gtk_widget_set_usize(fxproxy->portEntry , 140 , 25);
	gtk_fixed_put(GTK_FIXED(fixed) , fxproxy->portEntry , 190 , 75);

	userLabel = gtk_label_new(NULL);
	gtk_label_set_markup(GTK_LABEL(userLabel) , _("<b>Uesrname</b>"));
	gtk_fixed_put(GTK_FIXED(fixed) , userLabel , 20 , 110);

	passLabel = gtk_label_new(NULL);
	gtk_label_set_markup(GTK_LABEL(passLabel) , _("<b>Password</b>"));
	gtk_fixed_put(GTK_FIXED(fixed) , passLabel , 190 , 110);
	
	fxproxy->userEntry = gtk_entry_new();
	gtk_widget_set_usize(fxproxy->userEntry , 140 , 25);
	gtk_fixed_put(GTK_FIXED(fixed) , fxproxy->userEntry , 20 , 130);

	fxproxy->passEntry = gtk_entry_new();
	gtk_widget_set_usize(fxproxy->passEntry , 140 , 25);
	gtk_entry_set_visibility(GTK_ENTRY(fxproxy->passEntry) , FALSE);
	gtk_fixed_put(GTK_FIXED(fixed) , fxproxy->passEntry , 190 , 130);

	okBtn = gtk_button_new_with_label(_("OK"));
	g_signal_connect(okBtn , "clicked"
			, G_CALLBACK(fx_proxy_on_ok_clicked) , fxproxy);
	cancelBtn = gtk_button_new_with_label(_("Cancel"));
	g_signal_connect(cancelBtn , "clicked"
			, G_CALLBACK(fx_proxy_on_cancel_clicked) , fxproxy);

	gtk_box_pack_start_defaults(vbox , fixed);
	gtk_box_pack_start_defaults(action_area , okBtn);
	gtk_box_pack_start_defaults(action_area , cancelBtn);

	/* bind data*/
	if(proxy != NULL && proxy->proxyEnabled)
	{
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fxproxy->enableBtn) , TRUE);
		fx_proxy_set_sensitive(fxproxy , TRUE);
	}
	else
	{
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fxproxy->enableBtn) , FALSE);
		fx_proxy_set_sensitive(fxproxy , FALSE);
	}
	if(proxy != NULL)
	{
		gtk_entry_set_text(GTK_ENTRY(fxproxy->hostEntry) , proxy->proxyHost);
		snprintf(text, sizeof(text) - 1 , "%d" , proxy->proxyPort);
		gtk_entry_set_text(GTK_ENTRY(fxproxy->portEntry) , text);
		gtk_entry_set_text(GTK_ENTRY(fxproxy->userEntry) , proxy->proxyUser);
		gtk_entry_set_text(GTK_ENTRY(fxproxy->passEntry) , proxy->proxyPass);
	}
	/* show widgets*/
	gtk_widget_show_all(fxproxy->dialog);
}
コード例 #16
0
int main(int argc, char** argv) {
  currentPlayingTime = 0.0;
  startVideoAfter = 0.0;

  airframeID = 1;

  currentMode = MODE_REPLAY;
  replayMode = MANUAL_REPLAY;


  ml =  g_main_loop_new(NULL, FALSE);
  g_timeout_add(1000 , __timeout_func , ml);

  IvyInit("Video Synchronizer", "Video Synchronizer READY", NULL, NULL, NULL, NULL);
  IvyBindMsg(on_Message, NULL, "^time(\\S*) (\\S*)");
  IvyBindMsg(on_Message_Video, NULL, "^(\\S*) VIDEO_SYNC(\\S*) (\\S*)");
  IvyBindMsg(on_Airframe_ID, NULL, "^replay(\\S*) PONG(\\S*) (\\S*)");

#ifdef __APPLE__
  IvyStart("224.255.255.255");
#else
  IvyStart("127.255.255.255");
#endif

  /* Ugly because remove every possibility of translation.
   * But needed to prevent the use of the comma as float separator.
   */
  gtk_disable_setlocale();

  gtk_init(&argc, &argv);

  GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title(GTK_WINDOW(window), "Video synchronizer");
  g_signal_connect(GTK_OBJECT(window), "destroy", G_CALLBACK(on_quit), NULL);


  GtkNotebook *tab = (GtkNotebook*)gtk_notebook_new();
  g_signal_connect(GTK_OBJECT(tab), "switch-page", G_CALLBACK(on_change_mode), NULL);


  GtkNotebook *tabReplay = (GtkNotebook*)gtk_notebook_new();
  g_signal_connect(GTK_OBJECT(tabReplay), "switch-page", G_CALLBACK(on_change_replay), NULL);

  //Manual mode
  //create a box to align the widgets
  //false -> unheaven sizes; 0 space between widgets
  GtkWidget *box = gtk_hbox_new(FALSE, 0);

  //add a label to explain the values to enter
  GtkWidget *label = gtk_label_new("How long the video must be started \nafter the log file (may be negative) : ");
  gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 0);
  gtk_widget_show(label);

  //add a spinbutton (to enter the value of the video synchronisation)
  //startValue, lower, upper, step_increment, page_increment, page_size
  GtkAdjustment *adj = (GtkAdjustment *) gtk_adjustment_new(0.0, -999999999999.99, 999999999999.99, 0.1, 1.0, 0.0);
  spinButton = gtk_spin_button_new(adj, 0.1, 1);
  g_signal_connect(GTK_OBJECT(adj), "value_changed", G_CALLBACK(on_video_sync_changed), NULL);
  gtk_box_pack_start(GTK_BOX(box), spinButton, TRUE, TRUE, 0);
  gtk_widget_show(spinButton);

  //add the unit label at the end of the window
  label = gtk_label_new("s");
  gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 0);
  gtk_widget_show(label);

  gtk_notebook_append_page(tabReplay, box, gtk_label_new("Manual"));


  //Auto mode
  //create a box to align the widgets
  //false -> unheaven sizes; 0 space between widgets
  GtkWidget *boxAuto = gtk_hbox_new(FALSE, 0);

  //add a label to explain the values to enter
  label = gtk_label_new("At what time is the clap in the video : ");
  gtk_box_pack_start(GTK_BOX(boxAuto), label, FALSE, FALSE, 0);
  gtk_widget_show(label);

  //add a spinbutton (to enter the value of the video synchronisation)
  //startValue, lower, upper, step_increment, page_increment, page_size
  GtkAdjustment *adjAuto = (GtkAdjustment *) gtk_adjustment_new(0.0, 0.00, 999999999999.99, 0.1, 1.0, 0.0);
  spinButtonVideo = gtk_spin_button_new(adjAuto, 0.1, 1);
  g_signal_connect(GTK_OBJECT(adjAuto), "value_changed", G_CALLBACK(on_video_time_tag_changed), NULL);
  gtk_box_pack_start(GTK_BOX(boxAuto), spinButtonVideo, TRUE, TRUE, 0);
  gtk_widget_show(spinButtonVideo);

  //add the unit label at the end of the window
  label = gtk_label_new("s");
  gtk_box_pack_start(GTK_BOX(boxAuto), label, FALSE, FALSE, 0);
  gtk_widget_show(label);

  gtk_notebook_append_page(tabReplay, boxAuto, gtk_label_new("Auto"));


  //create the capture page
  GtkWidget *captureBox = gtk_hbox_new(FALSE, 0);

  GtkWidget *button = gtk_button_new_with_label("sync");
  gtk_box_pack_start(GTK_BOX(captureBox), button, FALSE, FALSE, 0);
  g_signal_connect(GTK_OBJECT(button), "clicked", G_CALLBACK(on_sync_clicked), NULL);
  gtk_widget_show(button);


  gtk_notebook_append_page(tab, (GtkWidget*)tabReplay, gtk_label_new("Replay"));
  gtk_notebook_append_page(tab, (GtkWidget*)captureBox, gtk_label_new("Capture"));

  gtk_container_add(GTK_CONTAINER(window), (GtkWidget*)tab);
  gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("data/pictures/penguin_icon_vid.png"));

  gtk_widget_show_all(window);
  gtk_main();

  return 0;
}
コード例 #17
0
static SyncDialog *sync_dialog_new(void)
{
    SyncDialog *sd;
    GtkWidget *dialog;
    GtkWidget *dialog1_vbox;
    GtkWidget *scrolledwindow2;
    GtkWidget *treeview2;
    GtkWidget *dialog1_action_area;
    GtkWidget *button8;
    GtkWidget *button7;
    GtkWidget *button6;
    GtkWidget *label;
    GtkWidget *hbox;

    GtkTreeViewColumn *column;
    GtkTreeModel *model;
    GtkListStore *store;
    GtkCellRenderer *cr_text, *cr_toggle;

    sd = g_new0(SyncDialog, 1);
    sd->sna = sync_dialog_netarea_new();

    dialog = gtk_dialog_new();
    gtk_window_set_title(GTK_WINDOW(dialog), "Network Updater");
    gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
    gtk_window_set_icon(GTK_WINDOW(dialog),
			icon_cache_get_pixbuf("syncmanager.png"));
    gtk_window_set_default_size(GTK_WINDOW(dialog), 420, 260);
    gtk_window_set_position(GTK_WINDOW(dialog),
			    GTK_WIN_POS_CENTER_ON_PARENT);
    gtk_window_set_type_hint(GTK_WINDOW(dialog),
			     GDK_WINDOW_TYPE_HINT_DIALOG);

    gtk_container_set_border_width(GTK_CONTAINER(dialog), 5);

    dialog1_vbox = GTK_DIALOG(dialog)->vbox;
    gtk_box_set_spacing(GTK_BOX(dialog1_vbox), 5);
    gtk_container_set_border_width(GTK_CONTAINER(dialog1_vbox), 4);
    gtk_widget_show(dialog1_vbox);

    hbox = gtk_hbox_new(FALSE, 5);
    gtk_box_pack_start(GTK_BOX(dialog1_vbox), hbox, FALSE, FALSE, 0);

    label = gtk_label_new(LABEL_SYNC_DEFAULT);
    gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
    gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
    gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);

    gtk_box_pack_start(GTK_BOX(hbox),
		       icon_cache_get_image("syncmanager.png"),
		       FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
    gtk_widget_show_all(hbox);


    gtk_box_pack_start(GTK_BOX(dialog1_vbox), sd->sna->vbox, TRUE, TRUE,
		       0);

    scrolledwindow2 = gtk_scrolled_window_new(NULL, NULL);
    gtk_widget_show(scrolledwindow2);
    gtk_box_pack_start(GTK_BOX(dialog1_vbox), scrolledwindow2, TRUE, TRUE,
		       0);
    gtk_widget_set_size_request(scrolledwindow2, -1, 200);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow2),
				   GTK_POLICY_AUTOMATIC,
				   GTK_POLICY_AUTOMATIC);
    gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW
					(scrolledwindow2), GTK_SHADOW_IN);

    store =
	gtk_list_store_new(3, G_TYPE_BOOLEAN, G_TYPE_STRING,
			   G_TYPE_POINTER);
    model = GTK_TREE_MODEL(store);

    treeview2 = gtk_tree_view_new_with_model(model);
    gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview2), FALSE);
    gtk_widget_show(treeview2);
    gtk_container_add(GTK_CONTAINER(scrolledwindow2), treeview2);

    column = gtk_tree_view_column_new();
    gtk_tree_view_append_column(GTK_TREE_VIEW(treeview2), column);

    cr_toggle = gtk_cell_renderer_toggle_new();
    gtk_tree_view_column_pack_start(column, cr_toggle, FALSE);
    g_signal_connect(cr_toggle, "toggled", G_CALLBACK(sel_toggle), model);
    gtk_tree_view_column_add_attribute(column, cr_toggle, "active", 0);

    cr_text = gtk_cell_renderer_text_new();
    gtk_tree_view_column_pack_start(column, cr_text, TRUE);
    gtk_tree_view_column_add_attribute(column, cr_text, "markup", 1);

    populate_store(store);

    dialog1_action_area = GTK_DIALOG(dialog)->action_area;
    gtk_widget_show(dialog1_action_area);
    gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog1_action_area),
			      GTK_BUTTONBOX_END);

    button8 = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
    gtk_widget_show(button8);
    gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button8,
				 GTK_RESPONSE_CANCEL);
    GTK_WIDGET_SET_FLAGS(button8, GTK_CAN_DEFAULT);

    button7 = gtk_button_new_with_mnemonic("_Synchronize");
    gtk_widget_show(button7);
    gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button7,
				 GTK_RESPONSE_ACCEPT);
    GTK_WIDGET_SET_FLAGS(button7, GTK_CAN_DEFAULT);

    button6 = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
    g_signal_connect(G_OBJECT(button6), "clicked",
		     (GCallback) close_clicked, NULL);
    gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button6,
				 GTK_RESPONSE_ACCEPT);
    GTK_WIDGET_SET_FLAGS(button6, GTK_CAN_DEFAULT);

    sd->dialog = dialog;
    sd->button_sync = button7;
    sd->button_cancel = button8;
    sd->button_close = button6;
    sd->scroll_box = scrolledwindow2;
    sd->label = label;

    return sd;
}
コード例 #18
0
ファイル: main.c プロジェクト: dumorte/Fid_Project
int main(int argc, char **argv){
	gtk_init (&argc, &argv);

	GtkWidget *p_window;
	GdkPixbuf *Pixbuf; 
	GError *error=NULL;

	/* Creation de la fenetre principale de notre application */
	p_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	gtk_window_set_position(GTK_WINDOW(p_window), GTK_WIN_POS_CENTER);
	gtk_window_set_title(GTK_WINDOW(p_window),"Face Identifier Project");
	gtk_window_set_default_size(GTK_WINDOW(p_window),800,500);
	Pixbuf = gdk_pixbuf_new_from_file("logo.jpeg",&error);
	gtk_window_set_icon(GTK_WINDOW(p_window),Pixbuf);
	GdkGeometry hints;
	hints.min_width = 800;
	hints.max_width = 800;
	hints.min_height = 500;
	hints.max_height = 500;

	gtk_window_set_geometry_hints(
			GTK_WINDOW(p_window),
			p_window,
			&hints,
			(GdkWindowHints)(GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE));

	/* Creation des buttons */
	GtkWidget *p_button1= gtk_button_new_with_label("Search");
	gtk_widget_set_size_request(p_button1,120,90);
	GtkWidget *p_button2= gtk_button_new_with_label("Identify");
	gtk_widget_set_size_request(p_button2,120,90);
	GtkWidget *p_button3= gtk_button_new_with_label("Add");
	gtk_widget_set_size_request(p_button3,120,90);

	/* Insertion des boutons */
	g_signal_connect (G_OBJECT (p_button1), "clicked", G_CALLBACK (cb_open), NULL);
	g_signal_connect (G_OBJECT (p_button2), "clicked", G_CALLBACK (face_detection), NULL);
	g_signal_connect (G_OBJECT (p_button3), "clicked", G_CALLBACK (cb_add), NULL);

	layout = gtk_layout_new(NULL, NULL);
	GtkWidget *backgrd = gtk_image_new_from_file("backgroundUI.jpg");
	GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
	GtkWidget *scrollbar = gtk_scrolled_window_new(NULL, NULL);
	
	DIR* FD = opendir ("./DataBase");
	struct dirent* in_file;

	GtkWidget *ImgScr;
	GdkPixbuf *Pbx;
	GtkWidget *Label;

	if (NULL != FD) 
	{
		while ((in_file =readdir(FD)))
		{
			if (!strcmp (in_file->d_name, "."))
				continue;
			if (!strcmp (in_file->d_name, ".."))    
				continue;

			Pbx = gdk_pixbuf_new_from_file_at_scale (concat("DataBase/",in_file->d_name),220,150,TRUE,NULL);
			ImgScr = gtk_image_new_from_pixbuf(Pbx);

			Label = gtk_label_new (remove_after_dot(in_file->d_name));
			g_object_unref (Pbx);
			gtk_box_pack_start(GTK_BOX(box), ImgScr, FALSE, FALSE, 3);
			gtk_box_pack_start(GTK_BOX(box), Label, FALSE, FALSE, 3);
		}
		(void) closedir (FD);
	}

	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollbar),GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);

	gtk_widget_set_size_request(scrollbar, 253,398);
	gtk_container_add(GTK_CONTAINER(scrollbar), box);

	gtk_layout_put(GTK_LAYOUT(layout), backgrd, 0, 0);

	gtk_container_add(GTK_CONTAINER(p_window), layout);
	gtk_layout_put(GTK_LAYOUT (layout), scrollbar, 548,0);

	gtk_layout_put (GTK_LAYOUT (layout), p_button1, 250, 405);
	gtk_layout_put (GTK_LAYOUT (layout), p_button2, 100, 405);
	gtk_layout_put (GTK_LAYOUT (layout), p_button3, 400, 405);

	g_signal_connect(G_OBJECT(p_window), "destroy",
			G_CALLBACK(gtk_main_quit), NULL);
	/* Affichage de la fenetre principale */
	gtk_widget_show_all (p_window); 
	/* Lancement de la boucle principale */
	gtk_main ();
	return EXIT_SUCCESS;

	return 0;
}
コード例 #19
0
ファイル: main.c プロジェクト: AlexandroCasanova/ClipIt
/* Called when About is selected from right-click menu */
static void show_about_dialog(GtkMenuItem *menu_item, gpointer user_data) {
  /* This helps prevent multiple instances */
  if (!gtk_grab_get_current()) {
    const gchar* authors[] = {"Cristian Henzel <*****@*****.**>\n"
				"Gilberto \"Xyhthyx\" Miralla <*****@*****.**>\n"
				"Eugene Nikolsky <*****@*****.**>", NULL};
    const gchar* license =
      "This program is free software; you can redistribute it and/or modify\n"
      "it under the terms of the GNU General Public License as published by\n"
      "the Free Software Foundation; either version 3 of the License, or\n"
      "(at your option) any later version.\n"
      "\n"
      "This program is distributed in the hope that it will be useful,\n"
      "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
      "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
      "GNU General Public License for more details.\n"
      "\n"
      "You should have received a copy of the GNU General Public License\n"
      "along with this program.  If not, see <http://www.gnu.org/licenses/>.";

    /* Create the about dialog */
    GtkWidget* about_dialog = gtk_about_dialog_new();
    gtk_window_set_icon((GtkWindow*)about_dialog,
                        gtk_widget_render_icon(about_dialog, GTK_STOCK_ABOUT, GTK_ICON_SIZE_MENU, NULL));

    gtk_about_dialog_set_name((GtkAboutDialog*)about_dialog, "ClipIt");
    #ifdef HAVE_CONFIG_H
    gtk_about_dialog_set_version((GtkAboutDialog*)about_dialog, VERSION);
    #endif
    gtk_about_dialog_set_comments((GtkAboutDialog*)about_dialog,
                                _("Lightweight GTK+ clipboard manager."));

    gtk_about_dialog_set_website((GtkAboutDialog*)about_dialog,
                                 "http://clipit.rspwn.com/");

    gtk_about_dialog_set_copyright((GtkAboutDialog*)about_dialog, "Copyright (C) 2010-2012 Cristian Henzel");
    gtk_about_dialog_set_authors((GtkAboutDialog*)about_dialog, authors);
    gtk_about_dialog_set_translator_credits ((GtkAboutDialog*)about_dialog,
                                             "Guido Tabbernuk <*****@*****.**>\n"
                                             "Miloš Koutný <*****@*****.**>\n"
                                             "Kim Jensen <*****@*****.**>\n"
                                             "Eckhard M. Jäger <*****@*****.**>\n"
                                             "Michael Stempin <*****@*****.**>\n"
                                             "Benjamin 'sphax3d' Danon <*****@*****.**>\n"
                                             "Németh Tamás <*****@*****.**>\n"
                                             "Davide Truffa <*****@*****.**>\n"
                                             "Jiro Kawada <*****@*****.**>\n"
                                             "Øyvind Sæther <*****@*****.**>\n"
                                             "pankamyk <*****@*****.**>\n"
                                             "Tomasz Rusek <*****@*****.**>\n"
                                             "Phantom X <*****@*****.**>\n"
                                             "Ovidiu D. Niţan <*****@*****.**>\n"
                                             "Alexander Kazancev <*****@*****.**>\n"
                                             "Daniel Nylander <*****@*****.**>\n"
                                             "Hedef Türkçe <*****@*****.**>\n"
                                             "Lyman Li <*****@*****.**>\n"
                                             "Gilberto \"Xyhthyx\" Miralla <*****@*****.**>");

    gtk_about_dialog_set_license((GtkAboutDialog*)about_dialog, license);
    gtk_about_dialog_set_logo_icon_name((GtkAboutDialog*)about_dialog, GTK_STOCK_PASTE);
    /* Run the about dialog */
    gtk_dialog_run((GtkDialog*)about_dialog);
    gtk_widget_destroy(about_dialog);
  } else {
    /* A window is already open, so we present it to the user */
    GtkWidget *toplevel = gtk_widget_get_toplevel(gtk_grab_get_current());
    gtk_window_present((GtkWindow*)toplevel);
  }
}
コード例 #20
0
ファイル: gamine.c プロジェクト: btong/gamine
gint
main (gint argc, gchar *argv[])
{
    Window root;
    //gettext
    bindtextdomain( "gamine", LOCALDIR );
    textdomain( "gamine" );
    gamine_t cb;
    GtkWidget *window;
    GdkWindow *gdkwindow;
    GtkWindow *gtkwindow;
    GdkScreen *screen;
    GdkPixbuf *cursor_pixbuf;
    GdkPixbuf *icon_pixbuf;
    GdkCursor *cursor;
    GdkColor bg_color;
    gchar *cursorfile;
    gchar *iconfile;

    cb.is_cairo = FALSE;
    gtk_init (&argc, &argv);
    gst_init (&argc, &argv);
    gconf_init(argc, argv, NULL);
    gst_play_background (cb.bus,
              "BachJSBrandenburgConcertNo2inFMajorBWV1047mvmt1.ogg", TRUE);

    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
/* Create the drawing area and configuration */
    cb.da = gtk_drawing_area_new ();
    bg_color.red   = 65535;
    bg_color.green = 65535;
    bg_color.blue  = 65535;
    gtk_widget_modify_bg (cb.da, GTK_STATE_NORMAL, &bg_color);
    gtk_container_add (GTK_CONTAINER (window), cb.da);
    cb.gc = gconf_client_get_default();

    gtkwindow = GTK_WINDOW(window);
    gtk_window_set_title (gtkwindow, "Gamine");
    gtk_window_set_wmclass(gtkwindow, "gamine", "Gamine");
    gtk_container_set_border_width (GTK_CONTAINER (gtkwindow), 0);


/* Event signals */
    g_signal_connect (gtkwindow, "destroy",
         G_CALLBACK (gtk_main_quit), &gtkwindow);
    g_signal_connect (G_OBJECT (cb.da), "expose-event",
        G_CALLBACK (display_help), &cb);
    g_signal_connect (cb.da, "motion_notify_event",
        G_CALLBACK (draw_line), &cb);
    g_signal_connect (cb.da, "button_press_event",
        G_CALLBACK (draw_star), &cb);
    g_signal_connect (gtkwindow, "key-press-event",
        G_CALLBACK (gamine_on_key), &cb);
    gtk_widget_set_events (cb.da, gtk_widget_get_events (cb.da)
        | GDK_LEAVE_NOTIFY_MASK
        | GDK_BUTTON_PRESS_MASK
        | GDK_BUTTON_RELEASE_MASK
        | GDK_POINTER_MOTION_MASK
        | GDK_POINTER_MOTION_HINT_MASK);
/* Set fullscreen, grab mouse/keyboard, ...*/
    gtk_widget_show_all (GTK_WIDGET(gtkwindow));
    gdkwindow = GDK_WINDOW(GTK_WIDGET(gtkwindow)->window);
    screen = gtk_widget_get_screen (cb.da);
    gtk_window_present (gtkwindow);
    gtk_window_stick(gtkwindow);

    //gtk_window_set_keep_above (gtkwindow), True);
    //gtk_window_set_transient_for (gtkwindow, NULL);
    //set fullscreen
    gdk_window_fullscreen (gdkwindow);
    gtk_window_fullscreen (gtkwindow);
    gdk_window_raise (gdkwindow);
    //set full screen without window manager
    XMoveResizeWindow(GDK_WINDOW_XDISPLAY(gdkwindow), GDK_WINDOW_XID(gdkwindow),
        0, 0, gdk_screen_get_width (screen), gdk_screen_get_height (screen));
    root = DefaultRootWindow(GDK_WINDOW_XDISPLAY (gdkwindow));
    XGrabPointer(GDK_WINDOW_XDISPLAY (gdkwindow), root, True, PointerMotionMask,
        GrabModeAsync, GrabModeAsync, root, None, CurrentTime); 
    XGrabKeyboard(GDK_WINDOW_XDISPLAY (gdkwindow), root, True,
                    GrabModeAsync, GrabModeAsync, CurrentTime);
    //remove keyboard repeat
    XAutoRepeatOff(GDK_WINDOW_XDISPLAY (gdkwindow));
    gtk_window_has_toplevel_focus (gtkwindow);
/*cursor*/
    cursorfile = g_build_filename(DATADIR, "pencil.png", NULL);
    if (!g_file_test (cursorfile, G_FILE_TEST_EXISTS)) {
        printf(gettext("*** error: %s does not exists***\n"), cursorfile);
    } else {
        cursor_pixbuf = gdk_pixbuf_new_from_file(cursorfile, NULL);
        cursor = gdk_cursor_new_from_pixbuf(gdk_display_get_default(),
            cursor_pixbuf, 0, 38);
        gdk_window_set_cursor(gdkwindow, cursor);
        gdk_cursor_unref(cursor);
        gdk_pixbuf_unref(cursor_pixbuf);
    }
    g_free(cursorfile);
/*Set icon*/
    iconfile = g_build_filename(DATADIR, "gamine.png", NULL);
    if (!g_file_test (iconfile, G_FILE_TEST_EXISTS))
        printf(gettext("*** error: %s does not exists***\n"), iconfile);
    else {
        icon_pixbuf = gdk_pixbuf_new_from_file(iconfile, NULL);
        gtk_window_set_icon (gtkwindow, icon_pixbuf);
        gdk_pixbuf_unref (icon_pixbuf);
    }
    g_free(iconfile);

    load_conf(&cb);
    gtk_main ();
    //set keyboard repeat
    XAutoRepeatOn(GDK_WINDOW_XDISPLAY (gdkwindow));
    XCloseDisplay(GDK_WINDOW_XDISPLAY (gdkwindow));
    return 0;
}
コード例 #21
0
ファイル: midiogre-app.c プロジェクト: prozum/midiogre
MidiogreApp *midiogre_app_init(void)
{
    MidiogreApp *app;

    GtkWidget *header;
    GtkWidget *separator;
    GtkWidget *scrolled;
    GtkWidget *label,*frame;
    GtkWidget *button;
    GtkBox *box;

    gint i;
    GError *err;

    /* Allocate app */
    app = calloc(1, sizeof(MidiogreApp));


    /* Setup window */
    app->window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
    gtk_window_set_default_size(GTK_WINDOW(app->window), 600, 400);
    g_signal_connect(app->window, "destroy", G_CALLBACK(gtk_widget_destroyed), NULL);
    g_signal_connect(app->window, "key-release-event", G_CALLBACK(key_event), NULL);
    gtk_window_set_icon(app->window,gdk_pixbuf_new_from_resource("/org/prozum/midiogre/midiogre_logo.png",&err));


    /* Setup header bar */
    header = gtk_header_bar_new();
    gtk_header_bar_set_title (GTK_HEADER_BAR(header), "Midiogre");
    gtk_window_set_titlebar(app->window, header);

    /* Setup close button */
    button = gtk_button_new();
    gtk_container_add (GTK_CONTAINER(button), gtk_image_new_from_resource("/org/prozum/midiogre/icons/window-close-symbolic.symbolic.png"));
    gtk_header_bar_pack_end(GTK_HEADER_BAR(header), button);
    g_signal_connect_swapped(button, "clicked", G_CALLBACK(gtk_main_quit), app->window);


    /* Add seperator */
    separator = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
    gtk_header_bar_pack_end(GTK_HEADER_BAR(header), separator);


    /* Setup folder button */
    button = gtk_button_new();
    gtk_container_add (GTK_CONTAINER(button), gtk_image_new_from_resource("/org/prozum/midiogre/icons/document-open-symbolic.symbolic.png"));
    gtk_header_bar_pack_end(GTK_HEADER_BAR(header), button);
    g_signal_connect_swapped(button, "clicked", G_CALLBACK(folder_chooser), app->window);

    /* Global horizontal box */
    app->win_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
    gtk_container_add(GTK_CONTAINER(app->window), GTK_WIDGET(app->win_box));


    /* Scroll container for sidepanel */
    scrolled = gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
    gtk_box_pack_start(app->win_box, scrolled, FALSE, FALSE, 0);


    /* Sidepanel box */
    app->panel_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 0));
    gtk_container_add(GTK_CONTAINER (scrolled), GTK_WIDGET(app->panel_box));
    gtk_container_set_border_width(GTK_CONTAINER(app->panel_box), 10);


    /* Frame with favorit info */
    frame = gtk_frame_new("Favorite");
    gtk_box_pack_start(app->panel_box, frame, FALSE, FALSE, 0);
    app->fav_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 0));
    gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->fav_box));


    /* Current favorite */
    app->fav_title_label = GTK_LABEL(gtk_label_new(""));
    gtk_label_set_max_width_chars(app->fav_title_label, 20);
    gtk_label_set_width_chars(app->fav_title_label, 20);
    gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_title_label), FALSE, FALSE, 0);
    app->fav_artist_label = GTK_LABEL(gtk_label_new("No favorite selected!"));
    gtk_label_set_max_width_chars(app->fav_artist_label, 20);
    gtk_label_set_width_chars(app->fav_artist_label, 20);
    gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_artist_label), FALSE, FALSE, 0);
    app->fav_album_label = GTK_LABEL(gtk_label_new(""));
    gtk_label_set_max_width_chars(app->fav_album_label, 20);
    gtk_label_set_width_chars(app->fav_album_label, 20);
    gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_album_label), FALSE, FALSE, 0);


    /* Frame with search criteria widgets */
    frame = gtk_frame_new("Search");
    gtk_box_pack_start(app->panel_box, frame, FALSE, FALSE, 0);

    app->search_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 10));
    gtk_container_set_border_width(GTK_CONTAINER(app->search_box), 10);

    gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->search_box));


    /* Title entry */
    frame = gtk_frame_new("Title");
    gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);

    box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
    gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));
    gtk_container_set_border_width(GTK_CONTAINER(box), 10);

    app->title_entry = GTK_ENTRY(gtk_entry_new());
    gtk_box_pack_start(box, GTK_WIDGET(app->title_entry), TRUE, FALSE, 0);


    /* Artist entry */
    frame = gtk_frame_new("Artist");
    gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
    gtk_container_set_border_width(GTK_CONTAINER(box), 10);

    box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
    gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));
    gtk_container_set_border_width(GTK_CONTAINER(box), 10);

    app->artist_entry = GTK_ENTRY(gtk_entry_new());
    gtk_box_pack_start(box, GTK_WIDGET(app->artist_entry), TRUE, FALSE, 0);


    /* Album entry */
    frame = gtk_frame_new("Album");
    gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);

    box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
    gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));
    gtk_container_set_border_width(GTK_CONTAINER(box), 10);

    app->album_entry = GTK_ENTRY(gtk_entry_new());
    gtk_box_pack_start(box, GTK_WIDGET(app->album_entry), TRUE, FALSE, 0);


    /* Instrument class buttons */
    frame = gtk_frame_new("Instrument Classes");
    gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);

    app->instr_grid = GTK_GRID(gtk_grid_new());

#if GTK_MINOR_VERSION >= 12
    gtk_widget_set_margin_start(GTK_WIDGET(app->instr_grid), 10);
    gtk_widget_set_margin_end(GTK_WIDGET(app->instr_grid), 10);
#else
    gtk_widget_set_margin_left(GTK_WIDGET(app->instr_grid), 10);
    gtk_widget_set_margin_right(GTK_WIDGET(app->instr_grid), 10);
#endif
    gtk_widget_set_margin_bottom(GTK_WIDGET(app->instr_grid), 10);
    gtk_widget_set_margin_top(GTK_WIDGET(app->instr_grid), 10);
    gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->instr_grid));


    for (i = 0; i < INSTR_CLASSES; i++) {

        label = gtk_label_new(instrument_classes[i]);
        gtk_widget_set_halign(GTK_WIDGET(label), GTK_ALIGN_START);
        gtk_grid_attach(app->instr_grid, label, 1, i + 1, 1, 1);

        app->instr_buttons[i] = GTK_CHECK_BUTTON(gtk_check_button_new());
        gtk_widget_set_halign(GTK_WIDGET(app->instr_buttons[i]), GTK_ALIGN_END);
        gtk_grid_attach(app->instr_grid, GTK_WIDGET(app->instr_buttons[i]), 2, i + 1, 1, 1);
    }


    /* Result spinbutton */
    frame = gtk_frame_new("Max result");
    gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);

    box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
    gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));
    gtk_container_set_border_width(GTK_CONTAINER(box), 10);

    app->result_spinbutton = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(1, 100, 1));
    gtk_spin_button_set_value(app->result_spinbutton, 25);

    gtk_box_pack_start(box, GTK_WIDGET(app->result_spinbutton), TRUE, TRUE, 0);

    /* Search button */
    app->search_button = GTK_BUTTON(gtk_button_new_with_label("Search"));
    gtk_box_pack_start(app->search_box, GTK_WIDGET(app->search_button), FALSE, FALSE, 0);
    g_signal_connect_swapped(app->search_button, "clicked", G_CALLBACK(search_event), app);


    /* Songboxes notebook (Tabsview) */
    app->song_notebook = GTK_NOTEBOOK(gtk_notebook_new());
    gtk_widget_set_hexpand(GTK_WIDGET(app->song_notebook), TRUE);
    gtk_box_pack_start(app->win_box, GTK_WIDGET(app->song_notebook), TRUE, TRUE, 0);


    /* Add song boxes */
    app->songboxes[SONGBOX_ALPHA] = songbox_new(app->song_notebook, "Alphabetical");
    app->songboxes[SONGBOX_FPRNT] = songbox_new(app->song_notebook, "Fingerprint");
    app->songboxes[SONGBOX_BEST]  = songbox_new(app->song_notebook, "Best Match");
    app->songboxes[SONGBOX_POP]   = songbox_new(app->song_notebook, "Popularity");
    app->songboxes[SONGBOX_NEW]   = songbox_new(app->song_notebook, "Newest");


    /* Show all widgets */
    gtk_widget_show_all(GTK_WIDGET(app->window));


    /* Allocate song queue */
    app->songs[SONGBOX_ALPHA]   = g_queue_new();
    app->songs[SONGBOX_FPRNT]   = g_queue_new();
    app->songs[SONGBOX_BEST]    = g_queue_new();
    app->songs[SONGBOX_POP]     = g_queue_new();
    app->songs[SONGBOX_NEW]     = g_queue_new();


    return app;
}
コード例 #22
0
CAboutDlg::CAboutDlg(GtkWindow *pParent)
{
	float x;
	char buf[2048];
	GtkWidget *tbox, *label, *scrolled_window, *text_view;

	// Dialog with buttons
	m_pDlg = gtk_dialog_new_with_buttons("About Muniwin", pParent, 
		(GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR),
		GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL);
	gtk_dialog_widget_standard_tooltips(GTK_DIALOG(m_pDlg));
	g_signal_connect(G_OBJECT(m_pDlg), "response", G_CALLBACK(response_dialog), this);

	// Dialog icon
	gchar *icon = get_icon_file("about");
	gtk_window_set_icon(GTK_WINDOW(m_pDlg), gdk_pixbuf_new_from_file(icon, NULL));
	g_free(icon);

	// Notebook
	m_Notebook = gtk_notebook_new();
	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(m_pDlg)->vbox), m_Notebook, TRUE, TRUE, 0);
	gtk_widget_set_size_request(m_Notebook, 400, 240);

	// Page "General"
	tbox = gtk_table_new(4, 1, FALSE);
	gtk_container_set_border_width(GTK_CONTAINER(tbox), 8);
	gtk_table_set_row_spacings(GTK_TABLE(tbox), 8);
	gtk_notebook_append_page(GTK_NOTEBOOK(m_Notebook), tbox, gtk_label_new("General"));

	label = gtk_label_new(NULL);
	gtk_label_set_markup(GTK_LABEL(label), "<span size=\"xx-large\" weight=\"bold\">Muniwin</span>");
	gtk_table_attach_defaults(GTK_TABLE(tbox), label, 0, 1, 0, 1);

	label = gtk_label_new(NULL);
	sprintf(buf, "<span size=\"x-large\" weight=\"bold\">Stable version %s</span>", VERSION);
	gtk_label_set_markup(GTK_LABEL(label), buf);
	gtk_table_attach_defaults(GTK_TABLE(tbox), label, 0, 1, 1, 2);

	label = gtk_label_new(NULL);
	sprintf(buf, "<span size=\"large\">%s</span>", ProjectDescription);
	gtk_label_set_markup(GTK_LABEL(label), buf);
	gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
	gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_CENTER);
	gtk_table_attach_defaults(GTK_TABLE(tbox), label, 0, 1, 2, 3);

	label = gtk_label_new(NULL);
	gtk_label_set_markup(GTK_LABEL(label), "<span size=\"x-large\" underline=\"single\" foreground=\"blue\">http://c-munipack.sourceforge.net</span>");
	gtk_table_attach_defaults(GTK_TABLE(tbox), label, 0, 1, 3, 4);

	// Page "Versions"
	tbox = gtk_table_new(5, 2, false);
	gtk_container_set_border_width(GTK_CONTAINER(tbox), 8);
	gtk_table_set_row_spacings(GTK_TABLE(tbox), 8);
	gtk_table_set_col_spacings(GTK_TABLE(tbox), 16);
	gtk_notebook_append_page(GTK_NOTEBOOK(m_Notebook), tbox, gtk_label_new("Versions"));
	AddVersion(GTK_TABLE(tbox), 0, g_AppTitle, VERSION);
	AddVersion(GTK_TABLE(tbox), 1, "C-Munipack", cmpack_versionid());
	sprintf(buf, "%.03f", ffvers(&x));
	AddVersion(GTK_TABLE(tbox), 2, "CFITSIO", buf);
	AddVersion(GTK_TABLE(tbox), 3, "Expat", XML_ExpatVersion());
	sprintf(buf, "%d.%d.%d", gtk_major_version, gtk_minor_version, gtk_micro_version);
	AddVersion(GTK_TABLE(tbox), 4, "GTK+", buf);
	sprintf(buf, "%d.%d.%d", glib_major_version, glib_minor_version, glib_micro_version);
	AddVersion(GTK_TABLE(tbox), 5, "GLib", buf);
#if HAVE_LIBGSTREAMER_0_10
	gchar *gstver = gst_version_string();
	AddVersion(GTK_TABLE(tbox), 6, "GStreamer", gstver);
	free(gstver);
#endif
	
	// Page "License"
	scrolled_window = gtk_scrolled_window_new (NULL, NULL);
	gtk_notebook_append_page(GTK_NOTEBOOK(m_Notebook), scrolled_window, gtk_label_new("License"));
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
		GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_window), 
		GTK_SHADOW_ETCHED_IN);

	text_view = gtk_text_view_new_with_buffer(NULL);
	gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text_view), GTK_WRAP_WORD);
	gtk_text_view_set_editable(GTK_TEXT_VIEW(text_view), false);
	gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(text_view), false);
	gtk_text_buffer_set_text(gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view)), 
		CopyrightText, -1);
	gtk_container_add(GTK_CONTAINER(scrolled_window), text_view);

	// Page "Credits"
	scrolled_window = gtk_scrolled_window_new (NULL, NULL);
	gtk_notebook_append_page(GTK_NOTEBOOK(m_Notebook), scrolled_window, gtk_label_new("Credits"));
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
		GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_window), 
		GTK_SHADOW_ETCHED_IN);

	text_view = gtk_text_view_new_with_buffer(NULL);
	gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text_view), GTK_WRAP_WORD);
	gtk_text_view_set_editable(GTK_TEXT_VIEW(text_view), false);
	gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(text_view), false);
	gtk_text_buffer_set_text(gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view)), 
		CreditsText, -1);
	gtk_container_add(GTK_CONTAINER(scrolled_window), text_view);

	gtk_widget_show_all(GTK_DIALOG(m_pDlg)->vbox);
}
コード例 #23
0
void create_mainwindow(void)
{
	char *imagename;
	GtkWidget *vbox_gs;
	GtkWidget *menu;
	GtkWidget *hbox25;
	GtkWidget *tab_button_icon;
	GtkWidget *label;
#ifndef USE_WEBKIT2
	GtkWidget *scrolledwindow;
#endif
	GtkWidget *box_book;
	GdkPixbuf *pixbuf;
	/*
	   GTK_SHADOW_NONE
	   GTK_SHADOW_IN
	   GTK_SHADOW_OUT
	   GTK_SHADOW_ETCHED_IN
	   GTK_SHADOW_ETCHED_OUT
	 */
	settings.shadow_type = GTK_SHADOW_IN;

	XI_print(("%s xiphos-%s\n", "Starting", VERSION));
	XI_print(("%s\n\n", "Building Xiphos interface"));

	widgets.studypad_dialog = NULL;

	/* A rough scektch of the main window (widgets.app) and it's children
	 *                widgets.app
	 *                     |
	 *                  vbox_gs
	 *                     |
	 *                  +--|----+
	 *                  |       |
	 *                 menu   hbox25
	 *                           |
	 *                     widgets.epaned
	 *                         |
	 *                 widgets.vboxMain
	 *                 |              |
	 *           widgets.hboxtb   widgets.page
	 *                            |         |
	 *                     widgets.hpaned  nav_toolbar
	 *                     |            |
	 *              widgets.vpaned---+  +----------------------------widgets.vpaned2---------------+
	 *               |               |                                      |                      |
	 * widgets.vbox_previewer   widgets.vbox_text              widgets.notebook_comm_book   widgets.box_dict
	 *                               |                         |                       |
	 *                widgets.notebook_bible_parallel   widgets.box_comm            box_book
	 *                               |
	 *                     widgets.notebook_text
	 *
	 */

	// The toplevel Xiphos window
	widgets.app = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(widgets.app), _("Xiphos - Bible Study Software"));
	g_object_set_data(G_OBJECT(widgets.app), "widgets.app", widgets.app);
	gtk_widget_set_size_request(widgets.app, 680, 425);
	gtk_widget_set_can_focus(widgets.app, 1);
	gtk_window_set_resizable(GTK_WINDOW(widgets.app), TRUE);

	// The app icon.
	// FIXME:: This should be a big copy of the logo because GTK does the scaling (GTK 3.16?)
	imagename = image_locator("gs2-48x48.png");
	pixbuf = gdk_pixbuf_new_from_file(imagename, NULL);
	g_free(imagename);
	gtk_window_set_icon(GTK_WINDOW(widgets.app), pixbuf);

	// The main box for our toplevel window.
	UI_VBOX(vbox_gs, FALSE, 0);
	gtk_widget_show(vbox_gs);
	gtk_container_add(GTK_CONTAINER(widgets.app), vbox_gs);

	// Add the main menu.
	menu = gui_create_main_menu();
	gtk_box_pack_start(GTK_BOX(vbox_gs), menu, FALSE, TRUE, 0);

	// Another box
	UI_HBOX(hbox25, FALSE, 0);
	gtk_widget_show(hbox25);
	gtk_box_pack_start(GTK_BOX(vbox_gs), hbox25, TRUE, TRUE, 0);

	// widgets.epaned
	widgets.epaned = UI_HPANE();
	gtk_widget_show(widgets.epaned);
#ifndef HAVE_GTK_314
	gtk_container_set_border_width(GTK_CONTAINER(widgets.epaned), 4);
#endif
	gtk_box_pack_start(GTK_BOX(hbox25), widgets.epaned, TRUE, TRUE, 0);
	// Another box
	UI_VBOX(widgets.vboxMain, FALSE, 0);
	gtk_widget_show(widgets.vboxMain);
	gtk_paned_pack2(GTK_PANED(widgets.epaned), widgets.vboxMain, TRUE, TRUE);
#ifndef HAVE_GTK_314
	gtk_container_set_border_width(GTK_CONTAINER(widgets.vboxMain), 2);
#endif

	/*
	 * Notebook to have separate passages opened at once the passages are not
	 * actually open but are switched between similar to bookmarks
	 */
	UI_HBOX(widgets.hboxtb, FALSE, 0);
	if (settings.browsing)
		gtk_widget_show(widgets.hboxtb);
	gtk_box_pack_start(GTK_BOX(widgets.vboxMain), widgets.hboxtb, FALSE, FALSE, 0);

	widgets.button_new_tab = gtk_button_new();
	// Don't show button here in case !settings.browsing

#ifdef HAVE_GTK_310
	tab_button_icon = gtk_image_new_from_icon_name("tab-new-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR);
#else
	tab_button_icon = gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_SMALL_TOOLBAR);
#endif

	gtk_widget_show(tab_button_icon);
	gtk_container_add(GTK_CONTAINER(widgets.button_new_tab), tab_button_icon);
	gtk_button_set_relief(GTK_BUTTON(widgets.button_new_tab), GTK_RELIEF_NONE);
	gtk_box_pack_start(GTK_BOX(widgets.hboxtb), widgets.button_new_tab, FALSE, FALSE, 0);
	gtk_widget_set_tooltip_text(widgets.button_new_tab, _("Open a new tab"));

	widgets.notebook_main = gtk_notebook_new();
	gtk_widget_show(widgets.notebook_main);
	gtk_box_pack_start(GTK_BOX(widgets.hboxtb), widgets.notebook_main, TRUE, TRUE, 0);
	gtk_widget_set_size_request(widgets.notebook_main, -1, 25);
	gtk_notebook_set_scrollable(GTK_NOTEBOOK(widgets.notebook_main), TRUE);
	gtk_notebook_popup_enable(GTK_NOTEBOOK(widgets.notebook_main));
	gtk_notebook_set_show_border(GTK_NOTEBOOK(widgets.notebook_main), FALSE);
	// Main passage tabbed notebook end

	// Another box
	UI_VBOX(widgets.page, FALSE, 0);
	gtk_widget_show(widgets.page);
	gtk_box_pack_start(GTK_BOX(widgets.vboxMain), widgets.page, TRUE, TRUE, 0);

	//nav toolbar
	nav_toolbar = gui_navbar_versekey_new();
	gtk_box_pack_start(GTK_BOX(widgets.page), nav_toolbar, FALSE, FALSE, 0);

	// widgets.hpaned
	widgets.hpaned = UI_HPANE();
	gtk_widget_show(widgets.hpaned);
	gtk_box_pack_start(GTK_BOX(widgets.page), widgets.hpaned, TRUE, TRUE, 0);

	// widgets.vpaned
	widgets.vpaned = UI_VPANE();
	gtk_widget_show(widgets.vpaned);
	gtk_widget_set_size_request(widgets.vpaned, 50, -1);
	gtk_paned_pack1(GTK_PANED(widgets.hpaned), widgets.vpaned, TRUE, FALSE);

	// widgets.vpaned2
	widgets.vpaned2 = UI_VPANE();
	gtk_widget_show(widgets.vpaned2);
	gtk_widget_set_size_request(widgets.vpaned2, 50, -1);
	gtk_paned_pack2(GTK_PANED(widgets.hpaned), widgets.vpaned2, TRUE, FALSE);

	// widgets.vbox_text
	UI_VBOX(widgets.vbox_text, FALSE, 0);
	gtk_widget_show(widgets.vbox_text);
	gtk_paned_pack1(GTK_PANED(widgets.vpaned), widgets.vbox_text, TRUE, TRUE);

	// Bible/parallel notebook
	widgets.notebook_bible_parallel = gtk_notebook_new();
	gtk_widget_show(widgets.notebook_bible_parallel);
	gtk_box_pack_start(GTK_BOX(widgets.vbox_text), widgets.notebook_bible_parallel, TRUE, TRUE, 0);
	gtk_notebook_set_tab_pos(GTK_NOTEBOOK(widgets.notebook_bible_parallel), GTK_POS_BOTTOM);
	gtk_notebook_set_show_tabs(GTK_NOTEBOOK(widgets.notebook_bible_parallel), TRUE);
	gtk_notebook_set_show_border(GTK_NOTEBOOK(widgets.notebook_bible_parallel), FALSE);
	gtk_container_set_border_width(GTK_CONTAINER(widgets.notebook_bible_parallel), 1);

	g_signal_connect(G_OBJECT(widgets.notebook_bible_parallel), "change-current-page", G_CALLBACK(on_notebook_bible_parallel_switch_page), NULL);

	// Text notebook (The bible text show in the standard view)
	widgets.notebook_text = gui_create_bible_pane();
	gtk_container_add(GTK_CONTAINER(widgets.notebook_bible_parallel), widgets.notebook_text);

	label = gtk_label_new(_("Standard View"));
	gtk_widget_show(label);
	gtk_notebook_set_tab_label(GTK_NOTEBOOK(widgets.notebook_bible_parallel), gtk_notebook_get_nth_page(GTK_NOTEBOOK(widgets.notebook_bible_parallel), 0), label);

	// Another box (For the previewer?)
	UI_VBOX(widgets.vbox_previewer, FALSE, 0);
	gtk_widget_show(widgets.vbox_previewer);
	gtk_paned_pack2(GTK_PANED(widgets.vpaned), widgets.vbox_previewer, TRUE, TRUE);
	gtk_container_set_border_width(GTK_CONTAINER(widgets.vbox_previewer), 2);

#ifndef USE_WEBKIT2
	scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
	gtk_widget_show(scrolledwindow);
	gtk_box_pack_start(GTK_BOX(widgets.vbox_previewer), scrolledwindow, TRUE, TRUE, 0);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
	gtk_scrolled_window_set_shadow_type((GtkScrolledWindow *) scrolledwindow, settings.shadow_type);
#endif
	widgets.html_previewer_text = GTK_WIDGET(XIPHOS_HTML_NEW(NULL, FALSE, VIEWER_TYPE));
	gtk_widget_show(widgets.html_previewer_text);
#ifdef USE_WEBKIT2
	gtk_box_pack_start(GTK_BOX(widgets.vbox_previewer), widgets.html_previewer_text, TRUE, TRUE, 0);
#else
	gtk_container_add(GTK_CONTAINER(scrolledwindow), widgets.html_previewer_text);
#endif

	// Commentary/book notebook
	widgets.notebook_comm_book = gtk_notebook_new();
	gtk_widget_show(widgets.notebook_comm_book);

	gtk_paned_pack1(GTK_PANED(widgets.vpaned2), widgets.notebook_comm_book, TRUE, TRUE);
	gtk_container_set_border_width(GTK_CONTAINER(widgets.notebook_comm_book), 1);

	gtk_notebook_set_tab_pos(GTK_NOTEBOOK(widgets.notebook_comm_book), GTK_POS_BOTTOM);
	gtk_notebook_set_show_tabs(GTK_NOTEBOOK(widgets.notebook_comm_book), TRUE);
	gtk_notebook_set_show_border(GTK_NOTEBOOK(widgets.notebook_comm_book), FALSE);

	// Commentary pane
	widgets.box_comm = gui_create_commentary_pane();
	gtk_container_add(GTK_CONTAINER(widgets.notebook_comm_book), widgets.box_comm);

	label = gtk_label_new(_("Commentary View"));
	gtk_widget_show(label);
	gtk_notebook_set_tab_label(GTK_NOTEBOOK(widgets.notebook_comm_book), gtk_notebook_get_nth_page(GTK_NOTEBOOK(widgets.notebook_comm_book), 0), label);

	// Book pane
	box_book = gui_create_book_pane();
	gtk_container_add(GTK_CONTAINER(widgets.notebook_comm_book), box_book);

	label = gtk_label_new(_("Book View"));
	gtk_widget_show(label);
	gtk_notebook_set_tab_label(GTK_NOTEBOOK(widgets.notebook_comm_book), gtk_notebook_get_nth_page(GTK_NOTEBOOK(widgets.notebook_comm_book), 1), label);

	// Dict/lex
	widgets.box_dict = gui_create_dictionary_pane();
	gtk_paned_pack2(GTK_PANED(widgets.vpaned2), widgets.box_dict, TRUE, TRUE);

	// Statusbar
	widgets.appbar = gtk_statusbar_new();
	if (settings.statusbar) {
		gtk_widget_show(widgets.appbar);
	}

#ifndef USE_GTK_3
	gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(widgets.appbar), TRUE);
#endif
	gtk_box_pack_start(GTK_BOX(vbox_gs), widgets.appbar, FALSE, TRUE, 0);
	gui_set_statusbar(_("Welcome to Xiphos"));

	g_signal_connect((gpointer)vbox_gs, "key_press_event", G_CALLBACK(on_vbox1_key_press_event), NULL);
	g_signal_connect((gpointer)vbox_gs, "key_release_event", G_CALLBACK(on_vbox1_key_release_event), NULL);

	g_signal_connect(G_OBJECT(widgets.notebook_comm_book), "switch_page", G_CALLBACK(on_notebook_comm_book_switch_page), NULL);

	g_signal_connect(G_OBJECT(widgets.app), "delete_event", G_CALLBACK(delete_event), NULL);

	g_signal_connect((gpointer)widgets.app, "configure_event", G_CALLBACK(on_configure_event), NULL);
	g_signal_connect(G_OBJECT(widgets.epaned), "button_release_event", G_CALLBACK(epaned_button_release_event), (gchar *)"epaned");
	g_signal_connect(G_OBJECT(widgets.vpaned), "button_release_event", G_CALLBACK(epaned_button_release_event), (gchar *)"vpaned");
	g_signal_connect(G_OBJECT(widgets.vpaned2), "button_release_event", G_CALLBACK(epaned_button_release_event), (gchar *)"vpaned2");
	g_signal_connect(G_OBJECT(widgets.hpaned), "button_release_event", G_CALLBACK(epaned_button_release_event), (gchar *)"hpaned1");

	gtk_widget_grab_focus(navbar_versekey.lookup_entry);

	gtk_window_set_default_size((GtkWindow *)widgets.app, settings.gs_width, settings.gs_height);
	main_window_created = TRUE;
}
コード例 #24
0
ファイル: main.c プロジェクト: debrouxl/tilp_and_gfm
int main(int argc, char *argv[])
{
	GdkPixbuf *icon;

	/* Redirect standard output to a file - printing to the Windows terminal slows operation down way too much */
#ifdef __WIN32__
	gchar *tmp;
	FILE *log_file;

	tmp = g_strconcat(g_get_home_dir(), G_DIR_SEPARATOR_S, LOG_FILE, NULL);
	log_file = g_fopen(tmp, "wt");
	g_free(tmp);

	if (log_file != NULL)
		g_log_set_default_handler(&default_log_handler, log_file);
#endif

	// Force GLib 2.32+ to print info and debug messages like older versions did, unless this variable is already set.
	// No effect on earlier GLib versions.
	g_setenv("G_MESSAGES_DEBUG", "all", /* overwrite = */ FALSE);

	/* Init the tilp core */
	tilp_init(&argc, &argv);

	/* Init GTK+ */
	gtk_init(&argc, &argv);
	add_pixmap_directory(inst_paths.pixmap_dir);
	add_pixmap_directory(inst_paths.icon_dir);
	splash_screen_start();

	/*
		Get rid of glib, gdk, gtk warnings when compiled in Release mode
	*/
#if !defined(_DEBUG)
	g_log_set_handler ("GLib", 
		G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG,
		my_blackhole_log_handler, NULL);
	g_log_set_handler ("Gdk", 
		G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG,
		my_blackhole_log_handler, NULL);
	g_log_set_handler ("Gtk", 
		G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG,
		my_blackhole_log_handler, NULL);

	g_log_set_handler ("GLib", G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION, 
		my_blackhole_log_handler, NULL);
#endif

	/* Init the GUI-independent functions */
	tilp_gif_set_gtk();
	tilp_update_set_gtk();

	/* Create the main window */
	if(!(working_mode & MODE_CMD))
	{
#if WITH_KDE
		splash_screen_set_label(_("Initializing KDE..."));
		sp_kde_init(argc, argv, "tilp", _("TiLP"), VERSION, _("Tilp Is a Linking Program"), "Copyright (c) 1999-2008 Romain Lievin", "http://lpg.ticalc.org/prj_tilp/", "*****@*****.**");
		atexit(sp_kde_finish);
		// Not needed unless we want to add a DCOP interface.
		// g_timeout_add(26, sp_kde_process_qt_events, NULL);
#endif

		splash_screen_set_label(_("Loading GUI..."));
		main_wnd = display_tilp_dbox();
	}

	/* Do a local directory list */
	g_free(local.cwdir);
	local.cwdir = g_get_current_dir();

	/* Update the local view (not visible yet) */
	if(!(working_mode & MODE_CMD))
	{
		clist_refresh();
		labels_refresh();
	}

	/* Inits are done ! */
	working_mode &= ~MODE_INI;
	tilp_err(0);		// pop errors (display console mode)

	/* In cmdline, does not display the entire window, only the pbar */
	if(!(working_mode & MODE_CMD))
	{
		gtk_widget_show(main_wnd);
		toolbar_refresh_buttons();
		icon = create_pixbuf("tilp.xpm");
		gtk_window_set_icon(GTK_WINDOW(main_wnd), icon);
		gdk_window_set_icon_name(main_wnd->window, _("TiLP2"));
	}

	/* 
	   If variables have been passed on the command line in GUI mode then
	   send them 
	 */
	if((working_mode & MODE_GUI) && (working_mode & MODE_CMD)) 
	{
		splash_screen_set_label(_("Command line..."));

		if(local.selection0 || local.selection2 || local.selection5)
			on_tilp_send("");
		else if(local.selection4)
			tilp_cmdline_send();
	}

	/* GTK main loop */
	splash_screen_stop();
	if(!(working_mode & MODE_CMD))
		gtk_main();
	tilp_exit();

	return 0;
}
コード例 #25
0
ファイル: main.c プロジェクト: snowasnow/DeSmuME
int main (int argc, char *argv[])
{
	int i;
	
	const char *commandLine_File = NULL;
	GtkWidget *pVBox;
	GtkWidget *pMenuBar;
	GtkWidget *pMenu, *pSubMenu;
	GtkWidget *pMenuItem, *pSubMenuItem;
	GtkAccelGroup * accel_group;
       
	if(argc == 2) commandLine_File = argv[1];
	
#ifdef DEBUG
        LogStart();
#endif
	
	gtk_init(&argc, &argv);
	SDL_Init(SDL_INIT_VIDEO);
	desmume_init();
	
 	dTools_running = (BOOL*)malloc(sizeof(BOOL) * dTools_list_size);
	for(i=0; i<dTools_list_size; i++) dTools_running[i]=FALSE;
	
	CONFIG_FILE = g_build_filename(g_get_home_dir(), ".desmume.ini", NULL);
	Read_ConfigFile();
	
	/* Creation de la fenetre */
	pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(pWindow), "Desmume");
	gtk_window_set_policy (GTK_WINDOW (pWindow), FALSE, FALSE, FALSE);
	gtk_window_set_icon(GTK_WINDOW (pWindow), gdk_pixbuf_new_from_xpm_data(DeSmuME_xpm));
	
	g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
	g_signal_connect(G_OBJECT(pWindow), "key_press_event", G_CALLBACK(Key_Press), NULL);
	g_signal_connect(G_OBJECT(pWindow), "key_release_event", G_CALLBACK(Key_Release), NULL);

	/* Creation de la GtkVBox */
	pVBox = gtk_vbox_new(FALSE, 0);
	gtk_container_add(GTK_CONTAINER(pWindow), pVBox);

	accel_group = gtk_accel_group_new();
	action_group = gtk_action_group_new("dui");
	gtk_action_group_add_actions(action_group, action_entries, sizeof(action_entries) / sizeof(GtkActionEntry), pWindow);
        {
                GList * list = gtk_action_group_list_actions(action_group);
                g_list_foreach(list, dui_set_accel_group, accel_group);
        }
	gtk_window_add_accel_group(GTK_WINDOW(pWindow), accel_group);
	gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "pause"), FALSE);
	gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "run"), FALSE);
	gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "reset"), FALSE);
	gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "printscreen"), FALSE);

	/**** Creation du menu ****/

	pMenuBar = gtk_menu_bar_new();
	
	/** Menu "Fichier" **/

	pMenu = gtk_menu_new();

	gtk_container_add(GTK_CONTAINER(pMenu), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "open")));
	gtk_container_add(GTK_CONTAINER(pMenu), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "printscreen")));
	gtk_container_add(GTK_CONTAINER(pMenu), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "quit")));
	
	pMenuItem = gtk_menu_item_new_with_label("File");
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu);
	gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);

	/** Menu "Emulation" **/
	GtkWidget *mEmulation;
		GtkWidget *mFrameskip;
			GtkWidget *mFrameskip_Radio[MAX_FRAMESKIP];
		GtkWidget *mGraphics;
			GtkWidget *mSize;
				GtkWidget *mSize_Radio[MAX_SCREENCOEFF];
			GtkWidget *mLayers;
				GtkWidget *mLayers_Radio[10];
	
	
	mEmulation = gtk_menu_new();
	pMenuItem = gtk_menu_item_new_with_label("Emulation");
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mEmulation);
	gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
	
	gtk_container_add(GTK_CONTAINER(mEmulation), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "run")));
	
	gtk_container_add(GTK_CONTAINER(mEmulation), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "pause")));

	gtk_container_add(GTK_CONTAINER(mEmulation), gtk_action_create_menu_item(gtk_action_group_get_action(action_group, "reset")));
	
		mFrameskip = gtk_menu_new();
		pMenuItem = gtk_menu_item_new_with_label("Frameskip");
		gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mFrameskip);
		gtk_menu_shell_append(GTK_MENU_SHELL(mEmulation), pMenuItem);
		
		for(i = 0; i < MAX_FRAMESKIP; i++) {
			char frameskipRadio_buf[16];
			sprintf(frameskipRadio_buf, "%d", i);
			if(i>0) mFrameskip_Radio[i] = gtk_radio_menu_item_new_with_label_from_widget(GTK_RADIO_MENU_ITEM(mFrameskip_Radio[i-1]), frameskipRadio_buf);
			else mFrameskip_Radio[i] = gtk_radio_menu_item_new_with_label(NULL, frameskipRadio_buf);
			g_signal_connect(G_OBJECT(mFrameskip_Radio[i]), "activate", G_CALLBACK(Modify_Frameskip), GINT_TO_POINTER(i));
			gtk_menu_shell_append(GTK_MENU_SHELL(mFrameskip), mFrameskip_Radio[i]);
		}
		gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mFrameskip_Radio[0]), TRUE);
		
		mGraphics = gtk_menu_new();
		pMenuItem = gtk_menu_item_new_with_label("Graphics");
		gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mGraphics);
		gtk_menu_shell_append(GTK_MENU_SHELL(mEmulation), pMenuItem);
			
// TODO: Un jour, peut être... ><
			mSize = gtk_menu_new();
			pMenuItem = gtk_menu_item_new_with_label("Size");
			gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mSize);
			gtk_menu_shell_append(GTK_MENU_SHELL(mGraphics), pMenuItem);
			
			for(i = 1; i < MAX_SCREENCOEFF; i++) {
				char sizeRadio_buf[16];
				sprintf(sizeRadio_buf, "x%d", i);
				if(i>1) mSize_Radio[i] = gtk_radio_menu_item_new_with_label_from_widget(GTK_RADIO_MENU_ITEM(mSize_Radio[i-1]), sizeRadio_buf);
				else mSize_Radio[i] = gtk_radio_menu_item_new_with_label(NULL, sizeRadio_buf);
				g_signal_connect(G_OBJECT(mSize_Radio[i]), "activate", G_CALLBACK(Modify_ScreenCoeff), GINT_TO_POINTER(i));
				gtk_menu_shell_append(GTK_MENU_SHELL(mSize), mSize_Radio[i]);
			}
			gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mFrameskip_Radio[0]), TRUE);
		
			mLayers = gtk_menu_new();
			pMenuItem = gtk_menu_item_new_with_label("Layers");
			gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mLayers);
			gtk_menu_shell_append(GTK_MENU_SHELL(mGraphics), pMenuItem);
		
			for(i = 0; i < 10; i++) {
				mLayers_Radio[i] = gtk_check_menu_item_new_with_label(Layers_Menu[i]);
				g_signal_connect(G_OBJECT(mLayers_Radio[i]), "activate", G_CALLBACK(Modify_Layer), (void*)Layers_Menu[i]);
				gtk_menu_shell_append(GTK_MENU_SHELL(mLayers), mLayers_Radio[i]);
				gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mLayers_Radio[i]), TRUE);
			}
			
	
	/** Menu "Options" **/
	GtkWidget *mConfig = gtk_menu_new();
	pMenuItem = gtk_menu_item_new_with_label("Config");
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mConfig);
	gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
	
	pMenuItem = gtk_menu_item_new_with_label("Edit controls");
	g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(Edit_Controls), (GtkWidget*) pWindow);
	gtk_menu_shell_append(GTK_MENU_SHELL(mConfig), pMenuItem);
	
#if 0
	
	GtkWidget *mFirmware;
	
	mFirmware = gtk_menu_new();
	pMenuItem = gtk_menu_item_new_with_label("Firmware");
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mFirmware);
	gtk_menu_shell_append(GTK_MENU_SHELL(mConfig), pMenuItem);
	
	pMenuItem = gtk_menu_item_new_with_label("Select...");
	g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(SelectFirmwareFile), (gpointer)0);
	gtk_menu_shell_append(GTK_MENU_SHELL(mFirmware), pMenuItem);
		
	pMenuItem = gtk_menu_item_new_with_label("Config");
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), mConfig);
	gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
	
#endif
	
	/** Menu "Outils" **/
	
	pMenu = gtk_menu_new();
	
	for(i = 0; i < dTools_list_size; i++)
	{
		pMenuItem = gtk_menu_item_new_with_label(dTools_list[i]->name);
		g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(Start_dTool), GINT_TO_POINTER(i));
		gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);
	}
		
	pMenuItem = gtk_menu_item_new_with_label("Tools");
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu);
	gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
	
	/** Menu "?" **/

	pMenu = gtk_menu_new();

#if ((GTK_MAJOR_VERSION >= 2) && (GTK_MINOR_VERSION >= 6))
	pMenuItem = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT,NULL);
#else
	pMenuItem = gtk_menu_item_new_with_label("About");
#endif
	g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(About), (GtkWidget*) pWindow);
	gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);

	pMenuItem = gtk_menu_item_new_with_label("?");
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu);
	gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);

	/* Ajout du menu a la fenetre */
	gtk_box_pack_start(GTK_BOX(pVBox), pMenuBar, FALSE, FALSE, 0);

	/* Création de la Toolbar */
	
	pToolbar = gtk_toolbar_new();
	gtk_box_pack_start(GTK_BOX(pVBox), pToolbar, FALSE, FALSE, 0);

	gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "open"))), -1);
	gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "run"))), -1);
	gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "pause"))), -1);
	gtk_toolbar_insert(GTK_TOOLBAR(pToolbar), GTK_TOOL_ITEM(gtk_action_create_tool_item(gtk_action_group_get_action(action_group, "quit"))), -1);

	/* Création de l'endroit pour l'affichage des écrans */
	
	pDrawingArea= gtk_drawing_area_new();
	
	gtk_drawing_area_size(GTK_DRAWING_AREA(pDrawingArea), 256, 384);
	gtk_widget_set_usize (pDrawingArea, 256, 384);
			
	gtk_widget_set_events(pDrawingArea, GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_KEY_PRESS_MASK );
	
	g_signal_connect(G_OBJECT(pDrawingArea), "button_press_event", G_CALLBACK(Stylus_Press), NULL);
	g_signal_connect(G_OBJECT(pDrawingArea), "button_release_event", G_CALLBACK(Stylus_Release), NULL);
	g_signal_connect(G_OBJECT(pDrawingArea), "motion_notify_event", G_CALLBACK(Stylus_Move), NULL);
	
	
	g_signal_connect( G_OBJECT(pDrawingArea), "realize", G_CALLBACK(Draw), NULL ) ;
	g_signal_connect( G_OBJECT(pDrawingArea), "expose_event", G_CALLBACK(gtkFloatExposeEvent), NULL ) ;
	
	gtk_box_pack_start(GTK_BOX(pVBox), pDrawingArea, FALSE, FALSE, 0);
	
	/* Création de la barre d'état */
	
	pStatusBar = gtk_statusbar_new();
	
	pStatusBar_Ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(pStatusBar), "Global");
	
	pStatusBar_Change("Desmume");

	gtk_box_pack_end(GTK_BOX(pVBox), pStatusBar, FALSE, FALSE, 0);
	
	gtk_widget_show_all(pWindow);
	
	//LoadFirmware("fw.bin");
	
	/* Vérifie la ligne de commandes */
	if(commandLine_File)
	{
		if(Open(commandLine_File) >= 0)
		{
			Launch();
		}
		else
		{
			GtkWidget *pDialog = gtk_message_dialog_new(GTK_WINDOW(pWindow),
					GTK_DIALOG_MODAL,
					GTK_MESSAGE_INFO,
					GTK_BUTTONS_OK,
					"Unable to load :\n%s", commandLine_File);
			gtk_dialog_run(GTK_DIALOG(pDialog));
			gtk_widget_destroy(pDialog);
		}
	}
	
	/* Boucle principale */
	
//	gtk_idle_add(&EmuLoop, pWindow);
//	g_idle_add(&EmuLoop, pWindow);
	
	gtk_main();
	
	desmume_free();

#ifdef DEBUG
        LogStop();
#endif

	SDL_Quit();
	
	Write_ConfigFile();
	
	return EXIT_SUCCESS;
}
コード例 #26
0
ファイル: about.c プロジェクト: Offlein/geany
static GtkWidget *create_dialog(void)
{
	GtkWidget *dialog;
	GtkWidget *header_image;
	GtkWidget *header_label;
	GtkWidget *label_info;
	GtkWidget *codename_label;
	GtkWidget *builddate_label;
	GtkWidget *url_button;
	GtkWidget *cop_label;
	GtkWidget *label;
	GtkWidget *license_textview;
	GtkWidget *notebook;
	GtkWidget *box;
	GtkWidget *credits_scrollwin;
	GtkWidget *table;
	GtkWidget *license_scrollwin;
	GtkWidget *info_box;
	GtkWidget *header_hbox;
	GtkWidget *header_eventbox;
	GdkPixbuf *icon;
	GtkTextBuffer* tb;
	gchar *license_text = NULL;
	gchar buffer[512];
	gchar buffer2[128];
	guint i, row = 0;

	dialog = gtk_dialog_new();

	/* configure dialog */
	gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(main_widgets.window));
	gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
	gtk_window_set_title(GTK_WINDOW(dialog), _("About Geany"));
	gtk_widget_set_name(dialog, "GeanyDialog");
	gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
	gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE);
	gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
	g_signal_connect(dialog, "key-press-event", G_CALLBACK(gb_on_key_pressed), NULL);

	/* create header */
	header_eventbox = gtk_event_box_new();
	gtk_widget_show(header_eventbox);
	header_hbox = gtk_hbox_new(FALSE, 12);
	gtk_container_set_border_width(GTK_CONTAINER(header_hbox), 4);
	gtk_widget_show(header_hbox);
	gtk_container_add(GTK_CONTAINER(header_eventbox), header_hbox);
	header_image = gtk_image_new();
	gtk_box_pack_start(GTK_BOX(header_hbox), header_image, FALSE, FALSE, 0);
	header_label = gtk_label_new(NULL);
	gtk_label_set_use_markup(GTK_LABEL(header_label), TRUE);
	/* print the subversion revision generated by ./configure if it is available */
	g_snprintf(buffer, sizeof(buffer), HEADER, main_get_version_string());
	gtk_label_set_markup(GTK_LABEL(header_label), buffer);
	gtk_widget_show(header_label);
	gtk_box_pack_start(GTK_BOX(header_hbox), header_label, FALSE, FALSE, 0);
	header_eventbox_style_set(header_eventbox);
	header_label_style_set(header_label);
	g_signal_connect_after(header_eventbox, "style-set", G_CALLBACK(header_eventbox_style_set), NULL);
	g_signal_connect_after(header_label, "style-set", G_CALLBACK(header_label_style_set), NULL);
	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), header_eventbox, FALSE, FALSE, 0);

	/* set image */
	icon = ui_new_pixbuf_from_inline(GEANY_IMAGE_LOGO);
	gtk_image_set_from_pixbuf(GTK_IMAGE(header_image), icon);
	gtk_window_set_icon(GTK_WINDOW(dialog), icon);
	g_object_unref(icon);	/* free our reference */

	/* create notebook */
	notebook = gtk_notebook_new();
	gtk_widget_show(notebook);
	gtk_container_set_border_width(GTK_CONTAINER(notebook), 2);
	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), notebook, TRUE, TRUE, 0);

	/* create "Info" tab */
	info_box = gtk_vbox_new(FALSE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(info_box), 6);
	gtk_widget_show(info_box);

	label_info = gtk_label_new(NULL);
	gtk_label_set_justify(GTK_LABEL(label_info), GTK_JUSTIFY_CENTER);
	gtk_label_set_selectable(GTK_LABEL(label_info), TRUE);
	gtk_label_set_use_markup(GTK_LABEL(label_info), TRUE);
	g_snprintf(buffer, sizeof(buffer), INFO, _("A fast and lightweight IDE"));
	gtk_label_set_markup(GTK_LABEL(label_info), buffer);
	gtk_misc_set_padding(GTK_MISC(label_info), 2, 11);
	gtk_widget_show(label_info);
	gtk_box_pack_start(GTK_BOX(info_box), label_info, FALSE, FALSE, 0);

	/* Codename label */
	codename_label = gtk_label_new(NULL);
	gtk_label_set_justify(GTK_LABEL(codename_label), GTK_JUSTIFY_CENTER);
	gtk_label_set_selectable(GTK_LABEL(codename_label), TRUE);
	gtk_label_set_use_markup(GTK_LABEL(codename_label), TRUE);
	gtk_label_set_markup(GTK_LABEL(codename_label), CODENAME);
	gtk_misc_set_padding(GTK_MISC(codename_label), 2, 8);
	gtk_widget_show(codename_label);
	gtk_box_pack_start(GTK_BOX(info_box), codename_label, FALSE, FALSE, 0);

	/* build date label */
	builddate_label = gtk_label_new(NULL);
	gtk_label_set_justify(GTK_LABEL(builddate_label), GTK_JUSTIFY_CENTER);
	gtk_label_set_selectable(GTK_LABEL(builddate_label), TRUE);
	gtk_label_set_use_markup(GTK_LABEL(builddate_label), TRUE);
	g_snprintf(buffer2, sizeof(buffer2), _("(built on or after %s)"), __DATE__);
	g_snprintf(buffer, sizeof(buffer), BUILDDATE, buffer2);
	gtk_label_set_markup(GTK_LABEL(builddate_label), buffer);
	gtk_misc_set_padding(GTK_MISC(builddate_label), 2, 2);
	gtk_widget_show(builddate_label);
	gtk_box_pack_start(GTK_BOX(info_box), builddate_label, FALSE, FALSE, 0);

	box = gtk_hbutton_box_new();
	url_button = gtk_button_new();
	gtk_button_set_relief(GTK_BUTTON(url_button), GTK_RELIEF_NONE);
	g_signal_connect(url_button, "clicked", G_CALLBACK(homepage_clicked), (gpointer)GEANY_HOMEPAGE);
	label = gtk_label_new(NULL);
	gtk_label_set_text(GTK_LABEL(label), GEANY_HOMEPAGE);
	gtk_widget_show(label);
	gtk_container_add(GTK_CONTAINER(url_button), label);
	gtk_widget_show(url_button);
	gtk_box_pack_start(GTK_BOX(box), url_button, FALSE, FALSE, 0);
	gtk_widget_show(box);
	gtk_box_pack_start(GTK_BOX(info_box), box, FALSE, FALSE, 10);

	/* copyright label */
	cop_label = gtk_label_new(NULL);
	gtk_label_set_justify(GTK_LABEL(cop_label), GTK_JUSTIFY_CENTER);
	gtk_label_set_selectable(GTK_LABEL(cop_label), FALSE);
	gtk_label_set_use_markup(GTK_LABEL(cop_label), TRUE);
	gtk_label_set_markup(GTK_LABEL(cop_label), COPYRIGHT);
	gtk_misc_set_padding(GTK_MISC(cop_label), 2, 10);
	gtk_widget_show(cop_label);
	gtk_box_pack_start(GTK_BOX(info_box), cop_label, FALSE, FALSE, 0);
	/*gtk_container_add(GTK_CONTAINER(info_box), cop_label); */

	label = gtk_label_new(_("Info"));
	gtk_widget_show(label);
	gtk_widget_show_all(info_box);
	gtk_notebook_append_page(GTK_NOTEBOOK(notebook), info_box, label);

	/* create "Credits" tab */
	credits_scrollwin = gtk_scrolled_window_new(NULL, NULL);
	gtk_container_set_border_width(GTK_CONTAINER(credits_scrollwin), 6);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(credits_scrollwin),
		GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);

	table = gtk_table_new(23 + translators_len + prev_translators_len, 3, FALSE);
	gtk_table_set_col_spacings(GTK_TABLE(table), 10);

	row = 0;
	g_snprintf(buffer, sizeof(buffer),
		"<span size=\"larger\" weight=\"bold\">%s</span>", _("Developers"));
	label = gtk_label_new(buffer);
	gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, GTK_FILL, 0, 0, 5);
	gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
	row++;

	g_snprintf(buffer, sizeof(buffer), "Colomban Wendling - %s", _("maintainer"));
	ROW(buffer, row, 0, 0, 0, 1);
	row++;
	ROW("&lt;[email protected]&gt;", row, 0, 0, 0, 1);
	row++;
	ROW("", row, 0, 0, 0, 0);
	row++;

	g_snprintf(buffer, sizeof(buffer), "Nick Treleaven - %s", _("developer"));
	ROW(buffer, row, 0, 0, 0, 1);
	row++;
	ROW("&lt;[email protected]&gt;", row, 0, 0, 0, 1);
	row++;
	ROW("", row, 0, 0, 0, 0);
	row++;

	g_snprintf(buffer, sizeof(buffer), "Enrico Tröger - %s", _("developer"));
	ROW(buffer, row, 0, 0, 0, 1);
	row++;
	ROW("&lt;[email protected]&gt;", row, 0, 0, 0, 1);
	row++;
	ROW("", row, 0, 0, 0, 0);
	row++;

	g_snprintf(buffer, sizeof(buffer), "Matthew Brush - %s", _("developer"));
	ROW(buffer, row, 0, 0, 0, 1);
	row++;
	ROW("&lt;[email protected]&gt;", row, 0, 0, 0, 1);
	row++;
	ROW("", row, 0, 0, 0, 0);
	row++;

	g_snprintf(buffer, sizeof(buffer), "Frank Lanitz - %s", _("translation maintainer"));
	ROW(buffer, row, 0, 0, 0, 1);
	row++;
	ROW("&lt;[email protected]&gt;", row, 0, 0, 0, 1);
	row++;
	ROW("", row, 0, 0, 0, 0);
	row++;

	g_snprintf(buffer, sizeof(buffer),
		"<span size=\"larger\" weight=\"bold\">%s</span>", _("Translators"));
	label = gtk_label_new(buffer);
	gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
					(GtkAttachOptions) (GTK_FILL),
					(GtkAttachOptions) (0), 0, 5);
	gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
	row++;

	for (i = 0; i < translators_len; i++)
	{
		ROW(translators[i][0], row, 0, 1, 4, 0);
		ROW(translators[i][1], row, 1, 0, 4, 0);
		row++;
	}

	ROW("", row, 0, 0, 0, 0);
	row++;

	g_snprintf(buffer, sizeof(buffer),
		"<span size=\"larger\" weight=\"bold\">%s</span>", _("Previous Translators"));
	label = gtk_label_new(buffer);
	gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
					(GtkAttachOptions) (GTK_FILL),
					(GtkAttachOptions) (0), 0, 5);
	gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
	row++;

	for (i = 0; i < prev_translators_len; i++)
	{
		ROW(prev_translators[i][0], row, 0, 1, 4, 0);
		ROW(prev_translators[i][1], row, 1, 0, 4, 0);
		row++;
	}


	ROW("", row, 0, 0, 0, 0);
	row++;

	g_snprintf(buffer, sizeof(buffer),
		"<span size=\"larger\" weight=\"bold\">%s</span>", _("Contributors"));
	label = gtk_label_new(buffer);
	gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
					(GtkAttachOptions) (GTK_FILL),
					(GtkAttachOptions) (0), 0, 5);
	gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
	row++;

	g_snprintf(buffer, sizeof(buffer),
		_("Some of the many contributors (for a more detailed list, see the file %s):"),
#ifdef G_OS_WIN32
			"Thanks.txt"
#else
			"THANKS"
#endif
		);
	label = geany_wrap_label_new(buffer);
	gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
					(GtkAttachOptions) (GTK_FILL),
					(GtkAttachOptions) (0), 0, 5);
	gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
	row++;

	label = geany_wrap_label_new(contributors);
	gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
					(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
					(GtkAttachOptions) (0), 0, 5);
	gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
	row++;

	gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(credits_scrollwin), table);
	gtk_viewport_set_shadow_type(GTK_VIEWPORT(gtk_widget_get_parent(table)), GTK_SHADOW_NONE);
	gtk_widget_show_all(table);
	label = gtk_label_new(_("Credits"));
	gtk_widget_show(label);
	gtk_notebook_append_page(GTK_NOTEBOOK(notebook), credits_scrollwin, label);

	/* create "License" tab */
	license_scrollwin = gtk_scrolled_window_new(NULL, NULL);
	gtk_container_set_border_width(GTK_CONTAINER(license_scrollwin), 6);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(license_scrollwin),
		GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(license_scrollwin), GTK_SHADOW_IN);
	license_textview = gtk_text_view_new();
	gtk_text_view_set_left_margin(GTK_TEXT_VIEW(license_textview), 2);
	gtk_text_view_set_right_margin(GTK_TEXT_VIEW(license_textview), 2);
	gtk_text_view_set_editable(GTK_TEXT_VIEW(license_textview), FALSE);
	gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(license_textview), FALSE);
	gtk_widget_show(license_textview);
	gtk_container_add(GTK_CONTAINER(license_scrollwin), license_textview);
	label = gtk_label_new(_("License"));
	gtk_widget_show(label);

	g_snprintf(buffer, sizeof(buffer), "%s" G_DIR_SEPARATOR_S "GPL-2", app->datadir);

	g_file_get_contents(buffer, &license_text, NULL, NULL);
	if (license_text == NULL)
	{
		license_text = g_strdup(
			_("License text could not be found, please visit http://www.gnu.org/licenses/gpl-2.0.txt to view it online."));
	}
	tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(license_textview));
	gtk_text_buffer_set_text(tb, license_text, -1);

	g_free(license_text);

	gtk_notebook_append_page(GTK_NOTEBOOK(notebook), license_scrollwin, label);

	gtk_widget_show_all(dialog);
	return dialog;
}
コード例 #27
0
ファイル: gcb.cpp プロジェクト: mangoicestar/gcin-debian
void gcb_main()
{

  GtkWidget *hbox,*vbox;
  int i;
#if 1
  if (gcb_enabled==old_gcb_enabled && gcb_position==old_gcb_position && gcb_position_x==old_gcb_position_x
      && gcb_position_y==old_gcb_position_y)
    return;
#endif
  old_gcb_enabled = gcb_enabled;
  old_gcb_position = gcb_position;
  old_gcb_position_x = gcb_position_x;
  old_gcb_position_y = gcb_position_y;

  if (mainwin) {
    gtk_widget_destroy(mainwin);
    mainwin = NULL;
  }
#if 0
  if (button_bar_tips)
    gtk_widget_destroy(button_bar_tips);
#endif
  if (hist_window) {
    gtk_widget_destroy(hist_window);
    hist_window = NULL;
  }

  if (!gcb_enabled)
    return;

//  printf("gcb_position:%d\n", gcb_position);

  static char geo[][2]={{0,0},{'+','-'},{'+','+'},{'-','-'},{'-','+'}};
  g_free(geomstr);
  geomstr = g_strdup_printf("%c%d%c%d",
  geo[gcb_position][0], gcb_position_x, geo[gcb_position][1], gcb_position_y);
  dbg("geomstr %s\n", geomstr);

  if (!buttonArr) {
    buttonArr=(GtkWidget**)g_malloc(gcb_button_n * sizeof(GtkWidget *));
    buttonStr=(gchar**)g_malloc0(gcb_button_n * sizeof(gchar *));
  }

  if (!hist_strArr) {
    hist_strArr=(gchar**)g_malloc0(gcb_history_n * sizeof(gchar *));
    hist_buttonArr=(GtkWidget**)g_malloc(gcb_history_n * sizeof(GtkWidget *));
  }

  mainwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_has_resize_grip(GTK_WINDOW(mainwin), FALSE);
  gtk_window_set_decorated(GTK_WINDOW(mainwin),FALSE);
  gtk_window_set_focus_on_map (GTK_WINDOW(mainwin), FALSE);

  hist_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_has_resize_grip(GTK_WINDOW(hist_window), FALSE);

  char icon_path[40];
  sys_icon_fname("gcb.png", icon_path);
  GtkWidget *win_icon=gtk_image_new_from_file(icon_path);
  gtk_window_set_icon(GTK_WINDOW(mainwin),
     gtk_image_get_pixbuf(GTK_IMAGE(win_icon)));
  gtk_window_set_icon(GTK_WINDOW(hist_window),
     gtk_image_get_pixbuf(GTK_IMAGE(win_icon)));

  // Under gnome 2.0, the mainwin is not fixed if decorated, annoying
  gtk_window_set_decorated(GTK_WINDOW(hist_window),FALSE);
  gtk_window_set_skip_pager_hint(GTK_WINDOW(hist_window),TRUE);
  gtk_window_set_skip_taskbar_hint(GTK_WINDOW(hist_window),TRUE);
  gtk_window_set_title (GTK_WINDOW (hist_window),"gcb history");

  gtk_window_set_title (GTK_WINDOW(mainwin), "gcb: gtk copy-paste buffer");
  gtk_window_stick(GTK_WINDOW(mainwin));

//  g_signal_connect(G_OBJECT (mainwin),"destroy", G_CALLBACK (do_exit), NULL);
  g_signal_connect(G_OBJECT (hist_window),"delete_event",
    G_CALLBACK (delete_hist_win), NULL);
  g_signal_connect(G_OBJECT (hist_window),"focus-out-event",
    G_CALLBACK (hist_focus_out_callback), NULL);

#if !GTK_CHECK_VERSION(2,12,0)
  button_bar_tips = gtk_tooltips_new ();
#endif

  hbox = gtk_hbox_new (FALSE, 1);
  gtk_container_add (GTK_CONTAINER(mainwin), hbox);

  gtk_window_parse_geometry(GTK_WINDOW(mainwin),geomstr);

  for(i=0;i<gcb_button_n;i++) {
    buttonArr[i] = gtk_button_new_with_label ("---");
//    gtk_container_set_border_width(GTK_CONTAINER(buttonArr[i]),0);
    gtk_box_pack_start (GTK_BOX(hbox), buttonArr[i], TRUE, TRUE, FALSE);
    gtk_widget_show (buttonArr[i]);
    g_signal_connect (G_OBJECT (buttonArr[i]), "button-press-event",
                      G_CALLBACK (get_mouse_button), (gpointer) buttonArr[i]);
#if 0
    g_signal_connect (G_OBJECT (buttonArr[i]), "key-press-event",
                      G_CALLBACK (key_press_event), NULL);
#endif
#if 1
    g_signal_connect (G_OBJECT (buttonArr[i]), "scroll-event",
                      G_CALLBACK (gcb_button_scroll_event), NULL);
#endif
  }

  vbox = gtk_vbox_new (FALSE, 1);
  gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox), GTK_ORIENTATION_VERTICAL);
  gtk_container_add (GTK_CONTAINER(hist_window), vbox);

  for(i=0;i<gcb_history_n;i++) {
    hist_buttonArr[i] = gtk_button_new_with_label ("---");
    gtk_container_set_border_width(GTK_CONTAINER(hist_buttonArr[i]),0);
    gtk_box_pack_start (GTK_BOX(vbox), hist_buttonArr[i], TRUE, TRUE, FALSE);
    gtk_widget_show (hist_buttonArr[i]);
    g_signal_connect (G_OBJECT (hist_buttonArr[i]), "button-press-event",
                      G_CALLBACK (hist_get_mouse_button), (gpointer) hist_buttonArr[i]);
#if 1
    g_signal_connect (G_OBJECT (hist_buttonArr[i]), "key-press-event",
                      G_CALLBACK (hist_key_press_event), NULL);
#endif
  }

#if 1
  // need this because on win32 scoll is not recieved if win is not focused.
  gtk_box_pack_start (GTK_BOX (hbox), gtk_vseparator_new(), FALSE, FALSE, 0);
  GtkWidget *eve_arrow = gtk_event_box_new();
  gtk_event_box_set_visible_window (GTK_EVENT_BOX(eve_arrow), FALSE);
  gtk_box_pack_start (GTK_BOX(hbox), eve_arrow, FALSE, FALSE, FALSE);
    g_signal_connect(G_OBJECT(eve_arrow),"button-press-event", G_CALLBACK(mouse_button_callback), NULL);
  gtk_container_add(GTK_CONTAINER(eve_arrow), gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_IN));
#endif


  gtk_widget_show_all(hbox);
  gtk_widget_show (vbox);
  gtk_widget_show (mainwin);


  pclipboard_prim = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
  pclipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);

  set_snoop_button(buttonArr[0]);
  get_selection(pclipboard);
  get_selection(pclipboard_prim);
  gtk_container_set_border_width(GTK_CONTAINER(hbox),0);
  gtk_container_set_border_width(GTK_CONTAINER(mainwin),0);

  gtk_window_parse_geometry(GTK_WINDOW(mainwin),geomstr);
#if GTK_CHECK_VERSION(2,6,0)
  g_signal_connect(pclipboard, "owner-change", G_CALLBACK (cb_owner_change), NULL);
  g_signal_connect(pclipboard_prim, "owner-change", G_CALLBACK (cb_owner_change), NULL);
#endif
}
コード例 #28
0
ファイル: bathmoi.c プロジェクト: LinuxTeam-teilar/Bathmoi
int main(int argc, char *argv[])
{
    GtkWidget *exp, *vbox1, *vbox, *hbox;
    gint kateuth = 0;
    i = 0;

    gtk_init (&argc, &argv);

    kateuth = epilogiKate();

    main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
//    gtk_window_set_icon (GTK_WINDOW(main_window), gdk_pixbuf_new_from_xpm_data((const char **) pixmap));
    gtk_window_set_icon (GTK_WINDOW(main_window), gdk_pixbuf_new_from_xpm_data((const char **) icon()));
    gtk_window_set_title (GTK_WINDOW (main_window), "Βαθμός πτυχίου!");
    gtk_window_set_default_size (GTK_WINDOW (main_window), (gint) 700, (gint) 300);
    gtk_window_set_position (GTK_WINDOW (main_window), GTK_WIN_POS_CENTER);
    gtk_window_set_resizable(GTK_WINDOW (main_window), FALSE);
    g_signal_connect (G_OBJECT (main_window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
    gtk_container_set_border_width (GTK_CONTAINER (main_window), 10);
    vbox = gtk_vbox_new (FALSE, 5);

    hbox = gtk_hbox_new (FALSE, 5);
    gtk_box_pack_start (GTK_BOX(hbox), gtk_label_new("Κωδικός"), FALSE, FALSE, 5);
    gtk_box_pack_start (GTK_BOX(hbox), gtk_label_new("Όνομα μαθήματος"), FALSE, FALSE, 5);
    gtk_box_pack_end (GTK_BOX(hbox), gtk_label_new("Δ.Μ."), FALSE, FALSE, 5);
    gtk_box_pack_end (GTK_BOX(hbox), gtk_label_new("Βαθμός"), FALSE, FALSE, 5);
    gtk_box_pack_start (GTK_BOX(vbox), hbox, FALSE, FALSE, 5);

    /* PROTO EKSAMINO */
    vbox1 = gtk_vbox_new (FALSE, 5);
    exp = addTitle("1o εξάμηνο");
    gtk_container_add (GTK_CONTAINER (exp), vbox1);

    addLesson("Μαθηματική ανάλυση I", 0, "5", "[120]", vbox1);
    addLesson("Φυσική", 0, "5", "[121]", vbox1);
    addLesson("Προγραμματισμός I", 0, "5", "[122]", vbox1);
    addLesson("Αρχές Τηλεπικοινωνιών", 0, "5", "[123]", vbox1);
    addLesson("Ηλεκτρονικά", 0, "5", "[124]", vbox1);
    addLesson("Διακριτά συστήματα", 0, "5", "[125]", vbox1);

    gtk_box_pack_start (GTK_BOX(vbox), exp, FALSE, FALSE, 0);

    /* DEYTERO EKSAMINO */
    vbox1 = gtk_vbox_new (FALSE, 5);
    exp = addTitle("2o εξάμηνο");
    gtk_container_add (GTK_CONTAINER (exp), vbox1);

    addLesson("Μαθηματική ανάλυση II", 0, "5", "[220]", vbox1);
    addLesson("Φυσικές Αρχές Τεχνολογίας Επικοινωνιών", 0, "6", "[221]", vbox1);
    addLesson("Αρχιτεκτονική Η/Υ I", 0, "5", "[223]", vbox1);
    addLesson("Ηλεκτρονικές Τηλεπικοινωνίες", 0, "5", "[224]", vbox1);
    addLesson("Αριθμητική ανάλυση", 0, "5", "[225]", vbox1);
    addLesson("Προγραμματισμός II", 0, "5", "[226]", vbox1);

    gtk_box_pack_start (GTK_BOX(vbox), exp, FALSE, FALSE, 0);

    /* TRITO EKSAMINO */
    vbox1 = gtk_vbox_new (FALSE, 5);
    exp = addTitle("3o εξάμηνο");
    gtk_container_add (GTK_CONTAINER (exp), vbox1);

    addLesson("Βάσεις δεδομένων I", 0, "5", "[320]", vbox1);
    addLesson("Δομές δεδομένων και αλγόριθμοι", 0, "5", "[321]", vbox1);
    addLesson("Θεωρία πιθανοτήτων και στατιστική", 0, "5", "[322]", vbox1);
    addLesson("Δίκτυα I", 0, "5", "[323]", vbox1);
    addLesson("Λειτουργικά συστήματα I", 0, "5", "[324]", vbox1);
    addLesson("Εφαρμογές γραμμική άλγεβρας", 0, "5", "[325]", vbox1);

    gtk_box_pack_start (GTK_BOX(vbox), exp, FALSE, FALSE, 0);

    /* TETARTO EKSAMINO */
    vbox1 = gtk_vbox_new (FALSE, 5);
    exp = addTitle("4o εξάμηνο");
    gtk_container_add (GTK_CONTAINER (exp), vbox1);

    addLesson("Αλγόριθμοι και πολυπλοκότητα", 0, "5", "[421]", vbox1);
    addLesson("Αρχιτεκτονική II", 0, "5", "[422]", vbox1);
    addLesson("Ανάλυση και σχεδιασμός Π.Σ.", 0, "5", "[425]", vbox1);
    addLesson("Θεωρία συστημάτων - ΣΑΕ", 0, "5", "[426]", vbox1);
    addLesson("Δίκτυα II", 0, "5", "[427]", vbox1);
    gtk_box_pack_start (GTK_BOX(vbox1), gtk_hseparator_new(), FALSE, FALSE, 5);
    gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("1 από τα 2"), FALSE, FALSE, 5);
    addLesson("Υπολογισιμότητα", 1, "5", "[423]", vbox1);
    addLesson("Αρχές γλωσσών προγραμματισμού", 1, "5", "[424]", vbox1);

    gtk_box_pack_start (GTK_BOX(vbox), exp, FALSE, FALSE, 0);

    /* PEMPTO EKSAMINO */
    vbox1 = gtk_vbox_new (FALSE, 5);
    exp = addTitle("5o εξάμηνο");
    gtk_container_add (GTK_CONTAINER (exp), vbox1);

    addLesson("Οικονομικά των επιχειρήσεων", 0, "5", "[920]", vbox1);

    if (kateuth == 0) {
        gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("Κατεύθυνση πληροφορικής"), FALSE, FALSE, 5);
        addLesson("Προγραμματισμός III", 0, "7", "[531Π]", vbox1);
        addLesson("Τεχνολογία λογισμικού", 0, "7", "[532Π]", vbox1);
        addLesson("Βάσεις δεδομένων II", 0, "6", "[533Π]", vbox1);
        gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("1 από τα 2"), FALSE, FALSE, 5);
        addLesson("Λογικός προγραμματισμός", 1, "5", "[534Π]", vbox1);
        addLesson("Οργάνωση και διαχείριση αρχείων ", 1, "5", "[535Π]", vbox1);
    } else {
        gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("Κατεύθυνση τηλεπικοινωνιών και δικτύων"), FALSE, FALSE, 5);
        addLesson("Επεξεργασία σήματος", 0, "7", "[541Τ]", vbox1);
        addLesson("Τηλεπικοινωνιακά συστήματα I", 0, "7", "[542Τ]", vbox1);
        addLesson("Οπτικές επικοινωνίες", 0, "6", "[543Τ]", vbox1);
        gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("1 από τα 2"), FALSE, FALSE, 5);
        addLesson("Κινητές επικοινωνίες", 1, "5", "[544Τ]", vbox1);
        addLesson("Σχεδίαση, μελέτη και υλοποίηση δικτύων", 1, "5", "[545Τ]", vbox1);
    }

    gtk_box_pack_start (GTK_BOX(vbox), exp, FALSE, FALSE, 0);


    /* ΕΚΤΟ EKSAMINO */
    vbox1 = gtk_vbox_new (FALSE, 5);
    exp = addTitle("6o εξάμηνο");
    gtk_container_add (GTK_CONTAINER (exp), vbox1);

    gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("ΔΟΝΑ"), FALSE, FALSE, 5);
    addLesson("Τεχνική νομοθεσία", 0, "5", "[921]", vbox1);
    gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("1 από τα 2"), FALSE, FALSE, 5);
    addLesson("Επιχειρησιακή έρευνα", 1, "5", "[930]", vbox1);
    addLesson("Διαχείριση έργων πληροφορικής", 1, "5", "[931]", vbox1);

    if (kateuth == 0) {
        gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("Κατεύθυνση πληροφορικής  (4 από τα 6)"), FALSE, FALSE, 5);
        addLesson("Τεχνητή νοημοσύνη", 1, "5", "[631Π]", vbox1);
        addLesson("Προχωρημένες εφαρμογές προγραμματισμού", 1, "5", "[632Π]", vbox1);
        addLesson("Πολυμέσα", 1, "5", "[633Π]", vbox1);
        addLesson("Λειτουργικά συστήματα II", 1, "5", "[634Π]", vbox1);
        addLesson("Δικτυακός προγραμματισμός", 1, "5", "[655]", vbox1);
        addLesson("Ασφάλεια πληροφοριακών συστημάτων", 1, "5", "[656]", vbox1);
    } else {
        gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("Κατεύθυνση τηλεπικοινωνιών και δικτύων  (4 από τα 6)"), FALSE, FALSE, 5);
        addLesson("Επικοινωνίες δεδομένων", 1, "5", "[641Τ]", vbox1);
        addLesson("Τηλεπικοινωνιακά συστήματα II", 1, "5", "[642Τ]", vbox1);
        addLesson("Ειδικά θέματα οπτικών επικοινωνιών", 1, "5", "[643Τ]", vbox1);
        addLesson("Ασύρματες επικοινωνίες", 1, "5", "[644Τ]", vbox1);
        addLesson("Δικτυακός προγραμματισμός", 1, "5", "[655]", vbox1);
        addLesson("Ασφάλεια πληροφοριακών συστημάτων", 1, "5", "[656]", vbox1);
    }

    gtk_box_pack_start (GTK_BOX(vbox), exp, FALSE, FALSE, 0);

    /* EBDOMO EKSAMINO */
    vbox1 = gtk_vbox_new (FALSE, 5);
    exp = addTitle("7o εξάμηνο");
    gtk_container_add (GTK_CONTAINER (exp), vbox1);

    gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("ΔΟΝΑ  (1 από τα 2)"), FALSE, FALSE, 5);
    addLesson("Μάρκετινγκ πληροφοριακών συστημάτων", 1, "3", "[922]", vbox1);
    addLesson("Διδακτική της πληροφορικής", 1, "3", "[923]", vbox1);

    if (kateuth == 0) {
        gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("Κατεύθυνση πληροφορικής"), FALSE, FALSE, 5);
        addLesson("Σεμινάριο θεμάτων τεχνολογικής αιχμής", 0, "6", "[731Π]", vbox1);
        gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("3 από τα 6"), FALSE, FALSE, 5);
        addLesson("Ειδικά θέματα βάσεων δεδομένων", 1, "7", "[732Π]", vbox1);
        addLesson("Ηλεκτρονικό εμπόριο", 1, "7", "[733Π]", vbox1);
        addLesson("Προγραμματισμός Ιντερνετ", 1, "7", "[734Π]", vbox1);
        addLesson("Υπολογιστικό πλέγμα", 1, "7", "[735Π]", vbox1);
        addLesson("Μεταγλωττιστές", 1, "7", "[736Π]", vbox1);
        addLesson("Κατανεμημένα συστήματα", 1, "7", "[757]", vbox1);
    } else {
        gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("Κατεύθυνση τηλεπικοινωνιών και δικτύων"), FALSE, FALSE, 5);
        addLesson("Σεμινάριο θεμάτων τεχνολογικής αιχμής", 0, "6", "[741Τ]", vbox1);
        gtk_box_pack_start (GTK_BOX(vbox1), gtk_label_new("3 από τα 6"), FALSE, FALSE, 5);
        addLesson("Δορυφορικές επικοινωνίες", 1, "7", "[742Τ]", vbox1);
        addLesson("CDMA", 1, "7", "[743Τ]", vbox1);
        addLesson("Δικτύωση και αυτοματοποίηση", 1, "7", "[744Τ]", vbox1);
        addLesson("Ευρυζωνικά δίκτυα", 1, "7", "[745Τ]", vbox1);
        addLesson("Απόδοση δικτύων", 1, "7", "[746Τ]", vbox1);
        addLesson("Κατανεμημένα συστήματα", 1, "7", "[757]", vbox1);
    }

    gtk_box_pack_start (GTK_BOX(vbox), exp, FALSE, FALSE, 0);
    addLesson("Πτυχιακή εργασία", 0, "20", "[801]", vbox);

    gtk_box_pack_start (GTK_BOX(vbox), addButtons(), FALSE, FALSE, 5);

    gtk_container_add (GTK_CONTAINER (main_window), vbox);

    gtk_widget_show_all (main_window);

    gtk_main ();
    return 0;
}
コード例 #29
0
ファイル: gtkutil.c プロジェクト: glebihan/hexchat
void
gtkutil_set_icon (GtkWidget *win)
{
	gtk_window_set_icon (GTK_WINDOW (win), pix_xchat);
}
コード例 #30
0
ファイル: s2nTest.cpp プロジェクト: IscasYuchen/garphic-s2n
int main(int argc,char** argv) {
	GtkWidget *window;
	GtkWidget *halign;
	GtkWidget *valign;
	GdkPixbuf *icon;

	GtkWidget *vbox;
	GtkWidget *hbox;

	GtkWidget *button_md5;
	GtkWidget *button_sha1;
	GtkWidget *button_sha256;

	struct EntryStruct entry;
	//GtkWidget *entry_context;
	//GtkWidget  *hash_context;

	gtk_init(&argc,&argv);
	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(window),"Hash from s2n libaray");
	gtk_window_set_default_size(GTK_WINDOW(window),260,150);
	gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
	gtk_container_set_border_width(GTK_CONTAINER(window),15);


	icon = create_pixbuf("hash_icon.png");
	gtk_window_set_icon(GTK_WINDOW(window),icon);

	entry.input = gtk_entry_new();
	entry.hash = gtk_entry_new();
	gtk_editable_set_editable(GTK_EDITABLE(entry.hash),false);
	vbox = gtk_vbox_new(FALSE,5);
	valign = gtk_alignment_new(0,1,0,0);

	gtk_container_add(GTK_CONTAINER(vbox),valign);
	gtk_container_add(GTK_CONTAINER(vbox),entry.input);
	gtk_container_add(GTK_CONTAINER(vbox),entry.hash);
	gtk_container_add(GTK_CONTAINER(window),vbox);

	hbox = gtk_hbox_new(true,3);
	button_md5 = gtk_button_new_with_label("MD5 hash");
	button_sha1 = gtk_button_new_with_label("SHA-1 hash");
	button_sha256 = gtk_button_new_with_label("SHA-256 hash");
	//button =gtk_button_new_with_mnemonic("_Button");
	g_signal_connect(G_OBJECT(button_md5),"clicked",G_CALLBACK(button_md5_clicked),&entry);
	g_signal_connect(G_OBJECT(button_sha1),"clicked",G_CALLBACK(button_sha1_clicked),NULL);
	g_signal_connect(G_OBJECT(button_sha256),"clicked",G_CALLBACK(button_sha256_clicked),NULL);
	gtk_widget_set_tooltip_text(button_md5,"calcutate the MD5 disget of the text");
	gtk_widget_set_tooltip_text(button_sha1,"calculate the SHA1 digest of the text");
	gtk_widget_set_tooltip_text(button_sha256,"calculate the SHA-256 digest of the text");


	//gtk_box_pack_start(GTK_BOX(vbox),button_md5,TRUE,TRUE,0);
	//gtk_box_pack_start(GTK_BOX(vbox),button_sha1,TRUE,TRUE,0);

	gtk_container_add(GTK_CONTAINER(hbox),button_md5);
	gtk_container_add(GTK_CONTAINER(hbox),button_sha1);
	gtk_container_add(GTK_CONTAINER(hbox),button_sha256);
	halign = gtk_alignment_new(0,1,0,0);
	gtk_container_add(GTK_CONTAINER(halign),hbox);
	gtk_container_add(GTK_CONTAINER(vbox),halign);
	gtk_box_pack_start(GTK_BOX(vbox),halign,FALSE,FALSE,0);
	gtk_widget_show_all(window);

	g_signal_connect(G_OBJECT(window),"destroy",G_CALLBACK(gtk_main_quit),NULL);
	gtk_main();

	g_object_unref(icon);
	return 0;
}