Exemple #1
0
/*!
 \brief Enables the serial connection and starts up  the reader thread
  */
G_MODULE_EXPORT void libreems_serial_enable(void)
{
	GIOChannel *channel = NULL;
	Serial_Params *serial_params = NULL;
	GThread *thread = NULL;
	gint tmpi = 0;

	ENTER();
	serial_params = (Serial_Params *)DATA_GET(global_data,"serial_params");
	if ((!serial_params->open) || (!serial_params->fd))
	{
		MTXDBG(CRITICAL,_("Serial port is NOT open, or filedescriptor is invalid!\n"));
		EXIT();
		return;
	}

	DATA_SET(global_data,"serial_abort",GINT_TO_POINTER(FALSE));
#ifdef __WIN32__
	thread = g_thread_new("Win32 Reader",win32_reader,GINT_TO_POINTER(serial_params->fd));
#else
	thread = g_thread_new("UNIX Reader",unix_reader,GINT_TO_POINTER(serial_params->fd));
#endif
	DATA_SET(global_data,"serial_thread_id",thread);
	EXIT();
	return;
}
Exemple #2
0
static void
gst_switch_server_run (GstSwitchServer * srv)
{
  srv->main_loop = g_main_loop_new (NULL, TRUE);

  if (!gst_switch_server_prepare_composite (srv, DEFAULT_COMPOSE_MODE))
    goto error_prepare;

  srv->video_acceptor = g_thread_new ("switch-server-video-acceptor",
      (GThreadFunc) gst_switch_server_video_acceptor, srv);

  srv->audio_acceptor = g_thread_new ("switch-server-audio-acceptor",
      (GThreadFunc) gst_switch_server_audio_acceptor, srv);

  srv->controller_thread = g_thread_new ("switch-server-controller",
      (GThreadFunc) gst_switch_server_controller, srv);

  gst_switch_server_prepare_bus_controller (srv);

  g_main_loop_run (srv->main_loop);

  g_thread_join (srv->video_acceptor);
  g_thread_join (srv->audio_acceptor);
  g_thread_join (srv->controller_thread);
  return;

  /* Errors Handling */
 error_prepare:
  {
    ERROR ("error preparing server");
    return;
  }
}
Exemple #3
0
void
rtcdc_loop(struct rtcdc_peer_connection *peer)
{
  if (peer == NULL)
    return;

  while (!peer->initialized)
    g_usleep(50000);

  GThread *thread_ice = g_thread_new("ICE thread", &ice_thread, peer);
  GThread *thread_sctp = g_thread_new("SCTP thread", &sctp_thread, peer);
  GThread *thread_startup = g_thread_new("Startup thread", &startup_thread, peer);

  struct ice_transport *ice = peer->transport->ice;
  g_main_loop_run(ice->loop);
  peer->exit_thread = TRUE;

  g_thread_join(thread_ice);
  g_thread_join(thread_sctp);
  g_thread_join(thread_startup);

  g_thread_unref(thread_ice);
  g_thread_unref(thread_sctp);
  g_thread_unref(thread_startup);
}
void button44_treeview_fun(GtkWidget *window,gpointer *data)//创建容器的选择界面
{

	GtkWidget *dialog;
	static gint gtk_run=0;
	dialog=gtk_message_dialog_new(NULL,GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT,GTK_MESSAGE_WARNING,GTK_BUTTONS_YES_NO,"是否使用系统默认的名字");
		gtk_run=gtk_dialog_run (GTK_DIALOG(dialog));
		if(gtk_run==GTK_RESPONSE_YES){
			//system("sudo gnome-terminal -x bash -c \"sudo docker run -ti --name chen ubuntu /bin/bash\"");
			g_thread_new("docker_contains_create",docker_contains_create_func,dialog);
			g_thread_new ("clean",docker_tree_view_clean,dialog);
			gtk_widget_destroy (dialog);
		}
		else if(gtk_run==GTK_RESPONSE_NO)
	{
		printf("nnnn\n");
		create_contians_view();//选择不是系统默认创建容器的界面
		gtk_widget_destroy (dialog);

	}
		else{
			gtk_widget_destroy (dialog);
			
		}

}
Exemple #5
0
void iopen_init(GtkWidget *window) {
	parent_window = window;

	GtkWidget *main_vbox = gtk_vbox_new(false, 0);

	iopen_buffer = buffer_create();
	iopen_buffer->single_line = true;
	load_empty(iopen_buffer);
	iopen_editor = new_editor(iopen_buffer, true);

	buffer_set_onchange(iopen_buffer, iopen_buffer_onchange);

	config_set(&(iopen_buffer->config), CFG_AUTOWRAP, "0");
	config_set(&(iopen_buffer->config), CFG_AUTOCOMPL_POPUP, "0");

	iopen_editor->single_line_escape = &iopen_escape;
	iopen_editor->single_line_return = &iopen_enter;
	iopen_editor->single_line_other_keys = &iopen_other_keys;

	gtk_box_pack_start(GTK_BOX(main_vbox), GTK_WIDGET(iopen_editor), FALSE, FALSE, 0);

	results_list = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_DOUBLE);
	gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(results_list), 3, GTK_SORT_ASCENDING);
	results_tree = gtk_tree_view_new();

	crt = gtk_cell_renderer_text_new();

	iopen_recoloring();

	gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(results_tree), -1, "Show", crt, "markup", 0, NULL);
	gtk_tree_view_set_model(GTK_TREE_VIEW(results_tree), GTK_TREE_MODEL(results_list));
	gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(results_tree), FALSE);
	gtk_tree_view_set_search_column(GTK_TREE_VIEW(results_tree), 1);

	g_signal_connect(G_OBJECT(results_tree), "row-activated", G_CALLBACK(result_activated_callback), NULL);

	GtkWidget *results_scroll = gtk_scrolled_window_new(NULL, NULL);
	gtk_container_add(GTK_CONTAINER(results_scroll), results_tree);

	gtk_box_pack_start(GTK_BOX(main_vbox), frame_piece(TRUE), FALSE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(main_vbox),  results_scroll, TRUE, TRUE, 0);

	iopen_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_decorated(GTK_WINDOW(iopen_window), TRUE);
	gtk_window_set_default_size(GTK_WINDOW(iopen_window), 640, 480);

	g_signal_connect(G_OBJECT(iopen_window), "delete-event", G_CALLBACK(delete_callback), NULL);
	g_signal_connect(G_OBJECT(iopen_window), "map_event", G_CALLBACK(map_callback), NULL);

	gtk_container_add(GTK_CONTAINER(iopen_window), main_vbox);

	file_recursor_requests = g_async_queue_new();
	tags_requests = g_async_queue_new();
	buffers_requests = g_async_queue_new();
	g_thread_new("iopen file recursion", iopen_recursor_thread, NULL);
	g_thread_new("tags iteration", iopen_tags_thread, NULL);
	g_thread_new("buffer iteration", iopen_buffer_thread, NULL);
}
Exemple #6
0
/**
 * Inits the main structure.
 * @note With sqlite version > 3.7.7 we should use URI filename.
 * @param opt : a filled options_t * structure that contains all options
 *        by default, read into the file or selected in the command line.
 * @returns a main_struct_t * pointer to the main structure
 */
