/*!
\brief Enable log playback controls
\param state whether to enable or disable the playback controls
*/
G_MODULE_EXPORT void enable_playback_controls(gboolean state)
{
static GtkWidget * playback_controls_window = NULL;
gchar *fname = NULL;
gchar * filename = NULL;
GladeXML *xml = NULL;
GtkWidget *widget = NULL;
GtkAdjustment *adj = NULL;
if (state) /* show the controls */
{
if (!GTK_IS_WIDGET(playback_controls_window))
{
fname = g_build_filename(GUI_DATA_DIR,"logviewer.glade",NULL);
filename = get_file(g_strdup(fname),NULL);
if (filename)
{
xml = glade_xml_new(filename, "logviewer_controls_window",NULL);
g_free(filename);
g_free(fname);
glade_xml_signal_autoconnect(xml);
playback_controls_window = glade_xml_get_widget(xml,"logviewer_controls_window");
OBJ_SET(glade_xml_get_widget(xml,"goto_start_button"),"handler",GINT_TO_POINTER(LV_GOTO_START));
OBJ_SET(glade_xml_get_widget(xml,"goto_end_button"),"handler",GINT_TO_POINTER(LV_GOTO_END));
OBJ_SET(glade_xml_get_widget(xml,"rewind_button"),"handler",GINT_TO_POINTER(LV_REWIND));
OBJ_SET(glade_xml_get_widget(xml,"fast_forward_button"),"handler",GINT_TO_POINTER(LV_FAST_FORWARD));
OBJ_SET(glade_xml_get_widget(xml,"play_button"),"handler",GINT_TO_POINTER(LV_PLAY));
OBJ_SET(glade_xml_get_widget(xml,"stop_button"),"handler",GINT_TO_POINTER(LV_STOP));
register_widget("logviewer_controls_hbox",glade_xml_get_widget(xml,"controls_hbox"));
widget = lookup_widget("logviewer_scroll_hscale");
if (GTK_IS_WIDGET(widget))
{
adj = gtk_range_get_adjustment(GTK_RANGE(widget));
gtk_range_set_adjustment(GTK_RANGE(glade_xml_get_widget(xml,"scroll_speed")),adj);
}
widget = lookup_widget("logviewer_log_position_hscale");
if (GTK_IS_WIDGET(widget))
{
adj = gtk_range_get_adjustment(GTK_RANGE(widget));
gtk_range_set_adjustment(GTK_RANGE(glade_xml_get_widget(xml,"log_position_hscale")),adj);
}
}
register_widget("playback_controls_window",playback_controls_window);
}
else
gtk_widget_show_all(playback_controls_window);
}
else
{
if (GTK_IS_WIDGET(playback_controls_window))
gtk_widget_hide(playback_controls_window);
}
return;
}
static void
gb_terminal_view_connect_terminal (GbTerminalView *self,
VteTerminal *terminal)
{
GtkAdjustment *vadj;
GQuark quark;
guint signal_id;
vadj = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (terminal));
if (terminal == self->terminal_top)
gtk_range_set_adjustment (GTK_RANGE (self->top_scrollbar), vadj);
else
gtk_range_set_adjustment (GTK_RANGE (self->bottom_scrollbar), vadj);
g_signal_connect_object (terminal,
"size-allocate",
G_CALLBACK (size_allocate_cb),
self,
0);
g_signal_connect_object (terminal,
"child-exited",
G_CALLBACK (child_exited_cb),
self,
0);
g_signal_connect_object (terminal,
"focus-in-event",
G_CALLBACK (focus_in_event_cb),
self,
0);
g_signal_connect_object (terminal,
"window-title-changed",
G_CALLBACK (window_title_changed_cb),
self,
0);
if (g_signal_parse_name ("notification-received",
VTE_TYPE_TERMINAL,
&signal_id,
&quark,
FALSE))
{
g_signal_connect_object (terminal,
"notification-received",
G_CALLBACK (notification_received_cb),
self,
0);
}
}
JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkRange_gtk_1range_1set_1adjustment
(
JNIEnv* env,
jclass cls,
jlong _self,
jlong _adjustment
)
{
GtkRange* self;
GtkAdjustment* adjustment;
// convert parameter self
self = (GtkRange*) _self;
// convert parameter adjustment
adjustment = (GtkAdjustment*) _adjustment;
// call function
gtk_range_set_adjustment(self, adjustment);
// cleanup parameter self
// cleanup parameter adjustment
}
static void
ide_terminal_page_connect_terminal (IdeTerminalPage *self,
VteTerminal *terminal)
{
GtkAdjustment *vadj;
vadj = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (terminal));
gtk_range_set_adjustment (GTK_RANGE (self->top_scrollbar), vadj);
g_signal_connect_object (terminal,
"focus-in-event",
G_CALLBACK (focus_in_event_cb),
self,
0);
g_signal_connect_object (terminal,
"window-title-changed",
G_CALLBACK (window_title_changed_cb),
self,
0);
if (terminal_has_notification_signal ())
{
g_signal_connect_object (terminal,
"notification-received",
G_CALLBACK (notification_received_cb),
self,
0);
}
}
static void zoom_adj(void)
{
float page_size=0;
float step_inc=0;
float page_inc=0;
float val=0;
float start=0;
float stop=0;
waveform_get_range(WAVEFORM(se->waveform), &start, &stop);
gtk_range_set_range(GTK_RANGE(se->hscroll), start, stop);
val = start;
se->range = page_size = stop - start;
step_inc = se->range / 100;
page_inc = step_inc / 10;
se->hscrolladj = gtk_adjustment_new(val, 0.0, 1.0,
step_inc,
page_inc,
page_size);
gtk_range_set_adjustment(GTK_RANGE(se->hscroll),
GTK_ADJUSTMENT(se->hscrolladj));
/* emit value-changed signal so waveform is redrawn with
* the new dimensions */
g_signal_emit_by_name(G_OBJECT(se->hscroll), "value-changed");
return;
}
Terminal::Terminal() {
dock_hint = GdkRectangle{0, 0, 0, 0};
vte = vte_terminal_new();
char *argv[] = { vte_get_user_shell(), NULL };
vte_terminal_spawn_sync(VTE_TERMINAL(vte), VTE_PTY_DEFAULT, NULL, argv, NULL,
(GSpawnFlags)0, NULL,
NULL, &child_pid, NULL, NULL);
set_orientation(Gtk::ORIENTATION_VERTICAL);
scrollbox.set_orientation(Gtk::ORIENTATION_HORIZONTAL);
scrollbar.set_orientation(Gtk::ORIENTATION_VERTICAL);
eventbox.add(label);
eventbox.signal_button_press_event().connect(mem_fun(this, &Terminal::header_button_press));
VteRegex *regex = vte_regex_new_for_match("(https?://|www\\.)[^\\s]*", -1, PCRE2_MULTILINE, NULL);
vte_terminal_match_add_regex(VTE_TERMINAL(vte), regex, 0);
vte_terminal_set_scrollback_lines(VTE_TERMINAL(vte), 10000);
g_signal_connect(vte, "bell", G_CALLBACK(Terminal::vte_beep), this);
g_signal_connect(vte, "child-exited", G_CALLBACK(Terminal::vte_child_exited), this);
g_signal_connect(vte, "button-press-event", G_CALLBACK(Terminal::vte_click), this);
g_signal_connect(vte, "focus-in-event", G_CALLBACK(Terminal::vte_got_focus), this);
g_signal_connect(vte, "focus-out-event", G_CALLBACK(Terminal::vte_lost_focus), this);
g_signal_connect(vte, "selection-changed", G_CALLBACK(Terminal::vte_selection_changed), this);
g_signal_connect(vte, "window-title-changed", G_CALLBACK(Terminal::vte_title_changed), this);
searchbar.add(searchentry);
searchbar.connect_entry(searchentry);
searchentry.signal_focus_out_event().connect(mem_fun(this, &Terminal::searchentry_lost_focus));
searchentry.signal_key_release_event().connect(mem_fun(this, &Terminal::searchentry_keypress));
pack_start(eventbox, false, false, 0);
pack_start(scrollbox, true, true, 0);
pack_start(searchbar, false, false, 0);
gtk_box_pack_start(GTK_BOX(scrollbox.gobj()), vte, true, true, 0);
scrollbox.pack_start(scrollbar, false, false, 0);
gtk_range_set_adjustment(GTK_RANGE(scrollbar.gobj()), gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(vte)));
show_all_children();
find_label.terminal = this;
find_label.set_alignment(0.0, 0.5);
find_window->list_box.prepend(find_label);
std::vector<Gtk::TargetEntry> listTargets;
listTargets.push_back(Gtk::TargetEntry("SvanTerminal", Gtk::TARGET_SAME_APP, 0));
eventbox.drag_source_set(listTargets);
drag_dest_set(listTargets);
eventbox.signal_drag_begin().connect(sigc::mem_fun(this, &Terminal::on_my_drag_begin));
eventbox.signal_drag_failed().connect(sigc::mem_fun(this, &Terminal::on_my_drag_failed));
eventbox.signal_drag_end().connect(sigc::mem_fun(this, &Terminal::on_my_drag_end));
signal_drag_motion().connect(sigc::mem_fun(this, &Terminal::on_my_drag_motion));
signal_drag_drop().connect(sigc::mem_fun(this, &Terminal::on_my_drag_drop));
signal_drag_leave().connect(sigc::mem_fun(this, &Terminal::on_my_drag_leave));
}
void AdjustScroller (GtkWidget* scrollbar, long viewport, long size)
{
GtkAdjustment* old = gtk_range_get_adjustment (GTK_RANGE(scrollbar));
double newPageSize = viewport*MAX_CONTROL_VALUE/size,
scaledValue = old->upper-old->page_size?old->value*(old->upper/(old->upper-old->page_size)):0.0;
scaledValue *= (old->upper-newPageSize)/old->upper;
GtkObject* newAdj = gtk_adjustment_new (scaledValue,0,MAX_CONTROL_VALUE,MAX_CONTROL_VALUE/100.0,MAX_CONTROL_VALUE/10.0,newPageSize);
gtk_range_set_adjustment (GTK_RANGE(scrollbar),GTK_ADJUSTMENT(newAdj));
}
/**************************************************************************
Refresh map canvas scrollbar as canvas size changes
**************************************************************************/
void update_map_canvas_scrollbars_size(void)
{
int xmin, ymin, xmax, ymax, xsize, ysize, xstep, ystep;
get_mapview_scroll_window(&xmin, &ymin, &xmax, &ymax, &xsize, &ysize);
get_mapview_scroll_step(&xstep, &ystep);
map_hadj = gtk_adjustment_new(-1, xmin, xmax, xstep, xsize, xsize);
map_vadj = gtk_adjustment_new(-1, ymin, ymax, ystep, ysize, ysize);
gtk_range_set_adjustment(GTK_RANGE(map_horizontal_scrollbar), map_hadj);
gtk_range_set_adjustment(GTK_RANGE(map_vertical_scrollbar), map_vadj);
g_signal_connect(map_hadj, "value_changed",
G_CALLBACK(scrollbar_jump_callback),
GINT_TO_POINTER(TRUE));
g_signal_connect(map_vadj, "value_changed",
G_CALLBACK(scrollbar_jump_callback),
GINT_TO_POINTER(FALSE));
}
static void
gb_terminal_view_connect_terminal (GbTerminalView *self,
VteTerminal *terminal)
{
GtkAdjustment *vadj;
vadj = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (terminal));
if (terminal == self->terminal_top)
gtk_range_set_adjustment (GTK_RANGE (self->top_scrollbar), vadj);
else
gtk_range_set_adjustment (GTK_RANGE (self->bottom_scrollbar), vadj);
g_signal_connect_object (terminal,
"size-allocate",
G_CALLBACK (size_allocate_cb),
self,
0);
g_signal_connect_object (terminal,
"focus-in-event",
G_CALLBACK (focus_in_event_cb),
self,
0);
g_signal_connect_object (terminal,
"window-title-changed",
G_CALLBACK (window_title_changed_cb),
self,
0);
if (terminal_has_notification_signal ())
{
g_signal_connect_object (terminal,
"notification-received",
G_CALLBACK (notification_received_cb),
self,
0);
}
}
static GtkWidget *
gtk_scale_button_scale_box_new (GtkScaleButton *button)
{
GtkScaleButtonPrivate *priv = button->priv;
GtkScaleButtonVScale *scale;
GtkWidget *box;
if (priv->orientation == GTK_ORIENTATION_VERTICAL)
{
box = gtk_vbox_new (FALSE, 0);
scale = g_object_new (GTK_TYPE_SCALE_BUTTON_VSCALE, NULL);
priv->scale = GTK_WIDGET (scale);
gtk_widget_set_size_request (priv->scale, -1, SCALE_SIZE);
gtk_range_set_inverted (GTK_RANGE (priv->scale), TRUE);
gtk_box_pack_start (GTK_BOX (box), button->plus_button, TRUE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box), priv->scale, TRUE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box), button->minus_button, TRUE, FALSE, 0);
}
else
{
box = gtk_hbox_new (FALSE, 0);
scale = g_object_new (GTK_TYPE_SCALE_BUTTON_HSCALE, NULL);
priv->scale = GTK_WIDGET (scale);
gtk_widget_set_size_request (priv->scale, SCALE_SIZE, -1);
gtk_box_pack_start (GTK_BOX (box), button->minus_button, TRUE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box), priv->scale, TRUE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box), button->plus_button, TRUE, FALSE, 0);
}
gtk_scale_set_draw_value (GTK_SCALE (priv->scale), FALSE);
gtk_range_set_adjustment (GTK_RANGE (scale),
GTK_ADJUSTMENT (priv->adjustment));
scale->button = button;
g_signal_connect (priv->scale, "grab-notify",
G_CALLBACK (cb_scale_grab_notify), button);
/* FIXME: without this, the popup window appears as a square
* after changing the orientation
*/
gtk_window_resize (GTK_WINDOW (priv->dock), 1, 1);
return box;
}
static void
hotssh_tab_init (HotSshTab *self)
{
HotSshTabPrivate *priv = hotssh_tab_get_instance_private (self);
priv->settings = g_settings_new ("org.gnome.hotssh");
gtk_widget_init_template (GTK_WIDGET (self));
gtk_notebook_set_show_tabs ((GtkNotebook*)self, FALSE);
g_signal_connect (priv->create_and_connect_button, "clicked", G_CALLBACK (on_create_and_connect), self);
g_signal_connect (priv->add_new_connection_button, "clicked", G_CALLBACK (on_add_new_connection), self);
g_signal_connect (priv->connect_cancel_button, "clicked", G_CALLBACK (on_connect_cancel), self);
g_signal_connect (priv->error_disconnect, "clicked", G_CALLBACK (on_connect_cancel), self);
g_signal_connect (priv->auth_cancel_button, "clicked", G_CALLBACK (on_connect_cancel), self);
g_signal_connect (priv->approve_hostkey_button, "clicked", G_CALLBACK (on_approve_hostkey_clicked), self);
g_signal_connect (priv->disapprove_hostkey_button, "clicked", G_CALLBACK (on_connect_cancel), self);
g_signal_connect_swapped (priv->password_entry, "activate", G_CALLBACK (submit_password), self);
g_signal_connect_swapped (priv->password_submit, "clicked", G_CALLBACK (submit_password), self);
g_signal_connect (priv->connections_treeview, "row-activated", G_CALLBACK (on_connection_row_activated), self);
priv->password_interaction = hotssh_password_interaction_new ((GtkEntry*)priv->password_entry);
priv->terminal = vte_terminal_new ();
g_signal_connect (priv->terminal, "realize", G_CALLBACK (on_vte_realize), self);
vte_terminal_set_audible_bell ((VteTerminal*)priv->terminal, FALSE); /* Audible bell is a terrible idea */
g_signal_connect ((GObject*)priv->terminal, "size-allocate", G_CALLBACK (on_terminal_size_allocate), self);
g_signal_connect ((GObject*)priv->terminal, "commit", G_CALLBACK (on_terminal_commit), self);
gtk_box_pack_start ((GtkBox*)priv->terminal_box, priv->terminal, TRUE, TRUE, 0);
gtk_range_set_adjustment ((GtkRange*)priv->terminal_vscrollbar,
gtk_scrollable_get_vadjustment ((GtkScrollable*)priv->terminal));
gtk_widget_show_all (priv->terminal_box);
g_queue_init (&priv->write_queue);
{
gs_unref_object HotSshHostDB *hostdb = hotssh_hostdb_get_instance ();
gs_unref_object GtkTreeModel *hostdb_model = hotssh_hostdb_get_model (hostdb);
priv->host_completion = gtk_entry_completion_new ();
gtk_entry_completion_set_match_func (priv->host_completion, host_entry_match, self, NULL);
gtk_entry_completion_set_model (priv->host_completion, hostdb_model);
gtk_entry_completion_set_text_column (priv->host_completion, 0);
gtk_entry_completion_set_inline_completion (priv->host_completion, TRUE);
gtk_entry_set_completion ((GtkEntry*)priv->host_entry, priv->host_completion);
}
}
GtkWidget *sigview_init(void)
{
GtkWidget *sw, *tv;
GtkTreeViewColumn *col;
GtkCellRenderer *cel;
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_ALWAYS, GTK_POLICY_AUTOMATIC);
tv = gtk_tree_view_new();
gtk_container_add(GTK_CONTAINER(sw), tv);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tv), FALSE);
g_object_set(G_OBJECT(tv), "reorderable", TRUE, NULL);
col = gtk_tree_view_column_new_with_attributes(NULL,
gtk_cell_renderer_text_new(),
"text", 0, "foreground", 1, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tv), col);
cel = gtk_cell_renderer_signal_new();
g_object_set(G_OBJECT(cel), "ypad", 1, NULL);
g_signal_connect(tv, "scroll-event", G_CALLBACK(do_scroll_event), cel);
g_signal_connect(tv, "button-press-event", G_CALLBACK(do_button_event), cel);
g_signal_connect(tv, "button-release-event", G_CALLBACK(do_button_event), cel);
col = gtk_tree_view_column_new();
g_object_set_data(G_OBJECT(tv), "signalcol", col);
g_object_set_data(G_OBJECT(tv), "signalcel", cel);
gtk_tree_view_column_pack_start(col, cel, TRUE);
gtk_tree_view_column_set_cell_data_func(col, cel, format_func,
NULL, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tv), col);
g_signal_connect_swapped(col, "notify::width",
G_CALLBACK(col_resized), tv);
siglist = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_INT);
gtk_tree_view_set_model(GTK_TREE_VIEW(tv), GTK_TREE_MODEL(siglist));
GtkObject *pan = gtk_adjustment_new(0, 0, 0, 1, 1, 1);
g_object_set_data(G_OBJECT(tv), "hadj", pan);
gtk_range_set_adjustment(GTK_RANGE(GTK_SCROLLED_WINDOW(sw)->hscrollbar),
GTK_ADJUSTMENT(pan));
g_signal_connect(pan, "value-changed", G_CALLBACK(pan_changed), tv);
return sw;
}
void ADM_flyDialogGtk::postInit(uint8_t reInit)
{
if (_slider)
{
GtkAdjustment *adj = (GtkAdjustment*)gtk_adjustment_new(0, 0, _in->getInfo()->nb_frames - 1, 0, 1, 0);
gtk_range_set_adjustment(GTK_RANGE(_slider), adj);
gtk_scale_set_digits(GTK_SCALE(_slider), 0);
}
GtkWindow *window = (GtkWindow*)gtk_widget_get_ancestor((GtkWidget*)_canvas, GTK_TYPE_WINDOW);
UI_centreCanvasWindow(window, (GtkWidget*)_canvas, _zoomW, _zoomH);
gtk_widget_set_size_request((GtkWidget*)_canvas, _zoomW, _zoomH);
#ifdef USE_JOG
if (!reInit)
physical_jog_shuttle->registerCBs (this, PhysicalJogShuttle::NoButtonCB,
jogDial, jogRing);
#endif
}
/**
* gtk_scale_button_set_adjustment:
* @button: a #GtkScaleButton
* @adjustment: a #GtkAdjustment
*
* Sets the #GtkAdjustment to be used as a model
* for the #GtkScaleButton's scale.
* See gtk_range_set_adjustment() for details.
*
* Since: 2.12
*/
void
gtk_scale_button_set_adjustment (GtkScaleButton *button,
GtkAdjustment *adjustment)
{
g_return_if_fail (GTK_IS_SCALE_BUTTON (button));
if (!adjustment)
adjustment = (GtkAdjustment*) gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
else
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
if (button->priv->adjustment != adjustment)
{
if (button->priv->adjustment)
g_object_unref (button->priv->adjustment);
button->priv->adjustment = g_object_ref_sink (adjustment);
if (button->priv->scale)
gtk_range_set_adjustment (GTK_RANGE (button->priv->scale), adjustment);
g_object_notify (G_OBJECT (button), "adjustment");
}
}
/*!
\brief convert_temps() changes the values of controls based on the currently
selected temperature scale. IT works for labels, spinbuttons, etc...
\param widget (gpointer) pointer to the widget that contains the necessary
paramaters re temp (Alt label, etc)
\param units (gpointer) the temp scale selected
*/
G_MODULE_EXPORT void convert_temps(gpointer widget, gpointer units)
{
static void (*update_widget_f)(gpointer, gpointer);
static gboolean (*check_deps)(gconstpointer *) = NULL;
gconstpointer *dep_obj = NULL;
gfloat upper = 0.0;
gfloat lower = 0.0;
gfloat value = 0.0;
gchar * text = NULL;
GtkAdjustment * adj = NULL;
gboolean state = FALSE;
gint widget_temp = -1;
/*extern GdkColor black;*/
extern gconstpointer *global_data;
/* If this widgt depends on anything call check_dependancy which will
* return TRUE/FALSE. True if what it depends on is in the matching
* state, FALSE otherwise...
*/
if ((!widget) || (DATA_GET(global_data,"leaving")))
return;
if (!check_deps)
if (!get_symbol("check_dependancies",(void *)&check_deps))
dbg_func(CRITICAL|CONVERSIONS,g_strdup_printf(__FILE__": convert_temps()\n\tCan NOT locate \"check_dependancies\" function pointer in plugins, BUG!\n"));
if (!update_widget_f)
if(!get_symbol("update_widget",(void *)&update_widget_f))
dbg_func(CRITICAL|CONVERSIONS,g_strdup_printf(__FILE__": convert_temps()\n\tCan NOT locate \"update_widget\" function pointer in plugins, BUG!\n"));
dep_obj = (gconstpointer *)OBJ_GET(widget,"dep_object");
widget_temp = (GINT)OBJ_GET(widget,"widget_temp");
if (dep_obj)
{
if (check_deps)
state = check_deps(dep_obj);
else
dbg_func(CRITICAL|CONVERSIONS,g_strdup_printf(__FILE__": convert_temps()\n\tWidget %s has dependant object bound but can't locate function ptr for \"check_dependancies\" from plugins, BUG!\n",glade_get_widget_name(widget)));
}
switch ((TempUnits)units)
{
case FAHRENHEIT:
/*printf("fahr %s\n",glade_get_widget_name(widget));*/
if (GTK_IS_LABEL(widget))
{
if ((dep_obj) && (state))
text = (gchar *)OBJ_GET(widget,"alt_f_label");
else
text = (gchar *)OBJ_GET(widget,"f_label");
gtk_label_set_text(GTK_LABEL(widget),text);
//gtk_widget_modify_text(widget,GTK_STATE_NORMAL,&black);
OBJ_SET(widget,"widget_temp",GINT_TO_POINTER(units));
}
if ((GTK_IS_SPIN_BUTTON(widget)) && (widget_temp != FAHRENHEIT))
{
adj = (GtkAdjustment *) gtk_spin_button_get_adjustment(
GTK_SPIN_BUTTON(widget));
upper = adj->upper;
value = adj->value;
lower = adj->lower;
if (widget_temp == CELSIUS)
{
adj->value = c_to_f(value);
adj->lower = c_to_f(lower);
adj->upper = c_to_f(upper);
}
else /* Previous is kelvin */
{
adj->value = k_to_f(value);
adj->lower = k_to_f(lower);
adj->upper = k_to_f(upper);
}
gtk_adjustment_changed(adj);
OBJ_SET(widget,"widget_temp",GINT_TO_POINTER(units));
update_widget_f(widget,NULL);
}
if ((GTK_IS_ENTRY(widget)) && (widget_temp != FAHRENHEIT))
{
OBJ_SET(widget,"widget_temp",GINT_TO_POINTER(units));
update_widget_f(widget,NULL);
}
if ((GTK_IS_RANGE(widget)) && (widget_temp != FAHRENHEIT))
{
adj = (GtkAdjustment *) gtk_range_get_adjustment(
GTK_RANGE(widget));
upper = adj->upper;
lower = adj->lower;
value = adj->value;
if (widget_temp == CELSIUS)
{
adj->value = c_to_f(value);
adj->lower = c_to_f(lower);
adj->upper = c_to_f(upper);
}
else /* Previous is kelvin */
{
adj->value = k_to_f(value);
adj->lower = k_to_f(lower);
adj->upper = k_to_f(upper);
}
gtk_range_set_adjustment(GTK_RANGE(widget),adj);
OBJ_SET(widget,"widget_temp",GINT_TO_POINTER(units));
}
break;
case CELSIUS:
/*printf("fahr %s\n",glade_get_widget_name(widget));*/
if (GTK_IS_LABEL(widget))
{
if ((dep_obj) && (state))
text = (gchar *)OBJ_GET(widget,"alt_c_label");
else
text = (gchar *)OBJ_GET(widget,"c_label");
gtk_label_set_text(GTK_LABEL(widget),text);
//gtk_widget_modify_text(widget,GTK_STATE_NORMAL,&black);
OBJ_SET(widget,"widget_temp",GINT_TO_POINTER(units));
}
if ((GTK_IS_SPIN_BUTTON(widget)) && (widget_temp != CELSIUS))
{
adj = (GtkAdjustment *) gtk_spin_button_get_adjustment(
GTK_SPIN_BUTTON(widget));
upper = adj->upper;
value = adj->value;
lower = adj->lower;
if (widget_temp == FAHRENHEIT)
{
adj->value = f_to_c(value);
adj->lower = f_to_c(lower);
adj->upper = f_to_c(upper);
}
else /* Previous is kelvin */
{
adj->value = k_to_c(value);
adj->lower = k_to_c(lower);
adj->upper = k_to_c(upper);
}
gtk_adjustment_changed(adj);
OBJ_SET(widget,"widget_temp",GINT_TO_POINTER(units));
update_widget_f(widget,NULL);
}
if ((GTK_IS_ENTRY(widget)) && (widget_temp != CELSIUS))
{
OBJ_SET(widget,"widget_temp",GINT_TO_POINTER(units));
update_widget_f(widget,NULL);
}
if ((GTK_IS_RANGE(widget)) && (widget_temp != CELSIUS))
{
adj = (GtkAdjustment *) gtk_range_get_adjustment(
GTK_RANGE(widget));
upper = adj->upper;
lower = adj->lower;
value = adj->value;
if (widget_temp == FAHRENHEIT)
{
adj->value = f_to_c(value);
adj->lower = f_to_c(lower);
adj->upper = f_to_c(upper);
}
else /* Previous is kelvin */
{
adj->value = k_to_c(value);
adj->lower = k_to_c(lower);
adj->upper = k_to_c(upper);
}
gtk_range_set_adjustment(GTK_RANGE(widget),adj);
OBJ_SET(widget,"widget_temp",GINT_TO_POINTER(units));
}
break;
case KELVIN:
/*printf("fahr %s\n",glade_get_widget_name(widget));*/
if (GTK_IS_LABEL(widget))
{
if ((dep_obj) && (state))
text = (gchar *)OBJ_GET(widget,"alt_k_label");
else
text = (gchar *)OBJ_GET(widget,"k_label");
gtk_label_set_text(GTK_LABEL(widget),text);
//gtk_widget_modify_text(widget,GTK_STATE_NORMAL,&black);
OBJ_SET(widget,"widget_temp",GINT_TO_POINTER(units));
}
if ((GTK_IS_SPIN_BUTTON(widget)) && (widget_temp != KELVIN))
{
adj = (GtkAdjustment *) gtk_spin_button_get_adjustment(
GTK_SPIN_BUTTON(widget));
upper = adj->upper;
value = adj->value;
lower = adj->lower;
if (widget_temp == FAHRENHEIT)
{
adj->value = f_to_k(value);
adj->lower = f_to_k(lower);
adj->upper = f_to_k(upper);
}
else /* Previous is celsius */
{
adj->value = c_to_k(value);
adj->lower = c_to_k(lower);
adj->upper = c_to_k(upper);
}
gtk_adjustment_changed(adj);
OBJ_SET(widget,"widget_temp",GINT_TO_POINTER(units));
update_widget_f(widget,NULL);
}
if ((GTK_IS_ENTRY(widget)) && (widget_temp != KELVIN))
{
OBJ_SET(widget,"widget_temp",GINT_TO_POINTER(units));
update_widget_f(widget,NULL);
}
if ((GTK_IS_RANGE(widget)) && (widget_temp != KELVIN))
{
adj = (GtkAdjustment *) gtk_range_get_adjustment(
GTK_RANGE(widget));
upper = adj->upper;
lower = adj->lower;
value = adj->value;
if (widget_temp == FAHRENHEIT)
{
adj->value = f_to_k(value);
adj->lower = f_to_k(lower);
adj->upper = f_to_k(upper);
}
else /* Previous is celsius */
{
adj->value = c_to_k(value);
adj->lower = c_to_k(lower);
adj->upper = c_to_k(upper);
}
gtk_range_set_adjustment(GTK_RANGE(widget),adj);
OBJ_SET(widget,"widget_temp",GINT_TO_POINTER(units));
}
break;
}
}
void help(char *file) {
char fullspec[1024], *temp, *pt;
if ( browser[0]=='\0' )
findbrowser();
#ifndef __CygWin
if ( browser[0]=='\0' ) {
gwwv_post_error(_("No Browser"),_("Could not find a browser. Set the BROWSER environment variable to point to one"));
return;
}
#endif
if ( strstr(file,"http://")==NULL ) {
fullspec[0] = 0;
if ( *file!='/' ) {
if ( helpdir==NULL || *helpdir=='\0' ) {
#ifdef DOCDIR
strcpy(fullspec,DOCDIR "/");
#elif defined(SHAREDIR)
strcpy(fullspec,SHAREDIR "/doc/fontforge/");
#else
strcpy(fullspec,"/usr/local/share/doc/fontforge/");
#endif
} else
strcpy(fullspec,helpdir);
}
strcat(fullspec,file);
if (( pt = strrchr(fullspec,'#') )!=NULL ) *pt ='\0';
if ( !GFileReadable( fullspec )) {
if ( *file!='/' ) {
strcpy(fullspec,"/usr/share/doc/fontforge/");
strcat(fullspec,file);
if (( pt = strrchr(fullspec,'#') )!=NULL ) *pt ='\0';
}
}
if ( !GFileReadable( fullspec )) {
strcpy(fullspec,"http://fontforge.sf.net/");
AppendSupportedLocale(fullspec);
strcat(fullspec,file);
} else if ( pt!=NULL )
*pt = '#';
} else
strcpy(fullspec,file);
#if __CygWin
if ( (strstrmatch(browser,"/cygdrive")!=NULL || browser[0]=='\0') &&
strstr(fullspec,":/")==NULL ) {
/* It looks as though the browser is a windows application, so we */
/* should give it a windows file name */
char *pt, *tpt;
temp = galloc(1024);
cygwin_conv_to_full_win32_path(fullspec,temp);
for ( pt = fullspec, tpt = temp; *tpt && pt<fullspec+sizeof(fullspec)-3; *pt++ = *tpt++ )
if ( *tpt=='\\' )
*pt++ = '\\';
*pt = '\0';
free(temp);
}
#endif
#if __Mac
if ( strcmp(browser,"open")==0 )
/* open doesn't want "file:" prepended */;
else
#endif
if ( strstr(fullspec,":/")==NULL ) {
char *t1 = galloc(strlen(fullspec)+strlen("file:")+20);
#if __CygWin
sprintf( t1, "file:\\\\\\%s", fullspec );
#else
sprintf( t1, "file:%s", fullspec);
#endif
strcpy(fullspec,t1);
free(t1);
}
#if 0 && __Mac
/* Starting a Mac application is weird... system() can't do it */
/* Thanks to Edward H. Trager giving me an example... */
if ( strstr(browser,".app")!=NULL ) {
*strstr(browser,".app") = '\0';
pt = strrchr(browser,'/');
if ( pt==NULL ) pt = browser-1;
++pt;
temp = galloc(strlen(pt)+strlen(fullspec) +
strlen( "osascript -l AppleScript -e \"Tell application \"\" to getURL \"\"\"" )+
20);
/* this doesn't work on Max OS X.0 (osascript does not support -e) */
sprintf( temp, "osascript -l AppleScript -e \"Tell application \"%s\" to getURL \"%s\"\"",
pt, fullspec);
system(temp);
ff_post_notice(_("Leave X"),_("A browser is probably running in the native Mac windowing system. You must leave the X environment to view it. Try Cmd-Opt-A"));
} else {
#elif __Mac
/* This seems a bit easier... Thanks to riggle */
if ( strcmp(browser,"open")==0 ) {
temp = galloc(strlen(browser) + strlen(fullspec) + 20);
sprintf( temp, "open \"%s\" &", fullspec );
system(temp);
ff_post_notice(_("Leave X"),_("A browser is probably running in the native Mac windowing system. You must leave the X environment to view it. Try Cmd-Opt-A"));
} else {
#elif __CygWin
if ( browser[0]=='\0' ) {
do_windows_browser(fullspec);
temp = NULL;
} else {
#else
{
#endif
temp = galloc(strlen(browser) + strlen(fullspec) + 20);
sprintf( temp, strcmp(browser,"kfmclient openURL")==0 ? "%s \"%s\" &" : "\"%s\" \"%s\" &", browser, fullspec );
system(temp);
}
free(temp);
}
#define MAX_ERR_LINES 200
static struct errordata {
char *errlines[MAX_ERR_LINES];
int fh, as;
GtkWidget *vsb;
GtkWidget *gw, *v;
PangoLayout *layout;
int cnt, linecnt;
int offtop;
int showing;
} errdata;
static void Warning_Hide(void) {
gdk_window_hide(errdata.gw->window);
errdata.showing = false;
}
static void Warning_VScroll(GtkRange *vsb, gpointer user_data) {
GtkAdjustment *sb;
sb = gtk_range_get_adjustment(GTK_RANGE(vsb));
if ( sb->value!=errdata.offtop) {
int diff = sb->value-errdata.offtop;
errdata.offtop = sb->value;
gdk_window_scroll(GDK_WINDOW(errdata.v->window),0,diff*errdata.fh);
}
}
static gboolean Warning_Resize(GtkWidget *widget, GdkEventConfigure *event, gpointer user_data) {
GtkAdjustment *sb;
errdata.linecnt = widget->allocation.width/errdata.fh;
sb = gtk_range_get_adjustment(GTK_RANGE(errdata.vsb));
sb->lower = 0; sb->upper = errdata.cnt; sb->page_size = errdata.linecnt;
sb->step_increment = 1; sb->page_increment = errdata.linecnt;
if ( errdata.offtop>=errdata.cnt-errdata.linecnt )
errdata.offtop = errdata.cnt-errdata.linecnt;
if ( errdata.offtop<0 ) errdata.offtop =0;
sb->value = errdata.offtop;
gtk_range_set_adjustment(GTK_RANGE(errdata.vsb),sb);
return 0;
}
/* Create and set up GtkBuilder */
static gboolean _xfdashboard_settings_create_builder(XfdashboardSettings *self)
{
XfdashboardSettingsPrivate *priv;
gchar *builderFile;
GtkBuilder *builder;
GError *error;
g_return_val_if_fail(XFDASHBOARD_IS_SETTINGS(self), FALSE);
priv=self->priv;
builderFile=NULL;
builder=NULL;
error=NULL;
/* If builder is already set up return immediately */
if(priv->builder) return(TRUE);
/* Find UI file */
builderFile=g_build_filename(PACKAGE_DATADIR, "xfdashboard", PREFERENCES_UI_FILE, NULL);
g_debug("Trying UI file: %s", builderFile);
if(!g_file_test(builderFile, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR))
{
g_critical(_("Could not find UI file '%s'."), builderFile);
/* Release allocated resources */
g_free(builderFile);
/* Return fail result */
return(FALSE);
}
/* Create builder */
builder=gtk_builder_new();
if(!gtk_builder_add_from_file(builder, builderFile, &error))
{
g_critical(_("Could not load UI resources from '%s': %s"),
builderFile,
error ? error->message : _("Unknown error"));
/* Release allocated resources */
g_free(builderFile);
g_object_unref(builder);
if(error) g_error_free(error);
/* Return fail result */
return(FALSE);
}
/* Loading UI resource was successful so take extra reference
* from builder object to keep it alive. Also get widget, set up
* xfconf bindings and connect signals.
* REMEMBER: Set (widget's) default value _before_ setting up
* xfconf binding.
*/
priv->builder=GTK_BUILDER(g_object_ref(builder));
g_debug("Loaded UI resources from '%s' successfully.", builderFile);
/* Tab: General */
priv->widgetResetSearchOnResume=GTK_WIDGET(gtk_builder_get_object(priv->builder, "reset-search-on-resume"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->widgetResetSearchOnResume), DEFAULT_RESET_SEARCH_ON_RESUME);
xfconf_g_property_bind(priv->xfconfChannel,
"/reset-search-on-resume",
G_TYPE_BOOLEAN,
priv->widgetResetSearchOnResume,
"active");
priv->widgetSwitchViewOnResume=GTK_WIDGET(gtk_builder_get_object(priv->builder, "switch-view-on-resume"));
if(priv->widgetSwitchViewOnResume)
{
GtkCellRenderer *renderer;
GtkListStore *listStore;
GtkTreeIter listStoreIter;
GtkTreeIter *defaultListStoreIter;
XfdashboardSettingsResumableViews *iter;
gchar *defaultValue;
/* Get default value from settings */
defaultValue=xfconf_channel_get_string(priv->xfconfChannel, "/switch-view-on-resume", DEFAULT_SWITCH_VIEW_ON_RESUME);
if(!defaultValue) defaultValue=g_strdup("");
/* Clear combo box */
gtk_cell_layout_clear(GTK_CELL_LAYOUT(priv->widgetSwitchViewOnResume));
/* Set up renderer for combo box */
renderer=gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(priv->widgetSwitchViewOnResume), renderer, TRUE);
gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(priv->widgetSwitchViewOnResume), renderer, "text", 0);
/* Set up list to show at combo box */
defaultListStoreIter=NULL;
listStore=gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
for(iter=resumableViews; iter->displayName; ++iter)
{
gtk_list_store_append(listStore, &listStoreIter);
gtk_list_store_set(listStore, &listStoreIter, 0, _(iter->displayName), 1, iter->viewName, -1);
if(!g_strcmp0(iter->viewName, defaultValue))
{
defaultListStoreIter=gtk_tree_iter_copy(&listStoreIter);
}
}
gtk_combo_box_set_model(GTK_COMBO_BOX(priv->widgetSwitchViewOnResume), GTK_TREE_MODEL(listStore));
g_object_unref(G_OBJECT(listStore));
/* Set up default value */
if(defaultListStoreIter)
{
gtk_combo_box_set_active_iter(GTK_COMBO_BOX(priv->widgetSwitchViewOnResume), defaultListStoreIter);
gtk_tree_iter_free(defaultListStoreIter);
defaultListStoreIter=NULL;
}
/* Connect signals */
g_signal_connect_swapped(priv->widgetSwitchViewOnResume,
"changed",
G_CALLBACK(_xfdashboard_settings_widget_changed_switch_view_on_resume),
self);
g_signal_connect_swapped(priv->xfconfChannel,
"property-changed::/switch-view-on-resume",
G_CALLBACK(_xfdashboard_settings_xfconf_changed_switch_view_on_resume),
self);
/* Release allocated resources */
if(defaultValue) g_free(defaultValue);
}
priv->widgetNotificationTimeout=GTK_WIDGET(gtk_builder_get_object(priv->builder, "notification-timeout"));
if(priv->widgetNotificationTimeout)
{
GtkAdjustment *adjustment;
gdouble defaultValue;
/* Get default value */
defaultValue=xfconf_channel_get_uint(priv->xfconfChannel, "/min-notification-timeout", DEFAULT_NOTIFICATION_TIMEOUT)/1000.0;
/* Set up scaling settings of widget */
adjustment=GTK_ADJUSTMENT(gtk_builder_get_object(priv->builder, "notification-timeout-adjustment"));
gtk_range_set_adjustment(GTK_RANGE(priv->widgetNotificationTimeout), adjustment);
/* Set up default value */
gtk_range_set_value(GTK_RANGE(priv->widgetNotificationTimeout), defaultValue);
/* Connect signals */
g_signal_connect(priv->widgetNotificationTimeout,
"format-value",
G_CALLBACK(_xfdashboard_settings_on_format_notification_timeout_value),
NULL);
g_signal_connect_swapped(priv->widgetNotificationTimeout,
"value-changed",
G_CALLBACK(_xfdashboard_settings_widget_changed_notification_timeout),
self);
g_signal_connect_swapped(priv->xfconfChannel,
"property-changed::/min-notification-timeout",
G_CALLBACK(_xfdashboard_settings_xfconf_changed_notification_timeout),
self);
}
priv->widgetEnableUnmappedWindowWorkaround=GTK_WIDGET(gtk_builder_get_object(priv->builder, "enable-unmapped-window-workaround"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->widgetEnableUnmappedWindowWorkaround), FALSE);
xfconf_g_property_bind(priv->xfconfChannel,
"/enable-unmapped-window-workaround",
G_TYPE_BOOLEAN,
priv->widgetEnableUnmappedWindowWorkaround,
"active");
priv->widgetShowAllApps=GTK_WIDGET(gtk_builder_get_object(priv->builder, "show-all-apps"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->widgetShowAllApps), FALSE);
xfconf_g_property_bind(priv->xfconfChannel,
"/components/applications-view/show-all-apps",
G_TYPE_BOOLEAN,
priv->widgetShowAllApps,
"active");
priv->widgetScrollEventChangedWorkspace=GTK_WIDGET(gtk_builder_get_object(priv->builder, "scroll-event-changes-workspace"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->widgetScrollEventChangedWorkspace), FALSE);
xfconf_g_property_bind(priv->xfconfChannel,
"/components/windows-view/scroll-event-changes-workspace",
G_TYPE_BOOLEAN,
priv->widgetScrollEventChangedWorkspace,
"active");
priv->widgetCloseButton=GTK_WIDGET(gtk_builder_get_object(priv->builder, "close-button"));
g_signal_connect_swapped(priv->widgetCloseButton,
"clicked",
G_CALLBACK(_xfdashboard_settings_on_close_clicked),
self);
/* Tab: Themes */
priv->widgetThemeScreenshot=GTK_WIDGET(gtk_builder_get_object(priv->builder, "theme-screenshot"));
priv->widgetThemeNameLabel=GTK_WIDGET(gtk_builder_get_object(priv->builder, "theme-name-label"));
priv->widgetThemeName=GTK_WIDGET(gtk_builder_get_object(priv->builder, "theme-name"));
priv->widgetThemeAuthorLabel=GTK_WIDGET(gtk_builder_get_object(priv->builder, "theme-author-label"));
priv->widgetThemeAuthor=GTK_WIDGET(gtk_builder_get_object(priv->builder, "theme-author"));
priv->widgetThemeVersionLabel=GTK_WIDGET(gtk_builder_get_object(priv->builder, "theme-version-label"));
priv->widgetThemeVersion=GTK_WIDGET(gtk_builder_get_object(priv->builder, "theme-version"));
priv->widgetThemeDescriptionLabel=GTK_WIDGET(gtk_builder_get_object(priv->builder, "theme-description-label"));
priv->widgetThemeDescription=GTK_WIDGET(gtk_builder_get_object(priv->builder, "theme-description"));
priv->widgetThemes=GTK_WIDGET(gtk_builder_get_object(priv->builder, "themes"));
if(priv->widgetThemes)
{
gchar *currentTheme;
GValue defaultValue=G_VALUE_INIT;
GtkTreeSelection *selection;
GtkCellRenderer *renderer;
/* Get default value */
currentTheme=xfconf_channel_get_string(priv->xfconfChannel, "/theme", DEFAULT_THEME);
g_value_init(&defaultValue, G_TYPE_STRING);
g_value_set_string(&defaultValue, currentTheme);
g_free(currentTheme);
/* Themes widget has only one column displaying theme's name.
* Set up column and renderer.
*/
renderer=gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(priv->widgetThemes),
0,
_("Theme"),
renderer,
"text",
COLUMN_THEME_NAME,
NULL);
/* Ensure only one selection at time is possible */
selection=gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->widgetThemes));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
/* Populate list of available themes */
_xfdashboard_settings_populate_themes_list(self, priv->widgetThemes);
/* Select default value */
_xfdashboard_settings_xfconf_changed_theme(self,
"/theme",
&defaultValue,
priv->xfconfChannel);
_xfdashboard_settings_widget_changed_theme(self, selection);
/* Connect signals */
g_signal_connect_swapped(selection,
"changed",
G_CALLBACK(_xfdashboard_settings_widget_changed_theme),
self);
g_signal_connect_swapped(priv->xfconfChannel,
"property-changed::/theme",
G_CALLBACK(_xfdashboard_settings_xfconf_changed_theme),
self);
/* Release allocated resources */
g_value_unset(&defaultValue);
}
/* Release allocated resources */
g_free(builderFile);
g_object_unref(builder);
/* Return success result */
return(TRUE);
}
/*
* displays the configuration window and opens the config file.
*/
static void alarm_configure(void)
{
int daynum = 0; // used to loop days
GtkWidget *w;
if (config_dialog)
{
gtk_window_present(GTK_WINDOW(config_dialog));
return;
}
alarm_read_config();
/*
* Create the widgets
*/
config_dialog = create_config_dialog();
w = lookup_widget(config_dialog, "alarm_h_spin");
alarm_conf.alarm_h = GTK_SPIN_BUTTON(w);
gtk_spin_button_set_value(alarm_conf.alarm_h, alarm_h);
w = lookup_widget(config_dialog, "alarm_m_spin");
alarm_conf.alarm_m = GTK_SPIN_BUTTON(w);
gtk_spin_button_set_value(alarm_conf.alarm_m, alarm_m);
w = lookup_widget(config_dialog, "stop_h_spin");
alarm_conf.stop_h = GTK_SPIN_BUTTON(w);
gtk_spin_button_set_value(alarm_conf.stop_h, stop_h);
w = lookup_widget(config_dialog, "stop_m_spin");
alarm_conf.stop_m = GTK_SPIN_BUTTON(w);
gtk_spin_button_set_value(alarm_conf.stop_m, stop_m);
w = lookup_widget(config_dialog, "stop_checkb");
alarm_conf.stop_on = GTK_TOGGLE_BUTTON(w);
gtk_toggle_button_set_active(alarm_conf.stop_on, stop_on);
w = lookup_widget(config_dialog, "vol_scale");
alarm_conf.volume = GTK_RANGE(w);
gtk_range_set_adjustment(alarm_conf.volume,
GTK_ADJUSTMENT(gtk_adjustment_new(volume, 0, 100, 1, 5, 0)));
w = lookup_widget(config_dialog, "quiet_vol_scale");
alarm_conf.quietvol = GTK_RANGE(w);
gtk_range_set_adjustment(alarm_conf.quietvol,
GTK_ADJUSTMENT(gtk_adjustment_new(quietvol, 0, 100, 1, 5, 0)));
/* days of week */
for(; daynum < 7; daynum++)
{
w = lookup_widget(config_dialog, day_cb[daynum]);
alarm_conf.day[daynum].cb = GTK_CHECK_BUTTON(w);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(alarm_conf.day[daynum].cb),
!(alarm_conf.day[daynum].flags & ALARM_OFF));
w = lookup_widget(config_dialog, day_def[daynum]);
alarm_conf.day[daynum].cb_def = GTK_CHECK_BUTTON(w);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(alarm_conf.day[daynum].cb_def),
alarm_conf.day[daynum].flags & ALARM_DEFAULT);
/* Changed to show default time instead of set time when ALARM_DEFAULT set,
* as suggested by Mark Brown
*/
/* w = lookup_widget(config_dialog, day_h[daynum]);
alarm_conf.day[daynum].spin_hr = GTK_SPIN_BUTTON(w);
gtk_spin_button_set_value(alarm_conf.day[daynum].spin_hr, alarm_conf.day[daynum].hour);
w = lookup_widget(config_dialog, day_m[daynum]);
alarm_conf.day[daynum].spin_min = GTK_SPIN_BUTTON(w);
gtk_spin_button_set_value(alarm_conf.day[daynum].spin_min, alarm_conf.day[daynum].min);
*/
if(alarm_conf.day[daynum].flags & ALARM_DEFAULT)
{
w = lookup_widget(config_dialog, day_h[daynum]);
alarm_conf.day[daynum].spin_hr = GTK_SPIN_BUTTON(w);
gtk_spin_button_set_value(alarm_conf.day[daynum].spin_hr, alarm_conf.default_hour);
w = lookup_widget(config_dialog, day_m[daynum]);
alarm_conf.day[daynum].spin_min = GTK_SPIN_BUTTON(w);
gtk_spin_button_set_value(alarm_conf.day[daynum].spin_min, alarm_conf.default_min);
gtk_widget_set_sensitive((GtkWidget *)alarm_conf.day[daynum].spin_hr, FALSE);
gtk_widget_set_sensitive((GtkWidget *)alarm_conf.day[daynum].spin_min, FALSE);
}
else
{
w = lookup_widget(config_dialog, day_h[daynum]);
alarm_conf.day[daynum].spin_hr = GTK_SPIN_BUTTON(w);
gtk_spin_button_set_value(alarm_conf.day[daynum].spin_hr, alarm_conf.day[daynum].hour);
w = lookup_widget(config_dialog, day_m[daynum]);
alarm_conf.day[daynum].spin_min = GTK_SPIN_BUTTON(w);
gtk_spin_button_set_value(alarm_conf.day[daynum].spin_min, alarm_conf.day[daynum].min);
gtk_widget_set_sensitive((GtkWidget *)alarm_conf.day[daynum].spin_hr, TRUE);
gtk_widget_set_sensitive((GtkWidget *)alarm_conf.day[daynum].spin_min, TRUE);
}
}
/* END: days of week */
w = lookup_widget(config_dialog,"fading_spin");
alarm_conf.fading = GTK_SPIN_BUTTON(w);
gtk_spin_button_set_value(alarm_conf.fading, fading);
char * cmdstr = aud_get_str ("alarm", "cmdstr");
w = lookup_widget(config_dialog, "cmd_entry");
alarm_conf.cmdstr = GTK_ENTRY(w);
gtk_entry_set_text(alarm_conf.cmdstr, cmdstr);
str_unref (cmdstr);
w = lookup_widget(config_dialog, "cmd_checkb");
alarm_conf.cmd_on = GTK_TOGGLE_BUTTON(w);
gtk_toggle_button_set_active(alarm_conf.cmd_on, cmd_on);
char * playlist = aud_get_str ("alarm", "playlist");
w = lookup_widget(config_dialog, "playlist");
alarm_conf.playlist = GTK_ENTRY(w);
gtk_entry_set_text(alarm_conf.playlist, playlist);
str_unref (playlist);
char * reminder_msg = aud_get_str ("alarm", "reminder_msg");
w = lookup_widget(config_dialog, "reminder_text");
alarm_conf.reminder = GTK_ENTRY(w);
gtk_entry_set_text(alarm_conf.reminder, reminder_msg);
str_unref (reminder_msg);
w = lookup_widget(config_dialog, "reminder_cb");
alarm_conf.reminder_cb = GTK_TOGGLE_BUTTON(w);
gtk_toggle_button_set_active(alarm_conf.reminder_cb, alarm_conf.reminder_on);
g_signal_connect (config_dialog, "destroy", (GCallback) gtk_widget_destroyed,
& config_dialog);
AUDDBG("END alarm_configure\n");
}
osso_return_t
execute(osso_context_t *osso, gpointer data, gboolean user_activated)
{
/* Create needed variables */
GtkWidget *dialog;
GtkObject *adj[NUM_BANDS];
struct label_band *lband[NUM_BANDS];
struct dialog_and_sliders *dialog_slid;
GtkWidget *slider_band[NUM_BANDS];
GtkWidget *single_slider_container[NUM_BANDS];
gulong update_label_signal[NUM_BANDS];
gulong update_band_signal[NUM_BANDS];
GtkWidget *sliders_container;
gint i;
GtkWidget *toolbar;
GtkToolItem *toolitem_open;
GtkToolItem *toolitem_save_as;
GtkToolItem *toolitem_delete;
GtkWidget *content_area;
guint update_slider_signal;
dialog = gtk_dialog_new();
gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
gtk_window_set_transient_for(GTK_WINDOW(dialog),
GTK_WINDOW(data));
gtk_window_set_title(GTK_WINDOW(dialog), "MAFW Equalizer");
gtk_window_set_default_size(GTK_WINDOW(dialog), -1, 400);
sliders_container = gtk_hbox_new(TRUE, 10);
toolbar = gtk_toolbar_new();
/* Create the bands */
for (i = 0; i < NUM_BANDS; i++) {
slider_band[i] = hildon_gtk_vscale_new();
adj[i] = gtk_adjustment_new(EQ_GAIN_MIN, EQ_GAIN_MIN,
EQ_GAIN_MAX, 1, 10, 0);
gtk_range_set_adjustment(GTK_RANGE(slider_band[i]),
GTK_ADJUSTMENT(adj[i]));
gtk_range_set_inverted(GTK_RANGE(slider_band[i]), TRUE);
gtk_range_set_update_policy(GTK_RANGE(slider_band[i]),
GTK_UPDATE_DELAYED);
gtk_range_set_show_fill_level(GTK_RANGE(slider_band[i]), FALSE);
single_slider_container[i] = gtk_hbox_new(TRUE, 0);
lband[i] = g_new0(struct label_band, 1);
lband[i]->label = gtk_label_new(NULL);
lband[i]->id = i;
gtk_label_set_angle(GTK_LABEL(lband[i]->label), 90);
gtk_misc_set_alignment(GTK_MISC(lband[i]->label), 0, 0.9);
gtk_box_pack_start(GTK_BOX(single_slider_container[i]),
lband[i]->label,
FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(single_slider_container[i]),
slider_band[i],
TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(sliders_container),
single_slider_container[i],
TRUE,
TRUE,
10);
update_label_signal[i] =
g_signal_connect(slider_band[i],
"value-changed",
G_CALLBACK(update_label_cb),
lband[i]);
gtk_range_set_value(GTK_RANGE(slider_band[i]),
get_band_value(i));
update_band_signal[i] =
g_signal_connect(slider_band[i],
"value-changed",
G_CALLBACK(update_band_cb),
GINT_TO_POINTER(i));
}
/* Listen for changes in gconf */
if (!confclient) {
confclient = gconf_client_get_default();
}
gconf_client_add_dir(confclient, GCONF_MAFW_GST_EQ_RENDERER,
GCONF_CLIENT_PRELOAD_ONELEVEL, NULL);
update_slider_signal =
gconf_client_notify_add(
confclient,
GCONF_MAFW_GST_EQ_RENDERER,
(GConfClientNotifyFunc) update_slider_cb,
slider_band,
NULL, NULL);
/* Create the toolbuttons */
toolitem_open = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN);
toolitem_save_as = gtk_tool_button_new_from_stock(GTK_STOCK_SAVE_AS);
toolitem_delete = gtk_tool_button_new_from_stock(GTK_STOCK_DELETE);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem_open, -1);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem_save_as, -1);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem_delete, -1);
g_signal_connect(toolitem_open, "clicked",
G_CALLBACK(open_button_cb),
dialog);
g_signal_connect(toolitem_delete, "clicked",
G_CALLBACK(delete_button_cb),
dialog);
dialog_slid = g_new0(struct dialog_and_sliders, 1);
dialog_slid->dialog = dialog;
dialog_slid->slider_band = slider_band;
g_signal_connect(toolitem_save_as, "clicked",
G_CALLBACK(save_as_button_cb),
dialog_slid);
content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
gtk_box_pack_start(GTK_BOX(content_area), sliders_container,
TRUE, TRUE, 1);
gtk_box_pack_start(GTK_BOX(content_area), toolbar,
FALSE, FALSE, 1);
/* Run the dialog */
gtk_widget_show_all(GTK_WIDGET(dialog));
gtk_dialog_run(GTK_DIALOG(dialog));
/* Free everything */
gconf_client_notify_remove(confclient, update_slider_signal);
for (i = 0; i < NUM_BANDS; i++) {
g_signal_handler_disconnect(slider_band[i],
update_label_signal[i]);
g_signal_handler_disconnect(slider_band[i],
update_band_signal[i]);
g_free(lband[i]);
}
g_free(dialog_slid);
gtk_widget_destroy(GTK_WIDGET(dialog));
return OSSO_OK;
}
/**
* gimp_scale_entry_set_logarithmic:
* @adjustment: a #GtkAdjustment as returned by gimp_scale_entry_new()
* @logarithmic: a boolean value to set or reset logarithmic behaviour
* of the scale widget
*
* Sets whether the scale_entry's scale widget will behave in a linear
* or logharithmic fashion. Useful when an entry has to attend large
* ranges, but smaller selections on that range require a finer
* adjustment.
*
* Since: GIMP 2.2
**/
void
gimp_scale_entry_set_logarithmic (GtkObject *adjustment,
gboolean logarithmic)
{
GtkAdjustment *adj;
GtkAdjustment *scale_adj;
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
adj = GTK_ADJUSTMENT (adjustment);
scale_adj = GIMP_SCALE_ENTRY_SCALE_ADJ (adjustment);
if (logarithmic == gimp_scale_entry_get_logarithmic (adjustment))
return;
if (logarithmic)
{
gdouble correction;
gdouble log_value, log_lower, log_upper;
gdouble log_step_increment, log_page_increment;
correction = (gtk_adjustment_get_lower (scale_adj) > 0 ?
0 : 0.1 + - gtk_adjustment_get_lower (scale_adj));
log_value = log (gtk_adjustment_get_value (scale_adj) + correction);
log_lower = log (gtk_adjustment_get_lower (scale_adj) + correction);
log_upper = log (gtk_adjustment_get_upper (scale_adj) + correction);
log_step_increment =
(log_upper - log_lower) / ((gtk_adjustment_get_upper (scale_adj) -
gtk_adjustment_get_lower (scale_adj)) /
gtk_adjustment_get_step_increment (scale_adj));
log_page_increment =
(log_upper - log_lower) / ((gtk_adjustment_get_upper (scale_adj) -
gtk_adjustment_get_lower (scale_adj)) /
gtk_adjustment_get_page_increment (scale_adj));
if (scale_adj == adj)
{
GtkObject *new_adj;
new_adj = gtk_adjustment_new (gtk_adjustment_get_value (scale_adj),
gtk_adjustment_get_lower (scale_adj),
gtk_adjustment_get_upper (scale_adj),
gtk_adjustment_get_step_increment (scale_adj),
gtk_adjustment_get_page_increment (scale_adj),
0.0);
gtk_range_set_adjustment (GTK_RANGE (GIMP_SCALE_ENTRY_SCALE (adj)),
GTK_ADJUSTMENT (new_adj));
scale_adj = (GtkAdjustment *) new_adj;
}
else
{
g_signal_handlers_disconnect_by_func (adj,
gimp_scale_entry_unconstrained_adjustment_callback,
scale_adj);
g_signal_handlers_disconnect_by_func (scale_adj,
gimp_scale_entry_unconstrained_adjustment_callback,
adj);
}
gtk_adjustment_configure (scale_adj,
log_value, log_lower, log_upper,
log_step_increment, log_page_increment, 0.0);
g_signal_connect (scale_adj, "value-changed",
G_CALLBACK (gimp_scale_entry_exp_adjustment_callback),
adj);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_scale_entry_log_adjustment_callback),
scale_adj);
g_object_set_data (G_OBJECT (adjustment),
"logarithmic", GINT_TO_POINTER (TRUE));
}
else
{
gdouble lower, upper;
g_signal_handlers_disconnect_by_func (adj,
gimp_scale_entry_log_adjustment_callback,
scale_adj);
g_signal_handlers_disconnect_by_func (scale_adj,
gimp_scale_entry_exp_adjustment_callback,
adj);
lower = exp (gtk_adjustment_get_lower (scale_adj));
upper = exp (gtk_adjustment_get_upper (scale_adj));
if (gtk_adjustment_get_lower (adj) <= 0.0)
{
lower += - 0.1 + gtk_adjustment_get_lower (adj);
upper += - 0.1 + gtk_adjustment_get_lower (adj);
}
gtk_adjustment_configure (scale_adj,
gtk_adjustment_get_value (adj),
lower, upper,
gtk_adjustment_get_step_increment (adj),
gtk_adjustment_get_page_increment (adj),
0.0);
g_signal_connect (scale_adj, "value-changed",
G_CALLBACK (gimp_scale_entry_unconstrained_adjustment_callback),
adj);
g_signal_connect (adj, "value-changed",
G_CALLBACK (gimp_scale_entry_unconstrained_adjustment_callback),
scale_adj);
g_object_set_data (G_OBJECT (adjustment),
"logarithmic", GINT_TO_POINTER (FALSE));
}
}
static GtkObject *
gimp_scale_entry_new_internal (gboolean color_scale,
GtkTable *table,
gint column,
gint row,
const gchar *text,
gint scale_width,
gint spinbutton_width,
gdouble value,
gdouble lower,
gdouble upper,
gdouble step_increment,
gdouble page_increment,
guint digits,
gboolean constrain,
gdouble unconstrained_lower,
gdouble unconstrained_upper,
const gchar *tooltip,
const gchar *help_id)
{
GtkWidget *label;
GtkWidget *scale;
GtkWidget *spinbutton;
GtkObject *adjustment;
GtkObject *return_adj;
label = gtk_label_new_with_mnemonic (text);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label,
column, column + 1, row, row + 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
if (! constrain &&
unconstrained_lower <= lower &&
unconstrained_upper >= upper)
{
GtkObject *constrained_adj;
constrained_adj = gtk_adjustment_new (value, lower, upper,
step_increment, page_increment,
0.0);
spinbutton = gimp_spin_button_new (&adjustment, value,
unconstrained_lower,
unconstrained_upper,
step_increment, page_increment, 0.0,
1.0, digits);
g_signal_connect
(G_OBJECT (constrained_adj), "value-changed",
G_CALLBACK (gimp_scale_entry_unconstrained_adjustment_callback),
adjustment);
g_signal_connect
(G_OBJECT (adjustment), "value-changed",
G_CALLBACK (gimp_scale_entry_unconstrained_adjustment_callback),
constrained_adj);
return_adj = adjustment;
adjustment = constrained_adj;
}
else
{
spinbutton = gimp_spin_button_new (&adjustment, value, lower, upper,
step_increment, page_increment, 0.0,
1.0, digits);
return_adj = adjustment;
}
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton);
if (spinbutton_width > 0)
{
if (spinbutton_width < 17)
gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), spinbutton_width);
else
gtk_widget_set_size_request (spinbutton, spinbutton_width, -1);
}
if (color_scale)
{
scale = gimp_color_scale_new (GTK_ORIENTATION_HORIZONTAL,
GIMP_COLOR_SELECTOR_VALUE);
gtk_range_set_adjustment (GTK_RANGE (scale),
GTK_ADJUSTMENT (adjustment));
}
else
{
scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL,
GTK_ADJUSTMENT (adjustment));
}
if (scale_width > 0)
gtk_widget_set_size_request (scale, scale_width, -1);
gtk_scale_set_digits (GTK_SCALE (scale), digits);
gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE);
gtk_table_attach (GTK_TABLE (table), scale,
column + 1, column + 2, row, row + 1,
GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
gtk_widget_show (scale);
gtk_table_attach (GTK_TABLE (table), spinbutton,
column + 2, column + 3, row, row + 1,
GTK_FILL | GTK_SHRINK, GTK_SHRINK, 0, 0);
gtk_widget_show (spinbutton);
if (tooltip || help_id)
{
gimp_help_set_help_data (label, tooltip, help_id);
gimp_help_set_help_data (scale, tooltip, help_id);
gimp_help_set_help_data (spinbutton, tooltip, help_id);
}
g_object_set_data (G_OBJECT (return_adj), "label", label);
g_object_set_data (G_OBJECT (return_adj), "scale", scale);
g_object_set_data (G_OBJECT (return_adj), "spinbutton", spinbutton);
return return_adj;
}
void malicrecog_gui_setup(MalicRecogGui* gui, MalibObject* handler){
GtkWidget * malicrecog_main_fixed, * malicrecog_main_viewport,
* malicrecog_statusbar, * malicrecog_scrolledwindow,
* alpha_progressbar, * toggle_running,
* malib_drawingarea;
gtk_signal_connect(GTK_OBJECT (gui->window), "delete_event",
GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
//GTK_SIGNAL_FUNC (gtk_wrap_malic_cv_gtkdisplay_delete), gui->display);
/* main viewport (drawingarea) */
malicrecog_main_viewport= lookup_widget(gui->window, "malicrecog_main_viewport");
gtk_widget_set_usize(malicrecog_main_viewport,
BTTV_DEFAULT_WIDTH, BTTV_DEFAULT_HEIGHT);
malib_drawingarea=
GTK_WIDGET (malib_gtkdisplay_get_drawarea(gui->display));
gtk_container_add(GTK_CONTAINER (malicrecog_main_viewport), malib_drawingarea);
gtk_widget_ref(malib_drawingarea);
/* toggle running button */
toggle_running= lookup_widget(gui->window, "toggle_running_button");
gtk_signal_connect(GTK_OBJECT (toggle_running), "clicked",
GTK_SIGNAL_FUNC (malicrecog_toggle_running_clicked),
gui);
/* create indicator's gdk_pixmap */
{
GtkPixmap* tmp_gtk_pixmap;
tmp_gtk_pixmap= (GtkPixmap*) create_pixmap
(gui->window, MALICRECOG_FACE_DETECT_PIXMAP);
gui->face_detect_indicator_malic_pixmap.gdk_pixmap = tmp_gtk_pixmap->pixmap;
gui->face_detect_indicator_malic_pixmap.pixmap_mask= tmp_gtk_pixmap->mask;
tmp_gtk_pixmap= (GtkPixmap*) create_pixmap
(gui->window, MALICRECOG_NAME_DETECT_PIXMAP);
gui->name_detect_indicator_malic_pixmap.gdk_pixmap = tmp_gtk_pixmap->pixmap;
gui->name_detect_indicator_malic_pixmap.pixmap_mask= tmp_gtk_pixmap->mask;
tmp_gtk_pixmap= (GtkPixmap*) create_pixmap
(gui->window, MALICRECOG_DUMMY_20_PIXMAP);
gui->dummy_20_malic_pixmap.gdk_pixmap = tmp_gtk_pixmap->pixmap;
gui->dummy_20_malic_pixmap.pixmap_mask= tmp_gtk_pixmap->mask;
}
/* face detect and name detect indicator setup */
{
gui->face_detect_indicator_malic_pixmap.pixmap=
lookup_widget(gui->window, "face_detect_indicator_pix");
gtk_pixmap_set((GtkPixmap*)gui->face_detect_indicator_malic_pixmap.pixmap,
gui->dummy_20_malic_pixmap.gdk_pixmap,
gui->dummy_20_malic_pixmap.pixmap_mask);
gui->name_detect_indicator_malic_pixmap.pixmap=
lookup_widget(gui->window, "name_detect_indicator_pix");
gtk_pixmap_set((GtkPixmap*)gui->name_detect_indicator_malic_pixmap.pixmap,
gui->dummy_20_malic_pixmap.gdk_pixmap,
gui->dummy_20_malic_pixmap.pixmap_mask);
}
/* face detect and name detect indicator setup end */
/* labels setup */
{
gui->last_name_label = lookup_widget(gui->window, "last_name_label");
gui->current_name_label = lookup_widget(gui->window, "current_name_label");
gui->current_similar_value_label= lookup_widget(gui->window, "current_similar_value_label");
gui->current_sim_jet_value_label= lookup_widget(gui->window, "current_sim_jet_value_label");
gui->current_sim_geo_value_label= lookup_widget(gui->window, "current_sim_geo_value_label");
}
/* labels setup end */
/* name detect threshold slider setup */
{
GtkAdjustment * adj;
GtkWidget * h_scale;
MalicFaceGraphMeasure * filter;
filter= gui->fg_measure_filter;
if(filter){
h_scale= lookup_widget(gui->window, "name_threshold_h_scale");
gtk_range_set_adjustment( GTK_RANGE(h_scale),
GTK_ADJUSTMENT (gtk_adjustment_new (filter->face_detect_threshold, 0, 1, 0, 0, 0)));
adj= gtk_range_get_adjustment ( GTK_RANGE(h_scale) );
gtk_signal_connect( GTK_OBJECT(adj), "value_changed",
on_malic_ftype_h_scale_value_change,
&filter->face_detect_threshold );
}
}
/* name detect threshold slider setup end */
/* color slider setup */
{
GtkAdjustment* adj;
GtkWidget * color_hscale;
MalicColorConfig * filter;
filter= (MalicColorConfig*)gui->c_conf_filter;
if(filter){
color_hscale= lookup_widget (gui->window, "hscale_red");
adj= gtk_range_get_adjustment (GTK_RANGE(color_hscale));
gtk_signal_connect(GTK_OBJECT(adj), "value_changed",
on_color_hscale_button_value_change,
&filter->red);
color_hscale= lookup_widget (gui->window, "hscale_green");
adj= gtk_range_get_adjustment (GTK_RANGE(color_hscale));
gtk_signal_connect(GTK_OBJECT(adj), "value_changed",
on_color_hscale_button_value_change,
&filter->green);
color_hscale= lookup_widget (gui->window, "hscale_blue");
adj= gtk_range_get_adjustment (GTK_RANGE(color_hscale));
gtk_signal_connect(GTK_OBJECT(adj), "value_changed",
on_color_hscale_button_value_change,
&filter->blue);
}
}
return;
}
static void
test_color_plane (void)
{
g_autoptr (GtkBuilder) builder = NULL;
GtkWidget *window;
GtkWidget *mode_box;
GtkListStore *mode_store;
GtkWidget *hue_scale;
GtkWidget *saturation_scale;
GtkWidget *value_scale;
GtkWidget *cielab_l_scale;
GtkWidget *cielab_a_scale;
GtkWidget *cielab_b_scale;
GtkWidget *red_scale;
GtkWidget *green_scale;
GtkWidget *blue_scale;
GtkWidget *box;
GstyleColorPlane *plane;
GError *error = NULL;
gtk_init (NULL, NULL);
builder = gtk_builder_new ();
gtk_builder_add_from_file (builder, TEST_DATA_DIR"/gstyle-color-editor.ui", &error);
g_assert_no_error (error);
plane = GSTYLE_COLOR_PLANE (gtk_builder_get_object (builder, "plane"));
hue_scale = GTK_WIDGET (gtk_builder_get_object (builder, "hsv_h_scale"));
gtk_range_set_adjustment (GTK_RANGE (hue_scale),
gstyle_color_plane_get_component_adjustment (plane, GSTYLE_COLOR_COMPONENT_HSV_H));
saturation_scale = GTK_WIDGET (gtk_builder_get_object (builder, "hsv_s_scale"));
gtk_range_set_adjustment (GTK_RANGE (saturation_scale),
gstyle_color_plane_get_component_adjustment (plane, GSTYLE_COLOR_COMPONENT_HSV_S));
value_scale = GTK_WIDGET (gtk_builder_get_object (builder, "hsv_v_scale"));
gtk_range_set_adjustment (GTK_RANGE (value_scale),
gstyle_color_plane_get_component_adjustment (plane, GSTYLE_COLOR_COMPONENT_HSV_V));
cielab_l_scale = GTK_WIDGET (gtk_builder_get_object (builder, "cielab_l_scale"));
gtk_range_set_adjustment (GTK_RANGE (cielab_l_scale),
gstyle_color_plane_get_component_adjustment (plane, GSTYLE_COLOR_COMPONENT_LAB_L));
cielab_a_scale = GTK_WIDGET (gtk_builder_get_object (builder, "cielab_a_scale"));
gtk_range_set_adjustment (GTK_RANGE (cielab_a_scale),
gstyle_color_plane_get_component_adjustment (plane, GSTYLE_COLOR_COMPONENT_LAB_A));
cielab_b_scale = GTK_WIDGET (gtk_builder_get_object (builder, "cielab_b_scale"));
gtk_range_set_adjustment (GTK_RANGE (cielab_b_scale),
gstyle_color_plane_get_component_adjustment (plane, GSTYLE_COLOR_COMPONENT_LAB_A));
red_scale = GTK_WIDGET (gtk_builder_get_object (builder, "rgb_red_scale"));
gtk_range_set_adjustment (GTK_RANGE (red_scale),
gstyle_color_plane_get_component_adjustment (plane, GSTYLE_COLOR_COMPONENT_RGB_RED));
green_scale = GTK_WIDGET (gtk_builder_get_object (builder, "rgb_green_scale"));
gtk_range_set_adjustment (GTK_RANGE (green_scale),
gstyle_color_plane_get_component_adjustment (plane, GSTYLE_COLOR_COMPONENT_RGB_RED));
blue_scale = GTK_WIDGET (gtk_builder_get_object (builder, "rgb_blue_scale"));
gtk_range_set_adjustment (GTK_RANGE (blue_scale),
gstyle_color_plane_get_component_adjustment (plane, GSTYLE_COLOR_COMPONENT_RGB_BLUE));
mode_box = GTK_WIDGET (gtk_builder_get_object (builder, "mode_box"));
mode_store = GTK_LIST_STORE (gtk_builder_get_object (builder, "mode_store"));
gtk_list_store_insert_with_values (mode_store, NULL, -1, 0, GSTYLE_COLOR_PLANE_MODE_HUE, 1, "Hsv Hue", -1);
gtk_list_store_insert_with_values (mode_store, NULL, -1, 0, GSTYLE_COLOR_PLANE_MODE_SATURATION, 1, "Hsv Saturation", -1);
gtk_list_store_insert_with_values (mode_store, NULL, -1, 0, GSTYLE_COLOR_PLANE_MODE_BRIGHTNESS, 1, "Hsv Brightness (Value)", -1);
gtk_list_store_insert_with_values (mode_store, NULL, -1, 0, GSTYLE_COLOR_PLANE_MODE_CIELAB_L, 1, "CieLab L*", -1);
gtk_list_store_insert_with_values (mode_store, NULL, -1, 0, GSTYLE_COLOR_PLANE_MODE_CIELAB_A, 1, "CieLab a*", -1);
gtk_list_store_insert_with_values (mode_store, NULL, -1, 0, GSTYLE_COLOR_PLANE_MODE_CIELAB_B, 1, "CieLab b*", -1);
gtk_list_store_insert_with_values (mode_store, NULL, -1, 0, GSTYLE_COLOR_PLANE_MODE_RED, 1, "rgb red", -1);
gtk_list_store_insert_with_values (mode_store, NULL, -1, 0, GSTYLE_COLOR_PLANE_MODE_GREEN, 1, "rgb green", -1);
gtk_list_store_insert_with_values (mode_store, NULL, -1, 0, GSTYLE_COLOR_PLANE_MODE_BLUE, 1, "rgb blue", -1);
gtk_combo_box_set_active (GTK_COMBO_BOX (mode_box), 0);
g_signal_connect_swapped (mode_box, "changed", G_CALLBACK (mode_changed), plane);
box = GTK_WIDGET (gtk_builder_get_object (builder, "editor_box"));
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_container_add (GTK_CONTAINER (window), box);
gtk_window_set_default_size (GTK_WINDOW (window), 400,400);
g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_show_all (window);
gtk_main ();
}
static void
handle_input(gpointer client_data, gint source, GdkInputCondition ic)
{
int message;
gtk_pipe_int_read(&message);
switch (message) {
case REFRESH_MESSAGE:
g_warning("REFRESH MESSAGE IS OBSOLETE !!!");
break;
case TOTALTIME_MESSAGE:
{
int tt;
int minutes,seconds;
char local_string[20];
GtkObject *adj;
gtk_pipe_int_read(&tt);
seconds=max_sec=tt/play_mode->rate;
minutes=seconds/60;
seconds-=minutes*60;
sprintf(local_string,"/ %i:%02i",minutes,seconds);
gtk_label_set(GTK_LABEL(tot_lbl), local_string);
/* Readjust the time scale */
adj = gtk_adjustment_new(0., 0., (gfloat)max_sec,
1., 10., 0.);
gtk_signal_connect(GTK_OBJECT(adj), "value_changed",
GTK_SIGNAL_FUNC(generic_scale_cb),
(gpointer)GTK_CHANGE_LOCATOR);
gtk_range_set_adjustment(GTK_RANGE(locator),
GTK_ADJUSTMENT(adj));
}
break;
case MASTERVOL_MESSAGE:
{
int volume;
GtkAdjustment *adj;
gtk_pipe_int_read(&volume);
adj = gtk_range_get_adjustment(GTK_RANGE(vol_scale));
my_adjustment_set_value(adj, MAX_AMPLIFICATION - volume);
}
break;
case FILENAME_MESSAGE:
{
char filename[255], title[255];
char *pc;
gtk_pipe_string_read(filename);
/* Extract basename of the file */
pc = strrchr(filename, '/');
if (pc == NULL)
pc = filename;
else
pc++;
sprintf(title, "Timidity %s - %s", timidity_version, pc);
gtk_window_set_title(GTK_WINDOW(window), title);
/* Clear the text area. */
#ifdef HAVE_GTK_2
textbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
gtk_text_buffer_get_start_iter(textbuf, &start_iter);
gtk_text_buffer_get_end_iter(textbuf, &end_iter);
iter = start_iter;
#else
gtk_text_freeze(GTK_TEXT(text));
gtk_text_set_point(GTK_TEXT(text), 0);
gtk_text_forward_delete(GTK_TEXT(text),
gtk_text_get_length(GTK_TEXT(text)));
gtk_text_thaw(GTK_TEXT(text));
#endif
}
break;
case FILE_LIST_MESSAGE:
{
gchar filename[255], *fnames[2];
gint i, number_of_files;
/* reset the playing list : play from the start */
file_number_to_play = -1;
gtk_pipe_int_read(&number_of_files);
for (i = 0; i < number_of_files; i++)
{
gtk_pipe_string_read(filename);
fnames[0] = filename;
fnames[1] = NULL;
gtk_clist_append(GTK_CLIST(clist), fnames);
}
gtk_clist_columns_autosize(GTK_CLIST(clist));
}
break;
case NEXT_FILE_MESSAGE:
case PREV_FILE_MESSAGE:
case TUNE_END_MESSAGE:
{
int nbfile;
/* When a file ends, launch next if auto_next toggle */
if ( (message==TUNE_END_MESSAGE) &&
!GTK_CHECK_MENU_ITEM(auto_next)->active )
return;
/* Total number of file to play in the list */
nbfile = GTK_CLIST(clist)->rows;
if (message == PREV_FILE_MESSAGE)
file_number_to_play--;
else
file_number_to_play++;
/* Do nothing if requested file is before first one */
if (file_number_to_play < 0) {
file_number_to_play = 0;
return;
}
/* Stop after playing the last file */
if (file_number_to_play >= nbfile) {
file_number_to_play = nbfile - 1;
return;
}
if(gtk_clist_row_is_visible(GTK_CLIST(clist),
file_number_to_play) !=
GTK_VISIBILITY_FULL) {
gtk_clist_moveto(GTK_CLIST(clist), file_number_to_play,
-1, 1.0, 0.0);
}
gtk_clist_select_row(GTK_CLIST(clist), file_number_to_play, 0);
}
break;
case CURTIME_MESSAGE:
{
int seconds, minutes;
int nbvoice;
char local_string[20];
gtk_pipe_int_read(&seconds);
gtk_pipe_int_read(&nbvoice);
if( is_quitting )
return;
minutes=seconds/60;
sprintf(local_string,"%2d:%02d", minutes, (int)(seconds % 60));
gtk_label_set(GTK_LABEL(cnt_lbl), local_string);
/* Readjust the time scale if not dragging the scale */
if( !locating && (seconds <= max_sec)) {
GtkAdjustment *adj;
adj = gtk_range_get_adjustment(GTK_RANGE(locator));
my_adjustment_set_value(adj, (gfloat)seconds);
}
}
break;
case NOTE_MESSAGE:
{
int channel;
int note;
gtk_pipe_int_read(&channel);
gtk_pipe_int_read(¬e);
g_warning("NOTE chn%i %i", channel, note);
}
break;
case PROGRAM_MESSAGE:
{
int channel;
int pgm;
gtk_pipe_int_read(&channel);
gtk_pipe_int_read(&pgm);
g_warning("NOTE chn%i %i", channel, pgm);
}
break;
case VOLUME_MESSAGE:
{
int channel;
int volume;
gtk_pipe_int_read(&channel);
gtk_pipe_int_read(&volume);
g_warning("VOLUME= chn%i %i", channel, volume);
}
break;
case EXPRESSION_MESSAGE:
{
int channel;
int express;
gtk_pipe_int_read(&channel);
gtk_pipe_int_read(&express);
g_warning("EXPRESSION= chn%i %i", channel, express);
}
break;
case PANNING_MESSAGE:
{
int channel;
int pan;
gtk_pipe_int_read(&channel);
gtk_pipe_int_read(&pan);
g_warning("PANNING= chn%i %i", channel, pan);
}
break;
case SUSTAIN_MESSAGE:
{
int channel;
int sust;
gtk_pipe_int_read(&channel);
gtk_pipe_int_read(&sust);
g_warning("SUSTAIN= chn%i %i", channel, sust);
}
break;
case PITCH_MESSAGE:
{
int channel;
int bend;
gtk_pipe_int_read(&channel);
gtk_pipe_int_read(&bend);
g_warning("PITCH BEND= chn%i %i", channel, bend);
}
break;
case RESET_MESSAGE:
g_warning("RESET_MESSAGE");
break;
case CLOSE_MESSAGE:
gtk_exit(0);
break;
case CMSG_MESSAGE:
{
int type;
char message[1000];
#ifdef HAVE_GTK_2
gchar *message_u8;
#endif
gtk_pipe_int_read(&type);
gtk_pipe_string_read(message);
#ifdef HAVE_GTK_2
message_u8 = g_locale_to_utf8( message, -1, NULL, NULL, NULL );
gtk_text_buffer_get_bounds(textbuf, &start_iter, &end_iter);
gtk_text_buffer_insert(textbuf, &end_iter,
message_u8, -1);
gtk_text_buffer_insert(textbuf, &end_iter,
"\n", 1);
gtk_text_buffer_get_bounds(textbuf, &start_iter, &end_iter);
mark = gtk_text_buffer_create_mark(textbuf, NULL, &end_iter, 1);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(text), mark, 0.0, 0, 0.0, 1.0);
gtk_text_buffer_delete_mark(textbuf, mark);
g_free( message_u8 );
#else
gtk_text_insert(GTK_TEXT(text), NULL, NULL, NULL,
message, -1);
gtk_text_insert(GTK_TEXT(text), NULL, NULL, NULL,
"\n", 1);
#endif
}
break;
case LYRIC_MESSAGE:
{
char message[1000];
#ifdef HAVE_GTK_2
gchar *message_u8;
#endif
gtk_pipe_string_read(message);
#ifdef HAVE_GTK_2
message_u8 = g_locale_to_utf8( message, -1, NULL, NULL, NULL );
gtk_text_buffer_get_bounds(textbuf, &start_iter, &end_iter);
// mod JN iter -> end_iter
gtk_text_buffer_insert(textbuf, &end_iter,
message_u8, -1);
gtk_text_buffer_get_bounds(textbuf, &start_iter, &end_iter);
mark = gtk_text_buffer_create_mark(textbuf, NULL, &end_iter, 1);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(text), mark, 0.0, 0, 0.0, 1.0);
gtk_text_buffer_delete_mark(textbuf, mark);
#else
gtk_text_insert(GTK_TEXT(text), NULL, NULL, NULL,
message, -1);
#endif
}
break;
default:
g_warning("UNKNOWN Gtk+ MESSAGE %i", message);
}
}
spin_button_ctx_t *time_scrollbar_new(void)
{
GtkObject *adj_msec;
GtkObject *adj_sec;
GtkObject *adj_min;
GtkObject *adj_scale;
GtkWidget *scale;
GtkWidget *spin_msec;
GtkWidget *spin_sec;
GtkWidget *spin_min;
GtkWidget *hbox;
GtkWidget *vbox;
spin_button_ctx_t *sbctx;
sbctx = (spin_button_ctx_t *) calloc(1, sizeof(spin_button_ctx_t));
vbox = gtk_vbox_new(FALSE, 4);
sbctx->time_scrollbar = vbox;
hbox = gtk_hbox_new(FALSE, 4);
gtk_widget_show(hbox);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
adj_msec = gtk_adjustment_new(0.0, -1.0, 1000.0, 1.0, 1.0, 1.0);
adj_sec = gtk_adjustment_new(0.0, -1.0, 60.0, 1.0, 1.0, 1.0);
adj_min = gtk_adjustment_new(0.0, 0.0, 99.0, 1.0, 1.0, 1.0);
adj_scale = gtk_adjustment_new(0.0, 0.0, 100.0*60*1000, 5.0, 5.0, 1.0);
spin_min = gtk_spin_button_new(GTK_ADJUSTMENT(adj_min), 1.0, 0);
gtk_widget_show(spin_min);
spin_sec = gtk_spin_button_new(GTK_ADJUSTMENT(adj_sec), 1.0, 0);
gtk_widget_show(spin_sec);
spin_msec = gtk_spin_button_new(GTK_ADJUSTMENT(adj_msec), 1.0, 0);
gtk_widget_show(spin_msec);
scale = gtk_hscale_new_with_range(0.0, 100.0, 1.0);
gtk_widget_show(scale);
gtk_range_set_adjustment(GTK_RANGE(scale), GTK_ADJUSTMENT(adj_scale));
gtk_range_set_update_policy(GTK_RANGE(scale), GTK_UPDATE_DELAYED);
gtk_scale_set_draw_value(GTK_SCALE(scale), FALSE);
gtk_box_pack_start(GTK_BOX(hbox), spin_min, FALSE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(hbox), spin_sec, FALSE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(hbox), spin_msec, FALSE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(vbox), scale, FALSE, TRUE, 2);
sbctx->spin_min = GTK_SPIN_BUTTON(spin_min);
sbctx->spin_sec = GTK_SPIN_BUTTON(spin_sec);
sbctx->spin_msec = GTK_SPIN_BUTTON(spin_msec);
sbctx->scale = GTK_SCALE(scale);
sbctx->adj_min = GTK_ADJUSTMENT(adj_min);
sbctx->adj_sec = GTK_ADJUSTMENT(adj_sec);
sbctx->adj_msec = GTK_ADJUSTMENT(adj_msec);
sbctx->adj_scale = GTK_ADJUSTMENT(adj_scale);
g_signal_connect(G_OBJECT(spin_msec), "value-changed",
G_CALLBACK(cb_block_scale), sbctx);
sbctx->hmsec = g_signal_connect(G_OBJECT(spin_msec), "value-changed",
G_CALLBACK(cb_spin_msec), sbctx);
g_signal_connect(G_OBJECT(spin_msec), "value-changed",
G_CALLBACK(cb_unblock_scale), sbctx);
g_signal_connect(G_OBJECT(spin_sec), "value-changed",
G_CALLBACK(cb_block_scale), sbctx);
sbctx->hsec = g_signal_connect(G_OBJECT(spin_sec), "value-changed",
G_CALLBACK(cb_spin_sec), sbctx);
g_signal_connect(G_OBJECT(spin_sec), "value-changed",
G_CALLBACK(cb_unblock_scale), sbctx);
g_signal_connect(G_OBJECT(spin_min), "value-changed",
G_CALLBACK(cb_block_scale), sbctx);
sbctx->hmin = g_signal_connect(G_OBJECT(spin_min), "value-changed",
G_CALLBACK(cb_spin_min), sbctx);
g_signal_connect(G_OBJECT(spin_min), "value-changed",
G_CALLBACK(cb_unblock_scale), sbctx);
g_signal_connect(G_OBJECT(scale), "value-changed",
G_CALLBACK(cb_block_spinners), sbctx);
sbctx->hscale = g_signal_connect(G_OBJECT(scale), "value-changed",
G_CALLBACK(cb_scale), sbctx);
g_signal_connect(G_OBJECT(scale), "value-changed",
G_CALLBACK(cb_unblock_spinners), sbctx);
return sbctx;
}
void
mate_volume_applet_dock_change (MateVolumeAppletDock *dock,
GtkAdjustment *adj)
{
gtk_range_set_adjustment (dock->scale, adj);
}
