static void on_mouse_scroll (GtkWidget* widget, GdkEventScroll* evt, volume_t *vol)
{
if ( ! vol->dlg ) {
vol->dlg = create_volume_window();
g_signal_connect( vol->dlg, "delete-event",
G_CALLBACK(on_volume_focus), widget );
}
else {
if (! vol_spin) return;
GtkAdjustment *vol_adjustment =
gtk_spin_button_get_adjustment (vol_spin);
if (! vol_adjustment) return;
curr_volume = gtk_adjustment_get_value (vol_adjustment);
if (evt->direction == GDK_SCROLL_UP) {
curr_volume += 2;
}
else /*if (evt->direction == GDK_SCROLL_DOWN)*/ {
curr_volume -= 2;
}
update_icon(widget, vol);
gtk_adjustment_set_value (vol_adjustment, curr_volume);
gtk_spin_button_set_adjustment(vol_spin, vol_adjustment);
skip_botton1_event = TRUE;
}
}
static void
gtk_color_editor_init (GtkColorEditor *editor)
{
GdkRGBA transparent = { 0, 0, 0, 0 };
editor->priv = G_TYPE_INSTANCE_GET_PRIVATE (editor,
GTK_TYPE_COLOR_EDITOR,
GtkColorEditorPrivate);
editor->priv->use_alpha = TRUE;
g_type_ensure (GTK_TYPE_COLOR_SCALE);
g_type_ensure (GTK_TYPE_COLOR_PLANE);
g_type_ensure (GTK_TYPE_COLOR_SWATCH);
gtk_widget_init_template (GTK_WIDGET (editor));
/* Some post processing is needed in code to set this up */
gtk_widget_set_events (editor->priv->swatch,
gtk_widget_get_events (editor->priv->swatch)
& ~(GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_KEY_PRESS_MASK
| GDK_KEY_RELEASE_MASK));
if (gtk_widget_get_direction (editor->priv->h_slider) == GTK_TEXT_DIR_RTL)
gtk_style_context_add_class (gtk_widget_get_style_context (editor->priv->h_slider),
GTK_STYLE_CLASS_SCALE_HAS_MARKS_ABOVE);
else
gtk_style_context_add_class (gtk_widget_get_style_context (editor->priv->h_slider),
GTK_STYLE_CLASS_SCALE_HAS_MARKS_BELOW);
gtk_widget_override_background_color (editor->priv->overlay, 0, &transparent);
/* Create the scaled popup adjustments manually here because connecting user data is not
* supported by template GtkBuilder xml (it would be possible to set this up in the xml
* but require 4 separate callbacks and would be rather ugly).
*/
gtk_spin_button_set_adjustment (GTK_SPIN_BUTTON (editor->priv->h_entry), scaled_adjustment (editor->priv->h_adj, 100));
gtk_spin_button_set_adjustment (GTK_SPIN_BUTTON (editor->priv->s_entry), scaled_adjustment (editor->priv->s_adj, 100));
gtk_spin_button_set_adjustment (GTK_SPIN_BUTTON (editor->priv->v_entry), scaled_adjustment (editor->priv->v_adj, 100));
gtk_spin_button_set_adjustment (GTK_SPIN_BUTTON (editor->priv->a_entry), scaled_adjustment (editor->priv->a_adj, 100));
/* This can be setup in the .ui file, but requires work in Glade otherwise it cannot be edited there */
gtk_overlay_add_overlay (GTK_OVERLAY (editor->priv->overlay), editor->priv->sv_popup);
gtk_overlay_add_overlay (GTK_OVERLAY (editor->priv->overlay), editor->priv->h_popup);
gtk_overlay_add_overlay (GTK_OVERLAY (editor->priv->overlay), editor->priv->a_popup);
}
EXPORT gboolean link_range_spinners(GtkWidget *widget, gpointer data)
{
GladeXML *xml = glade_get_widget_tree(widget);
GtkAdjustment *adj = NULL;
GtkWidget *upper_spin = glade_xml_get_widget(xml,"range_highpoint_spin");
adj = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(upper_spin));
adj->lower = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widget));
if (adj->value < adj->lower)
adj->value = adj->lower;
gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON(upper_spin),adj);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(upper_spin),adj->value);
return FALSE;
}
/* Changes which GtkAdjustment is associated with a spin button. */
int
clip_GTK_SPINBUTTONSETADJUSTMENT(ClipMachine * ClipMachineMemory)
{
C_widget *cspb = _fetch_cw_arg(ClipMachineMemory);
C_widget *cadj = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
CHECKCWID(cspb, GTK_IS_SPIN_BUTTON);
CHECKOPT2(2, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCWIDOPT(cadj, GTK_IS_ADJUSTMENT);
gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON(cspb->widget), GTK_ADJUSTMENT(cadj->widget));
return 0;
err:
return 1;
}
static void
intprop_reset_widget(IntProperty *prop, WIDGET *widget)
{
GtkAdjustment *adj;
if (prop->common.extra_data) {
PropNumData *numdata = prop->common.extra_data;
adj = GTK_ADJUSTMENT(gtk_adjustment_new(prop->int_data,
numdata->min, numdata->max,
numdata->step, 10.0 * numdata->step, 0));
} else {
adj = GTK_ADJUSTMENT(gtk_adjustment_new(prop->int_data,
G_MININT, G_MAXINT,
1.0, 10.0, 0));
}
gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON(widget), adj);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(widget), TRUE);
}
void setspinlimits(GtkWidget *widget, gpointer data) {
double value1, value2;
value1 = gtk_spin_button_get_value(GTK_SPIN_BUTTON (xspinner));
value2 = gtk_spin_button_get_value(GTK_SPIN_BUTTON (x2spinner));
adjx = (GtkAdjustment *) gtk_adjustment_new(value1, -10000.0, value2, 1.0,
5.0, 0.0);
adjx2 = (GtkAdjustment *) gtk_adjustment_new(value2, value1, 10000.0, 1.0,
5.0, 0.0);
gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON (xspinner), adjx);
gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON (x2spinner), adjx2);
value1 = gtk_spin_button_get_value(GTK_SPIN_BUTTON (yspinner));
value2 = gtk_spin_button_get_value(GTK_SPIN_BUTTON (y2spinner));
adjy = (GtkAdjustment *) gtk_adjustment_new(value1, -10000.0, value2, 1.0,
5.0, 0.0);
adjy2 = (GtkAdjustment *) gtk_adjustment_new(value2, value1, 10000.0, 1.0,
5.0, 0.0);
gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON (yspinner), adjy);
gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON (y2spinner), adjy2);
value1 = gtk_spin_button_get_value(GTK_SPIN_BUTTON (zspinner));
value2 = gtk_spin_button_get_value(GTK_SPIN_BUTTON (z2spinner));
adjz = (GtkAdjustment *) gtk_adjustment_new(value1, -10000.0, value2, 1.0,
5.0, 0.0);
adjz2 = (GtkAdjustment *) gtk_adjustment_new(value2, value1, 10000.0, 1.0,
5.0, 0.0);
gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON (zspinner), adjz);
gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON (z2spinner), adjz2);
g_signal_connect(G_OBJECT (adjx), "value_changed",
G_CALLBACK (setspinlimits), G_OBJECT (setupwin));
g_signal_connect(G_OBJECT (adjx2), "value_changed",
G_CALLBACK (setspinlimits), G_OBJECT (setupwin));
g_signal_connect(G_OBJECT (adjy), "value_changed",
G_CALLBACK (setspinlimits), G_OBJECT (setupwin));
g_signal_connect(G_OBJECT (adjy2), "value_changed",
G_CALLBACK (setspinlimits), G_OBJECT (setupwin));
g_signal_connect(G_OBJECT (adjz), "value_changed",
G_CALLBACK (setspinlimits), G_OBJECT (setupwin));
g_signal_connect(G_OBJECT (adjz2), "value_changed",
G_CALLBACK (setspinlimits), G_OBJECT (setupwin));
}
int main(int argc, char **argv)
{
gtk_init(&argc, &argv);
printf("%llf\n", exp_fall_function(0.0));
if(argc != 2) {
exit(1);
}
file_info = malloc(sizeof(SF_INFO));
SNDFILE *sndfile = sf_open (argv[1], SFM_READ, file_info);
printf("channels: %d, samplerate: %d, samples: %lld\n", file_info->channels, file_info->samplerate, file_info->frames);
snd_data = malloc(sizeof(short) * file_info->frames);
p_pos = malloc(sizeof(double) * file_info->frames);
for(int i=0; i<file_info->frames; i++) {
p_pos[i] = snd_data[i];
}
float *snd_dataf = malloc(sizeof(float) * file_info->frames);
sf_count_t items_read = sf_read_short(sndfile, snd_data, file_info->frames);
printf("items read: %lld\n", items_read);
sf_close(sndfile);
min_fall_lenght = (int) (0.4 * (file_info->samplerate / MAX_FREQ));
GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect(window, "destroy",
G_CALLBACK(delete_cb), window);
GtkWidget *grid = gtk_grid_new();
drawing_area = gtk_drawing_area_new();
gtk_widget_set_size_request(drawing_area, 1000, 400);
g_signal_connect (drawing_area, "draw", G_CALLBACK(draw_callback),
NULL);
scroll_adj = gtk_adjustment_new(0.0, 0.0, (double) file_info->frames, 1.0, SHOW_FRAMES, SHOW_FRAMES);
g_signal_connect(G_OBJECT(scroll_adj), "value-changed",
G_CALLBACK(drawing_area_redraw_cb), NULL);
GtkWidget *scrollbar = gtk_hscrollbar_new(GTK_ADJUSTMENT(scroll_adj));
gtk_grid_attach(GTK_GRID(grid), scrollbar, 0, 1, 2, 1);
spin = gtk_spin_button_new_with_range(0.0, (double) file_info->frames, 1.0);
gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON(spin), GTK_ADJUSTMENT(scroll_adj));
gtk_grid_attach(GTK_GRID(grid), spin, 0, 2, 1, 1);
g_signal_connect(G_OBJECT(spin), "value-changed",
G_CALLBACK(drawing_area_redraw_cb), NULL);
window_spin = gtk_spin_button_new_with_range(1.0, (double) file_info->frames, 1.0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(window_spin), 1000.0);
gtk_grid_attach(GTK_GRID(grid), window_spin, 1,2,1,1);
g_signal_connect(G_OBJECT(window_spin), "value-changed",
G_CALLBACK(drawing_area_redraw_cb), NULL);
GtkWidget* button = gtk_button_new_with_label("Calculate");
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(calculate_click_cb), NULL);
gtk_grid_attach(GTK_GRID(grid), button, 0, 3, 1, 1);
gtk_grid_attach(GTK_GRID(grid), drawing_area, 0, 0, 2, 1);
gtk_container_add(GTK_CONTAINER(window), grid);
gtk_widget_show (grid);
gtk_widget_show (drawing_area);
gtk_widget_show_all (window);
gtk_main();
free(snd_data);
free(p_pos);
return 0;
}
GtkWidget * XAP_UnixDialog_Image::_constructWindow ()
{
const XAP_StringSet * pSS = m_pApp->getStringSet();
const char * ui_file;
#if defined(EMBEDDED_TARGET) && EMBEDDED_TARGET == EMBEDDED_TARGET_HILDON
ui_file = "xap_UnixHildonDlg_Image.ui";
#else
#if GTK_CHECK_VERSION(3,0,0)
ui_file = "xap_UnixDlg_Image.ui";
#else
ui_file = "xap_UnixDlg_Image-2.ui";
#endif
#endif
GtkBuilder * builder = newDialogBuilder(ui_file);
mMainWindow = GTK_WIDGET(gtk_builder_get_object(builder, "xap_UnixDlg_Image"));
m_wHeightSpin = GTK_WIDGET(gtk_builder_get_object(builder, "sbHeight"));
m_wHeightEntry = GTK_WIDGET(gtk_builder_get_object(builder, "edHeight"));
m_wWidthSpin = GTK_WIDGET(gtk_builder_get_object(builder, "sbWidth"));
m_wWidthEntry = GTK_WIDGET(gtk_builder_get_object(builder, "edWidth"));
m_wAspectCheck = GTK_WIDGET(gtk_builder_get_object(builder, "cbAspect"));
m_wTitleEntry = GTK_WIDGET(gtk_builder_get_object(builder, "edTitle"));
m_wDescriptionEntry = GTK_WIDGET(gtk_builder_get_object(builder, "edDescription"));
m_bAspect = getPreserveAspect();
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (m_wAspectCheck), m_bAspect);
m_oHeightSpin_adj = (GtkAdjustment*)gtk_adjustment_new( 1,-2000, 2000, 1, 1, 10);
gtk_widget_set_size_request(m_wHeightSpin,14,-1);
gtk_spin_button_set_adjustment (GTK_SPIN_BUTTON(m_wHeightSpin), GTK_ADJUSTMENT(m_oHeightSpin_adj));
m_oWidthSpin_adj = (GtkAdjustment*)gtk_adjustment_new( 1,-2000, 2000, 1, 1, 10);
gtk_widget_set_size_request(m_wWidthSpin,14,-1);
gtk_spin_button_set_adjustment (GTK_SPIN_BUTTON(m_wWidthSpin), GTK_ADJUSTMENT(m_oWidthSpin_adj));
std::string s;
pSS->getValueUTF8(XAP_STRING_ID_DLG_Image_Title,s);
abiDialogSetTitle(mMainWindow, "%s", s.c_str());
localizeLabel(GTK_WIDGET(gtk_builder_get_object(builder, "lbDescTab")), pSS, XAP_STRING_ID_DLG_Image_DescTabLabel);
localizeLabel(GTK_WIDGET(gtk_builder_get_object(builder, "lbWrapTab")), pSS, XAP_STRING_ID_DLG_Image_WrapTabLabel);
#if defined(EMBEDDED_TARGET) && EMBEDDED_TARGET == EMBEDDED_TARGET_HILDON
localizeLabel(GTK_WIDGET(gtk_builder_get_object(builder, "lbPlacementTab")), pSS, XAP_STRING_ID_DLG_Image_PlacementTabLabel);
#endif
localizeLabelMarkup(GTK_WIDGET(gtk_builder_get_object(builder, "lbSize")), pSS, XAP_STRING_ID_DLG_Image_ImageSize);
localizeLabelMarkup(GTK_WIDGET(gtk_builder_get_object(builder, "lbImageDescription")), pSS, XAP_STRING_ID_DLG_Image_ImageDesc);
localizeLabelMarkup(GTK_WIDGET(gtk_builder_get_object(builder, "lbTextWrapping")), pSS, XAP_STRING_ID_DLG_Image_TextWrapping);
localizeLabelMarkup(GTK_WIDGET(gtk_builder_get_object(builder, "lbImagePlacement")), pSS, XAP_STRING_ID_DLG_Image_Placement);
localizeLabelMarkup(GTK_WIDGET(gtk_builder_get_object(builder, "lbWrapType")), pSS, XAP_STRING_ID_DLG_Image_WrapType);
localizeLabel(GTK_WIDGET(gtk_builder_get_object(builder, "lbHeight")), pSS, XAP_STRING_ID_DLG_Image_Height);
localizeLabel(GTK_WIDGET(gtk_builder_get_object(builder, "lbWidth")), pSS, XAP_STRING_ID_DLG_Image_Width);
localizeLabel(GTK_WIDGET(gtk_builder_get_object(builder, "lbTitle")), pSS, XAP_STRING_ID_DLG_Image_LblTitle);
localizeLabel(GTK_WIDGET(gtk_builder_get_object(builder, "lbDescription")), pSS, XAP_STRING_ID_DLG_Image_LblDescription);
localizeButton(GTK_WIDGET(gtk_builder_get_object(builder, "rbInLine")), pSS, XAP_STRING_ID_DLG_Image_InLine);
localizeButton(GTK_WIDGET(gtk_builder_get_object(builder, "rbNone")), pSS, XAP_STRING_ID_DLG_Image_WrappedNone);
localizeButton(GTK_WIDGET(gtk_builder_get_object(builder, "rbWrappedRight")), pSS, XAP_STRING_ID_DLG_Image_WrappedRight);
localizeButton(GTK_WIDGET(gtk_builder_get_object(builder, "rbWrappedLeft")), pSS, XAP_STRING_ID_DLG_Image_WrappedLeft);
localizeButton(GTK_WIDGET(gtk_builder_get_object(builder, "rbWrappedBoth")), pSS, XAP_STRING_ID_DLG_Image_WrappedBoth);
localizeButton(GTK_WIDGET(gtk_builder_get_object(builder, "rbPlaceParagraph")), pSS, XAP_STRING_ID_DLG_Image_PlaceParagraph);
localizeButton(GTK_WIDGET(gtk_builder_get_object(builder, "rbPlaceColumn")), pSS, XAP_STRING_ID_DLG_Image_PlaceColumn);
localizeButton(GTK_WIDGET(gtk_builder_get_object(builder, "rbPlacePage")), pSS, XAP_STRING_ID_DLG_Image_PlacePage);
localizeButton(GTK_WIDGET(gtk_builder_get_object(builder, "rbSquareWrap")), pSS, XAP_STRING_ID_DLG_Image_SquareWrap);
localizeButton(GTK_WIDGET(gtk_builder_get_object(builder, "rbTightWrap")), pSS, XAP_STRING_ID_DLG_Image_TightWrap);
m_wPlaceTable = GTK_WIDGET(gtk_builder_get_object(builder, "tbPlacement"));
m_wrbInLine = GTK_WIDGET(gtk_builder_get_object(builder, "rbInLine"));
m_wrbNone = GTK_WIDGET(gtk_builder_get_object(builder, "rbNone"));
m_wrbWrappedRight = GTK_WIDGET(gtk_builder_get_object(builder, "rbWrappedRight"));
m_wrbWrappedLeft = GTK_WIDGET(gtk_builder_get_object(builder, "rbWrappedLeft"));
m_wrbWrappedBoth = GTK_WIDGET(gtk_builder_get_object(builder, "rbWrappedBoth"));
m_wrbPlaceParagraph = GTK_WIDGET(gtk_builder_get_object(builder, "rbPlaceParagraph"));
m_wrbPlaceColumn = GTK_WIDGET(gtk_builder_get_object(builder, "rbPlaceColumn"));
m_wrbPlacePage = GTK_WIDGET(gtk_builder_get_object(builder, "rbPlacePage"));
m_wWrapTable = GTK_WIDGET(gtk_builder_get_object(builder, "tbWrapTable"));
m_wrbSquareWrap = GTK_WIDGET(gtk_builder_get_object(builder, "rbSquareWrap"));
m_wrbTightWrap = GTK_WIDGET(gtk_builder_get_object(builder, "rbTightWrap"));
pSS->getValueUTF8 (XAP_STRING_ID_DLG_Image_Aspect,s);
gtk_button_set_label(GTK_BUTTON(m_wAspectCheck), s.c_str());
m_iWidth = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON(m_wWidthSpin));
m_iHeight = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON(m_wHeightSpin));
gtk_entry_set_text (GTK_ENTRY(m_wTitleEntry), getTitle().utf8_str());
gtk_entry_set_text (GTK_ENTRY(m_wDescriptionEntry), getDescription().utf8_str());
_connectSignals ();
g_object_unref(G_OBJECT(builder));
return mMainWindow;
}
static GtkWidget *
get_config_frame(PurplePlugin *plugin)
{
GtkWidget *ret = NULL, *hbox = NULL, *frame = NULL, *vbox = NULL;
GtkWidget *label = NULL, *spin = NULL, *check = NULL;
GtkWidget *optmenu = NULL;
GtkObject *adj = NULL;
GtkSizeGroup *sg = NULL;
PurpleAccount *account = NULL;
int i;
gboolean last_match = purple_prefs_get_bool("/purple/contact/last_match");
sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
ret = gtk_vbox_new(FALSE, 18);
gtk_container_set_border_width(GTK_CONTAINER(ret), 12);
frame = pidgin_make_frame(ret, _("Point values to use when..."));
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_add(GTK_CONTAINER(frame), vbox);
/* Status Spinboxes */
for (i = 0 ; statuses[i].id != NULL && statuses[i].description != NULL ; i++)
{
char *pref = g_strconcat("/purple/status/scores/", statuses[i].id, NULL);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new_with_mnemonic(_(statuses[i].description));
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_size_group_add_widget(sg, label);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
adj = gtk_adjustment_new(purple_prefs_get_int(pref), -500, 500, 1, 1, 1);
spin = gtk_spin_button_new((GtkAdjustment *)adj, 1, 0);
g_signal_connect(G_OBJECT(spin), "value-changed", G_CALLBACK(pref_update), pref);
gtk_box_pack_start(GTK_BOX(hbox), spin, FALSE, FALSE, 0);
g_free(pref);
}
/* Explanation */
label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label), _("The buddy with the <i>largest score</i> is the buddy who will have priority in the contact.\n"));
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
/* Last match */
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
check = gtk_check_button_new_with_label(_("Use last buddy when scores are equal"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), last_match);
g_signal_connect(G_OBJECT(check), "toggled", G_CALLBACK(pref_update), "/purple/contact/last_match");
gtk_box_pack_start(GTK_BOX(hbox), check, FALSE, FALSE, 0);
frame = pidgin_make_frame(ret, _("Point values to use for account..."));
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_add(GTK_CONTAINER(frame), vbox);
/* Account */
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
/* make this here so I can use it in the option menu callback, we'll
* actually set it up later */
adj = gtk_adjustment_new(0, -500, 500, 1, 1, 1);
spin = gtk_spin_button_new((GtkAdjustment *)adj, 1, 0);
optmenu = pidgin_account_option_menu_new(NULL, TRUE,
G_CALLBACK(select_account),
NULL, spin);
gtk_box_pack_start(GTK_BOX(hbox), optmenu, FALSE, FALSE, 0);
/* this is where we set up the spin button we made above */
account = g_object_get_data(G_OBJECT(gtk_menu_get_active(GTK_MENU(gtk_option_menu_get_menu(GTK_OPTION_MENU(optmenu))))),
"account");
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin),
(gdouble)purple_account_get_int(account, "score", 0));
gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON(spin), GTK_ADJUSTMENT(adj));
g_signal_connect(G_OBJECT(spin), "value-changed",
G_CALLBACK(account_update), optmenu);
gtk_box_pack_start(GTK_BOX(hbox), spin, FALSE, FALSE, 0);
gtk_widget_show_all(ret);
g_object_unref(sg);
return ret;
}
static int configure( Tcl_Interp *interp, SpinButtonParams *para,
GnoclOption options[] )
{
int ret = TCL_ERROR;
int blocked = 0;
int setAdjust = 0;
GtkAdjustment *oldAdjust = gtk_spin_button_get_adjustment(
para->spinButton );
gfloat lower = oldAdjust->lower;
gfloat upper = oldAdjust->upper;
gfloat stepInc = oldAdjust->step_increment;
gfloat pageInc = oldAdjust->page_increment;
if( gnoclSetOptions( interp, options, G_OBJECT( para->spinButton ), -1 )
!= TCL_OK )
goto cleanExit;
gnoclAttacheOptCmdAndVar( options + onValueChangedIdx, ¶->onValueChanged,
options + variableIdx, ¶->variable,
"value-changed", G_OBJECT( para->spinButton ),
G_CALLBACK( changedFunc ), interp, traceFunc, para );
if( para->onValueChanged != NULL )
{
blocked = g_signal_handlers_block_matched(
G_OBJECT( para->spinButton ), G_SIGNAL_MATCH_FUNC,
0, 0, NULL, (gpointer *)changedFunc, NULL );
}
if( options[valueIdx].status == GNOCL_STATUS_CHANGED )
{
assert( strcmp( options[valueIdx].optName, "-value" ) == 0 );
gtk_spin_button_set_value( para->spinButton, options[valueIdx].val.d );
if( para->variable )
{
Tcl_Obj *obj = getObjValue( para->spinButton );
para->inSetVar++;
obj = Tcl_SetVar2Ex( para->interp, para->variable, NULL, obj,
TCL_GLOBAL_ONLY );
para->inSetVar--;
if( obj == NULL )
goto cleanExit;
}
}
/* if variable is set, synchronize variable and widget */
if( options[variableIdx].status == GNOCL_STATUS_CHANGED
&& para->variable != NULL
&& options[valueIdx].status != GNOCL_STATUS_CHANGED )
{
Tcl_Obj *var = Tcl_GetVar2Ex( interp, para->variable, NULL,
TCL_GLOBAL_ONLY );
assert( strcmp( options[variableIdx].optName, "-variable" ) == 0 );
if( var == NULL ) /* variable does not yet exist */
{
Tcl_Obj *obj = getObjValue( para->spinButton );
para->inSetVar++;
obj = Tcl_SetVar2Ex( para->interp, para->variable, NULL, obj,
TCL_GLOBAL_ONLY );
para->inSetVar--;
if( obj == NULL )
goto cleanExit;
}
else
{
double d;
if( Tcl_GetDoubleFromObj( interp, var, &d ) != TCL_OK )
goto cleanExit;
gtk_spin_button_set_value( para->spinButton, d );
}
}
if( options[lowerIdx].status == GNOCL_STATUS_CHANGED )
{
assert( strcmp( options[lowerIdx].optName, "-lower" ) == 0 );
lower = options[lowerIdx].val.d;
setAdjust = 1;
}
if( options[upperIdx].status == GNOCL_STATUS_CHANGED )
{
assert( strcmp( options[upperIdx].optName, "-upper" ) == 0 );
upper = options[upperIdx].val.d;
setAdjust = 1;
}
if( options[stepIncIdx].status == GNOCL_STATUS_CHANGED )
{
assert( strcmp( options[stepIncIdx].optName, "-stepInc" ) == 0 );
stepInc = options[stepIncIdx].val.d;
setAdjust = 1;
}
if( options[pageIncIdx].status == GNOCL_STATUS_CHANGED )
{
assert( strcmp( options[pageIncIdx].optName, "-pageInc" ) == 0 );
pageInc = options[pageIncIdx].val.d;
setAdjust = 1;
}
if( setAdjust )
{
/* see also scale.c */
/* last parameter is pageSize, where it is used? */
gtk_spin_button_set_adjustment( para->spinButton,
GTK_ADJUSTMENT( gtk_adjustment_new( oldAdjust->value, lower, upper,
stepInc, pageInc, 0 ) ) );
/* gtk_spin_button_update( para->spinButton ); */
}
/*
spinButtonTraceFunc( para, interp, para->variable, NULL, 0 );
*/
ret = TCL_OK;
cleanExit:
if( blocked )
{
g_signal_handlers_unblock_matched(
G_OBJECT( para->spinButton ), G_SIGNAL_MATCH_FUNC, 0,
0, NULL, (gpointer *)changedFunc, NULL );
}
return ret;
}
static void
cc_date_time_panel_init (CcDateTimePanel *self)
{
CcDateTimePanelPrivate *priv;
gchar *objects[] = { "datetime-panel", "region-liststore", "city-liststore",
"month-liststore", "city-modelfilter", "city-modelsort", NULL };
char *buttons[] = { "hour_up_button", "hour_down_button", "min_up_button",
"min_down_button", "ampm_up_button", "ampm_down_button" };
GtkWidget *widget;
GtkAdjustment *adjustment;
GError *err = NULL;
GtkTreeModelFilter *city_modelfilter;
GtkTreeModelSort *city_modelsort;
guint i, num_days;
gboolean using_ntp;
gboolean can_use_ntp;
int ret;
DateEndianess endianess;
GError *error;
priv = self->priv = DATE_TIME_PANEL_PRIVATE (self);
priv->cancellable = g_cancellable_new ();
error = NULL;
priv->dtm = date_time_mechanism_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_NONE,
"org.gnome.SettingsDaemon.DateTimeMechanism",
"/",
priv->cancellable,
&error);
if (priv->dtm == NULL) {
g_warning ("could not get proxy for DateTimeMechanism: %s", error->message);
g_error_free (error);
}
priv->builder = gtk_builder_new ();
ret = gtk_builder_add_objects_from_file (priv->builder, DATADIR"/datetime.ui",
objects, &err);
if (ret == 0)
{
g_warning ("Could not load ui: %s", err ? err->message : "No reason");
if (err)
g_error_free (err);
return;
}
/* set up network time button */
error = NULL;
using_ntp = can_use_ntp = FALSE;
if (!date_time_mechanism_call_get_using_ntp_sync (priv->dtm,
&can_use_ntp,
&using_ntp,
priv->cancellable,
&error))
{
g_warning ("Failed to get using ntp: %s", error->message);
g_error_free (error);
}
gtk_switch_set_active (GTK_SWITCH (W("network_time_switch")), using_ntp);
update_widget_state_for_ntp (self, using_ntp);
g_signal_connect (W("network_time_switch"), "notify::active",
G_CALLBACK (change_ntp), self);
/* set up time editing widgets */
for (i = 0; i < G_N_ELEMENTS (buttons); i++)
{
g_signal_connect (W(buttons[i]), "clicked",
G_CALLBACK (change_time), self);
}
/* set up date editing widgets */
priv->date = g_date_time_new_now_local ();
endianess = date_endian_get_default (FALSE);
reorder_date_widget (endianess, priv);
/* Force the direction for the time, so that the time
* is presented correctly for RTL languages */
gtk_widget_set_direction (W("table2"), GTK_TEXT_DIR_LTR);
gtk_combo_box_set_active (GTK_COMBO_BOX (W ("month-combobox")),
g_date_time_get_month (priv->date) - 1);
g_signal_connect (G_OBJECT (W("month-combobox")), "changed",
G_CALLBACK (month_year_changed), self);
num_days = g_date_get_days_in_month (g_date_time_get_month (priv->date),
g_date_time_get_year (priv->date));
adjustment = (GtkAdjustment*) gtk_adjustment_new (g_date_time_get_day_of_month (priv->date), 1,
num_days + 1, 1, 10, 1);
gtk_spin_button_set_adjustment (GTK_SPIN_BUTTON (W ("day-spinbutton")),
adjustment);
g_signal_connect (G_OBJECT (W("day-spinbutton")), "value-changed",
G_CALLBACK (day_changed), self);
adjustment = (GtkAdjustment*) gtk_adjustment_new (g_date_time_get_year (priv->date),
G_MINDOUBLE, G_MAXDOUBLE, 1,
10, 1);
gtk_spin_button_set_adjustment (GTK_SPIN_BUTTON (W ("year-spinbutton")),
adjustment);
g_signal_connect (G_OBJECT (W("year-spinbutton")), "value-changed",
G_CALLBACK (month_year_changed), self);
/* set up timezone map */
priv->map = widget = (GtkWidget *) cc_timezone_map_new ();
gtk_widget_show (widget);
gtk_container_add (GTK_CONTAINER (gtk_builder_get_object (priv->builder,
"aspectmap")),
widget);
gtk_container_add (GTK_CONTAINER (self),
GTK_WIDGET (gtk_builder_get_object (priv->builder,
"datetime-panel")));
/* setup the time itself */
priv->clock_tracker = g_object_new (GNOME_TYPE_WALL_CLOCK, NULL);
g_signal_connect (priv->clock_tracker, "notify::clock", G_CALLBACK (on_clock_changed), self);
priv->settings = g_settings_new (CLOCK_SCHEMA);
clock_settings_changed_cb (priv->settings, CLOCK_FORMAT_KEY, self);
g_signal_connect (priv->settings, "changed::" CLOCK_FORMAT_KEY,
G_CALLBACK (clock_settings_changed_cb), self);
g_signal_connect (W("24h_button"), "notify::active",
G_CALLBACK (change_clock_settings), self);
update_time (self);
priv->locations = (GtkTreeModel*) gtk_builder_get_object (priv->builder,
"region-liststore");
load_regions_model (GTK_LIST_STORE (priv->locations),
GTK_LIST_STORE (gtk_builder_get_object (priv->builder,
"city-liststore")));
city_modelfilter = GTK_TREE_MODEL_FILTER (gtk_builder_get_object (priv->builder, "city-modelfilter"));
widget = (GtkWidget*) gtk_builder_get_object (priv->builder,
"region_combobox");
city_modelsort = GTK_TREE_MODEL_SORT (gtk_builder_get_object (priv->builder, "city-modelsort"));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (city_modelsort), CITY_COL_CITY_TRANSLATED,
GTK_SORT_ASCENDING);
gtk_tree_model_filter_set_visible_func (city_modelfilter,
(GtkTreeModelFilterVisibleFunc) city_model_filter_func,
widget,
NULL);
/* After the initial setup, so we can be sure that
* the model is filled up */
date_time_mechanism_call_get_timezone (priv->dtm,
priv->cancellable,
get_timezone_cb,
self);
/* add the lock button */
priv->permission = polkit_permission_new_sync ("org.gnome.settingsdaemon.datetimemechanism.configure", NULL, NULL, NULL);
if (priv->permission == NULL)
{
g_warning ("Your system does not have the '%s' PolicyKit files installed. Please check your installation",
"org.gnome.settingsdaemon.datetimemechanism.configure");
return;
}
g_signal_connect (priv->permission, "notify",
G_CALLBACK (on_permission_changed), self);
on_permission_changed (priv->permission, NULL, self);
}
static gboolean on_button_press (GtkWidget* widget, GdkEventButton* evt, LXPanel* p)
{
volume_t *vol = lxpanel_plugin_get_data(widget);
/* for scroll correction */
if (skip_botton1_event) {
gtk_widget_destroy(vol->dlg);
vol->dlg = NULL;
skip_botton1_event = FALSE;
}
switch ( evt->button ) {
case 1: { /* Left click */
if ( ! vol->dlg ) {
vol->dlg = create_volume_window();
/* setting background to default */
gtk_widget_set_style(vol->dlg, panel_get_defstyle(p));
g_signal_connect( vol->dlg, "focus-out-event",
G_CALLBACK(on_volume_focus), widget );
gtk_window_present( GTK_WINDOW(vol->dlg) );
}
else {
/* update icon */
if (! vol_spin) return FALSE;
GtkAdjustment *vol_adjustment =
gtk_spin_button_get_adjustment (vol_spin);
if (! vol_adjustment) return FALSE;
curr_volume = gtk_adjustment_get_value (vol_adjustment);
update_icon(widget, vol);
gtk_widget_destroy(vol->dlg);
vol->dlg = NULL;
}
break;
}
case 2: { /* middle mouse button */
if ( ! vol->dlg ) {
vol->dlg = create_volume_window();
}
if (! vol_spin) return FALSE;
GtkAdjustment *vol_adjustment =
gtk_spin_button_get_adjustment (vol_spin);
if (! vol_adjustment) return FALSE;
curr_volume = gtk_adjustment_get_value (vol_adjustment);
if (curr_volume > 0) {
/* turning to mute */
vol_before_mute = curr_volume;
curr_volume = 0;
}
else {
curr_volume = vol_before_mute;
}
gtk_adjustment_set_value (vol_adjustment, curr_volume);
gtk_spin_button_set_adjustment(vol_spin, vol_adjustment);
update_icon(widget, vol);
gtk_widget_destroy( vol->dlg );
vol->dlg = NULL;
break;
}
default: /* never here */
break;
}
return FALSE;
}
static void
setup_datetime_dialog (CcDateTimePanel *self)
{
CcDateTimePanelPrivate *priv = self->priv;
GtkAdjustment *adjustment;
GdkScreen *screen;
GtkCssProvider *provider;
GtkWidget *dialog;
guint num_days;
setup_am_pm_button (self);
/* Big time buttons */
provider = gtk_css_provider_new ();
gtk_css_provider_load_from_data (GTK_CSS_PROVIDER (provider),
".gnome-control-center-datetime-setup-time>spinbutton,\n"
".gnome-control-center-datetime-setup-time>label {\n"
" font-size: 250%;\n"
"}\n"
".gnome-control-center-datetime-setup-time>spinbutton>entry {\n"
" padding: 8px 13px;\n"
"}", -1, NULL);
screen = gdk_screen_get_default ();
gtk_style_context_add_provider_for_screen (screen,
GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref (provider);
dialog = W ("datetime-dialog");
g_signal_connect (dialog, "delete-event",
G_CALLBACK (gtk_widget_hide_on_delete), NULL);
/* Force the direction for the time, so that the time
* is presented correctly for RTL languages */
gtk_widget_set_direction (W ("time_grid"), GTK_TEXT_DIR_LTR);
/* Month */
gtk_combo_box_set_active (GTK_COMBO_BOX (W ("month-combobox")),
g_date_time_get_month (priv->date) - 1);
g_signal_connect (G_OBJECT (W("month-combobox")), "changed",
G_CALLBACK (month_year_changed), self);
/* Day */
num_days = g_date_get_days_in_month (g_date_time_get_month (priv->date),
g_date_time_get_year (priv->date));
adjustment = (GtkAdjustment*) gtk_adjustment_new (g_date_time_get_day_of_month (priv->date), 1,
num_days + 1, 1, 10, 1);
gtk_spin_button_set_adjustment (GTK_SPIN_BUTTON (W ("day-spinbutton")),
adjustment);
g_signal_connect (G_OBJECT (W ("day-spinbutton")), "value-changed",
G_CALLBACK (day_changed), self);
/* Year */
adjustment = (GtkAdjustment*) gtk_adjustment_new (g_date_time_get_year (priv->date),
1, G_MAXDOUBLE, 1,
10, 1);
gtk_spin_button_set_adjustment (GTK_SPIN_BUTTON (W ("year-spinbutton")),
adjustment);
g_signal_connect (G_OBJECT (W ("year-spinbutton")), "value-changed",
G_CALLBACK (month_year_changed), self);
/* Hours and minutes */
g_signal_connect (W ("h_spinbutton"), "output",
G_CALLBACK (format_hours_combobox), self);
g_signal_connect (W ("m_spinbutton"), "output",
G_CALLBACK (format_minutes_combobox), self);
gtk_spin_button_set_increments (GTK_SPIN_BUTTON (W ("h_spinbutton")), 1, 0);
gtk_spin_button_set_increments (GTK_SPIN_BUTTON (W ("m_spinbutton")), 1, 0);
gtk_spin_button_set_range (GTK_SPIN_BUTTON (W ("h_spinbutton")), 0, 23);
gtk_spin_button_set_range (GTK_SPIN_BUTTON (W ("m_spinbutton")), 0, 59);
g_signal_connect_swapped (W ("h_spinbutton"), "value-changed",
G_CALLBACK (change_time), self);
g_signal_connect_swapped (W ("m_spinbutton"), "value-changed",
G_CALLBACK (change_time), self);
}
