コード例 #1
0
ファイル: main.c プロジェクト: jdelarosa36/webview
int main(int argc, char *argv[]) {
	pthread_t 		thread;

	/* init threads */
    g_thread_init (NULL);
    gdk_threads_init ();
    gdk_threads_enter ();

    gtk_init(&argc, &argv);

    initApp();

    appdata->program = HILDON_PROGRAM(hildon_program_get_instance());
    g_set_application_name("Webview");

    appdata->window = HILDON_WINDOW(hildon_window_new());
    hildon_program_add_window(appdata->program, appdata->window);


    create_menu(appdata->window);
    build_interface(appdata->window);

    /* Connect signal to X in the upper corner */
    g_signal_connect(G_OBJECT(appdata->window), "delete_event", G_CALLBACK(destroy), NULL);

	update_image();
	load_settings();

	gtk_widget_show_all(GTK_WIDGET(appdata->window));

	if(! start_camera(appdata->window))
	{
		g_warning("Unable to start camera\n");

		GtkWidget *failDialog = gtk_message_dialog_new(NULL,
	     		GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR,
	     		GTK_BUTTONS_OK,
	     		"Unable to start camera\n");
		gtk_dialog_run (GTK_DIALOG (failDialog));
		gtk_widget_destroy (failDialog);
	}

	if(! start_webserver())
	{
		GtkWidget *failDialog = gtk_message_dialog_new(NULL,
	     		GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR,
	     		GTK_BUTTONS_OK,
	     		"Unable to start web server.\nCheck server port is not already in use.\n");
		gtk_dialog_run (GTK_DIALOG (failDialog));
		gtk_widget_destroy (failDialog);
	}
	sleep(1);

	pthread_create(&thread, NULL, count_down_thread, NULL);

	gtk_main();

	gdk_threads_leave ();
	return( 0 );
}
コード例 #2
0
ファイル: cheese-test-chooser.c プロジェクト: genesi/cheese
int
main (int argc, char **argv)
{
  GtkWidget *window;

  g_thread_init (NULL);
  gdk_threads_init ();
  gst_init (&argc, &argv);

  bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALEDIR);
  bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
  textdomain (GETTEXT_PACKAGE);

  gtk_init (&argc, &argv);

  window = cheese_avatar_chooser_new ();
  g_signal_connect (G_OBJECT (window), "response",
                    G_CALLBACK (response_cb), window);

  gtk_widget_show_all (window);

  gtk_main ();

  gtk_widget_destroy (window);

  return 0;
}
コード例 #3
0
ファイル: cairoanimate.c プロジェクト: AlexKordic/sandbox
int main (int argc, char *argv[]){


    //we need to initialize all these functions so that gtk knows
    //to be thread-aware
    if (!g_thread_supported ()){ g_thread_init(NULL); }
    gdk_threads_init();
    gdk_threads_enter();

    gtk_init(&argc, &argv);

    GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
    g_signal_connect(G_OBJECT(window), "expose_event", G_CALLBACK(on_window_expose_event), NULL);
    g_signal_connect(G_OBJECT(window), "configure_event", G_CALLBACK(on_window_configure_event), NULL);

    //this must be done before we define our pixmap so that it can reference
    //the colour depth and such
    gtk_widget_show_all(window);

    //set up our pixmap so it is ready for drawing
    pixmap = gdk_pixmap_new(window->window,500,500,-1);
    //because we will be painting our pixmap manually during expose events
    //we can turn off gtk's automatic painting and double buffering routines.
    gtk_widget_set_app_paintable(window, TRUE);
    gtk_widget_set_double_buffered(window, FALSE);

    (void)g_timeout_add(33, (GSourceFunc)timer_exe, window);


    gtk_main();
    gdk_threads_leave();

    return 0;
}
コード例 #4
0
ファイル: cheese-test-widget.c プロジェクト: Sizokryl/cheese
int
main (int argc, char **argv)
{
  GtkWidget *window;
  GtkWidget *camera;

  g_thread_init (NULL);
  gdk_threads_init ();
  gst_init (&argc, &argv);

  bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALEDIR);
  bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
  textdomain (GETTEXT_PACKAGE);

  gtk_clutter_init (&argc, &argv);

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
  g_signal_connect (G_OBJECT (window), "delete-event",
                    G_CALLBACK (delete_callback), NULL);


  camera = cheese_widget_new ();
  gtk_container_add (GTK_CONTAINER (window), camera);

  gtk_widget_show_all (window);

  gtk_main ();

  return 0;
}
コード例 #5
0
void
rb_threads_init (void)
{
	GMutex *m;

	private_is_primary_thread = g_private_new (NULL);
	g_private_set (private_is_primary_thread, GUINT_TO_POINTER (1));

	g_static_rec_mutex_init (&rb_gdk_mutex);
	gdk_threads_set_lock_functions (_threads_enter, _threads_leave);
	gdk_threads_init ();

	m = g_mutex_new ();

	g_mutex_lock (m);
	mutex_recurses = g_mutex_trylock (m);
	if (mutex_recurses)
		g_mutex_unlock (m);
	g_mutex_unlock (m);
	g_mutex_free (m);

	rb_debug ("GMutex %s recursive", mutex_recurses ? "is" : "isn't");

	/* purge useless thread-pool threads occasionally */
	g_timeout_add_seconds (30, purge_useless_threads, NULL);
}
コード例 #6
0
ファイル: gui.c プロジェクト: alexbudy/FaceTrackingARDrone
void init_gui(int argc, char **argv)
{
  gui = vp_os_malloc(sizeof (gui_t));
 
  g_thread_init(NULL);
  gdk_threads_init();
  gtk_init(&argc, &argv);
 
  gui->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  g_signal_connect(G_OBJECT(gui->window),
           "destroy",
           G_CALLBACK(on_destroy),
           NULL);
  gui->box = gtk_vbox_new(FALSE, 10);
  gtk_container_add(GTK_CONTAINER(gui->window),
            gui->box);
  gui->cam = gtk_image_new();
  gtk_box_pack_start(GTK_BOX(gui->box), gui->cam, FALSE, TRUE, 0);
 
  gui->start = gtk_button_new_with_label("Start");
  g_signal_connect (gui->start, "clicked",
              G_CALLBACK (buttons_callback), NULL);
  gui->stop = gtk_button_new_with_label("Stop");
  g_signal_connect (gui->stop, "clicked",
              G_CALLBACK (buttons_callback), NULL);
    gtk_widget_set_sensitive(gui->start, TRUE);
  gtk_widget_set_sensitive(gui->stop, FALSE);
 
  gtk_box_pack_start(GTK_BOX(gui->box), gui->start, TRUE, TRUE, 0);
  gtk_box_pack_start(GTK_BOX(gui->box), gui->stop, TRUE, TRUE, 0);
 
  gtk_widget_show_all(gui->window);
}
コード例 #7
0
ファイル: gu.c プロジェクト: Cuervo-Nefasto/showtime
static int
gu_start(ui_t *ui, prop_t *root, int argc, char **argv, int primary)
{
  gtk_ui_t *gu = calloc(1, sizeof(gtk_ui_t));

  XInitThreads();

  hts_mutex_init(&gu_mutex);

  g_thread_init(NULL);

  gdk_threads_set_lock_functions(gu_enter, gu_leave);

  gdk_threads_init();
  gdk_threads_enter();

  gtk_init(&argc, &argv);

  gu_pixbuf_init();

  gu->gu_pc = prop_courier_create_thread(&gu_mutex, "GU");

  gu_win_create(gu, prop_create(prop_get_global(), "nav"), 1);

  /* Init popup controller */
  gu_popup_init(gu);

  gtk_main();
  return 0;
}
コード例 #8
0
gint main(gint argc,gchar* argv[])
{	
    int res;
    
    /*---GTK��ʼ��----*/
    gtk_init(&argc, &argv);	
    g_thread_init(NULL);
    gdk_threads_init();

    struct wcam_win *c = calloc(1, sizeof(struct wcam_win));

    c->entry_win = login_create();
    
    res = login_run(c->entry_win);
    if (res == -1) {
        goto err_win;
    }
    
    login_hide(c->entry_win);
  
    main_create(c);
    
    main_run();

err_win:
    free(c->entry_win);
    free(c);

    return 0;
}
コード例 #9
0
ファイル: progress-demo.c プロジェクト: JacobD10/MegaTunix
int main (int argc, char **argv)
{
	GtkWidget *window = NULL;
	GtkWidget *pbar = NULL;
	gint timeout = 0;

#if GLIB_MINOR_VERSION < 32
	g_thread_init(NULL);
#endif
	gdk_threads_init();
	gtk_init (&argc, &argv);

	window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

	pbar = mtx_progress_bar_new ();
	gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(pbar),
			                        GTK_PROGRESS_BOTTOM_TO_TOP);

	gtk_container_add (GTK_CONTAINER (window), pbar);
	/*gtk_widget_realize(pbar);*/

	gtk_widget_show_all (window);

	timeout = g_timeout_add(30,(GSourceFunc)update_pbar_wrapper,(gpointer)pbar);

	g_signal_connect (window, "delete_event",
			G_CALLBACK (close_demo), GINT_TO_POINTER(timeout));
	g_signal_connect (window, "destroy_event",
			G_CALLBACK (close_demo), GINT_TO_POINTER(timeout));

	gdk_threads_enter();
	gtk_main ();
	gdk_threads_leave();
	return 0;
}
コード例 #10
0
ファイル: main.cpp プロジェクト: felipe-lavratti/marsh
int main(int argc, char **argv)
{
	gdk_threads_init();
	gdk_threads_enter();

	gSimuApp = Gtk::Application::create(argc, argv, "org.gtkmm.example");

	Gtk::Window win;
	win.set_title("RE8000 Simulador");
	win.set_default_size(800, 480);

	/* Virtual Framebuffer area */
	pArea = new MyArea;

	/* Input */
	pArea->add_events(Gdk::BUTTON_PRESS_MASK);
	pArea->signal_button_press_event().connect(sigc::ptr_fun(&VirtualInputClickHandler));
	pArea->add_events(Gdk::BUTTON_RELEASE_MASK);
	pArea->signal_button_release_event().connect(sigc::ptr_fun(&VirtualInputClickHandler));
	gdk_threads_leave();

	/* Fb */
	pVirtFb = new char[800 * 480 * 2];

	/* Gtk Window call */
	win.add(*pArea);
	pArea->show();


	pMarsh = new marshmallow_thread;

	return gSimuApp->run(win);
}
コード例 #11
0
int
main (int argc, char **argv)
{
	GtkWidget *main_window;
	GtkTreeModel *main_model;
	GtkTreeIter iter;
	RBEntryView *view;
	RhythmDB *db;
	RhythmDBEntry *entry;

	gtk_init (&argc, &argv);
	gdk_threads_init ();
	rb_thread_helpers_init ();
	rb_file_helpers_init (TRUE);
	rb_stock_icons_init ();
	rb_debug_init (TRUE);

	GDK_THREADS_ENTER ();

	db = rhythmdb_tree_new ("test");

	rhythmdb_write_lock (db);

	entry = create_entry (db, "file:///sin.mp3",
			      "Sin", "Pretty Hate Machine", "Nine Inch Nails", "Rock");
	
	rhythmdb_write_unlock (db);

	rhythmdb_read_lock (db);

	main_model = GTK_TREE_MODEL (rhythmdb_query_model_new_empty (db));
	rhythmdb_do_full_query (db, main_model,
				RHYTHMDB_QUERY_PROP_EQUALS,
				RHYTHMDB_PROP_TYPE, RHYTHMDB_ENTRY_TYPE_IGNORE,
				RHYTHMDB_QUERY_END);

	wait_for_model_completion (RHYTHMDB_QUERY_MODEL (main_model));
	g_assert (gtk_tree_model_get_iter_first (main_model, &iter));

	main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

	view = rb_entry_view_new (db, rb_file ("rb-entry-view-library.xml"));

	rb_entry_view_set_query_model (view, RHYTHMDB_QUERY_MODEL (main_model));

	gtk_container_add (GTK_CONTAINER (main_window), GTK_WIDGET (view));

	g_signal_connect (G_OBJECT (main_window), "destroy",
			  G_CALLBACK (gtk_main_quit), NULL);

	gtk_widget_show_all (GTK_WIDGET (main_window));

	gtk_main ();
	
	rhythmdb_shutdown (db);
	g_object_unref (G_OBJECT (db));
	GDK_THREADS_LEAVE ();
	
	exit (0);
}
コード例 #12
0
ファイル: adcap.c プロジェクト: athurg/adcap
int main (gint argc, gchar **argv)
{
#ifdef WIN32
	WSADATA Ws;
	WSAStartup(MAKEWORD(2,2), &Ws);
#endif
	if(!g_thread_supported())
		g_thread_init(NULL);
	gdk_threads_init();
	gtk_init (&argc, &argv);

	builder = gtk_builder_new();
	gtk_builder_add_from_file(builder, "adcap.glade", NULL);
	gtk_builder_connect_signals(builder, NULL);

	canvas = GTK_WIDGET(gtk_builder_get_object(builder, "drawing_area"));
	g_signal_connect(canvas, "expose-event", G_CALLBACK(paint), NULL);
	gtk_builder_connect_signals(builder, NULL);


	//创建新线程,用于监听并刷新控件
	g_thread_create(refresh, NULL, 0, NULL);

	gdk_threads_enter();
	gtk_main();
	gdk_threads_leave();
#ifdef WIN32
	WSACleanup();
#endif
	return 0;
}
コード例 #13
0
ファイル: main-gtk.cpp プロジェクト: bowkenken/lnl
void	init_gtk_cui_mouse( int argc, char **argv )
{
	// GTK+ を初期化

	gtk_set_locale();

#if	defined( HAVE_G_THREAD_INIT )
	g_thread_init( NULL );
#endif
	gdk_threads_init();

	gtk_init( &argc, &argv );

	gPcgDun.nTileSizeRate = g_graph_scale_rate;

	// SDL を初期化

	gMusic.init();
	gSound.init();
	gJoystick.init();

	// 入力の初期化

	gKey.init();
	initMouseMotionFunc();

	change_scene_gui( SCENE_N_TITLE );

	// スレッドを切る

	call_game_thread_create( main_thread_cui );
}
コード例 #14
0
ファイル: startup.c プロジェクト: jmjeong-nemus/rexy-embedded
int main(int argc, char*argv[])
{
     int ret;
     GThread *rexy_thread;

     g_thread_init(NULL);
     gdk_threads_init();

     gtk_init(&argc, &argv);

     build_device();

     RalKernelBuffer = g_async_queue_new();

     if ( !RalKernelBuffer )
     {
	  printf("can't create message buffer\n");
	  return -1;
     }

     rexy_thread = g_thread_create( rexyThread, NULL, TRUE, NULL);

     gdk_threads_enter();
     gtk_main();
     gdk_threads_leave();

     g_thread_join( rexy_thread );
	
     return 0;
}
コード例 #15
0
ファイル: main.cpp プロジェクト: herrsergio/tx8-vcc
int main(int argc, char *argv[])
{
	GnomeProgram *tx8_vcc;
	GError *error = NULL;
	
	tx8_vcc = gnome_program_init("tx8-vcc",VERSION,LIBGNOMEUI_MODULE,argc,argv,NULL);
	
	/* init threads */
  	if (!g_thread_supported ()) 
		g_thread_init (NULL);
  	gdk_threads_init();
	
	init_listener_socket();
	tx8_vcc_main();
	
	/* create the threads */
	if (!g_thread_create(listen_message, NULL, FALSE, &error)) {
   	g_printerr ("Failed to create \"listen_message\" thread: %s\n", error->message);
      return 1;
   }
	
	if(!g_thread_create(draw_message, &mi_pizarron, FALSE, &error)) {
		g_printerr("Failed to create \"draw_message\" thread: %s\n", error->message);
		return 1;
	}
	
	gdk_threads_enter();
	gtk_main();
	gdk_threads_leave();
	
	kill_sockets();
	
	return(0);
}
コード例 #16
0
ファイル: main.c プロジェクト: tuhaihe/gtkhash
int main(int argc, char **argv)
{
#if ENABLE_NLS
    bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR);
    bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
    textdomain(GETTEXT_PACKAGE);