static main_struct_t *init_main_structure(options_t *opt)
{
    main_struct_t *main_struct = NULL;
    gchar *db_uri = NULL;
    gchar *conn = NULL;

    if (opt != NULL)
    {

        print_debug(_("Please wait while initializing main structure...\n"));

        main_struct = (main_struct_t *) g_malloc0(sizeof(main_struct_t));

        create_directory(opt->dircache);
        db_uri = g_build_filename(opt->dircache, opt->dbname , NULL);
        main_struct->database = open_database(db_uri);
        db_uri = free_variable(db_uri);

        main_struct->opt = opt;
        main_struct->hostname = g_get_host_name();

        if (opt != NULL && opt->ip != NULL)
        {
            conn = make_connexion_string(opt->ip, opt->port);
            main_struct->comm = init_comm_struct(conn);
            main_struct->reconnected = init_comm_struct(conn);
            free_variable(conn);
        }
        else
        {
            /* This should never happen because we have default values */
            main_struct->comm = NULL;
        }

        main_struct->signal_fd = start_signals();
        main_struct->fanotify_fd = start_fanotify(opt);

        /* inits the queue that will wait for events on files */
        main_struct->save_queue = g_async_queue_new();
        main_struct->dir_queue = g_async_queue_new();
        main_struct->regex_exclude_list = make_regex_exclude_list(opt->exclude_list);

        /* Thread initialization */
        main_struct->save_one_file = g_thread_new("save_one_file", save_one_file_threaded, main_struct);
        main_struct->carve_all_directories = g_thread_new("carve_all_directories", carve_all_directories, main_struct);
        main_struct->reconn_thread = g_thread_new("reconnected", reconnected, main_struct);

        print_debug(_("Main structure initialized !\n"));

    }

    return main_struct;
}
Exemple #7
0
static void
test_message (Fixture *f,
    gconstpointer data)
{
  DBusMessage *message = dbus_message_new_signal ("/foo", "foo.bar.baz",
      "Foo");
  Thread public_api = {
    f,
    message,
    (RefFunc) dbus_message_ref,
    NULL,
    (VoidFunc) dbus_message_unref,
    NULL,
    NULL,
    NULL };
  unsigned i;

  if (!dbus_message_set_data (message, message_slot, f, last_unref))
    g_error ("OOM");

  for (i = 0; i < f->n_threads; i++)
    {
      f->threads[i] = g_thread_new (NULL, ref_thread, &public_api);
      g_assert (f->threads[i] != NULL);
    }

  wait_for_all_threads (f);

  for (i = 0; i < f->n_threads; i++)
    {
      f->threads[i] = g_thread_new (NULL, cycle_thread, &public_api);
      g_assert (f->threads[i] != NULL);
    }

  wait_for_all_threads (f);

  for (i = 0; i < f->n_threads; i++)
    {
      f->threads[i] = g_thread_new (NULL, unref_thread, &public_api);
      g_assert (f->threads[i] != NULL);
    }

  wait_for_all_threads (f);

  /* Destroy the server. This should be the last-unref. */
  g_assert (!f->last_unref);
  dbus_message_unref (message);
  g_assert (f->last_unref);
}
Exemple #8
0
void
_start_worker(guint thread_num)
{
#define LEELA_EXTRA_THREADNUM 2
    GThread *all_threads[thread_num+LEELA_EXTRA_THREADNUM];

    struct monitor *m = g_malloc0(sizeof(*m));
    g_mutex_init(&m->mutex);
    g_cond_init(&m->cond);
    m->count = thread_num;
    m->sleep = 0;

    m->m = g_malloc0(thread_num * sizeof(struct leela_monitor *));
    int i = 0;
    for(i=0;i<thread_num;i++)
    {
        m->m[i] = leela_monitor_new();
    }

    all_threads[0] = g_thread_new("monitor",_monitor,m);
    all_threads[1] = g_thread_new("timer",_timer,m);

    static int weight[] = {
        -1, -1, -1, -1, 0, 0, 0, 0,
        1, 1, 1, 1, 1, 1, 1, 1,
        2, 2, 2, 2, 2, 2, 2, 2,
        3, 3, 3, 3, 3, 3, 3, 3, };
    struct worker_parm wp[thread_num];

    for(i=0;i<thread_num;i++)
    {
        wp[i].id = i;
        wp[i].m = m;
        if (i < sizeof(weight)/sizeof(weight[0])) {
            wp[i].weight= weight[i];
        } else {
            wp[i].weight = 0;
        }

        all_threads[i+LEELA_EXTRA_THREADNUM] = g_thread_new("worker",_worker,&wp[i]);
    }

    for(i=0;i<thread_num+LEELA_EXTRA_THREADNUM;i++)
    {
        g_thread_join(all_threads[i]);
    }

    free_monitor(m);
}
int main() {

  g_mutex_init(&lock);
  
  GThread *first_thread = g_thread_new("first_thread", &doSomeThing_simple, NULL);
  GThread *second_thread = g_thread_new("second_thread", &doSomeThing_simple, NULL);

  g_thread_join(first_thread);
  g_thread_join(second_thread);
  
  g_mutex_clear(&lock);
  
  return 0;
  
}
Exemple #10
0
gpointer 
ssl_ping_thread (gpointer _c)
{
  mongo_ssl_ctx *c = (mongo_ssl_ctx*) _c;
  GThread *s, *f;
  s = g_thread_new ("ping_success", ssl_ping_success_thread, c);
  f = g_thread_new ("ping_fail", ssl_ping_fail_thread, c);

  g_thread_join (s);
  g_thread_join (f);
  g_thread_unref (s);
  g_thread_unref (f);

  return NULL;
}
/**
 * gst_gl_context_create:
 * @context: a #GstGLContext:
 * @other_context: (allow-none): a #GstGLContext to share OpenGL objects with
 * @error: (allow-none): a #GError
 *
 * Creates an OpenGL context in the current thread with the specified
 * @other_context as a context to share shareable OpenGL objects with.  See the
 * OpenGL specification for what is shared between contexts.
 *
 * If an error occurs, and @error is not %NULL, then error will contain details
 * of the error and %FALSE will be returned.
 *
 * Should only be called once.
 *
 * Returns: whether the context could successfully be created
 */
