static void gimp_layer_prop_undo_pop (GimpUndo *undo, GimpUndoMode undo_mode, GimpUndoAccumulator *accum) { GimpLayerPropUndo *layer_prop_undo = GIMP_LAYER_PROP_UNDO (undo); GimpLayer *layer = GIMP_LAYER (GIMP_ITEM_UNDO (undo)->item); GIMP_UNDO_CLASS (parent_class)->pop (undo, undo_mode, accum); switch (undo->undo_type) { case GIMP_UNDO_LAYER_REPOSITION: { gint position; position = gimp_image_get_layer_index (undo->image, layer); gimp_image_position_layer (undo->image, layer, layer_prop_undo->position, FALSE, NULL); layer_prop_undo->position = position; } break; case GIMP_UNDO_LAYER_MODE: { GimpLayerModeEffects mode; mode = gimp_layer_get_mode (layer); gimp_layer_set_mode (layer, layer_prop_undo->mode, FALSE); layer_prop_undo->mode = mode; } break; case GIMP_UNDO_LAYER_OPACITY: { gdouble opacity; opacity = gimp_layer_get_opacity (layer); gimp_layer_set_opacity (layer, layer_prop_undo->opacity, FALSE); layer_prop_undo->opacity = opacity; } break; case GIMP_UNDO_LAYER_LOCK_ALPHA: { gboolean lock_alpha; lock_alpha = gimp_layer_get_lock_alpha (layer); gimp_layer_set_lock_alpha (layer, layer_prop_undo->lock_alpha, FALSE); layer_prop_undo->lock_alpha = lock_alpha; } break; default: g_assert_not_reached (); } }
/** * gimp_text_layer_from_layer: * @layer: a #GimpLayer object * @text: a #GimpText object * * Converts a standard #GimpLayer and a #GimpText object into a * #GimpTextLayer. The new text layer takes ownership of the @text and * @layer objects. The @layer object is rendered unusable by this * function. Don't even try to use if afterwards! * * This is a gross hack that is needed in order to load text layers * from XCF files in a backwards-compatible way. Please don't use it * for anything else! * * Return value: a newly allocated #GimpTextLayer object **/ static GimpLayer * gimp_text_layer_from_layer (GimpLayer *layer, GimpText *text) { GimpTextLayer *text_layer; GimpDrawable *drawable; g_return_val_if_fail (GIMP_IS_LAYER (layer), NULL); g_return_val_if_fail (GIMP_IS_TEXT (text), NULL); text_layer = g_object_new (GIMP_TYPE_TEXT_LAYER, "image", gimp_item_get_image (GIMP_ITEM (layer)), NULL); gimp_item_replace_item (GIMP_ITEM (text_layer), GIMP_ITEM (layer)); drawable = GIMP_DRAWABLE (text_layer); gimp_drawable_steal_buffer (drawable, GIMP_DRAWABLE (layer)); gimp_layer_set_opacity (GIMP_LAYER (text_layer), gimp_layer_get_opacity (layer), FALSE); gimp_layer_set_mode (GIMP_LAYER (text_layer), gimp_layer_get_mode (layer), FALSE); gimp_layer_set_blend_space (GIMP_LAYER (text_layer), gimp_layer_get_blend_space (layer), FALSE); gimp_layer_set_composite_space (GIMP_LAYER (text_layer), gimp_layer_get_composite_space (layer), FALSE); gimp_layer_set_composite_mode (GIMP_LAYER (text_layer), gimp_layer_get_composite_mode (layer), FALSE); gimp_layer_set_lock_alpha (GIMP_LAYER (text_layer), gimp_layer_get_lock_alpha (layer), FALSE); gimp_text_layer_set_text (text_layer, text); g_object_unref (text); g_object_unref (layer); return GIMP_LAYER (text_layer); }
void * jpeg_highlighter_algorithm(JOB_ARG *job) { GimpRunMode mode = GIMP_RUN_NONINTERACTIVE; int num_return_vals; gint32 layer, temp_layer; char temp_file_name[256]; int ii; printf("inside %s thread %d\n", jpeg_plugin.name, job->thread); // i really only want to run this once and the plugin doesnt know how many threads will get kicked off because its dynamic if(job->thread == 0) { sleep(1); sprintf(temp_file_name,"%stemp.jpg",job->file_name); // mkstemp(file_name); printf("using filename %s\n", temp_file_name); printf("saving jpeg at %f compression\n", jpeg_compress); gimp_progress_set_text("waiting for jpeg save\n"); gimp_run_procedure("file-jpeg-save",&num_return_vals, GIMP_PDB_INT32, mode, GIMP_PDB_IMAGE, job->image_id , GIMP_PDB_DRAWABLE, job->drawable->drawable_id, GIMP_PDB_STRING, temp_file_name, GIMP_PDB_STRING, "temp", GIMP_PDB_FLOAT, jpeg_compress, GIMP_PDB_FLOAT, 0.0, GIMP_PDB_INT32, 0, GIMP_PDB_INT32, 0, GIMP_PDB_STRING,"created with Koi", GIMP_PDB_INT32, 0, GIMP_PDB_INT32, 1, GIMP_PDB_INT32, 0, GIMP_PDB_INT32, 1, GIMP_PDB_END); // for(ii = 0; ii < SLEEP_TIME; ii++) // { // job->progress = ((float)ii/SLEEP_TIME) * 4; sleep(1); // } printf("saved jpeg\n"); // sleep(1); // reload our saved image and suck a layer off of it to subtract against or original image temp_layer = gimp_file_load_layer(mode, job->image_id, temp_file_name); printf("loaded new layer %d in image %d\n", temp_layer, job->image_id); //gimp_layer_add_alpha(temp_layer); gimp_layer_set_mode(temp_layer, 8); printf("set layer mode %d\n", temp_layer); /* Add the new layer to this image as the top layer */ if (gimp_image_add_layer(job->image_id, temp_layer, -1) != TRUE) { printf("failed to create layer\n"); return; } printf("set layer as top\n"); layer = gimp_image_get_active_layer(job->image_id); if (layer == -1) { printf("failed to get active layer\n"); return; } gimp_image_merge_down(job->image_id, layer, 2); printf("merged layers\n"); job->drawable->drawable_id = gimp_image_get_active_drawable(job->image_id); // printf("get active drawable\n"); // gimp_brightness_contrast(job->drawable->drawable_id, 126, 125); // printf("adjust contrast\n"); // // printf("Jpeg threshold: %d\n",jpeg_threshold); // // //I should have this subtract against an edge detection layer and then threshold it // // gimp_threshold(job->drawable->drawable_id, jpeg_threshold,255 ); // printf("threshold\n"); // if(! gimp_drawable_has_alpha (job->drawable->drawable_id)) // { // /* some filtermacros do not work with layer that do not have an alpha channel // * and cause gimp to fail on attempt to call gimp_pixel_rgn_init // * with both dirty and shadow flag set to TRUE // * in this situation GIMP displays the error message // * "expected tile ack and received: 5" // * and causes the called plug-in to exit immediate without success // * Therfore always add an alpha channel before calling a filtermacro. // */ // gimp_layer_add_alpha(layer); // printf("adding alpha channel\n"); // } remove(temp_file_name); sleep(1); // job->progress = 4; pthread_cond_broadcast(&jpeg_cond); pthread_mutex_lock(&jpeg_mutex); printf("got lock\n"); jpeg_wait = 0; pthread_mutex_unlock(&jpeg_mutex); printf("drawable ID after jpeg %d\n",gimp_image_get_active_drawable(job->image_id)); } else { printf("thread %d waiting\n", job->thread); pthread_mutex_lock(&jpeg_mutex); while (jpeg_wait) { pthread_cond_wait(&jpeg_cond, &jpeg_mutex); } pthread_mutex_unlock(&jpeg_mutex); } job->progress = 1; return NULL; }
static void gimp_warp_tool_animate (GimpWarpTool *wt) { GimpTool *tool = GIMP_TOOL (wt); GimpWarpOptions *options = GIMP_WARP_TOOL_GET_OPTIONS (wt); GimpImage *orig_image; GimpImage *image; GimpLayer *layer; GimpLayer *first_layer; GeglNode *scale_node; GimpProgress *progress; GtkWidget *widget; gint i; if (! gimp_warp_tool_get_undo_desc (tool, tool->display)) { gimp_tool_message_literal (tool, tool->display, _("Please add some warp strokes first.")); return; } /* get rid of the image map so we can use wt->graph */ if (wt->image_map) { gimp_image_map_abort (wt->image_map); g_object_unref (wt->image_map); wt->image_map = NULL; } gimp_progress_start (GIMP_PROGRESS (tool), FALSE, _("Rendering Frame %d"), 1); orig_image = gimp_item_get_image (GIMP_ITEM (tool->drawable)); image = gimp_create_image (orig_image->gimp, gimp_item_get_width (GIMP_ITEM (tool->drawable)), gimp_item_get_height (GIMP_ITEM (tool->drawable)), gimp_drawable_get_base_type (tool->drawable), gimp_drawable_get_precision (tool->drawable), TRUE); /* the first frame is always the unwarped image */ layer = GIMP_LAYER (gimp_item_convert (GIMP_ITEM (tool->drawable), image, GIMP_TYPE_LAYER)); gimp_object_take_name (GIMP_OBJECT (layer), g_strdup_printf (_("Frame %d"), 1)); gimp_item_set_offset (GIMP_ITEM (layer), 0, 0); gimp_item_set_visible (GIMP_ITEM (layer), TRUE, FALSE); gimp_layer_set_mode (layer, GIMP_NORMAL_MODE, FALSE); gimp_layer_set_opacity (layer, GIMP_OPACITY_OPAQUE, FALSE); gimp_image_add_layer (image, layer, NULL, 0, FALSE); first_layer = layer; scale_node = gegl_node_new_child (NULL, "operation", "gimp:scalar-multiply", "n-components", 2, NULL); gimp_warp_tool_add_op (wt, scale_node); progress = gimp_sub_progress_new (GIMP_PROGRESS (tool)); for (i = 1; i < options->n_animation_frames; i++) { gimp_progress_set_text (GIMP_PROGRESS (tool), _("Rendering Frame %d"), i + 1); gimp_sub_progress_set_step (GIMP_SUB_PROGRESS (progress), i, options->n_animation_frames); layer = GIMP_LAYER (gimp_item_duplicate (GIMP_ITEM (first_layer), GIMP_TYPE_LAYER)); gimp_object_take_name (GIMP_OBJECT (layer), g_strdup_printf (_("Frame %d"), i + 1)); gegl_node_set (scale_node, "factor", (gdouble) i / (gdouble) (options->n_animation_frames - 1), NULL); gimp_gegl_apply_operation (gimp_drawable_get_buffer (GIMP_DRAWABLE (first_layer)), progress, _("Frame"), wt->graph, gimp_drawable_get_buffer (GIMP_DRAWABLE (layer)), NULL); gimp_image_add_layer (image, layer, NULL, 0, FALSE); } g_object_unref (progress); gimp_warp_tool_remove_op (wt, scale_node); gimp_progress_end (GIMP_PROGRESS (tool)); /* recreate the image map */ gimp_warp_tool_create_image_map (wt, tool->drawable); gimp_image_map_apply (wt->image_map, NULL); widget = GTK_WIDGET (gimp_display_get_shell (tool->display)); gimp_create_display (orig_image->gimp, image, GIMP_UNIT_PIXEL, 1.0, G_OBJECT (gtk_widget_get_screen (widget)), gimp_widget_get_monitor (widget)); g_object_unref (image); }
static void preview_diffuse_only(gint32 image_ID) { gint32 noiselayer_ID = -1; gint32 drawable_ID = -1; gint32 drawableDiffuse_ID = -1; gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.0); gtk_label_set_text(GTK_LABEL(progress_label), "Begin"); drawableBeginActiveLayer = gimp_image_get_active_layer(image_ID); drawable_ID = gimp_layer_copy (drawableBeginActiveLayer); gimp_image_add_layer(image_ID, drawable_ID, -1); gimp_image_set_active_layer(image_ID, drawable_ID); /** Here I should hide previous active layer, make not visible. */ gimp_drawable_set_visible(drawableBeginActiveLayer, FALSE); /** * For preview do nothing here. * if(local_vals.Resizie) * { * } */ if (local_vals.Noise) { /** Already have active layer in drawable_ID. */ noiselayer_ID = gimp_layer_copy (drawable_ID); gimp_image_add_layer(image_ID, noiselayer_ID, -1); gimp_image_set_active_layer(image_ID, noiselayer_ID); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.03); gtk_label_set_text(GTK_LABEL(progress_label), "Noise"); /** * Filter "RGB Noise" applied * Standard plug-in. Source code ships with GIMP. * * Add the "f" here to signify float in c language. */ if (plug_in_rgb_noise_connector(image_ID, noiselayer_ID, 1, 1, 0.20f, 0.20f, 0.20f, 0.0f) != 1) return; gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.04); gimp_layer_set_mode(noiselayer_ID, GIMP_VALUE_MODE); gimp_image_merge_down(image_ID, noiselayer_ID, 0); gtk_label_set_text(GTK_LABEL(gwNormalLabel), "Noise affects every redraw!"); } else { gtk_label_set_text(GTK_LABEL(gwNormalLabel), ""); gtk_label_set_text(GTK_LABEL(progress_label), "Noise added"); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.04); } if(local_vals.RemoveLighting) { gtk_label_set_text(GTK_LABEL(progress_label), "Remove Shading"); removeShadingPreview(image_ID, local_vals.Noise); /** * See notes inside of removeShadingPreview * for explanation of next line. */ /** * If Noise is on, then noiselayer_ID was merged down into drawable_ID. * You cannot remove drawable_ID in this case, as it is the only * layer left! * * However, if Noise is Yes and RemoveLighting is Yes, * Then there is an extra layer floating around! * Delete noiselayer_ID? I thought it was merged! * No, I was right noiselayer_ID is already gone! */ gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.05); } else { gtk_label_set_text(GTK_LABEL(progress_label), "Stretch"); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.05); } drawableDiffuse_ID = gimp_image_get_active_layer(image_ID); gimp_levels_stretch(drawableDiffuse_ID); if(local_vals.Tile) { gtk_label_set_text(GTK_LABEL(progress_label), "Making Seamless"); /** * Filter "Tile Seamless" applied * Standard plug-in. Source code ships with GIMP. */ if (plug_in_make_seamless_connector(image_ID, drawableDiffuse_ID) != 1) return; gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.07); } else { gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.07); } /** Here I should un hide previously hidden layer, make visible. */ pDrawables.drawable_d = gimp_drawable_get(drawableDiffuse_ID); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.1); }