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);
}
//------------------------- 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(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);
}
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);
}
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;
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;
}
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;
}
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);
}
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 ColorOptionView::_createItem() {
GdkColor initialColor = convertColor(((ZLColorOptionEntry&)*myOption).initialColor());
GdkColor currentColor = convertColor(((ZLColorOptionEntry&)*myOption).color());
myColorSelection = GTK_COLOR_SELECTION(gtk_color_selection_new());
gtk_color_selection_set_has_opacity_control(myColorSelection, false);
gtk_color_selection_set_has_palette(myColorSelection, true);
gtk_color_selection_set_current_color(myColorSelection, ¤tColor);
gtk_color_selection_set_previous_color(myColorSelection, &initialColor);
GtkContainer *container = GTK_CONTAINER(gtk_vbox_new(true, 0));
gtk_container_set_border_width(container, 5);
gtk_container_add(container, GTK_WIDGET(myColorSelection));
myHolder.attachWidget(*this, GTK_WIDGET(container));
gtk_widget_show(GTK_WIDGET(container));
}
int
clip_GTK_COLORSELECTIONSETHASPALETTE(ClipMachine * ClipMachineMemory)
{
C_widget *ccsel = _fetch_cw_arg(ClipMachineMemory);
gboolean use_palette = _clip_parl(ClipMachineMemory, 2);
CHECKCWID(ccsel, GTK_IS_COLOR_SELECTION);
CHECKOPT(2, LOGICAL_type_of_ClipVarType);
if (_clip_parinfo(ClipMachineMemory, 2) == UNDEF_type_of_ClipVarType)
use_palette = TRUE;
gtk_color_selection_set_has_palette(GTK_COLOR_SELECTION(ccsel->widget), use_palette);
return 0;
err:
return 1;
}
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
gtk_color_selection_dialog_init (GtkColorSelectionDialog *colorseldiag)
{
GtkDialog *dialog = GTK_DIALOG (colorseldiag);
gtk_dialog_set_has_separator (dialog, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_box_set_spacing (GTK_BOX (dialog->vbox), 2); /* 2 * 5 + 2 = 12 */
gtk_container_set_border_width (GTK_CONTAINER (dialog->action_area), 5);
gtk_box_set_spacing (GTK_BOX (dialog->action_area), 6);
colorseldiag->colorsel = gtk_color_selection_new ();
gtk_container_set_border_width (GTK_CONTAINER (colorseldiag->colorsel), 5);
gtk_color_selection_set_has_palette (GTK_COLOR_SELECTION(colorseldiag->colorsel), FALSE);
gtk_color_selection_set_has_opacity_control (GTK_COLOR_SELECTION(colorseldiag->colorsel), FALSE);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (colorseldiag)->vbox), colorseldiag->colorsel);
gtk_widget_show (colorseldiag->colorsel);
colorseldiag->cancel_button = gtk_dialog_add_button (GTK_DIALOG (colorseldiag),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
colorseldiag->ok_button = gtk_dialog_add_button (GTK_DIALOG (colorseldiag),
GTK_STOCK_OK,
GTK_RESPONSE_OK);
gtk_widget_grab_default (colorseldiag->ok_button);
colorseldiag->help_button = gtk_dialog_add_button (GTK_DIALOG (colorseldiag),
GTK_STOCK_HELP,
GTK_RESPONSE_HELP);
gtk_widget_hide (colorseldiag->help_button);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (colorseldiag),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
GTK_RESPONSE_HELP,
-1);
gtk_window_set_title (GTK_WINDOW (colorseldiag),
_("Color Selection"));
_gtk_dialog_set_ignore_separator (dialog, TRUE);
}
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);
}
static void callback_color_clicked(GtkWidget *widget, gpointer data)
{
GtkWidget *button;
GtkColorSelection *colorsel;
GdkColor col;
int i;
i = GPOINTER_TO_INT(data);
col.red = new_settings.color[i].r * 256;
col.green = new_settings.color[i].g * 256;
col.blue = new_settings.color[i].b * 256;
color_dialog = gtk_color_selection_dialog_new("Changing color");
colorsel = GTK_COLOR_SELECTION(
GTK_COLOR_SELECTION_DIALOG(color_dialog)->colorsel);
/* set up the okay button */
button = GTK_COLOR_SELECTION_DIALOG(color_dialog)->ok_button;
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(callback_color_okay), data);
/* set up the cancel button */
button = GTK_COLOR_SELECTION_DIALOG(color_dialog)->cancel_button;
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(callback_color_cancel), data);
/* remove the help button */
button = GTK_COLOR_SELECTION_DIALOG(color_dialog)->help_button;
gtk_widget_destroy(button);
gtk_color_selection_set_previous_color(colorsel, &col);
gtk_color_selection_set_current_color(colorsel, &col);
gtk_color_selection_set_has_palette(colorsel, TRUE);
gtk_window_set_transient_for(GTK_WINDOW(color_dialog),
GTK_WINDOW(dialog_window));
gtk_window_set_modal(GTK_WINDOW(color_dialog), TRUE);
gtk_widget_show_all(color_dialog);
}
/*!
* Intercept clicks on the color button and show an own GtkColorSelectionDialog
* with palette enabled.
*/
static gboolean
AP_UnixDialog_FormatFrame__onBackgroundColorClicked (GtkWidget *button,
GdkEventButton *event,
gpointer data)
{
// only handle left clicks
if (event->button != 1) {
return FALSE;
}
AP_UnixDialog_FormatFrame *dlg = static_cast<AP_UnixDialog_FormatFrame *>(data);
UT_return_val_if_fail (button && dlg, FALSE);
GtkWidget *colordlg = gtk_color_selection_dialog_new ("");
gtk_window_set_transient_for (GTK_WINDOW (colordlg), GTK_WINDOW (dlg->getWindow ()));
GtkColorSelection *colorsel = GTK_COLOR_SELECTION ((GTK_COLOR_SELECTION_DIALOG (colordlg))->colorsel);
gtk_color_selection_set_has_palette (colorsel, TRUE);
gint result = gtk_dialog_run (GTK_DIALOG (colordlg));
if (result == GTK_RESPONSE_OK) {
// update button
GtkColorButton *colorbtn = GTK_COLOR_BUTTON (button);
GdkColor color;
gtk_color_selection_get_current_color (colorsel, &color);
gtk_color_button_set_color (colorbtn, &color);
// update dialog
UT_RGBColor* rgb = UT_UnixGdkColorToRGBColor (color);
dlg->setBGColor (*rgb);
DELETEP (rgb);
dlg->event_previewExposed ();
}
// do not propagate further
gtk_widget_destroy (colordlg);
return TRUE;
}
void DocActionFmt::Exec(bool bInteractive)
{
bool bExists = false;
if(bInteractive)
{
m_lstFmt = g_doc.GetNodeByIdx(m_nNodeIdx).m_lstTxtFmt;
int nCursor = 0;
int nSelection = 0;
g_text.GetSelectionBounds(nCursor, nSelection);
if(nCursor != nSelection)
{
int nStart = min(nCursor, nSelection);
int nEnd = max(nCursor, nSelection);
m_nStartOffset = nStart;
m_nEndOffset = nEnd;
bExists = g_doc.GetNodeByIdx(m_nNodeIdx).m_lstTxtFmt.IsRangeFormatted(m_nStartOffset, m_nEndOffset, m_nOperationTag);
//start color picker if required
GdkColor color;
if( (!bExists || m_bCtrlPressed) &&
(FMT_TXT_COLOR_BEGIN == m_nOperationTag || FMT_TXT_BKG_COLOR_BEGIN == m_nOperationTag))
{
if(m_bCtrlPressed)
{
if(FMT_TXT_COLOR_BEGIN == m_nOperationTag)
color = g_rgbTextColor;
else
color = g_rgbTextBgColor;
}
else
{
GtkWidget *picker = gtk_color_selection_dialog_new (_("Pick text color"));
gtk_window_set_modal (GTK_WINDOW (picker), TRUE);
gtk_window_set_destroy_with_parent (GTK_WINDOW (picker), TRUE);
#ifndef _WIN32 //TOFIX API is buggy on Win32 (kills modal dialog state)
gtk_window_set_skip_taskbar_hint (GTK_WINDOW (picker), TRUE);
#endif
gtk_window_set_skip_pager_hint (GTK_WINDOW (picker), TRUE);
gtk_window_set_type_hint (GTK_WINDOW (picker), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_transient_for(GTK_WINDOW (picker), GTK_WINDOW(window1)); //set parent
#if GTK_CHECK_VERSION(2,4,0) //new API TOFIX set proper version
#ifndef _WIN32 //TOFIX API is buggy on Win32 (kills modal dialog state)
//gtk_window_set_keep_above(GTK_WINDOW (picker), TRUE);
#endif
#endif
gtk_widget_realize(picker);
gdk_window_set_decorations(picker->window, (GdkWMDecoration)(GDK_DECOR_BORDER|GDK_DECOR_TITLE));
GtkColorSelection *colorsel = GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (picker)->colorsel);
if(FMT_TXT_COLOR_BEGIN == m_nOperationTag){
gtk_color_selection_set_previous_color(GTK_COLOR_SELECTION(colorsel), &g_rgbTextColor);
gtk_color_selection_set_current_color(GTK_COLOR_SELECTION(colorsel), &g_rgbTextColor);
}
else
{
gtk_color_selection_set_previous_color(GTK_COLOR_SELECTION(colorsel), &g_rgbTextBgColor);
gtk_color_selection_set_current_color(GTK_COLOR_SELECTION(colorsel), &g_rgbTextBgColor);
}
gtk_color_selection_set_has_palette (GTK_COLOR_SELECTION(colorsel), TRUE);
if(GTK_RESPONSE_OK != gtk_dialog_run(GTK_DIALOG(picker))){
gtk_widget_destroy(picker);
return;
}
gtk_color_selection_get_current_color(colorsel, &color);
gtk_widget_destroy(picker);
}
m_color = color;
if(FMT_TXT_COLOR_BEGIN == m_nOperationTag)
g_rgbTextColor = color; //remember last used color
else
g_rgbTextBgColor = color; //remember last used color
}
}
}
bExists = g_doc.GetNodeByIdx(m_nNodeIdx).m_lstTxtFmt.IsRangeFormatted(m_nStartOffset, m_nEndOffset, m_nOperationTag);
if(bExists){
g_doc.GetNodeByIdx(m_nNodeIdx).m_lstTxtFmt.ClearFormatRange(m_nStartOffset, m_nEndOffset, m_nOperationTag);
RefreshTextFormat(g_doc.GetNodeByIdx(m_nNodeIdx), false, m_nStartOffset, m_nEndOffset);
}
else{
g_doc.GetNodeByIdx(m_nNodeIdx).m_lstTxtFmt.AddFormatRange(m_nStartOffset, m_nEndOffset, m_nOperationTag, m_color);
if(FMT_NONE == m_nOperationTag)
RefreshTextFormat(g_doc.GetNodeByIdx(m_nNodeIdx), false, m_nStartOffset, m_nEndOffset);
}
textview_selection_changed(NULL, NULL, NULL, NULL);
TRACE("DocActionFmt::Exec\n");
}
GtkWidget *
color_create_widget (GtkWidget *dlg)
{
GtkWidget *w;
#if !GTK_CHECK_VERSION(3,0,0)
w = gtk_vbox_new (FALSE, 2);
#else
w = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
#endif
color = gtk_color_selection_new ();
gtk_widget_set_name (color, "yad-color-widget");
gtk_color_selection_set_has_palette (GTK_COLOR_SELECTION (color), settings.show_gtk_palette);
if (options.color_data.init_color)
{
GdkColor c;
if (gdk_color_parse (options.color_data.init_color, &c))
gtk_color_selection_set_current_color (GTK_COLOR_SELECTION (color), &c);
}
gtk_box_pack_start (GTK_BOX (w), color, FALSE, FALSE, 2);
if (options.color_data.use_palette)
{
GtkTreeModel *model;
if ((model = create_palette ()) != NULL)
{
GtkWidget *exp, *sw, *list;
GtkCellRenderer *r;
GtkTreeViewColumn *col;
GtkTreeSelection *sel;
/* create expander */
exp = gtk_expander_new (_("Palette"));
gtk_expander_set_expanded (GTK_EXPANDER (exp), settings.expand_palette);
gtk_container_set_border_width (GTK_CONTAINER (exp), 5);
gtk_box_pack_start (GTK_BOX (w), exp, TRUE, TRUE, 2);
/* create color list */
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (exp), sw);
list = gtk_tree_view_new_with_model (model);
gtk_widget_set_name (list, "yad-color-palette");
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (list), settings.rules_hint);
g_object_unref (model);
gtk_container_add (GTK_CONTAINER (sw), list);
/* add first columns */
col = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (col, _("Color"));
/* pixbuf */
r = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (col, r, FALSE);
gtk_tree_view_column_set_attributes (col, r, "pixbuf", 0, NULL);
/* color value */
r = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (col, r, TRUE);
gtk_tree_view_column_set_attributes (col, r, "text", 1, NULL);
gtk_tree_view_column_set_sort_column_id (col, 1);
gtk_tree_view_append_column (GTK_TREE_VIEW (list), col);
/* add second column */
r = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (_("Name"), r, "text", 2, NULL);
gtk_tree_view_column_set_sort_column_id (col, 2);
gtk_tree_view_append_column (GTK_TREE_VIEW (list), col);
/* enable searching on Name column */
gtk_tree_view_set_search_column (GTK_TREE_VIEW (list), 2);
/* setup the selection handler */
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (list));
gtk_tree_selection_set_mode (sel, GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT (sel), "changed", G_CALLBACK (palette_changed), NULL);
gtk_widget_show_all (exp);
}
}
return w;
}
static Tcolsel *colsel_dialog(Tbfwin *bfwin,const gchar *setcolor, gint modal, gint startpos, gint endpos) {
Tcolsel *csd;
GtkWidget *vbox, *hbox, *but;
GdkColor gcolor;
const gchar *this_color=setcolor;
csd = g_new0(Tcolsel, 1);
/* warning: bfwin might be NULL if this dialog is started by return_color() */
csd->bfwin = bfwin;
csd->is_modal = modal;
csd->startpos = startpos;
csd->endpos = endpos;
csd->returnval = setcolor ? g_strdup(setcolor) : g_strdup("");
DEBUG_MSG("colsel_dialog, malloced at %p, setcolor=%s\n", csd, setcolor);
csd->win = window_full2(_("Bluefish: Select color"), GTK_WIN_POS_CENTER, 12, G_CALLBACK(colsel_destroy_lcb), csd, TRUE, bfwin?bfwin->main_window:NULL);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(csd->win), vbox);
csd->csel = gtk_color_selection_new();
gtk_color_selection_set_has_opacity_control(GTK_COLOR_SELECTION(csd->csel), FALSE);
if (this_color) {
if (gdk_color_parse(this_color, &gcolor)) {
gtk_color_selection_set_current_color(GTK_COLOR_SELECTION(csd->csel), &gcolor);
} else {
this_color=NULL;
}
}
gtk_color_selection_set_has_palette(GTK_COLOR_SELECTION(csd->csel), TRUE);
gtk_box_pack_start(GTK_BOX(vbox), csd->csel, TRUE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 12);
#if GTK_CHECK_VERSION(3,0,0)
hbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
#else
hbox = gtk_hbutton_box_new();
#endif
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(hbox), 12);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
but = bf_stock_cancel_button(G_CALLBACK(colsel_cancel_clicked_lcb), csd);
gtk_box_pack_start(GTK_BOX(hbox), but, TRUE, TRUE, 0);
but = bf_stock_ok_button(G_CALLBACK(colsel_ok_clicked_lcb), csd);
gtk_window_set_default(GTK_WINDOW(csd->win), but);
gtk_box_pack_start(GTK_BOX(hbox), but, TRUE, TRUE, 0);
if (bfwin && bfwin->session->colorlist) {
GtkSettings* gtksettings;
/* Note that this function can only be called when the GtkWidget is attached to a toplevel, since the settings object is specific to a particular GdkScreen. */
gtksettings = gtk_widget_get_settings(GTK_WIDGET(csd->csel));
if (gtksettings) {
gchar *strings;
DEBUG_MSG("pallette list=%d\n",g_list_length(bfwin->session->colorlist));
bfwin->session->colorlist = limit_stringlist(bfwin->session->colorlist, 20, TRUE);
DEBUG_MSG("pallette list=%d\n",g_list_length(bfwin->session->colorlist));
strings = stringlist_to_string(bfwin->session->colorlist, ":");
strings[strlen(strings)-1] = '\0';
/* this property may contain max 20 colors, otherwise gtk will crash */
g_object_set(G_OBJECT(gtksettings), "gtk-color-palette", strings, NULL);
g_free(strings);
}
/* DEBUG_MSG("colsel_dialog, setting palette from %s\n", strings);
if (gtk_color_selection_palette_from_string(strings, &gcolorarr, &num)) {
DEBUG_MSG("num=%d, gcolorarr=%p\n",num,gcolorarr);
} else {
DEBUG_MSG("hmm, failed to parse our string :(\n");
} */
}
gtk_widget_show_all(csd->win);
DEBUG_MSG("colsel_dialog, finished\n");
return csd;
}
static int gtkColorDlgPopup(Ihandle* ih, int x, int y)
{
InativeHandle* parent = iupDialogGetNativeParent(ih);
GtkColorSelectionDialog* dialog;
GtkColorSelection* colorsel;
GdkColor color;
char *value;
unsigned char r = 0, g = 0, b = 0, a = 255;
int response, ret;
iupAttribSetInt(ih, "_IUPDLG_X", x); /* used in iupDialogUpdatePosition */
iupAttribSetInt(ih, "_IUPDLG_Y", y);
dialog = (GtkColorSelectionDialog*)gtk_color_selection_dialog_new(iupgtkStrConvertToUTF8(iupAttribGet(ih, "TITLE")));
if (!dialog)
return IUP_ERROR;
if (parent)
gtk_window_set_transient_for((GtkWindow*)dialog, (GtkWindow*)parent);
ret = iupStrToRGBA(iupAttribGet(ih, "VALUE"), &r, &g, &b, &a);
colorsel = (GtkColorSelection*)dialog->colorsel;
iupgdkColorSet(&color, r, g, b);
gtk_color_selection_set_current_color(colorsel, &color);
value = iupAttribGetStr(ih, "ALPHA");
if (value)
{
int alpha;
if (iupStrToInt(value, &alpha))
{
if (alpha<0) alpha=0;
if (alpha>255) alpha=255;
gtk_color_selection_set_has_opacity_control(colorsel, TRUE);
gtk_color_selection_set_current_alpha(colorsel, iupCOLOR8TO16(alpha));
}
}
else if (iupAttribGetBoolean(ih, "SHOWALPHA") || ret == 4)
{
gtk_color_selection_set_has_opacity_control(colorsel, TRUE);
gtk_color_selection_set_current_alpha(colorsel, iupCOLOR8TO16(a));
}
else
gtk_color_selection_set_has_opacity_control(colorsel, FALSE);
value = iupAttribGetStr(ih, "COLORTABLE");
if (value)
{
gtk_color_selection_set_has_palette (colorsel, TRUE);
gtkColorDlgSetPalette(colorsel, value);
}
else if (iupAttribGetBoolean(ih, "SHOWCOLORTABLE"))
gtk_color_selection_set_has_palette (colorsel, TRUE);
else
gtk_color_selection_set_has_palette (colorsel, FALSE);
if (IupGetCallback(ih, "HELP_CB"))
gtk_widget_show(dialog->help_button);
/* initialize the widget */
gtk_widget_realize(GTK_WIDGET(dialog));
ih->handle = GTK_WIDGET(dialog);
iupDialogUpdatePosition(ih);
ih->handle = NULL;
do
{
response = gtk_dialog_run(GTK_DIALOG(dialog));
if (response == GTK_RESPONSE_HELP)
{
Icallback cb = IupGetCallback(ih, "HELP_CB");
if (cb && cb(ih) == IUP_CLOSE)
response = GTK_RESPONSE_CANCEL;
}
} while (response == GTK_RESPONSE_HELP);
if (response == GTK_RESPONSE_OK)
{
GdkColor color;
gtk_color_selection_get_current_color(colorsel, &color);
IupSetAttribute(ih, "STATUS", "1");
if (gtk_color_selection_get_has_opacity_control(colorsel))
{
int alpha = gtk_color_selection_get_current_alpha(colorsel);
iupAttribSetInt(ih, "ALPHA", (int)iupCOLOR16TO8(alpha));
iupAttribSetStrf(ih, "VALUE", "%d %d %d %d", (int)iupCOLOR16TO8(color.red), (int)iupCOLOR16TO8(color.green), (int)iupCOLOR16TO8(color.blue), (int)iupCOLOR16TO8(alpha));
}
else
iupAttribSetStrf(ih, "VALUE", "%d %d %d", (int)iupCOLOR16TO8(color.red), (int)iupCOLOR16TO8(color.green), (int)iupCOLOR16TO8(color.blue));
if (gtk_color_selection_get_has_palette(colorsel))
gtkColorDlgGetPalette(ih, colorsel);
}
else
{
iupAttribSetStr(ih, "ALPHA", NULL);
iupAttribSetStr(ih, "VALUE", NULL);
iupAttribSetStr(ih, "COLORTABLE", NULL);
iupAttribSetStr(ih, "STATUS", NULL);
}
gtk_widget_destroy(GTK_WIDGET(dialog));
return IUP_NOERROR;
}
gint main(gint argc, gchar * argv[]){
GtkWidget *colorseldlg;
GdkColor color;
GtkColorSelection *colorsel;
gint response;
gint r, g, b;
guint16 alpha=65535;
float f;
self = argv[0];
gtk_init(&argc, &argv);
if(argc == 2){
g = 0;
b = 0;
if(argv[1][0] == 'r'){
if(argv[1][3] == 'a'){
//rgba(...)
sscanf(argv[1], "rgba(%d, %d, %d, %f)", &r, &g, &b, &f);
color.red = r * 256;
color.green = g * 256;
color.blue = b * 256;
alpha = f * 65535;
}else if(argv[1][3] == '('){
//rgb(...)
sscanf(argv[1], "rgb(%d, %d, %d)", &r, &g, &b);
color.red = r * 256;
color.green = g * 256;
color.blue = b * 256;
}else{
usage();
return 2;
}
goto option_ok;
}
if(argv[1][0] == '#'){
b = 1;
}
for(r=b; r<b+6; r++){
if(!isxdigit(argv[1][r])){
usage();
return 2;
}
}
if(b){
/* # 开头 */
argv[1]++;
}
sscanf(argv[1], "%2x%2x%2x", &r, &g, &b);
color.red = r * 256;
color.green = g * 256;
color.blue = b * 256;
}else if(argc == 1){
color.red = 0xffff;
color.green = 0xffff;
color.blue = 0xffff;
}else{
usage();
return 2;
}
option_ok:
colorseldlg = gtk_color_selection_dialog_new("Select color");
colorsel = GTK_COLOR_SELECTION(
gtk_color_selection_dialog_get_color_selection(
GTK_COLOR_SELECTION_DIALOG(colorseldlg)));
gtk_color_selection_set_current_color(colorsel, &color);
gtk_color_selection_set_has_palette(colorsel, TRUE);
gtk_color_selection_set_has_opacity_control(colorsel, TRUE);
gtk_color_selection_set_current_alpha(colorsel, alpha);
gtk_window_set_position(GTK_WINDOW(colorseldlg), GTK_WIN_POS_MOUSE);
gtk_window_set_keep_above(GTK_WINDOW(colorseldlg), TRUE);
response = gtk_dialog_run(GTK_DIALOG(colorseldlg));
if(response == GTK_RESPONSE_OK){
gtk_color_selection_get_current_color(colorsel, &color);
r = color.red / 256;
g = color.green / 256;
b = color.blue / 256;
alpha = gtk_color_selection_get_current_alpha(colorsel);
alpha /= 256;
if(alpha == 255)
printf("#%02x%02x%02x\n", r, g, b);
else
printf("rgba(%d, %d, %d, %.2f)\n", r, g, b, (float)alpha/256);
}else
/* 取消了 */
return 1;
return 0;
}
void dpr(GtkWidget *wgt, gpointer dta)
{
AtkObject *awg, *all;
gchar *str;
GdkColor cl1, cl2;
gdouble iv;
gint val;
GtkAdjustment *adj;
GtkPlot *pt;
GtkPlotLinear *plt;
GtkWidget *btt, *hbx, *hwn, *lbl, *spr, *tbl, *vbx;
guint16 alp, alp2;
hwn=gtk_dialog_new_with_buttons(_("Display Properties"), GTK_WINDOW(dta), GTK_DIALOG_DESTROY_WITH_PARENT, NULL);
g_signal_connect_swapped(G_OBJECT(hwn), "destroy", G_CALLBACK(gtk_widget_destroy), G_OBJECT(hwn));
btt=gtk_button_new_from_stock(GTK_STOCK_CLOSE);
gtk_widget_show(btt);
g_signal_connect_swapped(G_OBJECT(btt), "clicked", G_CALLBACK(gtk_widget_destroy), G_OBJECT(hwn));
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(hwn)->action_area), btt);
btt=gtk_button_new_from_stock(GTK_STOCK_APPLY);
gtk_widget_show(btt);
g_signal_connect(G_OBJECT(btt), "clicked", G_CALLBACK(dpa), NULL);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(hwn)->action_area), btt);
nb2=gtk_notebook_new();
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(nb2), GTK_POS_TOP);
tbl=gtk_table_new(4, 2, FALSE);
gtk_widget_show(tbl);
plt=GTK_PLOT_LINEAR(pt1);
pt=GTK_PLOT(pt1);
lbl=gtk_label_new(_("Axis label font:"));
gtk_widget_show(lbl);
gtk_table_attach(GTK_TABLE(tbl), lbl, 1, 2, 0, 1, GTK_FILL|GTK_SHRINK|GTK_EXPAND, GTK_FILL|GTK_SHRINK|GTK_EXPAND, 2, 2);
str=pango_font_description_to_string(pt->lfont);
bt1=gtk_font_button_new_with_font(str);
g_free(str);
gtk_font_button_set_show_style(GTK_FONT_BUTTON(bt1), TRUE);
gtk_font_button_set_show_size(GTK_FONT_BUTTON(bt1), TRUE);
gtk_font_button_set_use_font(GTK_FONT_BUTTON(bt1), TRUE);
gtk_font_button_set_use_size(GTK_FONT_BUTTON(bt1), FALSE);
gtk_font_button_set_title(GTK_FONT_BUTTON(bt1), _("Font Selection for Axis Labels"));
gtk_widget_show(bt1);
gtk_table_attach(GTK_TABLE(tbl), bt1, 1, 2, 1, 2, GTK_FILL|GTK_SHRINK|GTK_EXPAND, GTK_FILL|GTK_SHRINK|GTK_EXPAND, 2, 2);
awg=gtk_widget_get_accessible(bt1);
all=gtk_widget_get_accessible(GTK_WIDGET(lbl));
atk_object_add_relationship(all, ATK_RELATION_LABEL_FOR, awg);
atk_object_add_relationship(awg, ATK_RELATION_LABELLED_BY, all);
lbl=gtk_label_new(_("Tick label font:"));
gtk_widget_show(lbl);
gtk_table_attach(GTK_TABLE(tbl), lbl, 1, 2, 2, 3, GTK_FILL|GTK_SHRINK|GTK_EXPAND, GTK_FILL|GTK_SHRINK|GTK_EXPAND, 2, 2);
str=pango_font_description_to_string(pt->afont);
bt2=gtk_font_button_new_with_font(str);
g_free(str);
gtk_font_button_set_show_style(GTK_FONT_BUTTON(bt2), TRUE);
gtk_font_button_set_show_size(GTK_FONT_BUTTON(bt2), TRUE);
gtk_font_button_set_use_font(GTK_FONT_BUTTON(bt2), TRUE);
gtk_font_button_set_use_size(GTK_FONT_BUTTON(bt2), FALSE);
gtk_font_button_set_title(GTK_FONT_BUTTON(bt2), _("Font Selection for Tick Mark Labels"));
gtk_widget_show(bt2);
gtk_table_attach(GTK_TABLE(tbl), bt2, 1, 2, 3, 4, GTK_FILL|GTK_SHRINK|GTK_EXPAND, GTK_FILL|GTK_SHRINK|GTK_EXPAND, 2, 2);
awg=gtk_widget_get_accessible(bt2);
all=gtk_widget_get_accessible(GTK_WIDGET(lbl));
atk_object_add_relationship(all, ATK_RELATION_LABEL_FOR, awg);
atk_object_add_relationship(awg, ATK_RELATION_LABELLED_BY, all);
lbl=gtk_label_new(_("X axis text:"));
gtk_widget_show(lbl);
gtk_table_attach(GTK_TABLE(tbl), lbl, 0, 1, 0, 1, GTK_FILL|GTK_SHRINK|GTK_EXPAND, GTK_FILL|GTK_SHRINK|GTK_EXPAND, 2, 2);
en1=gtk_entry_new();
str=g_strdup(plt->xlab);
gtk_entry_set_text(GTK_ENTRY(en1), str);
g_free(str);
gtk_widget_show(en1);
gtk_table_attach(GTK_TABLE(tbl), en1, 0, 1, 1, 2, GTK_FILL|GTK_SHRINK|GTK_EXPAND, GTK_FILL|GTK_SHRINK|GTK_EXPAND, 2, 2);
awg=gtk_widget_get_accessible(en1);
all=gtk_widget_get_accessible(GTK_WIDGET(lbl));
atk_object_add_relationship(all, ATK_RELATION_LABEL_FOR, awg);
atk_object_add_relationship(awg, ATK_RELATION_LABELLED_BY, all);
lbl=gtk_label_new(_("Y axis text:"));
gtk_widget_show(lbl);
gtk_table_attach(GTK_TABLE(tbl), lbl, 0, 1, 2, 3, GTK_FILL|GTK_SHRINK|GTK_EXPAND, GTK_FILL|GTK_SHRINK|GTK_EXPAND, 2, 2);
en2=gtk_entry_new();
str=g_strdup(plt->ylab);
gtk_entry_set_text(GTK_ENTRY(en2), str);
g_free(str);
gtk_widget_show(en2);
gtk_table_attach(GTK_TABLE(tbl), en2, 0, 1, 3, 4, GTK_FILL|GTK_SHRINK|GTK_EXPAND, GTK_FILL|GTK_SHRINK|GTK_EXPAND, 2, 2);
awg=gtk_widget_get_accessible(en2);
all=gtk_widget_get_accessible(GTK_WIDGET(lbl));
atk_object_add_relationship(all, ATK_RELATION_LABEL_FOR, awg);
atk_object_add_relationship(awg, ATK_RELATION_LABELLED_BY, all);
lbl=gtk_label_new("Index of Plot:");
gtk_widget_show(lbl);
gtk_table_attach(GTK_TABLE(tbl), lbl, 0, 1, 4, 5, GTK_FILL|GTK_SHRINK|GTK_EXPAND, GTK_FILL|GTK_SHRINK|GTK_EXPAND, 2, 2);
adj=(GtkAdjustment*) gtk_adjustment_new(0, 0, 1, 1.0, 1.0, 0.0);
jix=gtk_spin_button_new(adj, 0, 0);
g_signal_connect(G_OBJECT(jix), "value-changed", G_CALLBACK(upj), NULL);
gtk_table_attach(GTK_TABLE(tbl), jix, 1, 2, 4, 5, GTK_FILL|GTK_SHRINK|GTK_EXPAND, GTK_FILL|GTK_SHRINK|GTK_EXPAND, 2, 2);
gtk_widget_show(jix);
awg=gtk_widget_get_accessible(jix);
all=gtk_widget_get_accessible(GTK_WIDGET(lbl));
atk_object_add_relationship(all, ATK_RELATION_LABEL_FOR, awg);
atk_object_add_relationship(awg, ATK_RELATION_LABELLED_BY, all);
vbx=gtk_vbox_new(FALSE, 2);
gtk_widget_show(vbx);
gtk_box_pack_start(GTK_BOX(vbx), tbl, FALSE, FALSE, 2);
spr=gtk_vseparator_new();
gtk_widget_show(spr);
cmp=gdk_colormap_get_system();
(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);
cs1=gtk_color_selection_new();
gtk_color_selection_set_has_opacity_control(GTK_COLOR_SELECTION(cs1), TRUE);
gtk_color_selection_set_current_color(GTK_COLOR_SELECTION(cs1), &cl1);
gtk_color_selection_set_has_palette(GTK_COLOR_SELECTION(cs1), TRUE);
gtk_color_selection_set_current_alpha(GTK_COLOR_SELECTION(cs1), alp);
gtk_widget_show(cs1);
hbx=gtk_hbox_new(FALSE, 2);
gtk_widget_show(hbx);
gtk_box_pack_start(GTK_BOX(hbx), vbx, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(hbx), spr, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(hbx), cs1, FALSE, FALSE, 2);
lbl=gtk_label_new(_("Spectrum"));
gtk_notebook_append_page(GTK_NOTEBOOK(nb2), hbx, lbl);
tbl=gtk_table_new(4, 2, FALSE);
gtk_widget_show(tbl);
plt=GTK_PLOT_LINEAR(pt2);
pt=GTK_PLOT(pt2);
lbl=gtk_label_new(_("Axis label font:"));
gtk_widget_show(lbl);
gtk_table_attach(GTK_TABLE(tbl), lbl, 1, 2, 0, 1, GTK_FILL|GTK_SHRINK|GTK_EXPAND, GTK_FILL|GTK_SHRINK|GTK_EXPAND, 2, 2);
str=pango_font_description_to_string(pt->lfont);
bt3=gtk_font_button_new_with_font(str);
g_free(str);
gtk_font_button_set_show_style(GTK_FONT_BUTTON(bt3), TRUE);
gtk_font_button_set_show_size(GTK_FONT_BUTTON(bt3), TRUE);
gtk_font_button_set_use_font(GTK_FONT_BUTTON(bt3), TRUE);
gtk_font_button_set_use_size(GTK_FONT_BUTTON(bt3), FALSE);
gtk_font_button_set_title(GTK_FONT_BUTTON(bt3), _("Font Selection for Axis Labels"));
gtk_widget_show(bt3);
gtk_table_attach(GTK_TABLE(tbl), bt3, 1, 2, 1, 2, GTK_FILL|GTK_SHRINK|GTK_EXPAND, GTK_FILL|GTK_SHRINK|GTK_EXPAND, 2, 2);
awg=gtk_widget_get_accessible(bt3);
all=gtk_widget_get_accessible(GTK_WIDGET(lbl));
atk_object_add_relationship(all, ATK_RELATION_LABEL_FOR, awg);
atk_object_add_relationship(awg, ATK_RELATION_LABELLED_BY, all);
lbl=gtk_label_new(_("Tick label font:"));
gtk_widget_show(lbl);
gtk_table_attach(GTK_TABLE(tbl), lbl, 1, 2, 2, 3, GTK_FILL|GTK_SHRINK|GTK_EXPAND, GTK_FILL|GTK_SHRINK|GTK_EXPAND, 2, 2);
str=pango_font_description_to_string(pt->afont);
bt4=gtk_font_button_new_with_font(str);
g_free(str);
gtk_font_button_set_show_style(GTK_FONT_BUTTON(bt4), TRUE);
gtk_font_button_set_show_size(GTK_FONT_BUTTON(bt4), TRUE);
gtk_font_button_set_use_font(GTK_FONT_BUTTON(bt4), TRUE);
gtk_font_button_set_use_size(GTK_FONT_BUTTON(bt4), FALSE);
gtk_font_button_set_title(GTK_FONT_BUTTON(bt4), _("Font Selection for Tick Mark Labels"));
gtk_widget_show(bt4);
gtk_table_attach(GTK_TABLE(tbl), bt4, 1, 2, 3, 4, GTK_FILL|GTK_SHRINK|GTK_EXPAND, GTK_FILL|GTK_SHRINK|GTK_EXPAND, 2, 2);
awg=gtk_widget_get_accessible(bt4);
all=gtk_widget_get_accessible(GTK_WIDGET(lbl));
atk_object_add_relationship(all, ATK_RELATION_LABEL_FOR, awg);
atk_object_add_relationship(awg, ATK_RELATION_LABELLED_BY, all);
lbl=gtk_label_new(_("X axis text:"));
gtk_widget_show(lbl);
gtk_table_attach(GTK_TABLE(tbl), lbl, 0, 1, 0, 1, GTK_FILL|GTK_SHRINK|GTK_EXPAND, GTK_FILL|GTK_SHRINK|GTK_EXPAND, 2, 2);
en3=gtk_entry_new();
str=g_strdup(plt->xlab);
gtk_entry_set_text(GTK_ENTRY(en3), str);
g_free(str);
gtk_widget_show(en3);
gtk_table_attach(GTK_TABLE(tbl), en3, 0, 1, 1, 2, GTK_FILL|GTK_SHRINK|GTK_EXPAND, GTK_FILL|GTK_SHRINK|GTK_EXPAND, 2, 2);
awg=gtk_widget_get_accessible(en3);
all=gtk_widget_get_accessible(GTK_WIDGET(lbl));
atk_object_add_relationship(all, ATK_RELATION_LABEL_FOR, awg);
atk_object_add_relationship(awg, ATK_RELATION_LABELLED_BY, all);
lbl=gtk_label_new(_("Y axis text:"));
gtk_widget_show(lbl);
gtk_table_attach(GTK_TABLE(tbl), lbl, 0, 1, 2, 3, GTK_FILL|GTK_SHRINK|GTK_EXPAND, GTK_FILL|GTK_SHRINK|GTK_EXPAND, 2, 2);
en4=gtk_entry_new();
str=g_strdup(plt->ylab);
gtk_entry_set_text(GTK_ENTRY(en4), str);
g_free(str);
gtk_widget_show(en4);
gtk_table_attach(GTK_TABLE(tbl), en4, 0, 1, 3, 4, GTK_FILL|GTK_SHRINK|GTK_EXPAND, GTK_FILL|GTK_SHRINK|GTK_EXPAND, 2, 2);
awg=gtk_widget_get_accessible(en4);
all=gtk_widget_get_accessible(GTK_WIDGET(lbl));
atk_object_add_relationship(all, ATK_RELATION_LABEL_FOR, awg);
atk_object_add_relationship(awg, ATK_RELATION_LABELLED_BY, all);
lbl=gtk_label_new("Index of Plot:");
gtk_widget_show(lbl);
gtk_table_attach(GTK_TABLE(tbl), lbl, 0, 1, 4, 5, GTK_FILL|GTK_SHRINK|GTK_EXPAND, GTK_FILL|GTK_SHRINK|GTK_EXPAND, 2, 2);
adj=(GtkAdjustment*) gtk_adjustment_new(0, 0, 1, 1.0, 1.0, 0.0);
jix2=gtk_spin_button_new(adj, 0, 0);
g_signal_connect(G_OBJECT(jix2), "value-changed", G_CALLBACK(upj2), NULL);
gtk_table_attach(GTK_TABLE(tbl), jix2, 1, 2, 4, 5, GTK_FILL|GTK_SHRINK|GTK_EXPAND, GTK_FILL|GTK_SHRINK|GTK_EXPAND, 2, 2);
gtk_widget_show(jix2);
awg=gtk_widget_get_accessible(jix2);
all=gtk_widget_get_accessible(GTK_WIDGET(lbl));
atk_object_add_relationship(all, ATK_RELATION_LABEL_FOR, awg);
atk_object_add_relationship(awg, ATK_RELATION_LABELLED_BY, all);
vbx=gtk_vbox_new(FALSE, 2);
gtk_widget_show(vbx);
gtk_box_pack_start(GTK_BOX(vbx), tbl, FALSE, FALSE, 2);
spr=gtk_vseparator_new();
gtk_widget_show(spr);
cs2=gtk_color_selection_new();
(cl2.red)=(guint16) (65535*g_array_index((pt->rd), gdouble, 0));
(cl2.green)=(guint16) (65535*g_array_index((pt->gr), gdouble, 0));
(cl2.blue)=(guint16) (65535*g_array_index((pt->bl), gdouble, 0));
alp2=(guint16) (65535*g_array_index((pt->al), gdouble, 0));
gdk_colormap_alloc_color(cmp, &cl2, FALSE, TRUE);
gtk_color_selection_set_has_opacity_control(GTK_COLOR_SELECTION(cs2), TRUE);
gtk_color_selection_set_current_color(GTK_COLOR_SELECTION(cs2), &cl2);
gtk_color_selection_set_has_palette(GTK_COLOR_SELECTION(cs2), TRUE);
gtk_color_selection_set_current_alpha(GTK_COLOR_SELECTION(cs2), alp2);
gtk_widget_show(cs2);
hbx=gtk_hbox_new(FALSE, 2);
gtk_widget_show(hbx);
gtk_box_pack_start(GTK_BOX(hbx), vbx, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(hbx), spr, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(hbx), cs2, FALSE, FALSE, 2);
lbl=gtk_label_new(_("Spatial Structure"));
gtk_notebook_append_page(GTK_NOTEBOOK(nb2), hbx, lbl);
val=gtk_notebook_get_current_page(GTK_NOTEBOOK(nbk));
gtk_notebook_set_current_page(GTK_NOTEBOOK(nb2), val);
gtk_widget_show(nb2);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(hwn)->vbox), nb2);
gtk_widget_show(hwn);
}
static void
color_area_edit (void)
{
Color col;
GtkWidget *window;
GdkColor color;
if (!color_select_active) {
stored_foreground = attributes_get_foreground();
stored_background = attributes_get_background();
}
if (active_color == FOREGROUND) {
col = attributes_get_foreground();
edit_color = FOREGROUND;
} else {
col = attributes_get_background();
edit_color = BACKGROUND;
}
if (! color_select) {
window = color_select =
gtk_color_selection_dialog_new(edit_color==FOREGROUND?
_("Select foreground color"):
_("Select background color"));
color_select_active = 1;
gtk_color_selection_set_has_palette (
GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
TRUE);
gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_MOUSE);
g_signal_connect (G_OBJECT (window), "delete_event",
G_CALLBACK(color_selection_delete),
window);
g_signal_connect (GTK_OBJECT (window), "destroy",
G_CALLBACK(color_selection_destroy),
window);
g_signal_connect (
G_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->colorsel),
"color_changed",
G_CALLBACK(color_selection_changed),
window);
g_signal_connect (
G_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->ok_button),
"clicked",
G_CALLBACK(color_selection_ok),
window);
g_signal_connect (
G_OBJECT (GTK_COLOR_SELECTION_DIALOG (window)->cancel_button),
"clicked",
G_CALLBACK(color_selection_cancel),
window);
/* Make sure window is shown before setting its colors: */
gtk_widget_show_now (color_select);
} else {
gtk_window_set_title(GTK_WINDOW(color_select),
edit_color==FOREGROUND?
_("Select foreground color"):
_("Select background color"));
if (! color_select_active) {
gtk_widget_show (color_select);
}
}
DIA_COLOR_TO_GDK(col, color);
gtk_color_selection_set_current_color(
GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (color_select)->colorsel),
&color);
}