gboolean
gst_gl_context_create (GstGLContext * context,
    GstGLContext * other_context, GError ** error)
{
  gboolean alive = FALSE;

  g_return_val_if_fail (GST_GL_IS_CONTEXT (context), FALSE);
  g_return_val_if_fail (!GST_GL_IS_WRAPPED_CONTEXT (context), FALSE);
  _ensure_window (context);

  g_mutex_lock (&context->priv->render_lock);

  if (!context->priv->created) {
    context->priv->other_context = other_context;
    context->priv->error = error;

    context->priv->gl_thread = g_thread_new ("gstglcontext",
        (GThreadFunc) gst_gl_context_create_thread, context);

    g_cond_wait (&context->priv->create_cond, &context->priv->render_lock);

    context->priv->created = TRUE;

    GST_INFO ("gl thread created");
  }

  alive = context->priv->alive;

  g_mutex_unlock (&context->priv->render_lock);

  return alive;
}
Exemple #12
0
static void
cockpit_ssh_transport_constructed (GObject *object)
{
  CockpitSshTransport *self = COCKPIT_SSH_TRANSPORT (object);
  CockpitSshData *data;

  static GSourceFuncs source_funcs = {
    cockpit_ssh_source_prepare,
    cockpit_ssh_source_check,
    cockpit_ssh_source_dispatch,
    NULL,
  };

  G_OBJECT_CLASS (cockpit_ssh_transport_parent_class)->constructed (object);

  g_return_if_fail (self->data->creds != NULL);
  g_warn_if_fail (ssh_options_set (self->data->session, SSH_OPTIONS_USER,
                                   cockpit_creds_get_user (self->data->creds)) == 0);

  self->io = g_source_new (&source_funcs, sizeof (CockpitSshSource));
  ((CockpitSshSource *)self->io)->transport = self;
  g_source_attach (self->io, self->data->context);

  /* Setup for connect thread */
  self->connect_fd = ssh_get_fd (self->data->session);
  g_atomic_int_set (&self->connecting, 1);
  self->data->connecting = &self->connecting;
  data = self->data;
  self->data = NULL;

  self->connect_thread = g_thread_new ("ssh-transport-connect",
                                       cockpit_ssh_connect_thread, data);

  g_debug ("%s: constructed", self->logname);
}
static void
input_selector_push_eos (gint stream, gboolean active)
{
  GstPad *pad = stream == 1 ? stream1_pad : stream2_pad;

  if (active) {
    fail_unless (gst_pad_push_event (pad, gst_event_new_eos ()));
  } else {
    /* The non-active pads will block when receving eos, so we need to do it
     * from a separate thread. This makes this test racy, but it should only
     * cause false positives, not false negatives */
    GThread *t = g_thread_new ("selector-test-push-eos",
        (GThreadFunc) input_selector_do_push_eos, pad);

    /* Sleep half a second to allow the other thread to execute, this is not
     * a definitive solution but there is no way to know when the
     * EOS has reached input-selector and blocked there, so this is just
     * to reduce the possibility of this test being racy (false positives)
     */
    g_usleep (0.5 * G_USEC_PER_SEC);
    g_thread_unref (t);
  }

  input_selector_check_eos (active);
}
/**
 * @brief main only creates two threads
 */
