void upj2(GtkWidget *wgt, gpointer dta)
{
GdkColor cl1;
guint16 alp;
GtkPlot *pt;
pt=GTK_PLOT(pt2);
if (gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(wgt)))
{
(cl1.red)=(guint16) (65535*g_array_index((pt->rd), gdouble, 1));
(cl1.green)=(guint16) (65535*g_array_index((pt->gr), gdouble, 1));
(cl1.blue)=(guint16) (65535*g_array_index((pt->bl), gdouble, 1));
alp=(guint16) (65535*g_array_index((pt->al), gdouble, 1));
}
else
{
(cl1.red)=(guint16) (65535*g_array_index((pt->rd), gdouble, 0));
(cl1.green)=(guint16) (65535*g_array_index((pt->gr), gdouble, 0));
(cl1.blue)=(guint16) (65535*g_array_index((pt->bl), gdouble, 0));
alp=(guint16) (65535*g_array_index((pt->al), gdouble, 0));
}
gdk_colormap_alloc_color(cmp, &cl1, FALSE, TRUE);
gtk_color_selection_set_current_color(GTK_COLOR_SELECTION(cs2), &cl1);
gtk_color_selection_set_current_alpha(GTK_COLOR_SELECTION(cs2), alp);
}
static void row_activated(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColumn *column, GtkWidget *widget)
{
GtkTreeIter iter;
GtkTreeModel *model = gtk_tree_view_get_model(view);
GValue value = { 0, };
int id;
if(!gtk_tree_model_get_iter(model,&iter,path))
{
gtk_widget_set_sensitive(widget,0);
return;
}
gtk_tree_model_get_value(model,&iter,1,&value);
id = g_value_get_int(&value);
g_object_set_data(G_OBJECT(widget),"selected",(gpointer) id);
if(id < 0 || id >= TERMINAL_COLOR_COUNT)
{
gtk_widget_set_sensitive(widget,0);
return;
}
gtk_color_selection_set_previous_color(GTK_COLOR_SELECTION(widget),color+id);
gtk_color_selection_set_current_color(GTK_COLOR_SELECTION(widget),color+id);
gtk_widget_set_sensitive(widget,1);
}
/* Sets the color in the GtkColorSelection. The widgets are updated to
* reflect the new color. */
int
clip_GTK_COLORSELECTIONSETCOLOR(ClipMachine * ClipMachineMemory)
{
C_widget *ccsel = _fetch_cw_arg(ClipMachineMemory);
ClipVar *mcolor = _clip_spar(ClipMachineMemory, 2);
gdouble color[4];
gdouble k, max;
CHECKCWID(ccsel, GTK_IS_COLOR_SELECTION);
CHECKOPT(2, MAP_type_of_ClipVarType);
if (_clip_parinfo(ClipMachineMemory, 2) == UNDEF_type_of_ClipVarType)
gtk_color_selection_get_color(GTK_COLOR_SELECTION(ccsel->widget), color);
else
_map_get_colors(ClipMachineMemory, mcolor, color);
color[0] = color[0] > 0 ? color[0] : 1;
color[1] = color[1] > 0 ? color[1] : 1;
color[2] = color[2] > 0 ? color[2] : 1;
max = color[0] > color[1] ? color[0] : color[1];
max = max > color[2] ? max : color[2];
max = max > 0 ? max : 1;
k = 1 / max;
color[0] *= k;
color[1] *= k;
color[2] *= k;
gtk_color_selection_set_color(GTK_COLOR_SELECTION(ccsel->widget), color);
return 0;
err:
return 1;
}
/**
* 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;
}
bool GtkToolkitColorChooser::Show(X11Types::Window parent, uint32_t initial_color)
{
GdkColor old_color = GtkUtils::ColorrefToGdkColor(initial_color);
gtk_color_selection_set_current_color (
GTK_COLOR_SELECTION(m_color_selector), &old_color);
// we have to show dialog before running it
gtk_widget_show(m_dialog);
// otherwise this will result in nasty crash inside gtk
XSetTransientForHint(GDK_WINDOW_XDISPLAY(gtk_widget_get_window(m_dialog)),
GDK_WINDOW_XID(gtk_widget_get_window(m_dialog)), parent);
GtkUtils::SetResourceName(m_dialog, "colorselectordialog");
gint result = gtk_dialog_run(GTK_DIALOG(m_dialog));
GdkColor new_color;
gtk_color_selection_get_current_color(
GTK_COLOR_SELECTION(m_color_selector), &new_color);
m_color = GtkUtils::GdkColorToColorref(&new_color);
gtk_widget_destroy (m_dialog);
GtkUtils::ProcessEvents();
return (GTK_RESPONSE_OK == result);
}
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));
}
int DIA_colorSel(uint8_t *r, uint8_t *g, uint8_t *b)
{
GtkWidget *dialog;
int ret=0;
GdkColor color;
dialog=create_colorselectiondialog1();
color.red=*r<<8;
color.green=*g<<8;
color.blue=*b<<8;
gtk_color_selection_set_current_color (GTK_COLOR_SELECTION(WID(color_selection1)),&color);
if(GTK_RESPONSE_OK==gtk_dialog_run(GTK_DIALOG(dialog)))
{
gtk_color_selection_get_current_color (GTK_COLOR_SELECTION(WID(color_selection1)),&color);
*r=color.red>>8;
*g=color.green>>8;
*b=color.blue>>8;
ret=1;
}
/* Retrieve the currently selected color value. */
int
clip_GTK_COLORSELECTIONGETCOLOR(ClipMachine * ClipMachineMemory)
{
C_widget *ccsel = _fetch_cw_arg(ClipMachineMemory);
GtkColorSelection *colorsel;
ClipVar mcolor;
gdouble color[4];
CHECKCWID(ccsel, GTK_IS_COLOR_SELECTION);
colorsel = GTK_COLOR_SELECTION(ccsel->widget);
gtk_color_selection_get_color(GTK_COLOR_SELECTION(ccsel->widget), color);
color[0] *= CLIP_GTK_MAX_COLOR;
color[1] *= CLIP_GTK_MAX_COLOR;
color[2] *= CLIP_GTK_MAX_COLOR;
memset(&mcolor, 0, sizeof(mcolor));
_clip_map(ClipMachineMemory, &mcolor);
_map_put_colors(ClipMachineMemory, &mcolor, color);
_clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &mcolor);
return 0;
err:
return 1;
}
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));
}
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;
}
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;
}
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);
}
static void colsel_ok_clicked_lcb(GtkWidget *widget, Tcolsel *csd) {
gchar *tmpstr;
GdkColor gcolor;
/* only on a OK click we do the setcolor thing */
gtk_color_selection_get_current_color(GTK_COLOR_SELECTION(csd->csel), &gcolor);
tmpstr = gdk_color_to_hexstring(&gcolor, FALSE);
if (csd->bfwin) {
csd->bfwin->session->colorlist = add_to_stringlist(csd->bfwin->session->colorlist, tmpstr);
}
if (csd->is_modal) {
g_free(csd->returnval);
csd->returnval = tmpstr;
gtk_main_quit();
} else {
if (string_is_color(tmpstr)) {
if (csd->startpos || csd->endpos) {
DEBUG_MSG("colsel_ok_clicked_lcb, replacing with %s\n", tmpstr);
doc_replace_text(csd->bfwin->current_document, tmpstr, csd->startpos, csd->endpos);
} else {
DEBUG_MSG("colsel_ok_clicked_lcb, inserting %s\n", tmpstr);
doc_insert_two_strings(csd->bfwin->current_document,tmpstr, NULL);
}
}
g_free(tmpstr);
window_destroy(csd->win);
}
}
void
on_color_change_button_clicked (GtkButton * button, gpointer user_data)
{
GtkTreePath *gpath;
GtkTreeViewColumn *gcol;
GtkTreeIter it;
GdkColor *gdk_color;
GtkColorSelectionDialog *dlg;
GtkColorSelection *csel;
EATreePos ep;
if (!get_color_store (&ep))
return;
/* gets the row (path) at cursor */
gtk_tree_view_get_cursor (ep.gv, &gpath, &gcol);
if (!gpath)
return; /* no row selected */
/* get iterator from path */
if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (ep.gs), &it, gpath))
return;
gtk_tree_model_get (GTK_TREE_MODEL (ep.gs), &it, 1, &gdk_color, -1);
dlg = GTK_COLOR_SELECTION_DIALOG
(glade_xml_get_widget (appdata.xml, "colorselectiondialog"));
csel = GTK_COLOR_SELECTION(dlg->colorsel);
gtk_color_selection_set_current_color(csel, gdk_color);
gtk_color_selection_set_previous_color(csel, gdk_color);
g_object_set_data( G_OBJECT(dlg), "isadd", GINT_TO_POINTER(FALSE));
gtk_widget_show (GTK_WIDGET(dlg));
} /* on_color_change_button_clicked */
static void
color_selection_ok (GtkWidget *w,
GtkColorSelectionDialog *cs)
{
GtkColorSelection *colorsel;
GdkColor color;
Color col;
colorsel=GTK_COLOR_SELECTION(cs->colorsel);
gtk_color_selection_get_current_color(colorsel,&color);
GDK_COLOR_TO_DIA(color, col);
if (edit_color == FOREGROUND) {
attributes_set_foreground(&col);
} else {
attributes_set_background(&col);
}
color_area_draw ();
/* gtk_color_selection_set_currentcolor(colorsel,&color);*/
gtk_widget_hide(color_select);
color_select_active = 0;
}
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);
}
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);
*/
}
void wxColourDialog::ColourDataToDialog()
{
GtkColorSelection* sel = GTK_COLOR_SELECTION(
gtk_color_selection_dialog_get_color_selection(
GTK_COLOR_SELECTION_DIALOG(m_widget)));
const wxColour& color = m_data.GetColour();
if (color.IsOk())
{
#ifdef __WXGTK3__
gtk_color_selection_set_current_rgba(sel, color);
#else
gtk_color_selection_set_current_color(sel, color.GetColor());
#endif
}
// setup the palette:
GdkColor colors[wxColourData::NUM_CUSTOM];
gint n_colors = 0;
for (unsigned i = 0; i < WXSIZEOF(colors); i++)
{
wxColour c = m_data.GetCustomColour(i);
if (c.IsOk())
{
colors[n_colors] = *c.GetColor();
n_colors++;
}
}
wxGtkString pal(gtk_color_selection_palette_to_string(colors, n_colors));
GtkSettings *settings = gtk_widget_get_settings(GTK_WIDGET(sel));
g_object_set(settings, "gtk-color-palette", pal.c_str(), NULL);
}
GtkWidget *roccat_color_selection_dialog_new(GtkWindow *parent) {
RoccatColorSelectionDialog *color_selection_dialog;
RoccatColorSelectionDialogPrivate *priv;
GtkWidget *content_area;
color_selection_dialog = g_object_new(ROCCAT_COLOR_SELECTION_DIALOG_TYPE, NULL);
priv = color_selection_dialog->priv;
gtk_dialog_add_button(GTK_DIALOG(color_selection_dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
gtk_dialog_add_button(GTK_DIALOG(color_selection_dialog), GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_window_set_title(GTK_WINDOW(color_selection_dialog), _("Choose color"));
gtk_window_set_transient_for(GTK_WINDOW(color_selection_dialog), parent);
gtk_window_set_modal(GTK_WINDOW(color_selection_dialog), TRUE);
gtk_window_set_destroy_with_parent(GTK_WINDOW(color_selection_dialog), TRUE);
priv->multiwidget = ROCCAT_MULTIWIDGET(roccat_multiwidget_new());
priv->palette_selector = ROCCAT_COLOR_PALETTE_SELECTOR(roccat_color_palette_selector_new());
roccat_multiwidget_add(priv->multiwidget, GTK_WIDGET(priv->palette_selector));
g_signal_connect(G_OBJECT(priv->palette_selector), "color-changed", G_CALLBACK(palette_color_changed_cb), color_selection_dialog);
priv->custom_selector = GTK_COLOR_SELECTION(gtk_color_selection_new());
roccat_multiwidget_add(priv->multiwidget, GTK_WIDGET(priv->custom_selector));
g_signal_connect(G_OBJECT(priv->custom_selector), "color-changed", G_CALLBACK(custom_color_changed_cb), color_selection_dialog);
content_area = gtk_dialog_get_content_area(GTK_DIALOG(color_selection_dialog));
gtk_box_pack_start(GTK_BOX(content_area), GTK_WIDGET(priv->multiwidget), TRUE, TRUE, 0);
gtk_widget_show_all(GTK_WIDGET(content_area));
return GTK_WIDGET(color_selection_dialog);
}
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);
}
/* 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 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);
}
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
dialog_response (GtkWidget * widget, GtkResponseType response, gpointer data)
{
GSMColorButton *color_button = GSM_COLOR_BUTTON (data);
GtkColorSelection *color_selection;
if (response == GTK_RESPONSE_OK) {
color_selection =
GTK_COLOR_SELECTION (gtk_color_selection_dialog_get_color_selection (GTK_COLOR_SELECTION_DIALOG
(color_button->priv->cs_dialog)));
gtk_color_selection_get_current_color (color_selection,
&color_button->priv->color);
gtk_widget_hide (color_button->priv->cs_dialog);
gtk_widget_queue_draw (GTK_WIDGET (&color_button->widget));
g_signal_emit (color_button, color_button_signals[COLOR_SET], 0);
g_object_freeze_notify (G_OBJECT (color_button));
g_object_notify (G_OBJECT (color_button), "color");
g_object_thaw_notify (G_OBJECT (color_button));
}
else /* (response == GTK_RESPONSE_CANCEL) */
gtk_widget_hide (color_button->priv->cs_dialog);
}
static void color_ok_sel( GtkWidget *widget, gpointer cb_data )
{
PXWT_GTK_MODAL xwtFilew = (PXWT_GTK_MODAL) ((PXWT_WIDGET)cb_data)->widget_data;
HB_ITEM itmFileName;
GdkColor color;
GtkColorSelection *colorsel;
char fname[8];
// this builds the Self object
// If you use this macro, you must put it AFTER variable decl,
// and BEFORE any other statement
XWT_GTK_MAKESELF( (((PXWT_WIDGET)cb_data)->owner) );
colorsel = GTK_COLOR_SELECTION( GTK_COLOR_SELECTION_DIALOG( xwtFilew->a.main_widget )->colorsel );
gtk_color_selection_get_current_color( colorsel, &color );
hb_snprintf( fname, sizeof( fname ), "#%2ix%2ix%2ix", color.red, color.green, color.blue );
// itemPutC uses the char* parameter as it were const: it does not
// mangles with that, it just creates a new local copy of the param.
hb_itemPutC( &itmFileName, ( char *) fname );
//rising the updated event, to signal that we have a candidate filename
xwt_rise_event( &Self, XWT_E_UPDATED, 1, &itmFileName );
// now we can reset the modal status
xwtFilew->modal = FALSE;
}
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;
}
GtkWidget* LightDialog::createColorSelector ()
{
_colorSelector = GTK_COLOR_SELECTION(gtk_color_selection_new());
gtk_color_selection_set_has_opacity_control(_colorSelector, FALSE);
gtk_color_selection_set_has_palette(_colorSelector, FALSE);
return GTK_WIDGET(_colorSelector);
}
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 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);
}
