/* void open (in nsIColorPickerShownCallback aColorPickerShownCallback); */
NS_IMETHODIMP nsColorPicker::Open(nsIColorPickerShownCallback *aColorPickerShownCallback)
{
if (mCallback) {
// It means Open has already been called: this is not allowed
NS_WARNING("mCallback is already set. Open called twice?");
return NS_ERROR_FAILURE;
}
mCallback = aColorPickerShownCallback;
nsXPIDLCString title;
title.Adopt(ToNewUTF8String(mTitle));
GtkWidget *color_chooser = gtk_color_selection_dialog_new(title);
GtkWindow *window = GTK_WINDOW(color_chooser);
gtk_window_set_modal(window, TRUE);
GtkWindow *parent_window = GTK_WINDOW(mParentWidget->GetNativeData(NS_NATIVE_SHELLWIDGET));
if (parent_window) {
gtk_window_set_transient_for(window, parent_window);
gtk_window_set_destroy_with_parent(window, TRUE);
}
gtk_color_selection_set_current_color(
GTK_COLOR_SELECTION(gtk_color_selection_dialog_get_color_selection(
GTK_COLOR_SELECTION_DIALOG(color_chooser))),
&mDefaultColor);
NS_ADDREF_THIS();
g_signal_connect(color_chooser, "response", G_CALLBACK(OnResponse), this);
g_signal_connect(color_chooser, "destroy", G_CALLBACK(OnDestroy), this);
gtk_widget_show(color_chooser);
return NS_OK;
}
static gboolean cb_tsin_cursor_color( GtkWidget *widget,
gpointer data )
{
GtkWidget *color_selector = gtk_color_selection_dialog_new (_("詞音游標的顏色"));
gtk_color_selection_set_current_color(
GTK_COLOR_SELECTION(gtk_color_selection_dialog_get_color_selection(GTK_COLOR_SELECTION_DIALOG(color_selector))),
&tsin_cursor_gcolor);
#if 0
g_signal_connect (GTK_OBJECT (color_selector->ok_button),
"clicked",
G_CALLBACK (cb_save_tsin_cursor_color),
(gpointer) color_selector);
#if 1
g_signal_connect_swapped (GTK_OBJECT (color_selector->ok_button),
"clicked",
G_CALLBACK (gtk_widget_destroy),
(gpointer) color_selector);
#endif
g_signal_connect_swapped (GTK_OBJECT (color_selector->cancel_button),
"clicked",
G_CALLBACK (gtk_widget_destroy),
(gpointer) color_selector);
#endif
gtk_widget_show((GtkWidget*)color_selector);
#if 1
if (gtk_dialog_run(GTK_DIALOG(color_selector)) == GTK_RESPONSE_OK)
cb_save_tsin_cursor_color((GtkWidget *)color_selector, (gpointer) color_selector);
gtk_widget_destroy((GtkWidget *)color_selector);
#endif
return TRUE;
}
static void
change_color_callback (GtkWidget *button,
gpointer data)
{
GtkWidget *dialog;
GtkColorSelection *colorsel;
gint response;
dialog = gtk_color_selection_dialog_new ("Changing color");
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (window));
colorsel = GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (dialog)->colorsel);
gtk_color_selection_set_previous_color (colorsel, &color);
gtk_color_selection_set_current_color (colorsel, &color);
gtk_color_selection_set_has_palette (colorsel, TRUE);
response = gtk_dialog_run (GTK_DIALOG (dialog));
if (response == GTK_RESPONSE_OK)
{
gtk_color_selection_get_current_color (colorsel,
&color);
gtk_widget_modify_bg (da, GTK_STATE_NORMAL, &color);
}
gtk_widget_destroy (dialog);
}
//------------------------- Color Selection -----------------------------------
// Open Dlg for color selection return true, if color changed
bool
showColorBox(const std::string &title,
GdkColor &colorInOut,
GtkWidget *transient_widget/*=NULL*/)
{
GtkWidget *dialog;
GtkColorSelection *colorsel;
gint response;
dialog = gtk_color_selection_dialog_new (title.c_str());
// Make transient if necessary
if (transient_widget)
{
GtkWidget *toplevel = getToplevel(transient_widget);
if (toplevel && GTK_IS_WINDOW (toplevel) && GTK_WIDGET_MAPPED (toplevel))
gtk_window_set_transient_for (GTK_WINDOW (dialog),
GTK_WINDOW (toplevel));
}
colorsel = GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (dialog)->colorsel);
gtk_color_selection_set_previous_color (colorsel, &colorInOut);
gtk_color_selection_set_current_color (colorsel, &colorInOut);
gtk_color_selection_set_has_palette (colorsel, TRUE);
response = runModalBox(dialog);
if (response == GTK_RESPONSE_OK)
{
gtk_color_selection_get_current_color (colorsel,&colorInOut);
}
gtk_widget_destroy (dialog);
return (response == GTK_RESPONSE_OK);
}
static void
change_color_cb(GtkWidget *button, t_sload *sload)
{
GtkWidget *dialog;
GtkColorSelection *colorsel;
gint response;
dialog = gtk_color_selection_dialog_new("Select color");
gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(sload->opt_dialog));
colorsel = GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(dialog)->colorsel);
gtk_color_selection_set_previous_color(colorsel, &sload->options.color);
gtk_color_selection_set_current_color(colorsel, &sload->options.color);
gtk_color_selection_set_has_palette(colorsel, TRUE);
response = gtk_dialog_run(GTK_DIALOG(dialog));
if (response == GTK_RESPONSE_OK)
{
gtk_color_selection_get_current_color(colorsel, &sload->options.color);
gtk_widget_modify_bg(sload->opt_da, GTK_STATE_NORMAL, &sload->options.color);
setup_sload(sload);
}
gtk_widget_destroy(dialog);
}
static void
menu_color_change_cb (col_sel * sel)
{
GtkColorSelectionDialog *selector;
gchar title[20];
GdkColor *color;
sprintf (title, "Choose color #%d", sel->index);
selector =
GTK_COLOR_SELECTION_DIALOG (gtk_color_selection_dialog_new (title));
gtk_widget_destroy (selector->help_button);
sel->selector = selector;
color = gtk_databox_graph_get_color (sel->graph);
gtk_color_selection_set_current_color (GTK_COLOR_SELECTION
(selector->colorsel), color);
g_signal_connect_object (G_OBJECT (selector->cancel_button), "clicked",
G_CALLBACK (gtk_widget_destroy),
G_OBJECT (selector), G_CONNECT_SWAPPED);
g_signal_connect_swapped (G_OBJECT
(selector->ok_button),
"clicked", G_CALLBACK (get_color_cb),
(gpointer) sel);
gtk_widget_show (GTK_WIDGET (selector));
return;
}
static void change_color(GtkWidget *button, t_global_monitor *global, gint type)
{
GtkWidget *dialog;
GtkColorSelection *colorsel;
gint response;
dialog = gtk_color_selection_dialog_new(_("Select color"));
gtk_window_set_transient_for(GTK_WINDOW(dialog),
GTK_WINDOW(global->opt_dialog));
colorsel =
GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(dialog)->colorsel);
gtk_color_selection_set_previous_color(colorsel,
&global->monitor->options.color[type]);
gtk_color_selection_set_current_color(colorsel,
&global->monitor->options.color[type]);
gtk_color_selection_set_has_palette(colorsel, TRUE);
response = gtk_dialog_run(GTK_DIALOG(dialog));
if (response == GTK_RESPONSE_OK)
{
gtk_color_selection_get_current_color(colorsel,
&global->monitor->options.color[type]);
gtk_widget_modify_bg(global->monitor->opt_da[type],
GTK_STATE_NORMAL,
&global->monitor->options.color[type]);
setup_monitor(global);
}
gtk_widget_destroy(dialog);
}
void changeFace(GtkButton* button,GtkButton* window)
{
GtkWidget *dialog;
GtkColorSelection *colorsel;
gint response;
GdkColor color;
dialog = gtk_color_selection_dialog_new("Ñ¡Ôñ±³¾°ÑÕÉ«");
gtk_window_set_transient_for(GTK_WINDOW(dialog),GTK_WINDOW(window));
colorsel = GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(dialog)->colorsel);
gtk_color_selection_set_has_opacity_control(colorsel,TRUE);
gtk_color_selection_set_has_palette(colorsel,TRUE);
gtk_signal_connect(GTK_OBJECT(dialog),"destroy",GTK_SIGNAL_FUNC(gtk_widget_destroy),&dialog);
gtk_color_selection_set_previous_color(colorsel,&color);
gtk_color_selection_set_current_color(colorsel,&color);
response = gtk_dialog_run(GTK_DIALOG(dialog));
if (response == GTK_RESPONSE_OK)
{
gtk_color_selection_get_current_color (colorsel, &color);
gtk_widget_modify_bg (window, GTK_STATE_NORMAL, &color);
}
gtk_widget_destroy(dialog);
}
void select_color (GtkButton *widget, gpointer user_data)
{
GtkColorSelectionDialog* dialog = GTK_COLOR_SELECTION_DIALOG(gtk_color_selection_dialog_new("Select Color")); //todo put the old color selection in
gint result = gtk_dialog_run(GTK_DIALOG(dialog));
//
if(result == GTK_RESPONSE_OK)
{
select_color_info* info = (select_color_info*)user_data;
GtkColorSelection* colsel = GTK_COLOR_SELECTION(dialog->colorsel);
GdkColor* sel_color = malloc(sizeof(GdkColor));
gtk_color_selection_get_current_color(colsel, sel_color);
GeglColor* color = gegl_color_new(NULL);
gegl_color_set_rgba(color, (double)sel_color->red/65535.0,
(double)sel_color->green/65535.0,
(double)sel_color->blue/65535.0,
(double)gtk_color_selection_get_current_alpha(colsel)/65535.0);
free(sel_color);
gegl_node_set(info->node, info->property, color, NULL);
refresh_images(info->layer);
}
gtk_widget_destroy(GTK_WIDGET(dialog));
}
/**
* uber_label_block_button_press_event:
* @widget: A #GtkWidget.
* @event: A #GdkEventButton.
* @label: An #UberLabel.
*
* Callback to handle a button press event within the colored block.
*
* Returns: %FALSE always to allow further signal emission.
* Side effects: None.
*/
static gboolean
uber_label_block_button_press_event (GtkWidget *widget, /* IN */
GdkEventButton *event, /* IN */
UberLabel *label) /* IN */
{
UberLabelPrivate *priv;
GtkWidget *dialog;
GtkWidget *selection;
g_return_val_if_fail(UBER_IS_LABEL(label), FALSE);
priv = label->priv;
dialog = gtk_color_selection_dialog_new("");
selection = gtk_color_selection_dialog_get_color_selection(
GTK_COLOR_SELECTION_DIALOG(dialog));
gtk_color_selection_set_current_color(
GTK_COLOR_SELECTION(selection),
&priv->color);
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) {
gtk_color_selection_get_current_color(
GTK_COLOR_SELECTION(selection),
&priv->color);
gtk_widget_queue_draw(widget);
g_signal_emit(label, signals[COLOR_CHANGED],
0, &priv->color);
}
gtk_widget_destroy(dialog);
return FALSE;
}
static void
colorpicker_callback (GtkDarktableButton *button, dt_iop_module_t *self)
{
if(self->dt->gui->reset) return;
dt_iop_invert_gui_data_t *g = (dt_iop_invert_gui_data_t *)self->gui_data;
dt_iop_invert_params_t *p = (dt_iop_invert_params_t *)self->params;
GtkColorSelectionDialog *csd = GTK_COLOR_SELECTION_DIALOG(gtk_color_selection_dialog_new(_("select color of film material")));
gtk_window_set_transient_for(GTK_WINDOW(csd), GTK_WINDOW(dt_ui_main_window(darktable.gui->ui)));
g_signal_connect (G_OBJECT (csd->ok_button), "clicked",
G_CALLBACK (colorpick_button_callback), csd);
g_signal_connect (G_OBJECT (csd->cancel_button), "clicked",
G_CALLBACK (colorpick_button_callback), csd);
GtkColorSelection *cs = GTK_COLOR_SELECTION(gtk_color_selection_dialog_get_color_selection(csd));
GdkColor c;
c.red = 65535 * p->color[0];
c.green = 65535 * p->color[1];
c.blue = 65535 * p->color[2];
gtk_color_selection_set_current_color(cs, &c);
if(gtk_dialog_run(GTK_DIALOG(csd)) == GTK_RESPONSE_ACCEPT)
{
gtk_color_selection_get_current_color(cs, &c);
p->color[0] = c.red /65535.0;
p->color[1] = c.green/65535.0;
p->color[2] = c.blue /65535.0;
gtk_widget_modify_fg(GTK_WIDGET(g->colorpicker), GTK_STATE_NORMAL, &c);
}
gtk_widget_destroy(GTK_WIDGET(csd));
dt_dev_add_history_item(darktable.develop, self, TRUE);
}
void ColorToolItem::activated(GdkEvent *event, GtkMenuItem *menuitem, GtkToolButton *toolbutton) {
XOJ_CHECK_TYPE(ColorToolItem);
if (inUpdate) {
return;
}
inUpdate = true;
if (isSelector()) {
this->colorDlg = gtk_color_selection_dialog_new(_("Select color"));
g_signal_connect(G_OBJECT(GTK_COLOR_SELECTION_DIALOG(this->colorDlg)->ok_button), "clicked", G_CALLBACK(&customColorSelected), this);
GdkColor color = Util::intToGdkColor(this->color);
GtkWidget* cw = gtk_color_selection_dialog_get_color_selection(GTK_COLOR_SELECTION_DIALOG(this->colorDlg));
gtk_color_selection_set_current_color(GTK_COLOR_SELECTION(cw), &color);
gtk_window_set_transient_for(GTK_WINDOW (this->colorDlg), GTK_WINDOW (this->parent));
gtk_dialog_run(GTK_DIALOG(this->colorDlg));
gtk_widget_destroy(this->colorDlg);
this->colorDlg = NULL;
}
toolHandler->setColor(this->color);
inUpdate = false;
}
void color_picker (void)
{
GtkColorSelectionDialog *ColorWindow;
if (ColorIsVisible) return;
ColorWindow = (GtkColorSelectionDialog *)gtk_color_selection_dialog_new
("Color Picker");
gtk_signal_connect (GTK_OBJECT(ColorWindow), "delete_event",
(GtkSignalFunc) color_picker_not_visible, NULL);
gtk_signal_connect_object (GTK_OBJECT(ColorWindow), "delete_event",
(GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT(ColorWindow));
gtk_signal_connect (GTK_OBJECT (ColorWindow), "destroy",
(GtkSignalFunc) color_picker_not_visible, NULL);
gtk_signal_connect_object (GTK_OBJECT(ColorWindow), "destroy",
(GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT(ColorWindow));
gtk_label_set_text (GTK_LABEL(GTK_BIN(ColorWindow -> ok_button) -> child),
"Insert");
gtk_signal_connect_object (GTK_OBJECT(ColorWindow -> ok_button), "clicked",
(GtkSignalFunc)insert_color,
GTK_OBJECT(ColorWindow -> colorsel));
gtk_signal_connect (GTK_OBJECT(ColorWindow -> cancel_button), "clicked",
(GtkSignalFunc)color_picker_not_visible, NULL);
gtk_signal_connect_object (GTK_OBJECT(ColorWindow -> cancel_button),
"clicked",
(GtkSignalFunc)gtk_widget_destroy,
GTK_OBJECT(ColorWindow));
gtk_widget_hide (ColorWindow -> help_button);
ColorIsVisible = TRUE;
gtk_widget_show (GTK_WIDGET(ColorWindow));
ColorIsVisible = TRUE;
print_msg ("Display Color Picker...");
}
static void
purplerc_set_color(GtkWidget *widget, gpointer data)
{
GdkColor color;
gchar title[128];
const gchar *pref = NULL;
GtkWidget *color_dialog = NULL;
gint subscript = GPOINTER_TO_INT(data);
g_snprintf(title, sizeof(title), _("Select Color for %s"),
_(color_names[GPOINTER_TO_INT(data)]));
color_dialog = gtk_color_selection_dialog_new(_("Select Color"));
g_signal_connect(G_OBJECT(color_dialog), "response",
G_CALLBACK(purplerc_color_response), data);
pref = purple_prefs_get_string(color_prefs[subscript]);
if (pref != NULL && strcmp(pref, "")) {
if (gdk_color_parse(pref, &color)) {
#if GTK_CHECK_VERSION(2,14,0)
gtk_color_selection_set_current_color(GTK_COLOR_SELECTION(
gtk_color_selection_dialog_get_color_selection(GTK_COLOR_SELECTION_DIALOG(color_dialog))),
&color);
#else
gtk_color_selection_set_current_color(GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(color_dialog)->colorsel), &color);
#endif
}
}
gtk_window_present(GTK_WINDOW(color_dialog));
}
void dialog_colour_new(GtkWidget *w, gdouble *colour)
{
GtkWidget *csd;
/* create colour selection dialog */
csd = gtk_color_selection_dialog_new("Edit colour");
/* set the initial colour */
gtk_color_selection_set_color(GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(csd)->colorsel), colour);
/* value colour update */
g_signal_connect(GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->colorsel), "color_changed",
GTK_SIGNAL_FUNC(set_colour_value), (gpointer) colour);
/* widget colour update */
if (w)
g_signal_connect(GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->colorsel), "color_changed",
GTK_SIGNAL_FUNC(set_colour_widget), (gpointer) w);
g_signal_connect(GTK_OBJECT(GTK_COLOR_SELECTION_DIALOG(csd)->ok_button), "clicked",
GTK_SIGNAL_FUNC(destroy_widget), (gpointer) csd);
gtk_widget_hide(GTK_COLOR_SELECTION_DIALOG(csd)->cancel_button);
gtk_widget_show(csd);
/*
g_signal_connect(GTK_OBJECT(w), "destroy", GTK_SIGNAL_FUNC(destroy_widget), csd);
*/
}
bool wxColourDialog::Create(wxWindow *parent, wxColourData *data)
{
if (data)
m_data = *data;
m_parent = GetParentForModalDialog(parent, 0);
GtkWindow * const parentGTK = m_parent ? GTK_WINDOW(m_parent->m_widget)
: NULL;
wxString title(_("Choose colour"));
m_widget = gtk_color_selection_dialog_new(wxGTK_CONV(title));
g_object_ref(m_widget);
if ( parentGTK )
{
gtk_window_set_transient_for(GTK_WINDOW(m_widget), parentGTK);
}
GtkColorSelection* sel = GTK_COLOR_SELECTION(
gtk_color_selection_dialog_get_color_selection(
GTK_COLOR_SELECTION_DIALOG(m_widget)));
gtk_color_selection_set_has_palette(sel, true);
return true;
}
static void
change_color_callback (GtkWidget *button,
gpointer data)
{
GtkWidget *dialog;
GtkColorSelection *colorsel;
GtkColorSelectionDialog *selection_dialog;
gint response;
dialog = gtk_color_selection_dialog_new ("Changing color");
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (window));
selection_dialog = GTK_COLOR_SELECTION_DIALOG (dialog);
colorsel = GTK_COLOR_SELECTION (gtk_color_selection_dialog_get_color_selection (selection_dialog));
gtk_color_selection_set_previous_rgba (colorsel, &color);
gtk_color_selection_set_current_rgba (colorsel, &color);
gtk_color_selection_set_has_palette (colorsel, TRUE);
response = gtk_dialog_run (GTK_DIALOG (dialog));
if (response == GTK_RESPONSE_OK)
{
gtk_color_selection_get_current_rgba (colorsel, &color);
gtk_widget_override_background_color (da, 0, &color);
}
gtk_widget_destroy (dialog);
}
bool wxColourDialog::Create(wxWindow *parent, wxColourData *data)
{
if (data)
m_data = *data;
m_parent = GetParentForModalDialog(parent, 0);
GtkWindow * const parentGTK = m_parent ? GTK_WINDOW(m_parent->m_widget)
: NULL;
#if wxUSE_LIBHILDON
m_widget = hildon_color_selector_new(parentGTK);
#elif wxUSE_LIBHILDON2 // !wxUSE_LIBHILDON
m_widget = hildon_color_chooser_dialog_new();
#else // !wxUSE_LIBHILDON && !wxUSE_LIBHILDON2
wxString title(_("Choose colour"));
m_widget = gtk_color_selection_dialog_new(wxGTK_CONV(title));
#endif // wxUSE_LIBHILDON/!wxUSE_LIBHILDON
g_object_ref(m_widget);
if ( parentGTK )
{
gtk_window_set_transient_for(GTK_WINDOW(m_widget), parentGTK);
}
#if !wxUSE_LIBHILDON && !wxUSE_LIBHILDON2
GtkColorSelection* sel = GTK_COLOR_SELECTION(
gtk_color_selection_dialog_get_color_selection(
GTK_COLOR_SELECTION_DIALOG(m_widget)));
gtk_color_selection_set_has_palette(sel, true);
#endif // !wxUSE_LIBHILDON && !wxUSE_LIBHILDON2
return true;
}
GtkToolkitColorChooser::GtkToolkitColorChooser()
: m_dialog(NULL)
, m_color_selector(NULL)
, m_color(0x0)
{
m_dialog = gtk_color_selection_dialog_new( NULL /* gchar *title */ );
m_color_selector = gtk_color_selection_dialog_get_color_selection(
GTK_COLOR_SELECTION_DIALOG(m_dialog));
}
static void
gtk_color_button_clicked (GtkButton *button)
{
GtkColorButton *color_button = GTK_COLOR_BUTTON (button);
GtkColorSelectionDialog *color_dialog;
/* if dialog already exists, make sure it's shown and raised */
if (!color_button->priv->cs_dialog)
{
/* Create the dialog and connects its buttons */
GtkWidget *parent;
parent = gtk_widget_get_toplevel (GTK_WIDGET (color_button));
color_button->priv->cs_dialog = gtk_color_selection_dialog_new (color_button->priv->title);
color_dialog = GTK_COLOR_SELECTION_DIALOG (color_button->priv->cs_dialog);
if (gtk_widget_is_toplevel (parent) && GTK_IS_WINDOW (parent))
{
if (GTK_WINDOW (parent) != gtk_window_get_transient_for (GTK_WINDOW (color_dialog)))
gtk_window_set_transient_for (GTK_WINDOW (color_dialog), GTK_WINDOW (parent));
gtk_window_set_modal (GTK_WINDOW (color_dialog),
gtk_window_get_modal (GTK_WINDOW (parent)));
}
g_signal_connect (color_dialog->ok_button, "clicked",
G_CALLBACK (dialog_ok_clicked), color_button);
g_signal_connect (color_dialog->cancel_button, "clicked",
G_CALLBACK (dialog_cancel_clicked), color_button);
g_signal_connect (color_dialog, "destroy",
G_CALLBACK (dialog_destroy), color_button);
}
color_dialog = GTK_COLOR_SELECTION_DIALOG (color_button->priv->cs_dialog);
gtk_color_selection_set_has_opacity_control (GTK_COLOR_SELECTION (color_dialog->colorsel),
color_button->priv->use_alpha);
gtk_color_selection_set_previous_color (GTK_COLOR_SELECTION (color_dialog->colorsel),
&color_button->priv->color);
gtk_color_selection_set_previous_alpha (GTK_COLOR_SELECTION (color_dialog->colorsel),
color_button->priv->alpha);
gtk_color_selection_set_current_color (GTK_COLOR_SELECTION (color_dialog->colorsel),
&color_button->priv->color);
gtk_color_selection_set_current_alpha (GTK_COLOR_SELECTION (color_dialog->colorsel),
color_button->priv->alpha);
gtk_window_present (GTK_WINDOW (color_button->priv->cs_dialog));
}
void SelectBackgroundColorDialog::showColorchooser()
{
XOJ_CHECK_TYPE(SelectBackgroundColorDialog);
this->colorDlg = gtk_color_selection_dialog_new(_C("Select color"));
g_signal_connect(G_OBJECT (GTK_COLOR_SELECTION_DIALOG(this->colorDlg)->ok_button), "clicked",
G_CALLBACK(&buttonSelectedCallback), this->colors.front()); // first entry
gtk_dialog_run(GTK_DIALOG(this->colorDlg));
gtk_widget_destroy(this->colorDlg);
this->colorDlg = NULL;
}
static gint
gsm_color_button_clicked (GtkWidget * widget, GdkEventButton * event)
{
GSMColorButton *color_button = GSM_COLOR_BUTTON (widget);
GtkColorSelectionDialog *color_dialog;
/* if dialog already exists, make sure it's shown and raised */
if (!color_button->priv->cs_dialog)
{
/* Create the dialog and connects its buttons */
GtkWidget *parent;
parent = gtk_widget_get_toplevel (GTK_WIDGET (color_button));
color_button->priv->cs_dialog =
gtk_color_selection_dialog_new (color_button->priv->title);
color_dialog =
GTK_COLOR_SELECTION_DIALOG (color_button->priv->cs_dialog);
if (gtk_widget_is_toplevel (parent) && GTK_IS_WINDOW (parent))
{
if (GTK_WINDOW (parent) !=
gtk_window_get_transient_for (GTK_WINDOW (color_dialog)))
gtk_window_set_transient_for (GTK_WINDOW (color_dialog),
GTK_WINDOW (parent));
gtk_window_set_modal (GTK_WINDOW (color_dialog),
gtk_window_get_modal (GTK_WINDOW (parent)));
}
g_signal_connect (color_dialog, "response",
G_CALLBACK (dialog_response), color_button);
g_signal_connect (color_dialog, "destroy",
G_CALLBACK (dialog_destroy), color_button);
}
color_dialog = GTK_COLOR_SELECTION_DIALOG (color_button->priv->cs_dialog);
gtk_color_selection_set_previous_color (GTK_COLOR_SELECTION
(gtk_color_selection_dialog_get_color_selection (color_dialog)),
&color_button->priv->color);
gtk_color_selection_set_current_color (GTK_COLOR_SELECTION
(gtk_color_selection_dialog_get_color_selection (color_dialog)),
&color_button->priv->color);
gtk_window_present (GTK_WINDOW (color_button->priv->cs_dialog));
return 0;
}
/**** Color selection dialog constructor ****/
int
clip_GTK_COLORSELECTIONDIALOGNEW(ClipMachine * ClipMachineMemory)
{
ClipVar *cv = _clip_spar(ClipMachineMemory, 1);
char *title = _clip_parc(ClipMachineMemory, 2);
GtkWidget *wid = NULL;
C_widget *cwid, *ccolorsel, *cokbtn, *ccancelbtn, *chlpbtn;
CHECKOPT(1, MAP_type_of_ClipVarType);
CHECKOPT(2, CHARACTER_type_of_ClipVarType);
if (_clip_parinfo(ClipMachineMemory, 2) == UNDEF_type_of_ClipVarType)
title = "\0";
LOCALE_TO_UTF(title);
wid = gtk_color_selection_dialog_new(title);
FREE_TEXT(title);
cwid = _register_widget(ClipMachineMemory, wid, cv);
ccolorsel = _register_widget(ClipMachineMemory, GTK_COLOR_SELECTION_DIALOG(wid)->colorsel, NULL);
cokbtn = _register_widget(ClipMachineMemory, GTK_COLOR_SELECTION_DIALOG(wid)->ok_button, NULL);
ccancelbtn = _register_widget(ClipMachineMemory, GTK_COLOR_SELECTION_DIALOG(wid)->cancel_button, NULL);
chlpbtn = _register_widget(ClipMachineMemory, GTK_COLOR_SELECTION_DIALOG(wid)->help_button, NULL);
if (ccolorsel)
_clip_madd(ClipMachineMemory, &cwid->obj, HASH_COLORSEL, &ccolorsel->obj);
if (cokbtn)
_clip_madd(ClipMachineMemory, &cwid->obj, HASH_OKBUTTON, &cokbtn->obj);
if (ccancelbtn)
_clip_madd(ClipMachineMemory, &cwid->obj, HASH_CANCELBUTTON, &ccancelbtn->obj);
if (chlpbtn)
_clip_madd(ClipMachineMemory, &cwid->obj, HASH_HELPBUTTON, &chlpbtn->obj);
if (ccolorsel)
_clip_destroy(ClipMachineMemory, &ccolorsel->obj);
if (cokbtn)
_clip_destroy(ClipMachineMemory, &cokbtn->obj);
if (ccancelbtn)
_clip_destroy(ClipMachineMemory, &ccancelbtn->obj);
if (chlpbtn)
_clip_destroy(ClipMachineMemory, &chlpbtn->obj);
_clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj);
return 0;
err:
return 1;
}
static void
colorpick_callback (GtkDarktableButton *button, gpointer user_data)
{
dt_iop_module_t *self = (dt_iop_module_t *)user_data;
dt_iop_splittoning_gui_data_t *g = (dt_iop_splittoning_gui_data_t *)self->gui_data;
if(self->dt->gui->reset) return;
dt_iop_splittoning_params_t *p = (dt_iop_splittoning_params_t *)self->params;
GtkColorSelectionDialog *csd = GTK_COLOR_SELECTION_DIALOG(gtk_color_selection_dialog_new(_("select tone color")));
gtk_window_set_transient_for(GTK_WINDOW(csd), GTK_WINDOW(dt_ui_main_window(darktable.gui->ui)));
GtkWidget *okButton, *cancelButton = 0;
g_object_get(G_OBJECT(csd), "ok-button", &okButton, NULL);
g_object_get(G_OBJECT(csd), "cancel-button", &cancelButton, NULL);
g_signal_connect (G_OBJECT (okButton), "clicked",
G_CALLBACK (colorpick_button_callback), csd);
g_signal_connect (G_OBJECT (cancelButton), "clicked",
G_CALLBACK (colorpick_button_callback), csd);
GtkColorSelection *cs = GTK_COLOR_SELECTION(gtk_color_selection_dialog_get_color_selection(csd));
GdkColor c;
float color[3],h,s,l;
h=(button==g->colorpick1)?p->shadow_hue:p->highlight_hue;
s=(button==g->colorpick1)?p->shadow_saturation:p->highlight_saturation;
l=0.5;
hsl2rgb(color,h,s,l);
c.red= 65535 * color[0];
c.green= 65535 * color[1];
c.blue= 65535 * color[2];
gtk_color_selection_set_current_color(cs,&c);
if(gtk_dialog_run(GTK_DIALOG(csd))==GTK_RESPONSE_ACCEPT)
{
gtk_color_selection_get_current_color(cs,&c);
color[0]=c.red/65535.0;
color[1]=c.green/65535.0;
color[2]=c.blue/65535.0;
rgb2hsl(color,&h,&s,&l);
l=0.5;
hsl2rgb(color,h,s,l);
dt_bauhaus_slider_set( (button==g->colorpick1)? g->gslider1: g->gslider3 ,h );
dt_bauhaus_slider_set( (button==g->colorpick1)? g->gslider2: g->gslider4 ,s );
}
gtk_widget_destroy(GTK_WIDGET(csd));
dt_dev_add_history_item(darktable.develop, self, TRUE);
}
/* void open (in nsIColorPickerShownCallback aColorPickerShownCallback); */
NS_IMETHODIMP nsColorPicker::Open(nsIColorPickerShownCallback *aColorPickerShownCallback)
{
// Input color string should be 7 length (i.e. a string representing a valid
// simple color)
if (mInitialColor.Length() != 7) {
return NS_ERROR_FAILURE;
}
const nsAString& withoutHash = StringTail(mInitialColor, 6);
nscolor color;
if (!NS_HexToRGB(withoutHash, &color)) {
return NS_ERROR_FAILURE;
}
GdkColor color_gdk = convertToGdkColor(color);
if (mCallback) {
// It means Open has already been called: this is not allowed
NS_WARNING("mCallback is already set. Open called twice?");
return NS_ERROR_FAILURE;
}
mCallback = aColorPickerShownCallback;
nsXPIDLCString title;
title.Adopt(ToNewUTF8String(mTitle));
GtkWidget *color_chooser = gtk_color_selection_dialog_new(title);
GtkWindow *parent_window = GTK_WINDOW(mParentWidget->GetNativeData(NS_NATIVE_SHELLWIDGET));
if (parent_window) {
GtkWindow *window = GTK_WINDOW(color_chooser);
gtk_window_set_transient_for(window, parent_window);
gtk_window_set_destroy_with_parent(window, TRUE);
}
gtk_color_selection_set_current_color(WidgetGetColorSelection(color_chooser),
&color_gdk);
NS_ADDREF_THIS();
g_signal_connect(WidgetGetColorSelection(color_chooser), "color-changed",
G_CALLBACK(OnColorChanged), this);
g_signal_connect(color_chooser, "response", G_CALLBACK(OnResponse), this);
g_signal_connect(color_chooser, "destroy", G_CALLBACK(OnDestroy), this);
gtk_widget_show(color_chooser);
return NS_OK;
}
static void
color_dialog( GdkColor *color, gchar * title )
{
GtkResponseType result;
GtkColorSelection *colorsel;
GtkWidget *dialog = gtk_color_selection_dialog_new( title );
colorsel = GTK_COLOR_SELECTION(
GTK_COLOR_SELECTION_DIALOG(dialog)->colorsel );
gtk_color_selection_set_has_palette ( colorsel, TRUE );
gtk_color_selection_set_current_color ( colorsel, color );
result = gtk_dialog_run(GTK_DIALOG(dialog));
if (result == GTK_RESPONSE_OK)
{
gtk_color_selection_get_current_color(colorsel, color);
}
gtk_widget_destroy(dialog);
}
static void
colorpick_callback (GtkDarktableButton *button, gpointer user_data)
{
dt_iop_module_t *self = (dt_iop_module_t *)user_data;
dt_iop_colorize_gui_data_t *g = (dt_iop_colorize_gui_data_t *)self->gui_data;
if(self->dt->gui->reset) return;
dt_iop_colorize_params_t *p = (dt_iop_colorize_params_t *)self->params;
GtkColorSelectionDialog *csd = GTK_COLOR_SELECTION_DIALOG(gtk_color_selection_dialog_new(_("select tone color")));
g_signal_connect (G_OBJECT (csd->ok_button), "clicked",
G_CALLBACK (colorpick_button_callback), csd);
g_signal_connect (G_OBJECT (csd->cancel_button), "clicked",
G_CALLBACK (colorpick_button_callback), csd);
GtkColorSelection *cs = GTK_COLOR_SELECTION(gtk_color_selection_dialog_get_color_selection(csd));
GdkColor c;
float color[3],h,s,l;
h = p->hue;
s = p->saturation;
l=0.5;
hsl2rgb(color,h,s,l);
c.red= 65535 * color[0];
c.green= 65535 * color[1];
c.blue= 65535 * color[2];
gtk_color_selection_set_current_color(cs,&c);
if(gtk_dialog_run(GTK_DIALOG(csd))==GTK_RESPONSE_ACCEPT)
{
gtk_color_selection_get_current_color(cs,&c);
color[0]=c.red/65535.0;
color[1]=c.green/65535.0;
color[2]=c.blue/65535.0;
rgb2hsl(color,&h,&s,&l);
l=0.5;
hsl2rgb(color,h,s,l);
dtgtk_gradient_slider_set_value(g->gslider1, h);
dtgtk_gradient_slider_set_value(g->gslider2, s);
}
gtk_widget_destroy(GTK_WIDGET(csd));
dt_dev_add_history_item(darktable.develop, self, TRUE);
}
static void open_color_dlg_axis(GtkWidget *button,gpointer data)
{
GtkColorSelectionDialog *colorDlg;
GtkStyle* style = g_object_get_data(G_OBJECT (button), "Style");
GtkWidget *win = g_object_get_data(G_OBJECT (button), "Win");
gdouble* v = g_object_get_data(G_OBJECT (button), "Color");;
GdkColor color;
colorDlg = (GtkColorSelectionDialog *)gtk_color_selection_dialog_new(_("Set Dipole Color"));
color.red = (gushort)(v[0]*65535);
color.green = (gushort)(v[1]*65535);
color.blue = (gushort)(v[2]*65535);
gtk_color_selection_set_current_color (GTK_COLOR_SELECTION (colorDlg->colorsel), &color);
gtk_color_selection_set_current_color (GTK_COLOR_SELECTION (colorDlg->colorsel), &color);
gtk_window_set_transient_for(GTK_WINDOW(colorDlg),GTK_WINDOW(win));
gtk_window_set_position(GTK_WINDOW(colorDlg),GTK_WIN_POS_CENTER);
gtk_window_set_modal (GTK_WINDOW (colorDlg), TRUE);
g_signal_connect(G_OBJECT(colorDlg), "delete_event",(GCallback)destroy_button_windows,NULL);
g_signal_connect(G_OBJECT(colorDlg), "delete_event",G_CALLBACK(gtk_widget_destroy),NULL);
g_object_set_data(G_OBJECT (colorDlg->colorsel), "Color", v);
gtk_widget_hide(colorDlg->help_button);
g_signal_connect_swapped(G_OBJECT(colorDlg->ok_button),"clicked",
(GCallback)set_axis_color,GTK_OBJECT(colorDlg->colorsel));
g_object_set_data(G_OBJECT (colorDlg->ok_button), "Color", v);
g_object_set_data(G_OBJECT (colorDlg->ok_button), "Button", button);
g_object_set_data(G_OBJECT (colorDlg->ok_button), "Style", style);
g_signal_connect(G_OBJECT(colorDlg->ok_button),"clicked", (GCallback)set_axis_button_color,NULL);
g_signal_connect_swapped(G_OBJECT(colorDlg->ok_button), "clicked",
(GCallback)destroy_button_windows,GTK_OBJECT(colorDlg));
g_signal_connect_swapped(G_OBJECT(colorDlg->ok_button),"clicked",
(GCallback)gtk_widget_destroy,GTK_OBJECT(colorDlg));
g_signal_connect_swapped(G_OBJECT(colorDlg->cancel_button), "clicked",
(GCallback)destroy_button_windows,GTK_OBJECT(colorDlg));
g_signal_connect_swapped(G_OBJECT(colorDlg->cancel_button),"clicked",
(GCallback)gtk_widget_destroy,GTK_OBJECT(colorDlg));
add_button_windows(" Set Color ",GTK_WIDGET(colorDlg));
gtk_widget_show(GTK_WIDGET(colorDlg));
}
static VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE options, rb_title;
const gchar *title;
GtkWidget *dialog;
rb_scan_args(argc, argv, "01", &options);
rbg_scan_options(options,
"title", &rb_title,
NULL);
title = RVAL2CSTR_ACCEPT_NIL(rb_title);
dialog = gtk_color_selection_dialog_new(title);
RBGTK_INITIALIZE(self, dialog);
return Qnil;
}
void ColorOptionView::onChangeColor() {
if (myColorSelectionDialog == NULL)
myColorSelectionDialog = gtk_color_selection_dialog_new("Select Color");
GtkColorSelection *colorSelection = GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(myColorSelectionDialog)->colorsel);
gtk_color_selection_set_previous_color(colorSelection, &myColor);
gtk_color_selection_set_current_color(colorSelection, &myColor);
gtk_color_selection_set_has_palette(colorSelection, TRUE);
gint response = gtk_dialog_run(GTK_DIALOG(myColorSelectionDialog));
if (response == GTK_RESPONSE_OK) {
gtk_color_selection_get_current_color(colorSelection, &myColor);
gtk_widget_modify_bg(myDrawingArea, GTK_STATE_NORMAL, &myColor);
}
gtk_widget_hide(myColorSelectionDialog);
}