int
main (int argc, char *argv[])
{
  GThread* GuiThread;
  GThread* DataThread;

  gtk_init(&argc, &argv);

  /* create two threads: one for the GUI and the DATA, respectively */
  GuiThread = g_thread_new("Thread GUI", (GThreadFunc)guiThread, (void *)NULL);
  DataThread = g_thread_new("Thread DATA", (GThreadFunc)dataThread, (void *)NULL);

  g_thread_join(DataThread);
  g_thread_join(GuiThread);
  return 0;
}
static gboolean
gst_ks_video_src_start_worker (GstKsVideoSrc * self)
{
    GstKsVideoSrcPrivate *priv = GST_KS_VIDEO_SRC_GET_PRIVATE (self);
    gboolean result;

    g_mutex_init (&priv->worker_lock);
    g_cond_init (&priv->worker_notify_cond);
    g_cond_init (&priv->worker_result_cond);

    priv->worker_pending_caps = NULL;
    priv->worker_pending_run = FALSE;

    priv->worker_state = KS_WORKER_STATE_STARTING;
    priv->worker_thread =
        g_thread_new ("ks-worker", gst_ks_video_src_worker_func, self);

    KS_WORKER_LOCK (priv);
    while (priv->worker_state < KS_WORKER_STATE_READY)
        KS_WORKER_WAIT_FOR_RESULT (priv);
    result = priv->worker_state == KS_WORKER_STATE_READY;
    KS_WORKER_UNLOCK (priv);

    return result;
}
void do_calibration (GtkWidget *widget, gpointer data)
{
	GtkToggleButton *silent_calib;

	plot_xcorr_4ch = plugin_get_new_plot();

	silent_calib = GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder, "silent_calibration"));
	if (gtk_toggle_button_get_active(silent_calib)) {
		osc_plot_set_visible(plot_xcorr_4ch, false);
	}

	if (plot_xcorr_4ch) {
		osc_plot_set_channel_state(plot_xcorr_4ch, CAP_DEVICE_ALT, 0, true);
		osc_plot_set_channel_state(plot_xcorr_4ch, CAP_DEVICE_ALT, 1, true);
		osc_plot_set_channel_state(plot_xcorr_4ch, CAP_DEVICE_ALT, 4, true);
		osc_plot_set_channel_state(plot_xcorr_4ch, CAP_DEVICE_ALT, 5, true);

		osc_plot_set_domain(plot_xcorr_4ch, XCORR_PLOT);
		osc_plot_set_marker_type(plot_xcorr_4ch,  MARKER_PEAK);
	} else
		return;

	g_thread_new("Calibrate_thread", (void *) &calibrate, data);
	gtk_widget_hide(GTK_WIDGET(data));
}
Exemple #17
0
int dt_lua_init_call(lua_State *L)
{

  dt_lua_push_darktable_lib(L);
  luaA_Type type_id = dt_lua_init_singleton(L, "control", NULL);
  lua_setfield(L, -2, "control");
  lua_pop(L, 1);
  
  lua_pushcfunction(L, ending_cb);
  dt_lua_type_register_const_type(L, type_id, "ending");
  lua_pushcfunction(L, dispatch_cb);
  lua_pushcclosure(L, dt_lua_type_member_common, 1);
  dt_lua_type_register_const_type(L, type_id, "dispatch");
  lua_pushcfunction(L,execute_cb);
  lua_pushcclosure(L, dt_lua_type_member_common, 1);
  dt_lua_type_register_const_type(L, type_id, "execute");
  lua_pushcfunction(L,sleep_cb);
  lua_pushcclosure(L, dt_lua_type_member_common, 1);
  dt_lua_type_register_const_type(L, type_id, "sleep");
  lua_pushcfunction(L,read_cb);
  lua_pushcclosure(L, dt_lua_type_member_common, 1);
  dt_lua_type_register_const_type(L, type_id, "read");

  lua_newtable(L);
  lua_setfield(L, LUA_REGISTRYINDEX, "dt_lua_bg_threads");
  // create stuff in init to avoid race conditions
  darktable.lua_state.context = g_main_context_new();
  stacked_job_init();
  alien_job_init();
  string_job_init();
  end_job_init();

  g_thread_new("lua thread",lua_thread_main,NULL);
  return 0;
}
Exemple #18
0
SR_PRIV int usb_source_add(struct sr_context *ctx, int timeout,
		sr_receive_data_callback cb, void *cb_data)
{
	if (ctx->usb_source_present) {
		sr_err("A USB event source is already present.");
		return SR_ERR;
	}

#ifdef _WIN32
	ctx->usb_event = CreateEvent(NULL, TRUE, FALSE, NULL);
	g_mutex_init(&ctx->usb_mutex);
	ctx->usb_thread_running = TRUE;
	ctx->usb_thread = g_thread_new("usb", usb_thread, ctx);
	ctx->usb_pollfd.fd = ctx->usb_event;
	ctx->usb_pollfd.events = G_IO_IN;
	ctx->usb_cb = cb;
	ctx->usb_cb_data = cb_data;
	sr_session_source_add_pollfd(&ctx->usb_pollfd, timeout, usb_callback, ctx);
#else
	const struct libusb_pollfd **lupfd;
	unsigned int i;

	lupfd = libusb_get_pollfds(ctx->libusb_ctx);
	for (i = 0; lupfd[i]; i++)
		sr_source_add(lupfd[i]->fd, lupfd[i]->events, timeout, cb, cb_data);
	free(lupfd);
#endif
	ctx->usb_source_present = TRUE;

	return SR_OK;
}
Exemple #19
0
int
test9 (void)
{
	g_print ("%s started, main thread is %p\n", __FUNCTION__, g_thread_self ());
	GdaWorker *worker;
	gint nfailed = 0;

	worker = gda_worker_new ();

#define NB_THREADS 2
	GThread *threads[NB_THREADS];
	guint i;
	for (i = 0; i < NB_THREADS; i++) {
		gchar *name;
		name = g_strdup_printf ("th%u", i);
		threads[i] = g_thread_new (name, (GThreadFunc) test9_main_func, worker);
		g_free (name);
	}

	for (i = 0; i < NB_THREADS; i++) {
		if (g_thread_join (threads[i]))
			nfailed++;
	}

	g_print ("Unref worker...\n");

	gda_worker_unref (worker);
	g_print ("%s done\n", __FUNCTION__);

	return nfailed;
}
static void TestWrite(gconstpointer user_data) {
  guint index = GPOINTER_TO_UINT(user_data);
  gint fds [] = { 0, 0 };
  GIOChannel *reader = NULL;
  GIOChannel *writer = NULL;
  GThread *thread = NULL;
  EscalateMessage *message = NULL;
  GError *error = NULL;
  gboolean success = FALSE;
  gchar *result = NULL;

  g_assert(g_unix_open_pipe(fds, 0, NULL));
  reader = g_io_channel_unix_new(fds[0]);
  writer = g_io_channel_unix_new(fds[1]);

  thread = g_thread_new("Reader", (GThreadFunc) ReaderThread, reader);

  message = EscalateMessageLoad(example_messages[index], NULL);
  g_assert(message);
  success = EscalateMessageWrite(message, writer, &error);
  g_assert_no_error(error);
  g_assert(success);

  g_assert_cmpint(G_IO_STATUS_NORMAL, ==,
                  g_io_channel_shutdown(writer, TRUE, NULL));

  result = (gchar *) g_thread_join(thread);
  result[strlen(result)-1] = '\0';  // Cut off newline.
  g_assert_cmpstr(example_messages[index], ==, result);

  g_io_channel_unref(reader);
  g_io_channel_unref(writer);
  EscalateMessageUnref(message);
  g_free(result);
}
JNIEXPORT void
JNICALL Java_org_GNOME_Accessibility_AtkWrapper_loadAtkBridge()
{
  // Enable ATK Bridge so we can load it now
  g_unsetenv ("NO_AT_BRIDGE");

  GThread *thread;
  GError *err;
  char * message;
  message = "JNI main loop";
  err = NULL;

  jaw_initialized = jaw_accessibility_init();
  if (jaw_debug)
    printf("Jaw Initialization STATUS in loadAtkBridge: %d\n", jaw_initialized);

  jni_main_loop = g_main_loop_new (NULL, FALSE); /*main loop NOT running*/
  thread = g_thread_new(message, jni_loop_callback, (void *) jni_main_loop);
  if(thread == NULL)
  {
    if (jaw_debug)
    {
      printf("Thread create failed: %s!!\n", err->message );
      g_error_free (err);
    }
  }
}
Exemple #22
0
static gpointer
ev_job_scheduler_init (gpointer data)
{
	g_thread_new ("EvJobScheduler", ev_job_thread_proxy, NULL);

	return NULL;
}
Exemple #23
0
/*
 * Start the version checking in a new thread.
 * @dialogs - The Dialogs structure to be used. Set it to NULL if a process bar
 *            is not required to be shown during version checking.
 */
