void cb_draw_value( GtkToggleButton *button ) { /* Turn the value display on the scale widgets off or on depending * on the state of the checkbutton */ gtk_scale_set_draw_value (GTK_SCALE (hscale), button->active); gtk_scale_set_draw_value (GTK_SCALE (vscale), button->active); }
void ColorOptionView::_createItem() { const ZLColor &color = ((ZLColorOptionEntry*)myOption)->color(); myDrawingArea = gtk_drawing_area_new(); gtk_widget_set_size_request(GTK_WIDGET(myDrawingArea), 60, 20); // myWidget = gtk_button_new(); // gtk_container_add(GTK_CONTAINER(myWidget), myDrawingArea); // g_signal_connect(G_OBJECT(myWidget), "clicked", G_CALLBACK(_onChangeColor), this); myWidget = gtk_table_new(3, 4, false); gtk_table_attach(GTK_TABLE(myWidget), gtk_label_new(""), 0, 3, 0, 1, (GtkAttachOptions)(GTK_FILL|GTK_SHRINK), (GtkAttachOptions)(GTK_FILL|GTK_EXPAND), 0, 0); gtk_table_attach(GTK_TABLE(myWidget), gtk_label_new("Red"), 0, 1, 1, 2, (GtkAttachOptions)(GTK_FILL|GTK_SHRINK), (GtkAttachOptions)(GTK_FILL|GTK_EXPAND), 0, 0); gtk_table_attach(GTK_TABLE(myWidget), gtk_label_new("Green"), 0, 1, 2, 3, (GtkAttachOptions)(GTK_FILL|GTK_SHRINK), (GtkAttachOptions)(GTK_FILL|GTK_EXPAND), 0, 0); gtk_table_attach(GTK_TABLE(myWidget), gtk_label_new("Blue"), 0, 1, 3, 4, (GtkAttachOptions)(GTK_FILL|GTK_SHRINK), (GtkAttachOptions)(GTK_FILL|GTK_EXPAND), 0, 0); myRSlider = gtk_hscale_new_with_range(0.0, 255.0, 1.0); gtk_scale_set_draw_value(GTK_SCALE(myRSlider), false); gtk_range_set_value(GTK_RANGE(myRSlider), color.Red); g_signal_connect(G_OBJECT(myRSlider), "value-changed", G_CALLBACK(_onSliderMove), this); myGSlider = gtk_hscale_new_with_range(0.0, 255.0, 1.0); gtk_scale_set_draw_value(GTK_SCALE(myGSlider), false); gtk_range_set_value(GTK_RANGE(myGSlider), color.Green); g_signal_connect(G_OBJECT(myGSlider), "value-changed", G_CALLBACK(_onSliderMove), this); myBSlider = gtk_hscale_new_with_range(0.0, 255.0, 1.0); gtk_scale_set_draw_value(GTK_SCALE(myBSlider), false); gtk_range_set_value(GTK_RANGE(myBSlider), color.Blue); g_signal_connect(G_OBJECT(myBSlider), "value-changed", G_CALLBACK(_onSliderMove), this); gtk_table_attach_defaults(GTK_TABLE(myWidget), myRSlider, 1, 2, 1, 2); gtk_table_attach_defaults(GTK_TABLE(myWidget), myGSlider, 1, 2, 2, 3); gtk_table_attach_defaults(GTK_TABLE(myWidget), myBSlider, 1, 2, 3, 4); myColor.red = color.Red * 65535 / 255; myColor.blue = color.Blue * 65535 / 255; myColor.green = color.Green * 65535 / 255; gtk_widget_modify_bg(myDrawingArea, GTK_STATE_NORMAL, &myColor); GtkWidget *frame = gtk_frame_new(NULL); gtk_container_add(GTK_CONTAINER(frame), myDrawingArea); gtk_table_attach(GTK_TABLE(myWidget), frame, 2, 3, 1, 4, (GtkAttachOptions)(GTK_FILL|GTK_SHRINK), (GtkAttachOptions)(GTK_FILL|GTK_EXPAND), 0, 0); gtk_table_set_col_spacings(GTK_TABLE(myWidget), 2); gtk_table_set_row_spacings(GTK_TABLE(myWidget), 2); gtk_widget_show_all(myWidget); myTab->addItem(myWidget, myRow, myFromColumn, myToColumn); }
static GObject * gam_slider_pan_constructor (GType type, guint n_construct_properties, GObjectConstructParam *construct_params) { GObject *object; GamSliderPan *gam_slider_pan; GamSliderPanPrivate *priv; object = (* G_OBJECT_CLASS (parent_class)->constructor) (type, n_construct_properties, construct_params); gam_slider_pan = GAM_SLIDER_PAN (object); priv = GAM_SLIDER_PAN_GET_PRIVATE (gam_slider_pan); if (!snd_mixer_selem_is_playback_mono (gam_slider_get_elem (GAM_SLIDER (gam_slider_pan)))) { priv->pan_adjustment = gtk_adjustment_new (gam_slider_pan_get_pan (gam_slider_pan), -100, 101, 1, 5, 1); g_signal_connect (G_OBJECT (priv->pan_adjustment), "value-changed", G_CALLBACK (gam_slider_pan_pan_value_changed_cb), gam_slider_pan); priv->pan_slider = gtk_hscale_new (GTK_ADJUSTMENT (priv->pan_adjustment)); gtk_scale_set_draw_value (GTK_SCALE (priv->pan_slider), FALSE); g_signal_connect (G_OBJECT (priv->pan_slider), "event", G_CALLBACK (gam_slider_pan_pan_event_cb), gam_slider_pan); } else priv->pan_slider = gtk_label_new (NULL); gtk_widget_show (priv->pan_slider); gam_slider_add_pan_widget (GAM_SLIDER (gam_slider_pan), priv->pan_slider); priv->vol_adjustment = gtk_adjustment_new (gam_slider_pan_get_volume (gam_slider_pan), 0, 101, 1, 5, 1); g_signal_connect (G_OBJECT (priv->vol_adjustment), "value-changed", G_CALLBACK (gam_slider_pan_volume_value_changed_cb), gam_slider_pan); priv->vol_slider = gtk_vscale_new (GTK_ADJUSTMENT (priv->vol_adjustment)); gtk_widget_show (priv->vol_slider); gtk_scale_set_draw_value (GTK_SCALE (priv->vol_slider), FALSE); gam_slider_add_volume_widget (GAM_SLIDER (gam_slider_pan), priv->vol_slider); gtk_label_set_mnemonic_widget (gam_slider_get_label_widget (GAM_SLIDER (gam_slider_pan)), priv->vol_slider); return object; }
/* greebo: This adds a horizontal slider and connects it to the value of the given registryKey */ void Dialog::addSlider (GtkWidget* vbox, const std::string& name, const std::string& registryKey, gboolean draw_value, double value, double lower, double upper, double step_increment, double page_increment, double page_size) { // Create a new adjustment with the boundaries <lower> and <upper> and all the increments GtkObject* adj = gtk_adjustment_new(value, lower, upper, step_increment, page_increment, page_size); // Connect the registry key to this adjustment _registryConnector.connectGtkObject(adj, registryKey); // scale GtkWidget* alignment = gtk_alignment_new(0.0, 0.5, 1.0, 0.0); gtk_widget_show(alignment); GtkWidget* scale = gtk_hscale_new(GTK_ADJUSTMENT(adj)); gtk_scale_set_value_pos(GTK_SCALE(scale), GTK_POS_LEFT); gtk_widget_show(scale); gtk_container_add(GTK_CONTAINER(alignment), scale); gtk_scale_set_draw_value(GTK_SCALE (scale), draw_value); int digits = (step_increment < 1.0f) ? 2 : 0; gtk_scale_set_digits(GTK_SCALE (scale), digits); GtkTable* row = DialogRow_new(name, alignment); DialogVBox_packRow(GTK_VBOX(vbox), GTK_WIDGET(row)); }
static GtkWidget *am_create_mixer_ui (GtkWidget *switch_btn, char *name, GtkAdjustment *adj, GtkWidget *adv_btn) { GtkWidget *vbox = NULL, *label = NULL, *img = NULL, *scale = NULL, *vhbox = NULL; GtkWidget *spin = NULL; vbox = gtk_vbox_new(FALSE, 2); vhbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vhbox), switch_btn, TRUE, TRUE, 30); gtk_box_pack_start(GTK_BOX(vbox), vhbox, FALSE, TRUE, 0); label = gtk_label_new(name); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, TRUE, 8); scale = gtk_vscale_new(adj); gtk_widget_set_size_request(scale, -1, 200); gtk_range_set_inverted(GTK_RANGE(scale), TRUE); gtk_scale_set_draw_value(GTK_SCALE(scale), FALSE); g_object_set(G_OBJECT(scale), "can-focus", FALSE, NULL); g_signal_connect(scale, "value-changed", G_CALLBACK(on_my_capture_mixer_changed), NULL); gtk_box_pack_start(GTK_BOX(vbox), scale, FALSE, TRUE, 0); vhbox = gtk_hbox_new(FALSE, 0); spin = gtk_spin_button_new(adj, 1, 0); gtk_box_pack_start(GTK_BOX(vhbox), spin, TRUE, TRUE, 24); gtk_box_pack_start(GTK_BOX(vbox), vhbox, FALSE, TRUE, 2); if(adv_btn) gtk_box_pack_start(GTK_BOX(vbox), adv_btn, FALSE, TRUE, 2); return vbox; }
static void add_channel(struct channel *c) { c->vbox = gtk_vbox_new(FALSE, 5); c->vscale = gtk_vscale_new(GTK_ADJUSTMENT(gtk_adjustment_new( mixer_get(c), 0, 100, 0, 0, 0))); gtk_scale_set_draw_value(GTK_SCALE(c->vscale), FALSE); gtk_range_set_inverted(GTK_RANGE(c->vscale), TRUE); gtk_container_add(GTK_CONTAINER(hbox), c->vbox); gtk_box_pack_start(GTK_BOX(c->vbox), c->vscale, TRUE, TRUE, 0); g_signal_connect((gpointer)c->vscale, "value_changed", G_CALLBACK(vol_change), c); g_signal_connect(c->vscale, "scroll-event", G_CALLBACK(scale_scroll), c); if (_has_switch(c->elem, c->playback)) { c->mute = gtk_check_button_new_with_label( c->playback ? _("Mute") : _("Capture")); g_signal_connect((gpointer)c->mute, "toggled", G_CALLBACK(mute), c); gtk_box_pack_end(GTK_BOX(c->vbox), c->mute, FALSE, FALSE, 0); } update_gui(c); }
static GtkWidget* gimp_scale_entry_new (GtkWidget *parent_box, gfloat value, gfloat lower, gfloat upper, gfloat step_increment, gfloat page_increment) { GtkWidget *hbox; GtkWidget *scale; GtkWidget *spinbutton; GtkObject *adj; adj = gtk_adjustment_new (value, lower, upper, step_increment, page_increment, 0.0); spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 1.0, 0); scale = gtk_hscale_new (GTK_ADJUSTMENT (adj)); gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE); gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED); gtk_widget_set_size_request (GTK_WIDGET (scale), SCALE_SIZE, -1); hbox = gtk_hbox_new (FALSE, 5); gtk_box_pack_start (GTK_BOX (hbox), scale, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (parent_box), hbox, TRUE, TRUE, 0); gtk_widget_show_all (hbox); return scale; }
static void hildon_vvolumebar_init (HildonVVolumebar *vvolumebar) { HildonVolumebarPrivate *priv; priv = HILDON_VOLUMEBAR_GET_PRIVATE (vvolumebar); g_assert (priv); priv->volumebar = HILDON_VOLUMEBAR_RANGE (hildon_volumebar_range_new (GTK_ORIENTATION_VERTICAL)); gtk_widget_set_parent (GTK_WIDGET (priv->tbutton), GTK_WIDGET (vvolumebar)); gtk_widget_set_parent (GTK_WIDGET (priv->volumebar), GTK_WIDGET (vvolumebar)); gtk_scale_set_draw_value (GTK_SCALE (priv->volumebar), FALSE); /* Signals */ g_signal_connect_swapped(G_OBJECT(priv->volumebar), "value-changed", G_CALLBACK(hildon_volumebar_level_change), vvolumebar); g_signal_connect_swapped(priv->tbutton, "toggled", G_CALLBACK(hildon_volumebar_mute_toggled), vvolumebar); /* FIXME Not sure why this is here */ gtk_widget_show (GTK_WIDGET (priv->volumebar)); }
static GtkWidget * create_slider (const char * name, int band) { GtkWidget * vbox, * slider, * label; vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); label = gtk_label_new (name); gtk_label_set_angle ((GtkLabel *) label, 90); gtk_box_pack_start ((GtkBox *) vbox, label, TRUE, FALSE, 0); slider = gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL, -EQUALIZER_MAX_GAIN, EQUALIZER_MAX_GAIN, 1); gtk_scale_set_draw_value ((GtkScale *) slider, TRUE); gtk_scale_set_value_pos ((GtkScale *) slider, GTK_POS_BOTTOM); gtk_widget_set_size_request (slider, -1, 120); g_object_set_data ((GObject *) slider, "band", GINT_TO_POINTER (band)); g_signal_connect ((GObject *) slider, "format-value", (GCallback) format_value, NULL); g_signal_connect ((GObject *) slider, "value-changed", (GCallback) slider_moved, NULL); slider_update (NULL, (GtkRange *) slider); if (band == -1) hook_associate ("set equalizer_preamp", (HookFunction) slider_update, slider); else hook_associate ("set equalizer_bands", (HookFunction) slider_update, slider); gtk_box_pack_start ((GtkBox *) vbox, slider, FALSE, FALSE, 0); return vbox; }
gboolean headerbarui_update_seekbar_cb(gpointer user_data) { if (seekbar_ismoving) return TRUE; DB_playItem_t *trk = deadbeef->streamer_get_playing_track (); if (!trk || deadbeef->pl_get_item_duration (trk) < 0) { if (trk) { deadbeef->pl_item_unref (trk); } headerbarui_reset_cb(NULL); return TRUE; } if (deadbeef->pl_get_item_duration (trk) > 0) { GtkAdjustment * adjustment = gtk_range_get_adjustment(GTK_RANGE (headerbar_seekbar)); gtk_adjustment_configure(adjustment, deadbeef->streamer_get_playpos (), //value 0, // lower deadbeef->pl_get_item_duration (trk), // upper 1, // step_increment 1, // page_increment 0); // page_size gtk_scale_set_draw_value(GTK_SCALE(headerbar_seekbar), TRUE); } if (trk) { deadbeef->pl_item_unref (trk); } return TRUE; }
void gui_subs_create_slider (GtkBox *destbox, gui_subs_slider *s) { GtkWidget *thing, *box; box = gtk_hbox_new(FALSE, 4); gtk_widget_show(box); gtk_box_pack_start(destbox, box, FALSE, TRUE, 0); thing = gtk_label_new(s->title); gtk_widget_show(thing); gtk_box_pack_start(GTK_BOX(box), thing, FALSE, TRUE, 0); s->adjustment1 = GTK_ADJUSTMENT(gtk_adjustment_new(s->min, s->min, s->max, 1, (s->max - s->min) / 10, 0)); s->slider = gtk_hscale_new(s->adjustment1); gtk_scale_set_draw_value(GTK_SCALE(s->slider), FALSE); gtk_widget_show(s->slider); gtk_box_pack_start(GTK_BOX(box), s->slider, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT(s->adjustment1), "value_changed", GTK_SIGNAL_FUNC(gui_subs_slider_update_1), s); s->adjustment2 = GTK_ADJUSTMENT(gtk_adjustment_new(s->min, s->min, s->max, 1, (s->max - s->min) / 10, 0)); thing = gtk_spin_button_new(s->adjustment2, 0, 0); gtk_box_pack_start(GTK_BOX(box), thing, FALSE, TRUE, 0); gtk_widget_show(thing); gtk_signal_connect(GTK_OBJECT(thing), "changed", GTK_SIGNAL_FUNC(gui_subs_slider_update_2), s); }
gSlider::gSlider(gContainer *par, bool scrollbar) : gControl(par) { g_typ = Type_gSlider; _mark = false; _step = 1; _page_step = 10; _value = 0; _min = 0; _max = 100; _tracking = true; border = gtk_alignment_new(0, 0, 1, 1); if (scrollbar) return; widget = gtk_vscale_new(NULL); gtk_scale_set_draw_value(GTK_SCALE(widget), false); init(); realize(false); onChange = NULL; g_signal_connect(G_OBJECT(widget), "value-changed", G_CALLBACK(cb_change), (gpointer)this); //g_signal_connect_after(G_OBJECT(border),"expose-event",G_CALLBACK(slider_Expose),(gpointer)this); }
void gSlider::orientation(int w,int h) { GtkAdjustment *adj; GType type; type = (w < h) ? GTK_TYPE_VSCALE : GTK_TYPE_HSCALE; if (type != G_OBJECT_TYPE(widget)) { adj = gtk_range_get_adjustment(GTK_RANGE(widget)); g_object_ref(adj); gtk_widget_destroy(widget); if (type == GTK_TYPE_VSCALE) widget = gtk_vscale_new(adj); else widget = gtk_hscale_new(adj); gtk_container_add(GTK_CONTAINER(border), widget); gtk_scale_set_draw_value(GTK_SCALE(widget), false); gtk_widget_show(widget); widgetSignals(); g_signal_connect(G_OBJECT(widget), "value-changed", G_CALLBACK(cb_change), (gpointer)this); g_object_unref(adj); init(); } }
void pVerticalSlider::constructor() { gtkWidget = gtk_vscale_new_with_range(0, 100, 1); gtk_scale_set_draw_value(GTK_SCALE(gtkWidget), false); g_signal_connect_swapped(G_OBJECT(gtkWidget), "value-changed", G_CALLBACK(VerticalSlider_change), (gpointer)&verticalSlider); setLength(verticalSlider.state.length); setPosition(verticalSlider.state.position); }
void scale_set_default_values( GtkScale *scale ) { gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_CONTINUOUS); gtk_scale_set_digits (scale, 1); gtk_scale_set_value_pos (scale, GTK_POS_TOP); gtk_scale_set_draw_value (scale, TRUE); }
/* * @brief creates all GTK+ widgets that compose the player & sets up callbacks * */ static void create_ui(CustomData *data) { GtkWidget *main_window; /* uppermost container window */ GtkWidget *video_window; /* video is shown here */ GtkWidget *main_box; /* holds hbox & controls */ GtkWidget *main_hbox; /* hold video window & streaminfo widget */ GtkWidget *controls; /* hold buttons & slider */ GtkWidget *play_button, *pause_button, *stop_button; GtkCellRenderer *renderer; main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); g_signal_connect(G_OBJECT(main_window), "delete-event", G_CALLBACK(delete_event_cb), data); video_window = gtk_drawing_area_new(); gtk_widget_set_double_buffered(video_window, FALSE); g_signal_connect(G_OBJECT(video_window), "realize", G_CALLBACK(realise_cb), data); g_signal_connect (video_window, "expose_event", G_CALLBACK (expose_cb), data); play_button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_PLAY); g_signal_connect (G_OBJECT (play_button), "clicked", G_CALLBACK (play_cb), data); pause_button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_PAUSE); g_signal_connect (G_OBJECT (pause_button), "clicked", G_CALLBACK (pause_cb), data); stop_button = gtk_button_new_from_stock (GTK_STOCK_MEDIA_STOP); g_signal_connect (G_OBJECT (stop_button), "clicked", G_CALLBACK (stop_cb), data); data->slider = gtk_hscale_new_with_range(0, 100, 1); gtk_scale_set_draw_value(GTK_SCALE(data->slider), 0); data->slider_update_signal_id = g_signal_connect (G_OBJECT (data->slider), "value-changed", G_CALLBACK (slider_cb), data); data->streams_list = gtk_tree_view_new(); renderer = gtk_cell_renderer_text_new (); gtk_cell_renderer_set_fixed_size(renderer, 15, -1); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(data->streams_list), -1, "Stream Name", renderer, "text", COL_STREAM_NAME, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_renderer_set_fixed_size(renderer, 15, -1); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(data->streams_list), -1, "Stream Details", renderer, "text", COL_STREAM_DETAILS, NULL); g_signal_connect(data->streams_list, "row-activated", G_CALLBACK(stream_select_cb), data); //gtk_text_view_set_editable (GTK_TEXT_VIEW (data->streams_list), FALSE); controls = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (controls), play_button, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (controls), pause_button, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (controls), stop_button, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (controls), data->slider, TRUE, TRUE, 2); main_box = gtk_vbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (main_box), video_window, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (main_box), data->streams_list, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (main_box), controls, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (main_window), main_box); gtk_window_set_default_size (GTK_WINDOW (main_window), 640, 480); gtk_widget_show_all (main_window); }
void FullscreenVideoControllerGtk::createHud() { m_hudWindow = gtk_window_new(GTK_WINDOW_POPUP); gtk_window_set_gravity(GTK_WINDOW(m_hudWindow), GDK_GRAVITY_SOUTH_WEST); gtk_window_set_type_hint(GTK_WINDOW(m_hudWindow), GDK_WINDOW_TYPE_HINT_NORMAL); m_hudMotionNotifySignalId = g_signal_connect(m_hudWindow, "motion-notify-event", G_CALLBACK(onFullscreenGtkMotionNotifyEvent), this); #ifdef GTK_API_VERSION_2 GtkWidget* hbox = gtk_hbox_new(FALSE, 4); #else GtkWidget* hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); #endif gtk_container_add(GTK_CONTAINER(m_hudWindow), hbox); m_playPauseAction = gtk_action_new("play", _("Play / Pause"), _("Play or pause the media"), PAUSE_ICON_NAME); m_playActionActivateSignalId = g_signal_connect(m_playPauseAction, "activate", G_CALLBACK(togglePlayPauseActivated), this); GtkWidget* item = gtk_action_create_tool_item(m_playPauseAction); gtk_box_pack_start(GTK_BOX(hbox), item, FALSE, TRUE, 0); GtkWidget* label = gtk_label_new(_("Time:")); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0); GtkAdjustment* adjustment = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 100.0, 0.1, 1.0, 1.0)); #ifdef GTK_API_VERSION_2 m_timeHScale = gtk_hscale_new(adjustment); #else m_timeHScale = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, adjustment); #endif gtk_scale_set_draw_value(GTK_SCALE(m_timeHScale), FALSE); gtk_range_set_show_fill_level(GTK_RANGE(m_timeHScale), TRUE); m_timeScaleButtonPressedSignalId = g_signal_connect(m_timeHScale, "button-press-event", G_CALLBACK(timeScaleButtonPressed), this); m_timeScaleButtonReleasedSignalId = g_signal_connect(m_timeHScale, "button-release-event", G_CALLBACK(timeScaleButtonReleased), this); m_hscaleUpdateId = g_signal_connect(m_timeHScale, "value-changed", G_CALLBACK(timeScaleValueChanged), this); gtk_box_pack_start(GTK_BOX(hbox), m_timeHScale, TRUE, TRUE, 0); m_timeLabel = gtk_label_new(""); gtk_box_pack_start(GTK_BOX(hbox), m_timeLabel, FALSE, TRUE, 0); // Volume button. m_volumeButton = gtk_volume_button_new(); gtk_box_pack_start(GTK_BOX(hbox), m_volumeButton, FALSE, TRUE, 0); gtk_scale_button_set_value(GTK_SCALE_BUTTON(m_volumeButton), m_player->volume()); m_volumeUpdateId = g_signal_connect(m_volumeButton, "value-changed", G_CALLBACK(volumeValueChanged), this); m_exitFullscreenAction = gtk_action_new("exit", _("Exit Fullscreen"), _("Exit from fullscreen mode"), EXIT_FULLSCREEN_ICON_NAME); m_exitFullcreenActionActivateSignalId = g_signal_connect(m_exitFullscreenAction, "activate", G_CALLBACK(exitFullscreenActivated), this); g_object_set(m_exitFullscreenAction, "icon-name", EXIT_FULLSCREEN_ICON_NAME, NULL); item = gtk_action_create_tool_item(m_exitFullscreenAction); gtk_box_pack_start(GTK_BOX(hbox), item, FALSE, TRUE, 0); m_progressBarUpdateId = g_timeout_add(PROGRESS_BAR_UPDATE_INTERVAL, reinterpret_cast<GSourceFunc>(progressBarUpdateCallback), this); playStateChanged(); }
static void gimp_rotate_tool_dialog (GimpTransformTool *tr_tool) { GimpRotateTool *rotate = GIMP_ROTATE_TOOL (tr_tool); GtkWidget *table; GtkWidget *button; GtkWidget *scale; GtkAdjustment *adj; table = gtk_table_new (4, 2, FALSE); gtk_table_set_row_spacings (GTK_TABLE (table), 2); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacing (GTK_TABLE (table), 1, 6); gtk_box_pack_start (GTK_BOX (gimp_tool_gui_get_vbox (tr_tool->gui)), table, FALSE, FALSE, 0); gtk_widget_show (table); rotate->angle_adj = (GtkAdjustment *) gtk_adjustment_new (0, -180, 180, 0.1, 15, 0); button = gtk_spin_button_new (rotate->angle_adj, 1.0, 2); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (button), TRUE); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (button), TRUE); gtk_entry_set_width_chars (GTK_ENTRY (button), SB_WIDTH); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("_Angle:"), 0.0, 0.5, button, 1, TRUE); rotate->angle_spin_button = button; g_signal_connect (rotate->angle_adj, "value-changed", G_CALLBACK (rotate_angle_changed), tr_tool); scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, rotate->angle_adj); gtk_scale_set_draw_value (GTK_SCALE (scale), FALSE); gtk_table_attach (GTK_TABLE (table), scale, 1, 2, 1, 2, GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 0); gtk_widget_show (scale); adj = (GtkAdjustment *) gtk_adjustment_new (0, -1, 1, 1, 10, 0); button = gtk_spin_button_new (adj, 1.0, 2); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (button), TRUE); gtk_entry_set_width_chars (GTK_ENTRY (button), SB_WIDTH); gimp_table_attach_aligned (GTK_TABLE (table), 0, 2, _("Center _X:"), 0.0, 0.5, button, 1, TRUE); rotate->sizeentry = gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a", TRUE, TRUE, FALSE, SB_WIDTH, GIMP_SIZE_ENTRY_UPDATE_SIZE); gimp_size_entry_add_field (GIMP_SIZE_ENTRY (rotate->sizeentry), GTK_SPIN_BUTTON (button), NULL); gimp_size_entry_set_pixel_digits (GIMP_SIZE_ENTRY (rotate->sizeentry), 2); gimp_table_attach_aligned (GTK_TABLE (table), 0, 3, _("Center _Y:"), 0.0, 0.5, rotate->sizeentry, 1, TRUE); g_signal_connect (rotate->sizeentry, "value-changed", G_CALLBACK (rotate_center_changed), tr_tool); }
void gui_init(dt_lib_module_t *self) { /* initialize ui widgets */ dt_lib_tool_lighttable_t *d = (dt_lib_tool_lighttable_t *)g_malloc0(sizeof(dt_lib_tool_lighttable_t)); self->data = (void *)d; self->widget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); d->layout = dt_conf_get_int("plugins/lighttable/layout"); d->previous_layout = d->layout == DT_LIGHTTABLE_LAYOUT_EXPOSE ? DT_LIGHTTABLE_LAYOUT_FILEMANAGER : DT_LIGHTTABLE_LAYOUT_EXPOSE; d->current_zoom = dt_conf_get_int("plugins/lighttable/images_in_row"); /* create layout selection combobox */ d->layout_combo = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(d->layout_combo), _("zoomable light table")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(d->layout_combo), _("file manager")); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(d->layout_combo), _("expose")); gtk_combo_box_set_active(GTK_COMBO_BOX(d->layout_combo), d->layout); g_signal_connect(G_OBJECT(d->layout_combo), "changed", G_CALLBACK(_lib_lighttable_layout_changed), (gpointer)self); gtk_box_pack_start(GTK_BOX(self->widget), d->layout_combo, TRUE, TRUE, 0); /* create horizontal zoom slider */ d->zoom = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, 1, 21, 1); gtk_widget_set_size_request(GTK_WIDGET(d->zoom), DT_PIXEL_APPLY_DPI(140), -1); gtk_scale_set_draw_value(GTK_SCALE(d->zoom), FALSE); gtk_range_set_increments(GTK_RANGE(d->zoom), 1, 1); gtk_box_pack_start(GTK_BOX(self->widget), d->zoom, TRUE, TRUE, 0); /* manual entry of the zoom level */ d->zoom_entry = gtk_entry_new(); gtk_entry_set_alignment(GTK_ENTRY(d->zoom_entry), 1.0); gtk_entry_set_max_length(GTK_ENTRY(d->zoom_entry), 2); gtk_entry_set_width_chars(GTK_ENTRY(d->zoom_entry), 3); gtk_entry_set_max_width_chars(GTK_ENTRY(d->zoom_entry), 3); dt_gui_key_accel_block_on_focus_connect(d->zoom_entry); gtk_box_pack_start(GTK_BOX(self->widget), d->zoom_entry, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(d->zoom), "value-changed", G_CALLBACK(_lib_lighttable_zoom_slider_changed), (gpointer)self); g_signal_connect(d->zoom_entry, "key-press-event", G_CALLBACK(_lib_lighttable_zoom_entry_changed), self); gtk_range_set_value(GTK_RANGE(d->zoom), d->current_zoom); _lib_lighttable_zoom_slider_changed(GTK_RANGE(d->zoom), self); // the slider defaults to 1 and GTK doesn't // fire a value-changed signal when setting // it to 1 => empty text box gtk_widget_set_no_show_all(d->zoom, TRUE); gtk_widget_set_no_show_all(d->zoom_entry, TRUE); _lib_lighttable_layout_changed(GTK_COMBO_BOX(d->layout_combo), self); darktable.view_manager->proxy.lighttable.module = self; darktable.view_manager->proxy.lighttable.set_zoom = _lib_lighttable_set_zoom; darktable.view_manager->proxy.lighttable.get_zoom = _lib_lighttable_get_zoom; darktable.view_manager->proxy.lighttable.get_layout = _lib_lighttable_get_layout; darktable.view_manager->proxy.lighttable.set_layout = _lib_lighttable_set_layout; }
void HorizontalSlider::create(Window &parent, unsigned x, unsigned y, unsigned width, unsigned height, unsigned length) { object->position = 0; length += (length == 0); object->widget = gtk_hscale_new_with_range(0, length - 1, 1); gtk_scale_set_draw_value(GTK_SCALE(object->widget), false); gtk_widget_set_size_request(object->widget, width, height); g_signal_connect_swapped(G_OBJECT(object->widget), "value-changed", G_CALLBACK(HorizontalSlider_change), (gpointer)this); gtk_fixed_put(GTK_FIXED(parent.object->formContainer), object->widget, x, y); gtk_widget_show(object->widget); }
GtkWidget *create_audio_sliders() { GtkWidget *vbox, *scrollbar, *label, *pixmap_w; GtkObject *adj; GtkTooltips *tooltip; int no_of_devs, i = -1, value; tooltip = gtk_tooltips_new(); vbox = gtk_vbox_new (FALSE, 0); mixer_id = mixer_init (getenv("LAV_MIXER_DEV")); if (mixer_id > 0) { no_of_devs = mixer_num_of_devs (mixer_id); for (i = 0; i < no_of_devs; i++) { if (strcmp(mixer_get_label(mixer_id, i), "Line ") == 0 && audio_recsrc == 'l') { break; } else if (strcmp(mixer_get_label(mixer_id, i), "Mic ") == 0 && audio_recsrc == 'm') { break; } else if (strcmp(mixer_get_label(mixer_id, i), "CD ") == 0 && audio_recsrc == 'c') { break; } } } value = 100 - mixer_get_vol_left(mixer_id, i); label = gtk_label_new("\n"); gtk_box_pack_start(GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); adj = gtk_adjustment_new(value, 0, 100, 1, 10, 0); gtk_signal_connect(adj, "value_changed", GTK_SIGNAL_FUNC(audio_slider_changed), NULL); scrollbar = gtk_vscale_new(GTK_ADJUSTMENT (adj)); gtk_scale_set_draw_value(GTK_SCALE(scrollbar), 0); gtk_box_pack_start(GTK_BOX (vbox), scrollbar, TRUE, TRUE, 0); gtk_widget_show(scrollbar); gtk_tooltips_set_tip(tooltip, scrollbar, "Volume", NULL); pixmap_w = gtk_widget_from_xpm_data(slider_volume_xpm); gtk_widget_show(pixmap_w); gtk_box_pack_start(GTK_BOX(vbox), pixmap_w, FALSE, FALSE, 0); label = gtk_label_new("\n"); gtk_box_pack_start(GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); return vbox; }
/** create a control for float ports */ static GtkWidget * create_float_control (plugin_desc_t * desc, unsigned long port_index) { LADSPA_Data lower; LADSPA_Data upper; GtkWidget *widget; if (LADSPA_IS_HINT_SAMPLE_RATE (desc->port_range_hints[port_index].HintDescriptor)) { lower = desc->port_range_hints[port_index].LowerBound * (LADSPA_Data) sample_rate; upper = desc->port_range_hints[port_index].UpperBound * (LADSPA_Data) sample_rate; } else { lower = desc->port_range_hints[port_index].LowerBound; upper = desc->port_range_hints[port_index].UpperBound; } if (!LADSPA_IS_HINT_BOUNDED_BELOW (desc->port_range_hints[port_index].HintDescriptor)) { lower = (LADSPA_Data) - 100.0; } if (!LADSPA_IS_HINT_BOUNDED_ABOVE (desc->port_range_hints[port_index].HintDescriptor)) { upper = (LADSPA_Data) 100.0; } if (LADSPA_IS_HINT_LOGARITHMIC (desc->port_range_hints[port_index].HintDescriptor)) { if (lower < FLT_EPSILON) lower = FLT_EPSILON; lower = log (lower); upper = log (upper); } widget = gtk_hscale_new_with_range ((gdouble) lower, (gdouble) upper, (upper - lower) / 10.0); gtk_scale_set_draw_value (GTK_SCALE (widget), FALSE); gtk_scale_set_digits (GTK_SCALE (widget), 8); gtk_range_set_increments (GTK_RANGE (widget), (upper - lower) / 1000.0, (upper - lower) / 10.0); g_assert (widget != NULL); return widget; }
GtkWidget *create_video_sliders() { GtkWidget *hbox, *vbox, *pixmap, *scrollbar; GtkTooltips *tooltip; int i=0; char *titles[4] = { "Hue", "Contrast", "Brightness", "Colour Saturation" }; char *names[4] = { "hue", "contrast", "brightness", "colour" }; GtkAdjustment *adj[4] = { GTK_TVPLUG(tv)->hue_adj, GTK_TVPLUG(tv)->contrast_adj, GTK_TVPLUG(tv)->brightness_adj, GTK_TVPLUG(tv)->saturation_adj, }; char **pixmaps[4] = { slider_hue_xpm, slider_contrast_xpm, slider_brightness_xpm, slider_sat_colour_xpm, }; tooltip = gtk_tooltips_new(); hbox = gtk_hbox_new(TRUE, 20); for (i=0;i<4;i++) { vbox = gtk_vbox_new (FALSE, 0); gtk_object_ref(GTK_OBJECT(adj[i])); gtk_signal_connect(GTK_OBJECT(adj[i]), "value_changed", GTK_SIGNAL_FUNC(video_slider_changed), names[i]); scrollbar = gtk_vscale_new(adj[i]); gtk_scale_set_draw_value(GTK_SCALE(scrollbar), 0); gtk_box_pack_start(GTK_BOX (vbox), scrollbar, TRUE, TRUE, 10); gtk_widget_show(scrollbar); gtk_widget_set_usize(scrollbar, -1, 150); gtk_tooltips_set_tip(tooltip, scrollbar, titles[i], NULL); pixmap = gtk_widget_from_xpm_data(pixmaps[i]); gtk_widget_show(pixmap); gtk_box_pack_start(GTK_BOX(vbox), pixmap, FALSE, FALSE, 10); gtk_box_pack_start(GTK_BOX (hbox), vbox, FALSE, FALSE, 0); gtk_widget_show(vbox); } return hbox; }
/** * Updates the alignment of the volume text which is shown on the * volume popup_window (left click) around the scroll bar. */ void update_vol_text() { gboolean show = TRUE; if (g_key_file_has_key(keyFile,"PNMixer","DisplayTextVolume",NULL)) show = g_key_file_get_boolean(keyFile,"PNMixer","DisplayTextVolume",NULL); if (show) { GtkPositionType pos = GTK_POS_RIGHT; if (g_key_file_has_key(keyFile,"PNMixer","TextVolumePosition",NULL)) { gint pi = g_key_file_get_integer(keyFile,"PNMixer","TextVolumePosition",NULL); pos = pi==0?GTK_POS_TOP: pi==1?GTK_POS_BOTTOM: pi==2?GTK_POS_LEFT: GTK_POS_RIGHT; } gtk_scale_set_draw_value (GTK_SCALE (vol_scale), TRUE); gtk_scale_set_value_pos (GTK_SCALE (vol_scale), pos); } else gtk_scale_set_draw_value (GTK_SCALE (vol_scale), FALSE); }
/** * Updates the alignment of the volume text which is shown on the * volume popup_window (left click) around the scroll bar. */ void update_vol_text(void) { gboolean show; show = prefs_get_boolean("DisplayTextVolume", TRUE); if (show) { gint pi; GtkPositionType pos; pi = prefs_get_integer("TextVolumePosition", 0); pos = pi == 0 ? GTK_POS_TOP : pi == 1 ? GTK_POS_BOTTOM : pi == 2 ? GTK_POS_LEFT : GTK_POS_RIGHT; gtk_scale_set_draw_value(GTK_SCALE(vol_scale), TRUE); gtk_scale_set_value_pos(GTK_SCALE(vol_scale), pos); } else gtk_scale_set_draw_value(GTK_SCALE(vol_scale), FALSE); }
SHOES_CONTROL_REF shoes_native_slider(VALUE self, shoes_canvas *canvas, shoes_place *place, VALUE attr, char *msg) { SHOES_CONTROL_REF ref = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, 0., 1., 0.01); if (!NIL_P(shoes_hash_get(attr, rb_intern("tooltip")))) { gtk_widget_set_tooltip_text(GTK_WIDGET(ref), RSTRING_PTR(shoes_hash_get(attr, rb_intern("tooltip")))); } gtk_scale_set_draw_value(GTK_SCALE(ref), FALSE); g_signal_connect(G_OBJECT(ref), "value-changed", G_CALLBACK(shoes_widget_changed), (gpointer)self); return ref; }
GtkWidget * AddVScaler( GtkAdjustment * adj,GtkWidget * parent,int digit ) { GtkWidget * VS; VS=gtk_vscale_new( adj ); gtk_widget_set_name( VS,"VS" ); gtk_widget_show( VS ); if ( parent ) gtk_box_pack_start( GTK_BOX( parent ),VS,TRUE,TRUE,0 ); // gtk_scale_set_value_pos( GTK_SCALE( VS ),GTK_POS_RIGHT ); if ( digit == -1 ) gtk_scale_set_draw_value( GTK_SCALE( VS ),FALSE ); else gtk_scale_set_digits( GTK_SCALE( VS ),digit ); return VS; }
/* This creates all the GTK+ widgets that compose our application, and registers the callbacks */ static void create_ui (CustomData *data) { GtkWidget *main_window; /* The uppermost window, containing all other windows */ GtkWidget *video_window; /* The drawing area where the video will be shown */ GtkWidget *main_box; /* VBox to hold main_hbox and the controls */ GtkWidget *main_hbox; /* HBox to hold the video_window and the stream info text widget */ GtkWidget *controls; /* HBox to hold the buttons and the slider */ GtkWidget *play_button, *pause_button, *stop_button; /* Buttons */ main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (G_OBJECT (main_window), "delete-event", G_CALLBACK (delete_event_cb), data); video_window = gtk_drawing_area_new (); gtk_widget_set_double_buffered (video_window, FALSE); g_signal_connect (video_window, "realize", G_CALLBACK (realize_cb), data); g_signal_connect (video_window, "draw", G_CALLBACK (draw_cb), data); play_button = gtk_button_new_with_label("play"); g_signal_connect (G_OBJECT (play_button), "clicked", G_CALLBACK (play_cb), data); pause_button = gtk_button_new_with_label("pause"); g_signal_connect (G_OBJECT (pause_button), "clicked", G_CALLBACK (pause_cb), data); stop_button = gtk_button_new_with_label("stop"); g_signal_connect (G_OBJECT (stop_button), "clicked", G_CALLBACK (stop_cb), data); data->slider = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL,0, 100, 1); gtk_scale_set_draw_value (GTK_SCALE (data->slider), 0); data->slider_update_signal_id = g_signal_connect (G_OBJECT (data->slider), "value-changed", G_CALLBACK (slider_cb), data); data->streams_list = gtk_text_view_new (); gtk_text_view_set_editable (GTK_TEXT_VIEW (data->streams_list), FALSE); controls = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (controls), play_button, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (controls), pause_button, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (controls), stop_button, FALSE, FALSE, 2); gtk_box_pack_start (GTK_BOX (controls), data->slider, TRUE, TRUE, 2); main_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (main_hbox), video_window, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (main_hbox), data->streams_list, FALSE, FALSE, 2); main_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_box_pack_start (GTK_BOX (main_box), main_hbox, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (main_box), controls, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (main_window), main_box); gtk_window_set_default_size (GTK_WINDOW (main_window), 640, 480); gtk_widget_realize(video_window); gtk_widget_show_all (main_window); }
GtkWidget *slider_int_new(char *label_str, int *data, int lower, int upper, int vert) { Slider *slider; GtkWidget *label; slider = gtk_type_new(slider_get_type()); gtk_container_border_width(GTK_CONTAINER(slider), 1); slider->type = SLIDER_TYPE_INT; slider->data.iptr = data; snprintf(slider->value_str, sizeof(slider->value_str), "%d", *data); slider->value_label = gtk_label_new(slider->value_str); gtk_box_pack_start(GTK_BOX(slider), slider->value_label, FALSE, TRUE, 0); gtk_widget_show(slider->value_label); slider->adj = gtk_adjustment_new((gfloat) (lower + upper - *data), (gfloat) lower, (gfloat) upper, 1.0, 1.0, 0.0); if (vert) { slider->scale = GTK_SCALE(gtk_vscale_new(GTK_ADJUSTMENT(slider->adj))); /* gtk_widget_set_usize(GTK_WIDGET(slider->scale), 16, 120); */ } else { slider->scale = GTK_SCALE(gtk_hscale_new(GTK_ADJUSTMENT(slider->adj))); /* gtk_widget_set_usize(GTK_WIDGET(slider->scale), 120, 16); */ } gtk_box_pack_start(GTK_BOX(slider), GTK_WIDGET(slider->scale), TRUE, TRUE, 0); gtk_range_set_update_policy(GTK_RANGE(slider->scale), GTK_UPDATE_CONTINUOUS); /* draw number above scale */ gtk_scale_set_draw_value(GTK_SCALE(slider->scale), FALSE); g_signal_connect(G_OBJECT(slider->adj), "value_changed", G_CALLBACK(slider_cb), slider); gtk_widget_show(GTK_WIDGET(slider->scale)); label = gtk_label_new(label_str); gtk_box_pack_start(GTK_BOX(slider), label, FALSE, FALSE, 0); gtk_widget_show(label); return GTK_WIDGET(slider); }
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; }