static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { GimpDrawable *drawable; GimpRunMode run_mode; GimpPDBStatusType status = GIMP_PDB_SUCCESS; /* assume the best! */ static GimpParam values[1]; INIT_I18N (); /* * Get the specified drawable, do standard initialization. */ if (strcmp (name, PLUG_IN_PROC[0]) == 0) rndm_type = RNDM_HURL; else if (strcmp (name, PLUG_IN_PROC[1]) == 0) rndm_type = RNDM_PICK; else if (strcmp (name, PLUG_IN_PROC[2]) == 0) rndm_type = RNDM_SLUR; run_mode = param[0].data.d_int32; drawable = gimp_drawable_get(param[2].data.d_drawable); *nreturn_vals = 1; *return_vals = values; values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; gr = g_rand_new (); /* * Make sure the drawable type is appropriate. */ if (gimp_drawable_is_rgb (drawable->drawable_id) || gimp_drawable_is_gray (drawable->drawable_id) || gimp_drawable_is_indexed (drawable->drawable_id)) { gimp_tile_cache_ntiles (2 * drawable->ntile_cols); switch (run_mode) { /* * If we're running interactively, pop up the dialog box. */ case GIMP_RUN_INTERACTIVE: gimp_get_data (PLUG_IN_PROC[rndm_type - 1], &pivals); if (! randomize_dialog (drawable)) /* return on Cancel */ return; break; /* * If we're not interactive (probably scripting), we * get the parameters from the param[] array, since * we don't use the dialog box. Make sure they all * parameters have legitimate values. */ case GIMP_RUN_NONINTERACTIVE: if (nparams != 7) { status = GIMP_PDB_CALLING_ERROR; } else { pivals.rndm_pct = (gdouble) param[3].data.d_float; pivals.rndm_rcount = (gdouble) param[4].data.d_float; pivals.randomize = (gboolean) param[5].data.d_int32; pivals.seed = (gint) param[6].data.d_int32; if (pivals.randomize) pivals.seed = g_random_int (); if ((rndm_type != RNDM_PICK && rndm_type != RNDM_SLUR && rndm_type != RNDM_HURL) || (pivals.rndm_pct < 1.0 || pivals.rndm_pct > 100.0) || (pivals.rndm_rcount < 1.0 || pivals.rndm_rcount > 100.0)) { status = GIMP_PDB_CALLING_ERROR; } } break; /* * If we're running with the last set of values, get those values. */ case GIMP_RUN_WITH_LAST_VALS: gimp_get_data (PLUG_IN_PROC[rndm_type - 1], &pivals); if (pivals.randomize) pivals.seed = g_random_int (); break; /* * Hopefully we never get here! */ default: break; } if (status == GIMP_PDB_SUCCESS) { gimp_progress_init_printf ("%s", gettext (RNDM_NAME[rndm_type - 1])); /* * Initialize the g_rand() function seed */ g_rand_set_seed (gr, pivals.seed); randomize (drawable, NULL); /* * If we ran interactively (even repeating) update the display. */ if (run_mode != GIMP_RUN_NONINTERACTIVE) { gimp_displays_flush (); } /* * If we use the dialog popup, set the data for future use. */ if (run_mode == GIMP_RUN_INTERACTIVE) { gimp_set_data (PLUG_IN_PROC[rndm_type - 1], &pivals, sizeof (RandomizeVals)); } } } else { /* * If we got the wrong drawable type, we need to complain. */ status = GIMP_PDB_EXECUTION_ERROR; } /* * DONE! * Set the status where GIMP can see it, and let go * of the drawable. */ g_rand_free (gr); values[0].data.d_status = status; gimp_drawable_detach(drawable); }
/* ibus stress test Send random key press and release event message to ibus-daemon. Key kind are a-z and space. Check ibus-daemon and ibus engine crash. */ gint main (gint argc, gchar **argv) { GTimer *timer; GRand *rnd; BusTestClient *client; /* num of send space key */ guint32 seed = (guint32) time (NULL); int count = 0; int send_key_num = 0; setlocale (LC_ALL, ""); gtk_set_locale (); gtk_init (&argc, &argv); /* need to set active engine */ client = bus_test_client_new (); if (client == NULL) { g_printerr ("don't create test-client instance."); exit(1); } timer = g_timer_new (); rnd = g_rand_new (); g_rand_set_seed (rnd, seed); g_print("random seed:%u\n",seed); g_timer_start (timer); while (1) { guint keysym; if (send_key_num > MAX_SEND_KEY_NUM) { break; } if (!bus_test_client_is_connected (client)) { g_printerr ("ibus-daemon is disconnected\n"); break; } if (!bus_test_client_is_enabled (client)) { g_printerr ("ibus engine is enabled\n"); break; } if(count>0 || g_rand_int_range (rnd, 0, 5) == 0) { /* send space key 20% */ if (count == 0) { count = g_rand_int_range (rnd, 0, MAX_RANDOM_SPACE) + 1; } if (count-- == 1) { keysym = IBUS_KEY_Return; } else { keysym = IBUS_KEY_space; } } else { /* send random a-z key */ keysym = g_rand_int_range (rnd, 0, 'z'-'a'+1) + 'a'; } bus_test_client_send_key (client, keysym); send_key_num += 1; /* limit the typing rate to 800 hits/minutes */ _sleep (1000 * 60 / 800); } g_print ("%f sec\n", g_timer_elapsed (timer, NULL)); return 0; }
gint main (gint argc, gchar **argv) { GOptionContext *context; xmlParserCtxtPtr parser; xmlDocPtr doc; YelpTransform *transform; gchar **params; const gchar *stylesheet; gchar *file; context = g_option_context_new ("[STYLESHEET] FILE"); g_option_context_add_main_entries (context, options, NULL); g_option_context_parse (context, &argc, &argv, NULL); if (files == NULL || files[0] == NULL) { g_printerr ("Usage: test-transform [OPTION...] [STYLESHEET] FILE\n"); return 1; } if (files[1] == NULL) { stylesheet = DATADIR"/yelp/xslt/db2html.xsl"; file = files[0]; } else { stylesheet = files[0]; file = files[1]; } params = g_new0 (gchar *, 7); params[0] = g_strdup ("db.chunk.extension"); params[1] = g_strdup ("\"\""); params[2] = g_strdup ("db.chunk.info_basename"); params[3] = g_strdup ("\"x-yelp-titlepage\""); params[4] = g_strdup ("db.chunk.max_depth"); params[5] = g_strdup ("2"); params[6] = NULL; transform = yelp_transform_new (stylesheet); g_object_weak_ref ((GObject *) transform, transform_destroyed, NULL); g_signal_connect (transform, "chunk-ready", (GCallback) transform_chunk, NULL); g_signal_connect (transform, "finished", (GCallback) transform_finished, NULL); g_signal_connect (transform, "error", (GCallback) transform_error, NULL); parser = xmlNewParserCtxt (); doc = xmlCtxtReadFile (parser, file, NULL, XML_PARSE_DTDLOAD | XML_PARSE_NOCDATA | XML_PARSE_NOENT | XML_PARSE_NONET ); xmlFreeParserCtxt (parser); xmlXIncludeProcessFlags (doc, XML_PARSE_DTDLOAD | XML_PARSE_NOCDATA | XML_PARSE_NOENT | XML_PARSE_NONET ); if (!yelp_transform_start (transform, doc, NULL, (const gchar **) params)) return 1; if (random_timeout) { GRand *rand = g_rand_new (); timeout = g_rand_int_range (rand, 80, 280); g_rand_free (rand); } if (timeout >= 0) g_timeout_add (timeout, (GSourceFunc) transform_release, transform); loop = g_main_loop_new (NULL, FALSE); g_main_loop_run (loop); return 0; }
static void run (const gchar *name, gint nparams, const GimpParam *param, gint *nreturn_vals, GimpParam **return_vals) { static GimpParam values[1]; gint sel_x1, sel_y1, sel_x2, sel_y2; gint img_height, img_width, img_bpp, img_has_alpha; GimpDrawable *drawable; GimpRunMode run_mode; GimpPDBStatusType status; *nreturn_vals = 1; *return_vals = values; status = GIMP_PDB_SUCCESS; if (param[0].type != GIMP_PDB_INT32) status = GIMP_PDB_CALLING_ERROR; run_mode = param[0].data.d_int32; INIT_I18N (); if (param[2].type != GIMP_PDB_DRAWABLE) status = GIMP_PDB_CALLING_ERROR; drawable = gimp_drawable_get (param[2].data.d_drawable); img_width = gimp_drawable_width (drawable->drawable_id); img_height = gimp_drawable_height (drawable->drawable_id); img_bpp = gimp_drawable_bpp (drawable->drawable_id); img_has_alpha = gimp_drawable_has_alpha (drawable->drawable_id); gimp_drawable_mask_bounds (drawable->drawable_id, &sel_x1, &sel_y1, &sel_x2, &sel_y2); if (!gimp_drawable_is_rgb (drawable->drawable_id)) status = GIMP_PDB_CALLING_ERROR; if (status == GIMP_PDB_SUCCESS) { gr = g_rand_new (); memset (&qbist_info, 0, sizeof (qbist_info)); create_info (&qbist_info.info); qbist_info.oversampling = 4; switch (run_mode) { case GIMP_RUN_INTERACTIVE: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &qbist_info); /* Get information from the dialog */ if (dialog_run ()) { status = GIMP_PDB_SUCCESS; gimp_set_data (PLUG_IN_PROC, &qbist_info, sizeof (QbistInfo)); } else status = GIMP_PDB_EXECUTION_ERROR; break; case GIMP_RUN_NONINTERACTIVE: status = GIMP_PDB_CALLING_ERROR; break; case GIMP_RUN_WITH_LAST_VALS: /* Possibly retrieve data */ gimp_get_data (PLUG_IN_PROC, &qbist_info); status = GIMP_PDB_SUCCESS; break; default: status = GIMP_PDB_CALLING_ERROR; break; } if (status == GIMP_PDB_SUCCESS) { GimpPixelRgn imagePR; gpointer pr; gimp_tile_cache_ntiles ((drawable->width + gimp_tile_width () - 1) / gimp_tile_width ()); gimp_pixel_rgn_init (&imagePR, drawable, 0, 0, img_width, img_height, TRUE, TRUE); optimize (&qbist_info.info); gimp_progress_init (_("Qbist")); for (pr = gimp_pixel_rgns_register (1, &imagePR); pr != NULL; pr = gimp_pixel_rgns_process (pr)) { gint row; for (row = 0; row < imagePR.h; row++) { qbist (&qbist_info.info, imagePR.data + row * imagePR.rowstride, imagePR.x, imagePR.y + row, imagePR.w, sel_x2 - sel_x1, sel_y2 - sel_y1, imagePR.bpp, qbist_info.oversampling); } gimp_progress_update ((gfloat) (imagePR.y - sel_y1) / (gfloat) (sel_y2 - sel_y1)); } gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); gimp_drawable_update (drawable->drawable_id, sel_x1, sel_y1, (sel_x2 - sel_x1), (sel_y2 - sel_y1)); gimp_displays_flush (); } g_rand_free (gr); } values[0].type = GIMP_PDB_STATUS; values[0].data.d_status = status; gimp_drawable_detach (drawable); }