#endif

    g_thread_init(NULL);
    gdk_threads_init();
    gdk_threads_enter();
    g_atexit(gdk_threads_leave);

    read_opts_preinit(&argc, &argv);

    hash_init();
    g_atexit(hash_deinit);

    gui_init(opts.datadir ? opts.datadir : DATADIR);
    g_atexit(gui_deinit);

    list_init();

    prefs_init();
    g_atexit(prefs_deinit);

    read_opts_postinit();

    gui_run();

    return EXIT_SUCCESS;
}
コード例 #17
0
ファイル: cef_base_gtk.cpp プロジェクト: MikhailTatsky/appjs
void CefBase::Init() {
      
  g_thread_init (NULL);
  gdk_threads_init ();
  gtk_init(NULL,NULL);

};
コード例 #18
0
ファイル: liblinphone_tester.c プロジェクト: artur/linphone
int main (int argc, char *argv[])
{
	int i;
	int ret;

#ifdef HAVE_GTK
	gtk_init(&argc, &argv);
#if !GLIB_CHECK_VERSION(2,32,0) // backward compatibility with Debian 6 and CentOS 6
	g_thread_init(NULL);
#endif
	gdk_threads_init();
#endif

	liblinphone_tester_init(NULL);
	linphone_core_set_log_level(ORTP_ERROR);

	for(i = 1; i < argc; ++i) {
		if (strcmp(argv[i], "--verbose") == 0) {
			linphone_core_set_log_level(ORTP_MESSAGE);
		} else if (strcmp(argv[i], "--silent") == 0) {
			linphone_core_set_log_level(ORTP_FATAL);
		} else if (strcmp(argv[i],"--log-file")==0){
			CHECK_ARG("--log-file", ++i, argc);
			if (liblinphone_tester_set_log_file(argv[i]) < 0) return -2;
		} else if (strcmp(argv[i],"--domain")==0){
			CHECK_ARG("--domain", ++i, argc);
			test_domain=argv[i];
		} else if (strcmp(argv[i],"--auth-domain")==0){
			CHECK_ARG("--auth-domain", ++i, argc);
			auth_domain=argv[i];
		}else if (strcmp(argv[i],"--dns-hosts")==0){
			CHECK_ARG("--dns-hosts", ++i, argc);
			userhostsfile=argv[i];
		} else if (strcmp(argv[i],"--keep-recorded-files")==0){
			liblinphone_tester_keep_recorded_files(TRUE);
		} else if (strcmp(argv[i],"--disable-leak-detector")==0){
			liblinphone_tester_disable_leak_detector(TRUE);
		} else if (strcmp(argv[i],"--disable-tls-support")==0){
			liblinphone_tester_tls_support_disabled = TRUE;
		} else if (strcmp(argv[i],"--no-ipv6")==0){
			liblinphonetester_ipv6 = FALSE;
		} else if (strcmp(argv[i],"--show-account-manager-logs")==0){
			liblinphonetester_show_account_manager_logs=TRUE;
		} else {
			int bret = bc_tester_parse_args(argc, argv, i);
			if (bret>0) {
				i += bret - 1;
				continue;
			} else if (bret<0) {
				bc_tester_helper(argv[0], liblinphone_helper);
			}
			return bret;
		}
	}

	ret = bc_tester_start(argv[0]);
	liblinphone_tester_uninit();
	return ret;
}
コード例 #19
0
int
main (int argc,
      char *argv[])
{
   unicap_handle_t handle;
   unicap_format_t format;
   
   /* Initialize */
   gtk_init (&argc, &argv);
   g_thread_init(NULL);
   gdk_threads_init ();
   gtk_gl_init (&argc, &argv);
   init_extensions ();
   init_gl_resources ();

   handle = open_device();
   set_format( handle );
   unicap_get_format( handle, &format );
   if( ( format.size.width != 640 ) ||
       ( format.size.height != 480 ) )
   {
      g_warning( "The default .cg file assumes a video format of 640x480 pixels. \nYou need to change the yuv.cg file to match your size.\n" );
   }
   
   prepare_yuv_buffer(&yuvbuffer, &format);
   unicap_register_callback( handle, UNICAP_EVENT_NEW_FRAME, (unicap_callback_t)new_frame_cb, NULL ); 
   unicap_start_capture( handle );
   

   /* Gtk window & container */
   GtkWindow *window = GTK_WINDOW (gtk_window_new (GTK_WINDOW_TOPLEVEL));
   glarea = gtk_drawing_area_new ();
   gtk_widget_set_size_request (GTK_WIDGET (glarea), WINDOW_WIDTH, WINDOW_HEIGHT);
   g_signal_connect (glarea, "expose-event", G_CALLBACK (on_expose), NULL);
   g_signal_connect (glarea, "configure-event", G_CALLBACK (on_configure), NULL);
   g_signal_connect (glarea, "map-event", G_CALLBACK (on_mapped), NULL);
   g_signal_connect (window, "delete-event", G_CALLBACK (gtk_main_quit), NULL);

   GdkGLConfig *gl_config;
   gl_config = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGBA | GDK_GL_MODE_DOUBLE);

   if (gl_config == NULL) 
      g_critical ("Failed to setup a double-buffered RGB visual");

   if (! gtk_widget_set_gl_capability (GTK_WIDGET (glarea), 
				       gl_config,
				       NULL,
				       TRUE,
				       GDK_GL_RGBA_TYPE))
      g_critical ("Failed to add gl capability");

   gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (glarea));
   gtk_widget_show_all (GTK_WIDGET (window));


   /* Main loop */
   gtk_main ();
   return 0;
}
コード例 #20
0
ファイル: utility.cpp プロジェクト: DGLSBC/jabs-clock
// -----------------------------------------------------------------------------
void g_init_threads_gui()
{
#if _USEGTK
	g_init_threads();         // must go before gtk_init_check call
	gdk_threads_init();       // ditto
#endif
	g_sync_threads_gui_beg(); // ditto
}
コード例 #21
0
EXPORT void wrapper_gdk_lib_init( void ) {
        if( g_thread_supported() ) {
                printf("g_thread NOT supported\n");
                exit(-1);
        }
        g_thread_init(NULL);
        gdk_threads_init();
}
コード例 #22
0
ファイル: stripchart-demo.c プロジェクト: BMWPower/MegaTunix
int main (int argc, char **argv)
{
	GtkWidget *window = NULL;
	GdkColor col = { 0,100,200,300};
	gint i = 0;
	gfloat j = 0.0;
	gint trace1 = 0;
	gint trace2 = 0;
	gint trace3 = 0;
	gfloat data[3] = {0.1,1.1,2.2};
	gint timeout = 0;

	g_thread_init(NULL);
	gdk_threads_init();
	gtk_init (&argc, &argv);

	window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

	gtk_widget_set_size_request(GTK_WIDGET(window),320,320);
	chart = mtx_stripchart_new ();
	gtk_container_add (GTK_CONTAINER (window), chart);
	gtk_widget_realize(chart);
	trace1 = mtx_stripchart_add_trace(MTX_STRIPCHART(chart),-512.0,1536.0,0,"Trace 1", NULL);
	printf("trace 1's ID %i\n",trace1);
	trace2 = mtx_stripchart_add_trace(MTX_STRIPCHART(chart),-100.0,512.0,0,"Trace 2", NULL);
	printf("trace 2's ID %i\n",trace2);
	trace3 = mtx_stripchart_add_trace(MTX_STRIPCHART(chart),512.0,1024.0,1,"Trace 3", NULL);
	printf("trace 3's ID %i\n",trace3);
	for (j=0;j<1024;j+=2.5)
	{
		for (i=0;i<3;i++)
			data[i] = j;
		/*printf("setting values to %f, %f, %f\n",data[0],data[1],data[2]); */

		mtx_stripchart_set_values(MTX_STRIPCHART(chart),data);
	}
	mtx_stripchart_get_latest_values(MTX_STRIPCHART(chart),data);
/*	printf("latest values are %f, %f, %f\n",data[0],data[1],data[2]);*/

	/*mtx_stripchart_delete_trace(MTX_STRIPCHART(chart),trace2);*/

	timeout = g_timeout_add(40,(GSourceFunc)update_stripchart_wrapper,(gpointer)chart);
/*	g_timeout_add(4000,(GSourceFunc)remove_trace,GINT_TO_POINTER(trace2));*/

	gtk_widget_show_all (window);

	g_signal_connect (window, "delete_event",
			G_CALLBACK (close_demo), GINT_TO_POINTER(timeout));
	g_signal_connect (window, "destroy_event",
			G_CALLBACK (close_demo), GINT_TO_POINTER(timeout));

	gdk_threads_enter();
	gtk_main ();
	gdk_threads_leave();
	return 0;
}
コード例 #23
0
ファイル: main.c プロジェクト: rborisov/streamripperd
int main (int argc, char *argv[])
{
    gchar *path;
    guint hndl_id0, hndl_id1;
//    char *lang;
    int opt;
    int longopt_index;
    setlocale (LC_ALL, "");//lang);
    static struct option long_options[] = {
        {"help", 0, NULL, 'h'},
        {"version", 0, NULL, 'v'},
        {NULL, 0, NULL, 0}
    };

    while ((opt = getopt_long(argc, argv, "h:v", long_options, &longopt_index)) > 0)
    {
        switch (opt)
        {
            case 'v':
                printf ("%s %s\n%s\n", g_ascii_strdown(APPNAME,strlen(APPNAME)),
                        VERSION,
                        "Copyright 2016 Roman Borisov");
                goto cleanup;
                break;
            case 'h':
            default:
                fprintf(stderr, "usage: %s [options]\n", basename(argv[0]));
                fprintf(stderr, "  -h, --help           display this help\n");
                fprintf(stderr, "  -v, --version            version information\n");
                return 1;
        }
    }

    gdk_threads_init ();

    gtk_init (&argc, &argv);
    gtk_app_init();
//    gtk_window_fullscreen(GDK_WINDOW(gtk.main_window));
    gtk_widget_show (gtk.main_window);

    db_init();

    gdk_threads_enter ();
	hndl_id0 = g_idle_add((GtkFunction)mpd_idle, NULL);
    hndl_id1 = g_idle_add((GtkFunction)player_idle, NULL);
    gtk_main ();
    gtk_idle_remove(hndl_id0);
    gtk_idle_remove(hndl_id1);
    gdk_threads_leave ();

    db_close();
cleanup:
    

    return 0;
}
コード例 #24
0
ファイル: Core.cpp プロジェクト: N4TT/LevelSet
void * initGTK(void * t) {
	gdk_threads_init ();	
	gtk_init(0, (char ***) "");
	init = true;
    windowCountMutex = g_mutex_new();
	gdk_threads_enter ();
	gtk_main();
    gdk_threads_leave();
    return 0;
}
コード例 #25
0
int main(int argc, char **argv)
{
	UpdaterAppState* app_state = new UpdaterAppState;
	GThread *worker_thread;

	parse_args_and_init(argc, argv, app_state);

	// Initialize logger, and rename old log file
	gDirUtilp->initAppDirs("SecondLife");
	LLError::initForApplication
		(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, ""));
	std::string old_log_file = gDirUtilp->getExpandedFilename
		(LL_PATH_LOGS, "updater.log.old");
	std::string log_file =
		gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "updater.log");
	LLFile::rename(log_file, old_log_file);
	LLError::logToFile(log_file);

	// initialize gthreads and gtk+
	if (!g_thread_supported())
	{
		g_thread_init(NULL);
		gdk_threads_init();
	}

	gtk_init(&argc, &argv);

	// create UI
	updater_app_ui_init(app_state);

	//llinfos << "SAMPLE TRANSLATION IS: " << LLTrans::getString("LoginInProgress") << llendl;

	// create download thread
	worker_thread = g_thread_create
		(GThreadFunc(worker_thread_cb), app_state, FALSE, NULL);

	gdk_threads_enter();
	gtk_main();
	gdk_threads_leave();

	// Delete the file only if created from url download.
	if(!app_state->url.empty() && !app_state->file.empty())
	{
		if (gDirUtilp->fileExists(app_state->file))
		{
			LLFile::remove(app_state->file);
		}
	}

	bool success = !app_state->failure;
	delete app_state->image_dir_iter;
	delete app_state;
	return success ? 0 : 1;
}
コード例 #26
0
int main(int argc, char *argv[])
{
	pthread_t v4l_thread;
	struct _Ourarg ourarg;


	if(XInitThreads () == 0)
		printf(" XInitThreads err\n");

	if(!g_thread_supported()) 
		g_thread_init(NULL);
	gdk_threads_init();
	  
	gtk_init(&argc, &argv);
	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
///////////////////////////////////////////////////////
	fixed = gtk_fixed_new ();
	gtk_container_add(GTK_CONTAINER(window),fixed);
	gtk_widget_show(fixed);
      
	label = gtk_label_new ("123456789012345678901234567890");
	gtk_container_add (GTK_CONTAINER (fixed), label);
	gtk_fixed_move (GTK_FIXED (fixed), label, 0, 10); 
	gtk_widget_show(label);

    gtk_fixed_move (GTK_FIXED (fixed),
                                    label,
                                    200,
                                    0); 

    gtk_window_set_resizable(GTK_WINDOW(window),TRUE);
    gtk_window_resize(GTK_WINDOW(window), window_width,window_height);

	gtk_widget_show(window);
	 
/*
	if( pthread_create(&v4l_thread, NULL, v4l_show, NULL) == 0)
		printf("thread create Ok, v4l show thread start \n");
	else
		printf("thread create Err\n");
*/
//	gtk_timeout_add (1000, RepaintClock, (gpointer) label);

	g_thread_create(thread_go, &ourarg, FALSE, NULL);
	gdk_threads_enter();
	gtk_main();
	gdk_threads_leave();


	printf("gtk main end \n");

	return 0;
}
コード例 #27
0
ファイル: thread.c プロジェクト: Eddyding/GTK-2.0
int
main(int argc,char *argv[])
{
    
    //gtk_init(&argc,&argv);
    gtk_init(NULL,NULL);

    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

	// 信号回调函数
    g_signal_connect(G_OBJECT(window),"delete_event"
           ,G_CALLBACK(on_delete_event),NULL);

    gtk_window_set_title(GTK_WINDOW(window),"多线程使用");

  //  gtk_window_set_default_size(GTK_WINDOW(window),500,100);

  gtk_widget_set_usize(GTK_WIDGET(window),500,100);

    gtk_window_set_position(GTK_WINDOW(window),
    GTK_WIN_POS_CENTER
        );



    gtk_container_set_border_width(GTK_CONTAINER(window),0);


    label = gtk_label_new("10");
   
    gtk_container_add(GTK_CONTAINER(window),label);
   
    gtk_widget_show(label);
    gtk_widget_show(window);// 显示控件。参数是要显示的控件的指针。


// 线程的初始化
 if(!g_thread_supported()) 
     g_thread_init(NULL);
gdk_threads_init();


// 创建线程
// g_thread_create((GThreadFunc)hello,NULL,FALSE,NULL);
g_thread_new("子线程",(GThreadFunc)hello,NULL);

// 事件循环。
gdk_threads_enter();
    gtk_main();
gdk_threads_leave();

    return EXIT_SUCCESS;
}
コード例 #28
0
void display_windows(struct list * addr_list, int argc, char * argv[])
{
  struct listnode * addr_node;
  struct listnode * local_addr_node;

  LIST_FOREACH(addr_list, addr_node)
  {
    struct addr * cur_addr = (struct addr *)addr_node->data;
    if(strcmp(cur_addr->type, "1") == 0)
    {
      char * host = cur_addr->host;
      struct list * addr_list_procs = calloc(1, sizeof(struct list));

      LIST_FOREACH(addr_list, local_addr_node)
      {
        struct addr * local_cur_addr = (struct addr *)local_addr_node->data;
        if((strcmp(local_cur_addr->type, "1") != 0) && (strcmp(local_cur_addr->host, host) == 0))
        {
          printf("%s\n", local_cur_addr->prefix_str);
          struct listnode * node_to_be_added = calloc(1, sizeof(struct listnode));
          struct addr * addr_to_be_added = calloc(1, sizeof(struct addr));
          node_to_be_added->data = (void *)addr_to_be_added;

          memcpy(addr_to_be_added, local_cur_addr, sizeof(struct addr));
          printf("memcpied %s\n", addr_to_be_added->prefix_str);
          LIST_APPEND(addr_list_procs, node_to_be_added);
        }
      }

      LIST_FOREACH(addr_list_procs, local_addr_node)
      {
        struct addr * local_cur_addr = (struct addr *)local_addr_node->data;
        printf("address copied: %s\n", local_cur_addr->prefix_str);
      }

      // create new child for each window
      pid_t pid = fork();

      if(pid == 0)
      {

        if (!g_thread_supported ()){ g_thread_init(NULL); }
        gdk_threads_init();
        gdk_threads_enter();

        gtk_init(&argc, &argv);
        display_window(cur_addr, addr_list_procs);
        gdk_threads_leave();
        // make sure child doesn't fork again
        _exit(0);
      }
    }
  }
コード例 #29
0
ファイル: smooth-gtk-thread.c プロジェクト: AndyUI/curl
int main(int argc, char **argv)
{
  GtkWidget *top_window, *outside_frame, *inside_frame, *progress_bar;

  /* Must initialize libcurl before any threads are started */
  curl_global_init(CURL_GLOBAL_ALL);

  /* Init thread */
  g_thread_init(NULL);
  gdk_threads_init ();
  gdk_threads_enter ();

  gtk_init(&argc, &argv);

  /* Base window */
  top_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

  /* Frame */
  outside_frame = gtk_frame_new(NULL);
  gtk_frame_set_shadow_type(GTK_FRAME(outside_frame), GTK_SHADOW_OUT);
  gtk_container_add(GTK_CONTAINER(top_window), outside_frame);

  /* Frame */
  inside_frame = gtk_frame_new(NULL);
  gtk_frame_set_shadow_type(GTK_FRAME(inside_frame), GTK_SHADOW_IN);
  gtk_container_set_border_width(GTK_CONTAINER(inside_frame), 5);
  gtk_container_add(GTK_CONTAINER(outside_frame), inside_frame);

  /* Progress bar */
  progress_bar = gtk_progress_bar_new();
  gtk_progress_bar_pulse (GTK_PROGRESS_BAR (progress_bar));
  /* Make uniform pulsing */
  gint pulse_ref = g_timeout_add (300, pulse_bar, progress_bar);
  g_object_set_data(G_OBJECT(progress_bar), "pulse_id",
                    GINT_TO_POINTER(pulse_ref));
  gtk_container_add(GTK_CONTAINER(inside_frame), progress_bar);

  gtk_widget_show_all(top_window);
  printf("gtk_widget_show_all\n");

  g_signal_connect(G_OBJECT (top_window), "delete-event",
                   G_CALLBACK(cb_delete), NULL);

  if(!g_thread_create(&create_thread, progress_bar, FALSE, NULL) != 0)
    g_warning("can't create the thread");

  gtk_main();
  gdk_threads_leave();
  printf("gdk_threads_leave\n");

  return 0;
}
コード例 #30
0
ファイル: _main_.c プロジェクト: biddyweb/xwbot
int
main(int argc, char *argv[])
{
//  int major;
//  int minor;
  GtkWidget *app_win;
  pthread_t tid;

  parse_cmd_line_params(argc, argv);
  printf("\n width: %d"
      "\n height: %d"
      "\n remote ip: %s"
      "\n remote port: %d"
      "\n local ip: %s"
      "\n local port: %d"
      "\n", displayW, displayH, remoteIp, remotePort, localIp, localPort);

  gtk_init(&argc, &argv);

  printf("%s:%d\n", __FUNCTION__, __LINE__);

  /* load the interface */
  xml = glade_xml_new(/* SHARE_DIR */"xwrcptex.glade", NULL, NULL);
  /* connect the signals in the interface */
  glade_xml_signal_autoconnect(xml);
  app_win = glade_xml_get_widget(xml, "mainwin");

  printf("%s:%d\n", __FUNCTION__, __LINE__);

  g_signal_connect(G_OBJECT(app_win), "event",
      G_CALLBACK(on_mainwin_frame_event), NULL);

#if defined(USE_THEORA)
  x_theora_init();
#endif

  printf("%s:%d\n", __FUNCTION__, __LINE__);

  if (!g_thread_supported())
    g_thread_init(NULL);
  gdk_threads_init();
  pthread_create(&tid, NULL, rtpthread, NULL);

  /* start the event loop */
  // gtk_main();
  printf("%s:%d\n", __FUNCTION__, __LINE__);
  x_main_loop((void *) app_win);

  getchar();

  return 0;
}