/* --------------------------------- * gap_colordiff_GimpRGB * --------------------------------- * returns difference of 2 colors as gdouble value * in range 0.0 (exact match) to 1.0 (maximal difference) * Note: * this procedure uses the same HSV colormodel based * Algorithm as the HSV specific procedures. */ gdouble gap_colordiff_GimpRGB(GimpRGB *aRgbPtr , GimpRGB *bRgbPtr , gdouble colorSensitivity , gboolean debugPrint) { GimpHSV aHsv; GimpHSV bHsv; gdouble colordiff; gimp_rgb_to_hsv(aRgbPtr, &aHsv); gimp_rgb_to_hsv(bRgbPtr, &bHsv); colordiff = gap_colordiff_GimpHSV(&aHsv, &bHsv, colorSensitivity, debugPrint); if(debugPrint) { printf("RGB 1/2 (%.3g %.3g %.3g) / (%.3g %.3g %.3g) colordiff:%f\n" , aRgbPtr->r , aRgbPtr->g , aRgbPtr->b , bRgbPtr->r , bRgbPtr->g , bRgbPtr->b , colordiff ); } return (colordiff); } /* end gap_colordiff_GimpRGB */
static void add_pigment (ColorselWater *water, gboolean erase, gdouble x, gdouble y, gdouble much) { GimpColorSelector *selector = GIMP_COLOR_SELECTOR (water); much *= (gdouble) water->pressure_adjust; if (erase) { selector->rgb.r = 1.0 - (1.0 - selector->rgb.r) * (1.0 - much); selector->rgb.g = 1.0 - (1.0 - selector->rgb.g) * (1.0 - much); selector->rgb.b = 1.0 - (1.0 - selector->rgb.b) * (1.0 - much); } else { gdouble r = calc (x, y, 0) / 256.0; gdouble g = calc (x, y, 120) / 256.0; gdouble b = calc (x, y, 240) / 256.0; selector->rgb.r *= (1.0 - (1.0 - r) * much); selector->rgb.g *= (1.0 - (1.0 - g) * much); selector->rgb.b *= (1.0 - (1.0 - b) * much); } gimp_rgb_clamp (&selector->rgb); gimp_rgb_to_hsv (&selector->rgb, &selector->hsv); gimp_color_selector_color_changed (selector); }
static WidgetInfo * create_color_scale (void) { GtkWidget *vbox; GtkWidget *scale; GtkWidget *align; GimpRGB rgb; GimpHSV hsv; color_init (&rgb); gimp_rgb_to_hsv (&rgb, &hsv); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); align = gtk_alignment_new (0.5, 0.5, 0.8, 0.0); scale = gimp_color_scale_new (GTK_ORIENTATION_HORIZONTAL, GIMP_COLOR_SELECTOR_HUE); gimp_color_scale_set_color (GIMP_COLOR_SCALE (scale), &rgb, &hsv); gtk_range_set_value (GTK_RANGE (scale), 40); gtk_container_add (GTK_CONTAINER (align), scale); gtk_box_pack_start (GTK_BOX (vbox), align, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new ("Color Scale"), FALSE, FALSE, 0); return new_widget_info ("gimp-widget-color-scale", vbox, SMALL); }
static VALUE rb_gimp_rgb_to_hsv (VALUE self, VALUE rgb) { GimpHSV hsv; gimp_rgb_to_hsv(rb2GimpRGBPtr(rgb), &hsv); return GimpHSV2rb(&hsv); }
static void colorsel_cmyk_adj_update (GtkAdjustment *adj, ColorselCmyk *module) { GimpColorSelector *selector = GIMP_COLOR_SELECTOR (module); gint i; gdouble value; for (i = 0; i < 4; i++) if (module->adj[i] == adj) break; value = gtk_adjustment_get_value (adj) / 100.0; switch (i) { case 0: module->cmyk.c = value; break; case 1: module->cmyk.m = value; break; case 2: module->cmyk.y = value; break; case 3: module->cmyk.k = value; break; default: return; } if (module->cmyk2rgb) { gdouble cmyk_values[4]; gdouble rgb_values[3]; cmyk_values[0] = module->cmyk.c * 100.0; cmyk_values[1] = module->cmyk.m * 100.0; cmyk_values[2] = module->cmyk.y * 100.0; cmyk_values[3] = module->cmyk.k * 100.0; cmsDoTransform (module->cmyk2rgb, cmyk_values, rgb_values, 1); selector->rgb.r = rgb_values[0]; selector->rgb.g = rgb_values[1]; selector->rgb.b = rgb_values[2]; } else { gimp_cmyk_to_rgb (&module->cmyk, &selector->rgb); } gimp_rgb_to_hsv (&selector->rgb, &selector->hsv); gimp_color_selector_color_changed (selector); }
static void gimp_color_selection_new_color_changed (GtkWidget *widget, GimpColorSelection *selection) { gimp_color_area_get_color (GIMP_COLOR_AREA (widget), &selection->rgb); gimp_rgb_to_hsv (&selection->rgb, &selection->hsv); gimp_color_selection_update (selection, UPDATE_NOTEBOOK | UPDATE_SCALES | UPDATE_ENTRY); gimp_color_selection_color_changed (selection); }
static void gimp_color_selector_palette_entry_clicked (GimpPaletteView *view, GimpPaletteEntry *entry, GdkModifierType state, GimpColorSelector *selector) { selector->rgb = entry->color; gimp_rgb_to_hsv (&selector->rgb, &selector->hsv); gimp_color_selector_color_changed (selector); }
static void gimp_color_selection_entry_changed (GimpColorHexEntry *entry, GimpColorSelection *selection) { gimp_color_hex_entry_get_color (entry, &selection->rgb); gimp_rgb_to_hsv (&selection->rgb, &selection->hsv); gimp_color_selection_update (selection, UPDATE_NOTEBOOK | UPDATE_SCALES | UPDATE_COLOR); gimp_color_selection_color_changed (selection); }
/* --------------------------------- * gap_colordiff_hvmax_guchar * --------------------------------- * returns difference of 2 colors as gdouble value * in range 0.0 (exact match) to 1.0 (maximal difference) * Note: * this procedure uses an HSV colormodel based * Algorithm and calculates difference as max HSV difference. * * DEPRECATED * */ gdouble gap_colordiff_hvmax_guchar(guchar *aPixelPtr , guchar *bPixelPtr , gboolean debugPrint ) { GimpRGB aRgb; GimpRGB bRgb; GimpHSV aHsv; GimpHSV bHsv; gimp_rgba_set_uchar (&aRgb, aPixelPtr[0], aPixelPtr[1], aPixelPtr[2], 255); gimp_rgba_set_uchar (&bRgb, bPixelPtr[0], bPixelPtr[1], bPixelPtr[2], 255); gimp_rgb_to_hsv(&aRgb, &aHsv); gimp_rgb_to_hsv(&bRgb, &bHsv); return (gap_colordiff_hvmax_GimpHSV(&aHsv , &bHsv , debugPrint )); } /* end gap_colordiff_hvmax_guchar */
/** * gimp_color_selection_set_color: * @selection: A #GimpColorSelection widget. * @color: The @color to set as current color. * * Sets the #GimpColorSelection's current color to the new @color. **/ void gimp_color_selection_set_color (GimpColorSelection *selection, const GimpRGB *color) { g_return_if_fail (GIMP_IS_COLOR_SELECTION (selection)); g_return_if_fail (color != NULL); selection->rgb = *color; gimp_rgb_to_hsv (&selection->rgb, &selection->hsv); gimp_color_selection_update (selection, UPDATE_ALL); gimp_color_selection_color_changed (selection); }
static int l_get_hsv (lua_State * lua) { Priv *p; lua_Number x, y; lua_Number img_no = 0; lua_Number pixel[4]; lua_pushstring (lua, "priv"); lua_gettable (lua, LUA_REGISTRYINDEX); p = lua_touserdata (lua, -1); lua_pop(lua, 1); switch (lua_gettop (lua)) { case 3: img_no = lua_tonumber(lua, -3); break; case 2: img_no = 0; break; default: lua_pushstring (lua, "incorrect number of arguments to get_rgb ([image_no,] x, y)\n"); lua_error (lua); break; } x = lua_tonumber(lua, -2); y = lua_tonumber(lua, -1); get_rgba_pixel (p, img_no, x, y, pixel); #if 0 { GimpRGB rgb; GimpHSV hsv; rgb.r = pixel[0]; rgb.g = pixel[1]; rgb.b = pixel[2]; gimp_rgb_to_hsv (&rgb, &hsv); lua_pushnumber (lua, hsv.h ); lua_pushnumber (lua, hsv.s ); lua_pushnumber (lua, hsv.v ); } #endif return 3; }
static void gimp_color_selector_init (GimpColorSelector *selector) { selector->toggles_visible = TRUE; selector->toggles_sensitive = TRUE; selector->show_alpha = TRUE; gtk_orientable_set_orientation (GTK_ORIENTABLE (selector), GTK_ORIENTATION_VERTICAL); gimp_rgba_set (&selector->rgb, 0.0, 0.0, 0.0, 1.0); gimp_rgb_to_hsv (&selector->rgb, &selector->hsv); selector->channel = GIMP_COLOR_SELECTOR_HUE; }
/* --------------------------------- * gap_colordiff_guchar_GimpHSV * --------------------------------- * returns difference of 2 colors as gdouble value * in range 0.0 (exact match) to 1.0 (maximal difference) */ gdouble gap_colordiff_guchar_GimpHSV(GimpHSV *aHsvPtr , guchar *pixel , gdouble colorSensitivity , gboolean debugPrint) { GimpRGB bRgb; GimpHSV bHsv; gdouble colordiff; gimp_rgba_set_uchar (&bRgb, pixel[0], pixel[1], pixel[2], 255); gimp_rgb_to_hsv(&bRgb, &bHsv); colordiff = gap_colordiff_GimpHSV(aHsvPtr, &bHsv, colorSensitivity, debugPrint); return (colordiff); } /* end gap_colordiff_guchar_GimpHSV */
void context_background_value_cmd_callback (GtkAction *action, gint value, gpointer data) { GimpContext *context; GimpRGB color; GimpHSV hsv; return_if_no_context (context, data); gimp_context_get_background (context, &color); gimp_rgb_to_hsv (&color, &hsv); hsv.v = action_select_value ((GimpActionSelectType) value, hsv.v, 0.0, 1.0, 1.0, 0.01, 0.01, 0.1, 0.0, FALSE); gimp_hsv_to_rgb (&hsv, &color); gimp_context_set_background (context, &color); }
static gboolean gimp_operation_value_mode_process (GeglOperation *operation, void *in_buf, void *aux_buf, void *aux2_buf, void *out_buf, glong samples, const GeglRectangle *roi, gint level) { gdouble opacity = GIMP_OPERATION_POINT_LAYER_MODE (operation)->opacity; gfloat *in = in_buf; gfloat *layer = aux_buf; gfloat *mask = aux2_buf; gfloat *out = out_buf; const gboolean has_mask = mask != NULL; while (samples--) { GimpHSV layer_hsv, out_hsv; GimpRGB layer_rgb = {layer[0], layer[1], layer[2]}; GimpRGB out_rgb = {in[0], in[1], in[2]}; gfloat comp_alpha, new_alpha; comp_alpha = MIN (in[ALPHA], layer[ALPHA]) * opacity; if (has_mask) comp_alpha *= *mask; new_alpha = in[ALPHA] + (1.0 - in[ALPHA]) * comp_alpha; if (comp_alpha && new_alpha) { gint b; gfloat ratio = comp_alpha / new_alpha; gimp_rgb_to_hsv (&layer_rgb, &layer_hsv); gimp_rgb_to_hsv (&out_rgb, &out_hsv); out_hsv.v = layer_hsv.v; gimp_hsv_to_rgb (&out_hsv, &out_rgb); out[0] = out_rgb.r; out[1] = out_rgb.g; out[2] = out_rgb.b; for (b = RED; b < ALPHA; b++) { out[b] = out[b] * ratio + in[b] * (1.0 - ratio); } } else { gint b; for (b = RED; b < ALPHA; b++) { out[b] = in[b]; } } out[ALPHA] = in[ALPHA]; in += 4; layer += 4; out += 4; if (has_mask) mask++; } return TRUE; }
static void nova (GimpDrawable *drawable, GimpPreview *preview) { GimpPixelRgn src_rgn; GimpPixelRgn dest_rgn; gpointer pr; guchar *src_row, *dest_row, *save_src; guchar *src, *dest; gint x1, y1, x2, y2, x, y; gint row, col; gint alpha, bpp; gint progress, max_progress; gboolean has_alpha; gint xc, yc; /* center of nova */ gdouble u, v, l, w, w1, c, t; gdouble *spoke; gdouble nova_alpha, src_alpha, new_alpha = 0.0; gdouble compl_ratio, ratio; GimpRGB color; GimpRGB *spokecolor; GimpHSV hsv; gdouble spokecol; gint i; GRand *gr; guchar *cache = NULL; gint width, height; gdouble zoom = 0.0; gr = g_rand_new (); /* initialize */ has_alpha = gimp_drawable_has_alpha (drawable->drawable_id); spoke = g_new (gdouble, pvals.nspoke); spokecolor = g_new (GimpRGB, pvals.nspoke); gimp_rgb_set_alpha (&pvals.color, 1.0); gimp_rgb_to_hsv (&pvals.color, &hsv); for (i = 0; i < pvals.nspoke; i++) { spoke[i] = gauss (gr); hsv.h += ((gdouble) pvals.randomhue / 360.0) * g_rand_double_range (gr, -0.5, 0.5); if (hsv.h < 0) hsv.h += 1.0; else if (hsv.h >= 1.0) hsv.h -= 1.0; gimp_hsv_to_rgb (&hsv, spokecolor + i); } if (preview) { cache = gimp_zoom_preview_get_source (GIMP_ZOOM_PREVIEW (preview), &width, &height, &bpp); zoom = gimp_zoom_preview_get_factor (GIMP_ZOOM_PREVIEW (preview)); gimp_preview_transform (preview, pvals.xcenter, pvals.ycenter, &xc, &yc); x1 = 0; y1 = 0; x2 = width; y2 = height; } else { gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2); bpp = gimp_drawable_bpp (drawable->drawable_id); xc = pvals.xcenter; yc = pvals.ycenter; gimp_pixel_rgn_init (&src_rgn, drawable, x1, y1, x2-x1, y2-y1, FALSE, FALSE); gimp_pixel_rgn_init (&dest_rgn, drawable, x1, y1, x2-x1, y2-y1, TRUE, TRUE); } alpha = (has_alpha) ? bpp - 1 : bpp; /* Initialize progress */ progress = 0; max_progress = (x2 - x1) * (y2 - y1); if (preview) { save_src = src_row = g_new (guchar, y2 * width * bpp); memcpy (src_row, cache, y2 * width * bpp); dest_row = g_new (guchar, y2 * width * bpp); dest = dest_row; src = src_row; for (row = 0, y = 0; row < y2; row++, y++) { for (col = 0, x = 0; col < x2; col++, x++) { u = ((gdouble) (x - xc) / ((gdouble) pvals.radius * width / drawable->width * zoom)); v = ((gdouble) (y - yc) / ((gdouble) pvals.radius * height / drawable->height * zoom)); l = sqrt (SQR (u) + SQR (v)); /* This algorithm is still under construction. */ t = (atan2 (u, v) / (2 * G_PI) + .51) * pvals.nspoke; i = (gint) floor (t); t -= i; i %= pvals.nspoke; w1 = spoke[i] * (1 - t) + spoke[(i + 1) % pvals.nspoke] * t; w1 = w1 * w1; w = 1.0 / (l + 0.001) * 0.9; nova_alpha = CLAMP (w, 0.0, 1.0); if (has_alpha) { src_alpha = (gdouble) src[alpha] / 255.0; new_alpha = src_alpha + (1.0 - src_alpha) * nova_alpha; if (new_alpha != 0.0) ratio = nova_alpha / new_alpha; else ratio = 0.0; } else ratio = nova_alpha; compl_ratio = 1.0 - ratio; /* red or gray */ spokecol = (gdouble)spokecolor[i ].r * (1.0-t) + (gdouble)spokecolor[(i+1) % pvals.nspoke].r * t; if (w>1.0) color.r = CLAMP (spokecol * w, 0.0, 1.0); else color.r = src[0]/255.0 * compl_ratio + spokecol * ratio; c = CLAMP (w1 * w, 0.0, 1.0); color.r += c; dest[0] = CLAMP (color.r*255.0, 0, 255); if (bpp>2) { /* green */ spokecol = (gdouble)spokecolor[i ].g * (1.0-t) + (gdouble)spokecolor[(i+1) % pvals.nspoke].g * t; if (w>1.0) color.g = CLAMP (spokecol * w, 0.0, 1.0); else color.g = src[1]/255.0 * compl_ratio + spokecol * ratio; c = CLAMP (w1 * w, 0.0, 1.0); color.g += c; dest[1] = CLAMP (color.g*255.0, 0, 255); /* blue */ spokecol = (gdouble)spokecolor[i ].b * (1.0-t) + (gdouble)spokecolor[(i+1) % pvals.nspoke].b * t; if (w>1.0) color.b = CLAMP (spokecol * w, 0.0, 1.0); else color.b = src[2]/255.0 * compl_ratio + spokecol * ratio; c = CLAMP (w1 * w, 0.0, 1.0); color.b += c; dest[2] = CLAMP (color.b*255.0, 0, 255); } /* alpha */ if (has_alpha) dest[alpha] = new_alpha * 255.0; src += bpp; dest += bpp; } } gimp_preview_draw_buffer (preview, dest_row, bpp * width); g_free (cache); g_free (save_src); g_free (dest_row); } else { /* normal mode */ for (pr = gimp_pixel_rgns_register (2, &src_rgn, &dest_rgn); pr != NULL ; pr = gimp_pixel_rgns_process (pr)) { src_row = src_rgn.data; dest_row = dest_rgn.data; for (row = 0, y = src_rgn.y; row < src_rgn.h; row++, y++) { src = src_row; dest = dest_row; for (col = 0, x = src_rgn.x; col < src_rgn.w; col++, x++) { u = (gdouble) (x-xc) / pvals.radius; v = (gdouble) (y-yc) / pvals.radius; l = sqrt(u*u + v*v); /* This algorithm is still under construction. */ t = (atan2 (u, v) / (2 * G_PI) + .51) * pvals.nspoke; i = (gint) floor (t); t -= i; i %= pvals.nspoke; w1 = spoke[i] * (1 - t) + spoke[(i + 1) % pvals.nspoke] * t; w1 = w1 * w1; w = 1/(l+0.001)*0.9; nova_alpha = CLAMP (w, 0.0, 1.0); if (has_alpha) { src_alpha = (gdouble) src[alpha] / 255.0; new_alpha = src_alpha + (1.0 - src_alpha) * nova_alpha; if (new_alpha != 0.0) ratio = nova_alpha / new_alpha; else ratio = 0.0; } else ratio = nova_alpha; compl_ratio = 1.0 - ratio; switch (bpp) { case 1: case 2: /* gray */ spokecol = (gdouble)spokecolor[i ].r * (1.0-t) + (gdouble)spokecolor[(i+1) % pvals.nspoke].r * t; if (w>1.0) color.r = CLAMP (spokecol * w, 0.0, 1.0); else color.r = src[0]/255.0 * compl_ratio + spokecol * ratio; c = CLAMP (w1 * w, 0.0, 1.0); color.r += c; dest[0] = CLAMP (color.r*255.0, 0, 255); break; case 3: case 4: /* red */ spokecol = (gdouble)spokecolor[i ].r * (1.0-t) + (gdouble)spokecolor[(i+1) % pvals.nspoke].r * t; if (w>1.0) color.r = CLAMP (spokecol * w, 0.0, 1.0); else color.r = src[0]/255.0 * compl_ratio + spokecol * ratio; c = CLAMP (w1 * w, 0.0, 1.0); color.r += c; dest[0] = CLAMP (color.r*255.0, 0, 255); /* green */ spokecol = (gdouble)spokecolor[i ].g * (1.0-t) + (gdouble)spokecolor[(i+1) % pvals.nspoke].g * t; if (w>1.0) color.g = CLAMP (spokecol * w, 0.0, 1.0); else color.g = src[1]/255.0 * compl_ratio + spokecol * ratio; c = CLAMP (w1 * w, 0.0, 1.0); color.g += c; dest[1] = CLAMP (color.g*255.0, 0, 255); /* blue */ spokecol = (gdouble)spokecolor[i ].b * (1.0-t) + (gdouble)spokecolor[(i+1) % pvals.nspoke].b * t; if (w>1.0) color.b = CLAMP (spokecol * w, 0.0, 1.0); else color.b = src[2]/255.0 * compl_ratio + spokecol * ratio; c = CLAMP (w1 * w, 0.0, 1.0); color.b += c; dest[2] = CLAMP (color.b*255.0, 0, 255); break; } if (has_alpha) dest[alpha] = new_alpha * 255.0; src += src_rgn.bpp; dest += dest_rgn.bpp; } src_row += src_rgn.rowstride; dest_row += dest_rgn.rowstride; } /* Update progress */ progress += src_rgn.w * src_rgn.h; gimp_progress_update ((gdouble) progress / (gdouble) max_progress); } gimp_progress_update (1.0); gimp_drawable_flush (drawable); gimp_drawable_merge_shadow (drawable->drawable_id, TRUE); gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1)); } g_free (spoke); g_free (spokecolor); g_rand_free (gr); }
gboolean gimp_operation_saturation_mode_process_pixels (gfloat *in, gfloat *layer, gfloat *mask, gfloat *out, gdouble opacity, glong samples, const GeglRectangle *roi, gint level) { const gboolean has_mask = mask != NULL; while (samples--) { GimpHSV layer_hsv, out_hsv; GimpRGB layer_rgb = {layer[0], layer[1], layer[2]}; GimpRGB out_rgb = {in[0], in[1], in[2]}; gfloat comp_alpha, new_alpha; comp_alpha = MIN (in[ALPHA], layer[ALPHA]) * opacity; if (has_mask) comp_alpha *= *mask; new_alpha = in[ALPHA] + (1.0 - in[ALPHA]) * comp_alpha; if (comp_alpha && new_alpha) { gint b; gfloat ratio = comp_alpha / new_alpha; gimp_rgb_to_hsv (&layer_rgb, &layer_hsv); gimp_rgb_to_hsv (&out_rgb, &out_hsv); out_hsv.s = layer_hsv.s; gimp_hsv_to_rgb (&out_hsv, &out_rgb); out[0] = out_rgb.r; out[1] = out_rgb.g; out[2] = out_rgb.b; for (b = RED; b < ALPHA; b++) { out[b] = out[b] * ratio + in[b] * (1.0 - ratio); } } else { gint b; for (b = RED; b < ALPHA; b++) { out[b] = in[b]; } } out[ALPHA] = in[ALPHA]; in += 4; layer += 4; out += 4; if (has_mask) mask++; } return TRUE; }
static gboolean remap_dialog (gint32 image_ID, guchar *map) { GtkWidget *dialog; GtkWidget *vbox; GtkWidget *box; GtkWidget *iconview; GtkListStore *store; GtkCellRenderer *renderer; GtkTreeIter iter; guchar *cmap; gint ncols, i; gboolean valid; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Rearrange Colormap"), PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC_REMAP, GIMP_STOCK_RESET, RESPONSE_RESET, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), RESPONSE_RESET, GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dialog)); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), vbox, TRUE, TRUE, 0); cmap = gimp_image_get_colormap (image_ID, &ncols); g_return_val_if_fail ((ncols > 0) && (ncols <= 256), FALSE); store = gtk_list_store_new (NUM_COLS, G_TYPE_INT, G_TYPE_STRING, GIMP_TYPE_RGB, G_TYPE_DOUBLE, G_TYPE_DOUBLE, G_TYPE_DOUBLE); for (i = 0; i < ncols; i++) { GimpRGB rgb; GimpHSV hsv; gint index = map[i]; gchar *text = g_strdup_printf ("%d", index); gimp_rgb_set_uchar (&rgb, cmap[index * 3], cmap[index * 3 + 1], cmap[index * 3 + 2]); gimp_rgb_to_hsv (&rgb, &hsv); reverse_order[i] = ncols - i - 1; gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, COLOR_INDEX, index, COLOR_INDEX_TEXT, text, COLOR_RGB, &rgb, COLOR_H, hsv.h, COLOR_S, hsv.s, COLOR_V, hsv.v, -1); g_free (text); } g_free (cmap); remap_ui = remap_ui_manager_new (dialog, store); iconview = gtk_icon_view_new_with_model (GTK_TREE_MODEL (store)); g_object_unref (store); gtk_box_pack_start (GTK_BOX (vbox), iconview, TRUE, TRUE, 0); gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (iconview), GTK_SELECTION_SINGLE); gtk_icon_view_set_orientation (GTK_ICON_VIEW (iconview), GTK_ORIENTATION_VERTICAL); gtk_icon_view_set_columns (GTK_ICON_VIEW (iconview), 16); gtk_icon_view_set_row_spacing (GTK_ICON_VIEW (iconview), 0); gtk_icon_view_set_column_spacing (GTK_ICON_VIEW (iconview), 0); gtk_icon_view_set_reorderable (GTK_ICON_VIEW (iconview), TRUE); renderer = gimp_cell_renderer_color_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (iconview), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (iconview), renderer, "color", COLOR_RGB, NULL); g_object_set (renderer, "width", 24, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (iconview), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (iconview), renderer, "text", COLOR_INDEX_TEXT, NULL); g_object_set (renderer, "size-points", 6.0, "xalign", 0.5, "ypad", 0, NULL); g_signal_connect (iconview, "popup-menu", G_CALLBACK (remap_popup_menu), NULL); g_signal_connect (iconview, "button-press-event", G_CALLBACK (remap_button_press), NULL); box = gimp_hint_box_new (_("Drag and drop colors to rearrange the colormap. " "The numbers shown are the original indices. " "Right-click for a menu with sort options.")); gtk_box_pack_start (GTK_BOX (vbox), box, FALSE, FALSE, 0); gtk_widget_show (box); g_signal_connect (dialog, "response", G_CALLBACK (remap_response), store); gtk_widget_show_all (dialog); gtk_main (); i = 0; for (valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter); valid; valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter)) { gint index; gtk_tree_model_get (GTK_TREE_MODEL (store), &iter, COLOR_INDEX, &index, -1); map[i++] = index; } gtk_widget_destroy (dialog); return remap_run; }
static void gimp_color_selection_init (GimpColorSelection *selection) { GtkWidget *main_hbox; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *frame; GtkWidget *label; GtkWidget *entry; GtkWidget *button; GtkSizeGroup *new_group; GtkSizeGroup *old_group; selection->show_alpha = TRUE; gtk_orientable_set_orientation (GTK_ORIENTABLE (selection), GTK_ORIENTATION_VERTICAL); gimp_rgba_set (&selection->rgb, 0.0, 0.0, 0.0, 1.0); gimp_rgb_to_hsv (&selection->rgb, &selection->hsv); selection->channel = GIMP_COLOR_SELECTOR_HUE; main_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (selection), main_hbox, TRUE, TRUE, 0); gtk_widget_show (main_hbox); /* The left vbox with the notebook */ selection->left_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (main_hbox), selection->left_vbox, TRUE, TRUE, 0); gtk_widget_show (selection->left_vbox); if (_gimp_ensure_modules_func) { g_type_class_ref (GIMP_TYPE_COLOR_SELECT); _gimp_ensure_modules_func (); } selection->notebook = gimp_color_selector_new (GIMP_TYPE_COLOR_NOTEBOOK, &selection->rgb, &selection->hsv, selection->channel); if (_gimp_ensure_modules_func) g_type_class_unref (g_type_class_peek (GIMP_TYPE_COLOR_SELECT)); gimp_color_selector_set_toggles_visible (GIMP_COLOR_SELECTOR (selection->notebook), FALSE); gtk_box_pack_start (GTK_BOX (selection->left_vbox), selection->notebook, TRUE, TRUE, 0); gtk_widget_show (selection->notebook); g_signal_connect (selection->notebook, "color-changed", G_CALLBACK (gimp_color_selection_notebook_changed), selection); g_signal_connect (GIMP_COLOR_NOTEBOOK (selection->notebook)->notebook, "switch-page", G_CALLBACK (gimp_color_selection_switch_page), selection); /* The hbox for the color_areas */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_end (GTK_BOX (selection->left_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); /* The labels */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); label = gtk_label_new (_("Current:")); gtk_label_set_xalign (GTK_LABEL (label), 1.0); gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0); gtk_widget_show (label); new_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL); gtk_size_group_add_widget (new_group, label); g_object_unref (new_group); label = gtk_label_new (_("Old:")); gtk_label_set_xalign (GTK_LABEL (label), 1.0); gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0); gtk_widget_show (label); old_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL); gtk_size_group_add_widget (old_group, label); g_object_unref (old_group); /* The color areas */ frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); selection->new_color = gimp_color_area_new (&selection->rgb, selection->show_alpha ? GIMP_COLOR_AREA_SMALL_CHECKS : GIMP_COLOR_AREA_FLAT, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK); gtk_size_group_add_widget (new_group, selection->new_color); gtk_box_pack_start (GTK_BOX (vbox), selection->new_color, FALSE, FALSE, 0); gtk_widget_show (selection->new_color); g_signal_connect (selection->new_color, "color-changed", G_CALLBACK (gimp_color_selection_new_color_changed), selection); selection->old_color = gimp_color_area_new (&selection->rgb, selection->show_alpha ? GIMP_COLOR_AREA_SMALL_CHECKS : GIMP_COLOR_AREA_FLAT, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK); gtk_drag_dest_unset (selection->old_color); gtk_size_group_add_widget (old_group, selection->old_color); gtk_box_pack_start (GTK_BOX (vbox), selection->old_color, FALSE, FALSE, 0); gtk_widget_show (selection->old_color); /* The right vbox with color scales */ selection->right_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (main_hbox), selection->right_vbox, TRUE, TRUE, 0); gtk_widget_show (selection->right_vbox); selection->scales = gimp_color_selector_new (GIMP_TYPE_COLOR_SCALES, &selection->rgb, &selection->hsv, selection->channel); gimp_color_selector_set_toggles_visible (GIMP_COLOR_SELECTOR (selection->scales), TRUE); gimp_color_selector_set_show_alpha (GIMP_COLOR_SELECTOR (selection->scales), selection->show_alpha); gtk_box_pack_start (GTK_BOX (selection->right_vbox), selection->scales, TRUE, TRUE, 0); gtk_widget_show (selection->scales); g_signal_connect (selection->scales, "channel-changed", G_CALLBACK (gimp_color_selection_channel_changed), selection); g_signal_connect (selection->scales, "color-changed", G_CALLBACK (gimp_color_selection_scales_changed), selection); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (selection->right_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); /* The color picker */ button = gimp_pick_button_new (); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "color-picked", G_CALLBACK (gimp_color_selection_color_picked), selection); /* The hex triplet entry */ entry = gimp_color_hex_entry_new (); gimp_help_set_help_data (entry, _("Hexadecimal color notation as used in HTML and " "CSS. This entry also accepts CSS color names."), NULL); gtk_box_pack_end (GTK_BOX (hbox), entry, TRUE, TRUE, 0); gtk_widget_show (entry); label = gtk_label_new_with_mnemonic (_("HTML _notation:")); gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry); gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_object_set_data (G_OBJECT (selection), "color-hex-entry", entry); g_signal_connect (entry, "color-changed", G_CALLBACK (gimp_color_selection_entry_changed), selection); }