void version_check_start(Dialogs *_dialogs)
{
    g_thread_new("version-check", (GThreadFunc)version_check, NULL);
    g_timeout_add(150, version_progress_update, _dialogs);
    if (_dialogs)
        gtk_widget_show(_dialogs->ver_progress_window);
}
void
xviewer_job_scheduler_init ()
{
	g_thread_new ("XviewerJobScheduler",
		      xviewer_job_scheduler,
		      NULL);
}
void probe_modem(char* device, PyObject* callback) {
	struct thread_info* info = g_new0(struct thread_info, 1);
	info->device = g_strdup(device);
	info->callback = callback;
	Py_INCREF(callback);
	g_thread_new("probe modem", do_probe, info);
}
Exemple #26
0
int
main (int argc, char **argv)
{
  gst_init (&argc, &argv);

  g_mutex_init (&trans_lock);

  mainloop = g_main_loop_new (NULL, TRUE);

  worker0 = GST_WORKER (g_object_new (GST_TYPE_WORKER,
          "name", "test-worker-0", NULL));

  worker0->pipeline_func = test_worker_pipeline;

  g_signal_connect (worker0, "prepare-worker",
      G_CALLBACK (test_worker_prepare), NULL);
  g_signal_connect (worker0, "start-worker",
      G_CALLBACK (test_worker_start), NULL);
  g_signal_connect (worker0, "end-worker", G_CALLBACK (test_worker_end), NULL);

  g_thread_new ("test-pulse", (GThreadFunc) test_worker_pulse, worker0);

  gst_worker_start (worker0);

  g_main_loop_run (mainloop);

  g_mutex_clear (&trans_lock);

  INFO ("end");
  return 0;
}
Exemple #27
0
gboolean
kiro_sb_clone (KiroSb *self, const gchar* address, const gchar* port)
{
    g_return_val_if_fail (self != NULL, FALSE);

    KiroSbPrivate *priv = KIRO_SB_GET_PRIVATE (self);
    g_return_val_if_fail (priv->initialized == 0, FALSE);

    g_return_val_if_fail ((priv->trb = kiro_trb_new ()), FALSE);

    priv->client = kiro_client_new ();
    if (0 > kiro_client_connect (priv->client, address, port)) {
        g_debug ("Failed to connect to remote Sync Buffer");
        kiro_trb_free (priv->trb);
        kiro_client_free (priv->client);
        return FALSE;
    }

    kiro_client_sync (priv->client);
    kiro_trb_adopt (priv->trb, kiro_client_get_memory (priv->client));

    priv->main_loop = g_main_loop_new (NULL, FALSE);
    g_idle_add ((GSourceFunc)idle_func, priv);
    priv->main_thread = g_thread_new ("KIRO SB Main Loop", (GThreadFunc)start_main_loop, priv->main_loop);

    priv->initialized = 2;
    return TRUE;
}
Exemple #28
0
static GtkWidget* create_viewer()
{
    GtkWidget *viewer;
    GtkWidget *hpanel;
    GtkWidget *canvas;
    GThread   *worker;

    // canvas to draw framebuffer
    canvas = gtk_drawing_area_new();
    g_signal_connect(canvas, "expose-event", G_CALLBACK(on_canvas_expose), NULL);

    // root container
    hpanel = gtk_hbox_new(FALSE, 0);
    gtk_box_pack_start(GTK_BOX(hpanel), canvas, TRUE, TRUE, 0);

    // window
    viewer = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_container_add(GTK_CONTAINER(viewer), hpanel);
    gtk_window_set_default_size(GTK_WINDOW(viewer), 640, 480);
    gtk_window_set_title(GTK_WINDOW(viewer), "Framebuffer Viewer");
    g_signal_connect(viewer, "delete-event", G_CALLBACK(on_window_destroy), &worker);

    // paint thread worker
    running = 1;
    worker = g_thread_new("Painter", (GThreadFunc) thread_queue_draw_framebuffer, canvas);

    return viewer;
}
static struct httpc* _httpc_new()
{
	gint err;
	gchar sid[33];
	GString *buff = qev_buffer_get();
	struct httpc *hc = g_slice_alloc0(sizeof(*hc));

	_uuid(sid);

	hc->polling = test_socket();
	hc->waiting = test_socket();
	hc->aq = g_async_queue_new();
	hc->sid = g_strdup(sid);
	hc->th_run = TRUE;
	g_mutex_init(&hc->lock);

	hc->th = g_thread_new("httpc", _httpc_thread, hc);

	g_string_printf(buff, INIT_HEADERS, hc->sid);
	err = send(hc->polling, buff->str, buff->len, 0);
	ck_assert_int_eq(err, buff->len);

	qev_buffer_put(buff);

	_next(hc, "/qio/callback/1:0={\"code\":200,\"data\":\"localhost\"}");

	return hc;
}
int main(int ac, char **av)
{
	ThreadData td;
	td.argc = ac;
	td.argv = av;
	td.testResult = 0;

	DEBUG_CONF("ut_cangenplugin",
#ifdef _DEBUG
		  CUtil::Logger::file_on|CUtil::Logger::screen_on,
#else
		  CUtil::Logger::file_on|CUtil::Logger::screen_off,
#endif
		  CUtil::Logger::EInfo, CUtil::Logger::EWarning);

	td.mainLoop = g_main_loop_new(NULL, FALSE);

	// Run the mainloop and the tests thread
	GThread* testThread = g_thread_new("tests thread", &tests_thread, &td);

	g_main_loop_run(td.mainLoop);
	g_thread_join(testThread);

	g_main_loop_unref(td.mainLoop);


	return td.testResult;
}