Exemplo n.º 1
0
void wxControl::GTKFrameSetMnemonicWidget(GtkFrame* w, GtkWidget* widget)
{
    GtkLabel* labelwidget = GTK_LABEL(gtk_frame_get_label_widget(w));

    gtk_label_set_mnemonic_widget(labelwidget, widget);
}
Exemplo n.º 2
0
void wxControl::GTKFrameApplyWidgetStyle(GtkFrame* w, GtkRcStyle* style)
{
    gtk_widget_modify_style(GTK_WIDGET(w), style);
    gtk_widget_modify_style(gtk_frame_get_label_widget (w), style);
}
Exemplo n.º 3
0
static void pref_construct(GtkWidget *con)
{
    GtkWidget *frame,*vbox;
    GtkWidget *a_a_ck, *a_b_ck, *a_s_ck, *c_a_ck, *a_i_ck, *s_s_ck, *s_g_ck;

    /**
     * Enable/Disable checkbox
     */
    frame = gtk_frame_new("");
    gtk_label_set_markup(GTK_LABEL(gtk_frame_get_label_widget(GTK_FRAME(frame))), "<b>Fetch</b>");
    gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_NONE);
    vbox = gtk_vbox_new(FALSE,6);
    gtk_container_set_border_width(GTK_CONTAINER(vbox), 12);
    gtk_container_add(GTK_CONTAINER(frame), vbox);

    /* Fetch artist art */
    a_a_ck = gtk_check_button_new_with_label(_("Artist images"));    
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(a_a_ck),
        cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-art-artist", TRUE)); 
    gtk_box_pack_start(GTK_BOX(vbox), a_a_ck, FALSE, TRUE, 0);
    g_signal_connect(G_OBJECT(a_a_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_ARTIST_ART));

    /* Fetch artist text*/
    a_b_ck = gtk_check_button_new_with_label(_("Artist biography"));    
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(a_b_ck),
        cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-biography-artist", TRUE)); 
    gtk_box_pack_start(GTK_BOX(vbox), a_b_ck, FALSE, TRUE, 0);
    g_signal_connect(G_OBJECT(a_b_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_ARTIST_TXT));

    /* Fetch similar artists */
    a_s_ck = gtk_check_button_new_with_label(_("Similar artists"));    
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(a_s_ck),
        cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-similar-artist", TRUE)); 
    gtk_box_pack_start(GTK_BOX(vbox), a_s_ck, FALSE, TRUE, 0);
    g_signal_connect(G_OBJECT(a_s_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_ARTIST_SIMILAR));

    /* Fetch album art */
    c_a_ck = gtk_check_button_new_with_label(_("Album cover"));    
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(c_a_ck),
        cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-art-album", TRUE)); 
    gtk_box_pack_start(GTK_BOX(vbox), c_a_ck, FALSE, TRUE, 0);
    g_signal_connect(G_OBJECT(c_a_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_ALBUM_ART));

    /* Fetch album info */
    a_i_ck = gtk_check_button_new_with_label(_("Album information"));    
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(a_i_ck),
        cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-album-info", TRUE)); 
    gtk_box_pack_start(GTK_BOX(vbox), a_i_ck, FALSE, TRUE, 0);
    g_signal_connect(G_OBJECT(c_a_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_ALBUM_TXT));

    /* Fetch similar songs */
    s_s_ck = gtk_check_button_new_with_label(_("Similar songs"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s_s_ck),
        cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-similar-song", TRUE)); 
    gtk_box_pack_start(GTK_BOX(vbox), s_s_ck, FALSE, TRUE, 0);
    g_signal_connect(G_OBJECT(s_s_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_SONG_SIMILAR));

	/* Fetch similar genre */
	s_g_ck = gtk_check_button_new_with_label(_("Similar genres"));
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s_g_ck),
		cfg_get_single_value_as_int_with_default(config, "cover-lastfm", "fetch-similar-genre", TRUE));
	gtk_box_pack_start(GTK_BOX(vbox), s_g_ck, FALSE, TRUE, 0);
	g_signal_connect(G_OBJECT(s_g_ck), "toggled", G_CALLBACK(pref_enable_fetch), GINT_TO_POINTER(META_GENRE_SIMILAR));


    if(!lastfm_get_enabled()) {
        gtk_widget_set_sensitive(GTK_WIDGET(vbox), FALSE);
    }

    gtk_widget_show_all(frame);
    gtk_container_add(GTK_CONTAINER(con), frame);
}
static void
gvc_sound_theme_chooser_init (GvcSoundThemeChooser *chooser)
{
        GtkWidget   *box;
        GtkWidget   *label;
        GtkWidget   *scrolled_window;
        GtkWidget   *alignment;
        gchar       *str;

        chooser->priv = GVC_SOUND_THEME_CHOOSER_GET_PRIVATE (chooser);

#if GTK_CHECK_VERSION (3, 0, 0)
        chooser->priv->theme_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
#else
        chooser->priv->theme_box = gtk_hbox_new (FALSE, 0);
#endif

        gtk_box_pack_start (GTK_BOX (chooser),
                            chooser->priv->theme_box, FALSE, FALSE, 0);

        label = gtk_label_new_with_mnemonic (_("Sound _theme:"));
        gtk_box_pack_start (GTK_BOX (chooser->priv->theme_box), label, FALSE, FALSE, 0);
        chooser->priv->combo_box = gtk_combo_box_new ();
        gtk_box_pack_start (GTK_BOX (chooser->priv->theme_box), chooser->priv->combo_box, FALSE, FALSE, 6);
        gtk_label_set_mnemonic_widget (GTK_LABEL (label), chooser->priv->combo_box);

        chooser->priv->sound_settings = g_settings_new (KEY_SOUNDS_SCHEMA);

        g_signal_connect (G_OBJECT (chooser->priv->sound_settings),
                          "changed",
                          G_CALLBACK (on_key_changed),
                          chooser);

        str = g_strdup_printf ("<b>%s</b>", _("C_hoose an alert sound:"));
        chooser->priv->selection_box = box = gtk_frame_new (str);
        g_free (str);

        label = gtk_frame_get_label_widget (GTK_FRAME (box));
        gtk_label_set_use_underline (GTK_LABEL (label), TRUE);
        gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
        gtk_frame_set_shadow_type (GTK_FRAME (box), GTK_SHADOW_NONE);

        alignment = gtk_alignment_new (0, 0, 1, 1);
        gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 6, 0, 0, 0);
        gtk_container_add (GTK_CONTAINER (alignment), box);
        gtk_box_pack_start (GTK_BOX (chooser), alignment, TRUE, TRUE, 6);

        alignment = gtk_alignment_new (0, 0, 1, 1);
        gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 6, 0, 0, 0);
        gtk_container_add (GTK_CONTAINER (box), alignment);

        chooser->priv->treeview = create_alert_treeview (chooser);
        gtk_label_set_mnemonic_widget (GTK_LABEL (label), chooser->priv->treeview);

        scrolled_window = gtk_scrolled_window_new (NULL, NULL);

        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
                                        GTK_POLICY_NEVER,
                                        GTK_POLICY_AUTOMATIC);
        gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
                                             GTK_SHADOW_IN);

        gtk_container_add (GTK_CONTAINER (scrolled_window), chooser->priv->treeview);
        gtk_container_add (GTK_CONTAINER (alignment), scrolled_window);

        chooser->priv->click_feedback_button = gtk_check_button_new_with_mnemonic (_("Enable _window and button sounds"));
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (chooser->priv->click_feedback_button),
                                      g_settings_get_boolean (chooser->priv->sound_settings, INPUT_SOUNDS_KEY));

        gtk_box_pack_start (GTK_BOX (chooser),
                            chooser->priv->click_feedback_button,
                            FALSE, FALSE, 0);

        g_signal_connect (G_OBJECT (chooser->priv->click_feedback_button),
                          "toggled",
                          G_CALLBACK (on_click_feedback_toggled),
                          chooser);

        setup_theme_selector (chooser);
        update_theme (chooser);

        setup_list_size_constraint (scrolled_window, chooser->priv->treeview);
}
int
main (int   argc,
      char *argv[])
{
  GtkWidget *win, *vbox, *frame, *alignment, *group_box;
  GtkWidget *hbox, *label, *chooser, *button;
  GtkSizeGroup *label_group;
  GOptionContext *context;
  gchar *cwd;

  context = g_option_context_new ("- test GtkFileChooserButton widget");
  g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
  g_option_context_add_group (context, gtk_get_option_group (TRUE));
  g_option_context_parse (context, &argc, &argv, NULL);
  g_option_context_free (context);

  gtk_init (&argc, &argv);

  /* to test rtl layout, use "--right-to-left" */
  if (rtl)
    gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);

  cwd = g_get_current_dir();
  gtk_src_dir = g_path_get_dirname (cwd);
  g_free (cwd);

  win = gtk_dialog_new_with_buttons ("TestFileChooserButton", NULL, 0,
				     "_Quit", GTK_RESPONSE_CLOSE, NULL);
  g_signal_connect (win, "response", G_CALLBACK (gtk_main_quit), NULL);

  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18);
  g_object_set (vbox, "margin", 6, NULL);
  gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (win))), vbox);

  frame = gtk_frame_new ("<b>GtkFileChooserButton</b>");
  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
  gtk_label_set_use_markup (GTK_LABEL (gtk_frame_get_label_widget (GTK_FRAME (frame))), TRUE);
  gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);

  alignment = gtk_alignment_new (0.0, 0.0, 1.0, 1.0);
  gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 6, 0, 12, 0);
  gtk_container_add (GTK_CONTAINER (frame), alignment);
  
  label_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
  
  group_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
  gtk_container_add (GTK_CONTAINER (alignment), group_box);

  /* OPEN */
  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
  gtk_box_pack_start (GTK_BOX (group_box), hbox, FALSE, FALSE, 0);

  label = gtk_label_new_with_mnemonic ("_Open:");
  gtk_size_group_add_widget (GTK_SIZE_GROUP (label_group), label);
  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);

  chooser = gtk_file_chooser_button_new ("Select A File - testfilechooserbutton",
                                         GTK_FILE_CHOOSER_ACTION_OPEN);
  gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL);
  gtk_file_chooser_remove_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL);
  gtk_label_set_mnemonic_widget (GTK_LABEL (label), chooser);
  g_signal_connect (chooser, "current-folder-changed",
		    G_CALLBACK (chooser_current_folder_changed_cb), NULL);
  g_signal_connect (chooser, "selection-changed", G_CALLBACK (chooser_selection_changed_cb), NULL);
  g_signal_connect (chooser, "file-activated", G_CALLBACK (chooser_file_activated_cb), NULL);
  g_signal_connect (chooser, "update-preview", G_CALLBACK (chooser_update_preview_cb), NULL);
  gtk_box_pack_start (GTK_BOX (hbox), chooser, TRUE, TRUE, 0);

  button = gtk_button_new_with_label ("Properties");
  g_signal_connect (button, "clicked", G_CALLBACK (properties_button_clicked_cb), chooser);
  gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);

  button = gtk_button_new_with_label ("Tests");
  g_signal_connect (button, "clicked", G_CALLBACK (tests_button_clicked_cb), chooser);
  gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);

  /* SELECT_FOLDER */
  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
  gtk_box_pack_start (GTK_BOX (group_box), hbox, FALSE, FALSE, 0);

  label = gtk_label_new_with_mnemonic ("Select _Folder:");
  gtk_size_group_add_widget (GTK_SIZE_GROUP (label_group), label);
  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);

  chooser = gtk_file_chooser_button_new ("Select A Folder - testfilechooserbutton",
                                         GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
  gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL);
  gtk_file_chooser_remove_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL);
  gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL);
  gtk_label_set_mnemonic_widget (GTK_LABEL (label), chooser);
  g_signal_connect (chooser, "current-folder-changed",
		    G_CALLBACK (chooser_current_folder_changed_cb), NULL);
  g_signal_connect (chooser, "selection-changed", G_CALLBACK (chooser_selection_changed_cb), NULL);
  g_signal_connect (chooser, "file-activated", G_CALLBACK (chooser_file_activated_cb), NULL);
  g_signal_connect (chooser, "update-preview", G_CALLBACK (chooser_update_preview_cb), NULL);
  gtk_box_pack_start (GTK_BOX (hbox), chooser, TRUE, TRUE, 0);

  button = gtk_button_new_with_label ("Properties");
  g_signal_connect (button, "clicked", G_CALLBACK (properties_button_clicked_cb), chooser);
  gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);

  button = gtk_button_new_with_label ("Tests");
  g_signal_connect (button, "clicked", G_CALLBACK (tests_button_clicked_cb), chooser);
  gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);

  g_object_unref (label_group);

  gtk_widget_show_all (win);
  gtk_window_present (GTK_WINDOW (win));

  gtk_main ();

  return 0;
}
Exemplo n.º 6
0
void wxControl::GTKSetLabelForFrame(GtkFrame *w, const wxString& label)
{
    GtkLabel* labelwidget = GTK_LABEL(gtk_frame_get_label_widget(w));
    GTKSetLabelForLabel(labelwidget, label);
}
Exemplo n.º 7
0
/**
 * \brief  Creates new instance of item properties widget
 *
 */
GtkWidget *
sp_item_widget_new (void)
{

    GtkWidget *spw, *vb, *t, *cb, *l, *f, *tf, *pb, *int_expander, *int_label;
    GtkTextBuffer *desc_buffer;

    GtkTooltips *tt = gtk_tooltips_new();

    /* Create container widget */
    spw = sp_widget_new_global (INKSCAPE);
    gtk_signal_connect ( GTK_OBJECT (spw), "modify_selection",
                         GTK_SIGNAL_FUNC (sp_item_widget_modify_selection),
                         spw );
    gtk_signal_connect ( GTK_OBJECT (spw), "change_selection",
                         GTK_SIGNAL_FUNC (sp_item_widget_change_selection),
                         spw );

    vb = gtk_vbox_new (FALSE, 0);
    gtk_container_add (GTK_CONTAINER (spw), vb);

    t = gtk_table_new (3, 4, FALSE);
    gtk_container_set_border_width(GTK_CONTAINER(t), 4);
    gtk_table_set_row_spacings (GTK_TABLE (t), 4);
    gtk_table_set_col_spacings (GTK_TABLE (t), 4);
    gtk_box_pack_start (GTK_BOX (vb), t, TRUE, TRUE, 0);


    /* Create the label for the object id */
    l = gtk_label_new_with_mnemonic (_("_Id"));
    gtk_misc_set_alignment (GTK_MISC (l), 1, 0.5);
    gtk_table_attach ( GTK_TABLE (t), l, 0, 1, 0, 1,
                       (GtkAttachOptions)( GTK_SHRINK | GTK_FILL ),
                       (GtkAttachOptions)0, 0, 0 );
    gtk_object_set_data (GTK_OBJECT (spw), "id_label", l);

    /* Create the entry box for the object id */
    tf = gtk_entry_new ();
    gtk_tooltips_set_tip (tt, tf, _("The id= attribute (only letters, digits, and the characters .-_: allowed)"), NULL);
    gtk_entry_set_max_length (GTK_ENTRY (tf), 64);
    gtk_table_attach ( GTK_TABLE (t), tf, 1, 2, 0, 1,
                       (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),
                       (GtkAttachOptions)0, 0, 0 );
    gtk_object_set_data (GTK_OBJECT (spw), "id", tf);
    gtk_label_set_mnemonic_widget (GTK_LABEL(l), tf);

    // pressing enter in the id field is the same as clicking Set:
    g_signal_connect ( G_OBJECT (tf), "activate", G_CALLBACK (sp_item_widget_label_changed), spw);
    // focus is in the id field initially:
    gtk_widget_grab_focus (GTK_WIDGET (tf));

    /* Button for setting the object's id, label, title and description. */
    pb = gtk_button_new_with_mnemonic (_("_Set"));
    gtk_table_attach ( GTK_TABLE (t), pb, 2, 3, 0, 1,
                       (GtkAttachOptions)( GTK_SHRINK | GTK_FILL ),
                       (GtkAttachOptions)0, 0, 0 );
    gtk_signal_connect ( GTK_OBJECT (pb), "clicked",
                         GTK_SIGNAL_FUNC (sp_item_widget_label_changed),
                         spw );

    /* Create the label for the object label */
    l = gtk_label_new_with_mnemonic (_("_Label"));
    gtk_misc_set_alignment (GTK_MISC (l), 1, 0.5);
    gtk_table_attach ( GTK_TABLE (t), l, 0, 1, 1, 2,
                       (GtkAttachOptions)( GTK_SHRINK | GTK_FILL ),
                       (GtkAttachOptions)0, 0, 0 );
    gtk_object_set_data (GTK_OBJECT (spw), "label_label", l);

    /* Create the entry box for the object label */
    tf = gtk_entry_new ();
    gtk_tooltips_set_tip (tt, tf, _("A freeform label for the object"), NULL);
    gtk_entry_set_max_length (GTK_ENTRY (tf), 256);
    gtk_table_attach ( GTK_TABLE (t), tf, 1, 2, 1, 2,
                       (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),
                       (GtkAttachOptions)0, 0, 0 );
    gtk_object_set_data (GTK_OBJECT (spw), "label", tf);
    gtk_label_set_mnemonic_widget (GTK_LABEL(l), tf);

    // pressing enter in the label field is the same as clicking Set:
    g_signal_connect ( G_OBJECT (tf), "activate", G_CALLBACK (sp_item_widget_label_changed), spw);

    /* Create the label for the object title */
    l = gtk_label_new_with_mnemonic (_("_Title"));
    gtk_misc_set_alignment (GTK_MISC (l), 1, 0.5);
    gtk_table_attach ( GTK_TABLE (t), l, 0, 1, 2, 3,
                       (GtkAttachOptions)( GTK_SHRINK | GTK_FILL ),
                       (GtkAttachOptions)0, 0, 0 );
    gtk_object_set_data (GTK_OBJECT (spw), "title_label", l);

    /* Create the entry box for the object title */
    tf = gtk_entry_new ();
    gtk_widget_set_sensitive (GTK_WIDGET (tf), FALSE);
    gtk_entry_set_max_length (GTK_ENTRY (tf), 256);
    gtk_table_attach ( GTK_TABLE (t), tf, 1, 3, 2, 3,
                       (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),
                       (GtkAttachOptions)0, 0, 0 );
    gtk_object_set_data (GTK_OBJECT (spw), "title", tf);
    gtk_label_set_mnemonic_widget (GTK_LABEL(l), tf);

    /* Create the frame for the object description */
    l = gtk_label_new_with_mnemonic (_("_Description"));
    f = gtk_frame_new (NULL);
    gtk_frame_set_label_widget (GTK_FRAME (f),l);
    gtk_table_attach ( GTK_TABLE (t), f, 0, 3, 3, 4,
                       (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),
                       (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ), 0, 0 );

    /* Create the text view box for the object description */
    GtkWidget *textframe = gtk_frame_new(NULL);
    gtk_container_set_border_width(GTK_CONTAINER(textframe), 4);
    gtk_widget_set_sensitive (GTK_WIDGET (textframe), FALSE);
    gtk_container_add (GTK_CONTAINER (f), textframe);
    gtk_frame_set_shadow_type (GTK_FRAME (textframe), GTK_SHADOW_IN);
    gtk_object_set_data(GTK_OBJECT(spw), "desc_frame", textframe);

    tf = gtk_text_view_new();
    gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(tf), GTK_WRAP_WORD);
    desc_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(tf));
    gtk_text_buffer_set_text(desc_buffer, "", -1);
    gtk_container_add (GTK_CONTAINER (textframe), tf);
    gtk_object_set_data (GTK_OBJECT (spw), "desc", tf);
    gtk_label_set_mnemonic_widget (GTK_LABEL (gtk_frame_get_label_widget (GTK_FRAME (f))), tf);

    /* Check boxes */
    GtkWidget *hb_cb = gtk_hbox_new (FALSE, 0);
    gtk_box_pack_start (GTK_BOX (vb), hb_cb, FALSE, FALSE, 0);
    t = gtk_table_new (1, 2, TRUE);
    gtk_container_set_border_width(GTK_CONTAINER(t), 0);
    gtk_box_pack_start (GTK_BOX (hb_cb), t, TRUE, TRUE, 10);

    /* Hide */
    cb = gtk_check_button_new_with_mnemonic (_("_Hide"));
    gtk_tooltips_set_tip (tt, cb, _("Check to make the object invisible"), NULL);
    gtk_table_attach ( GTK_TABLE (t), cb, 0, 1, 0, 1,
                       (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),
                       (GtkAttachOptions)0, 0, 0 );
    g_signal_connect (G_OBJECT(cb), "toggled", G_CALLBACK(sp_item_widget_hidden_toggled), spw);
    gtk_object_set_data(GTK_OBJECT(spw), "hidden", cb);

    /* Lock */
    // TRANSLATORS: "Lock" is a verb here
    cb = gtk_check_button_new_with_mnemonic (_("L_ock"));
    gtk_tooltips_set_tip (tt, cb, _("Check to make the object insensitive (not selectable by mouse)"), NULL);
    gtk_table_attach ( GTK_TABLE (t), cb, 1, 2, 0, 1,
                       (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),
                       (GtkAttachOptions)0, 0, 0 );
    gtk_signal_connect ( GTK_OBJECT (cb), "toggled",
                         GTK_SIGNAL_FUNC (sp_item_widget_sensitivity_toggled),
                         spw );
    gtk_object_set_data (GTK_OBJECT (spw), "sensitive", cb);

    /* Create the frame for interactivity options */
    int_label = gtk_label_new_with_mnemonic (_("_Interactivity"));
    int_expander = gtk_expander_new (NULL);
    gtk_expander_set_label_widget (GTK_EXPANDER (int_expander),int_label);
    gtk_object_set_data (GTK_OBJECT (spw), "interactivity", int_expander);

    gtk_box_pack_start (GTK_BOX (vb), int_expander, FALSE, FALSE, 0);

    gtk_widget_show_all (spw);

    sp_item_widget_setup (SP_WIDGET (spw), sp_desktop_selection (SP_ACTIVE_DESKTOP));

    return (GtkWidget *) spw;

} //end of sp_item_widget_new()
Exemplo n.º 8
0
/**
* @brief Build the GUI
*
* @return
*/
GtkWidget* buildVfoUI() {
    GtkWidget* label;

    vfoFixed=gtk_fixed_new();
    //gtk_widget_modify_bg(vfoFixed,GTK_STATE_NORMAL,&background);

    // vfoA
    vfoAFrame=gtk_frame_new("VFO A");
    label=gtk_frame_get_label_widget((GtkFrame*)vfoAFrame);
    //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);

#ifdef NETBOOK
    gtk_widget_set_size_request(GTK_WIDGET(vfoAFrame),258,40);
#else
    gtk_widget_set_size_request(GTK_WIDGET(vfoAFrame),300,80);
#endif
    vfoAFrequency=gtk_drawing_area_new();
#ifdef NETBOOK
    gtk_widget_set_size_request(GTK_WIDGET(vfoAFrequency),240,75);
#else
    //gtk_widget_set_size_request(GTK_WIDGET(vfoAFrequency),250,35);
#endif
    g_signal_connect(G_OBJECT (vfoAFrequency),"configure_event",G_CALLBACK(vfoAFrequency_configure_event),NULL);
    g_signal_connect(G_OBJECT (vfoAFrequency),"expose_event",G_CALLBACK(vfoAFrequency_expose_event),NULL);
    g_signal_connect(G_OBJECT(vfoAFrequency),"scroll_event",G_CALLBACK(frequency_scroll_event),NULL);
    gtk_widget_set_events(vfoAFrequency,GDK_EXPOSURE_MASK|GDK_SCROLL_MASK);
    gtk_widget_show(vfoAFrequency);
    gtk_widget_show(vfoAFrame);
    gtk_container_add((GtkContainer*)vfoAFrame,vfoAFrequency);
    gtk_fixed_put((GtkFixed*)vfoFixed,vfoAFrame,0,0);

    // vfoB
    vfoBFrame=gtk_frame_new("VFO B");
    label=gtk_frame_get_label_widget((GtkFrame*)vfoBFrame);
    //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
#ifdef NETBOOK
    gtk_widget_set_size_request(GTK_WIDGET(vfoBFrame),258,40);
#else
    gtk_widget_set_size_request(GTK_WIDGET(vfoBFrame),300,80);
#endif
    vfoBFrequency=gtk_drawing_area_new();
#ifdef NETBOOK
    gtk_widget_set_size_request(GTK_WIDGET(vfoBFrequency),240,35);
#else
    //gtk_widget_set_size_request(GTK_WIDGET(vfoBFrequency),300,35);
#endif
    g_signal_connect(G_OBJECT (vfoBFrequency),"configure_event",G_CALLBACK(vfoBFrequency_configure_event),NULL);
    g_signal_connect(G_OBJECT (vfoBFrequency),"expose_event",G_CALLBACK(vfoBFrequency_expose_event),NULL);
    g_signal_connect(G_OBJECT(vfoBFrequency),"scroll_event",G_CALLBACK(frequency_scroll_event),NULL);
    gtk_widget_set_events(vfoBFrequency,GDK_EXPOSURE_MASK|GDK_SCROLL_MASK);
    gtk_widget_show(vfoBFrequency);
    gtk_widget_show(vfoBFrame);
    gtk_container_add((GtkContainer*)vfoBFrame,vfoBFrequency);
#ifdef NETBOOK
    gtk_fixed_put((GtkFixed*)vfoFixed,vfoBFrame,456,0);
#else
    gtk_fixed_put((GtkFixed*)vfoFixed,vfoBFrame,500,0);
#endif

    // vfo control
    vfoControlFrame=gtk_frame_new(NULL);

    buttonAtoB = gtk_button_new_with_label ("A>B");
    //gtk_widget_modify_bg(buttonAtoB, GTK_STATE_NORMAL, &buttonBackground);
    label=gtk_bin_get_child((GtkBin*)buttonAtoB);
    //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
#ifdef NETBOOK
    gtk_widget_set_size_request(GTK_WIDGET(buttonAtoB),50,20);
#else
    gtk_widget_set_size_request(GTK_WIDGET(buttonAtoB),45,25);
#endif
    g_signal_connect(G_OBJECT(buttonAtoB),"clicked",G_CALLBACK(vfoCallback),NULL);
    gtk_widget_show(buttonAtoB);
#ifdef NETBOOK
    gtk_fixed_put((GtkFixed*)vfoFixed,buttonAtoB,258,0);
#else
    gtk_fixed_put((GtkFixed*)vfoFixed,buttonAtoB,300,0);
#endif

    buttonAswapB = gtk_button_new_with_label ("A<>B");
    //gtk_widget_modify_bg(buttonAswapB, GTK_STATE_NORMAL, &buttonBackground);
    label=gtk_bin_get_child((GtkBin*)buttonAswapB);
    //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
#ifdef NETBOOK
    gtk_widget_set_size_request(GTK_WIDGET(buttonAswapB),49,20);
#else
    gtk_widget_set_size_request(GTK_WIDGET(buttonAswapB),60,25);
#endif
    g_signal_connect(G_OBJECT(buttonAswapB),"clicked",G_CALLBACK(vfoCallback),NULL);
    gtk_widget_show(buttonAswapB);
#ifdef NETBOOK
    gtk_fixed_put((GtkFixed*)vfoFixed,buttonAswapB,308,0);
#else
    gtk_fixed_put((GtkFixed*)vfoFixed,buttonAswapB,345,0);
#endif

    buttonBtoA = gtk_button_new_with_label ("A<B");
    //gtk_widget_modify_bg(buttonBtoA, GTK_STATE_NORMAL, &buttonBackground);
    label=gtk_bin_get_child((GtkBin*)buttonBtoA);
    //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
#ifdef NETBOOK
    gtk_widget_set_size_request(GTK_WIDGET(buttonBtoA),49,20);
#else
    gtk_widget_set_size_request(GTK_WIDGET(buttonBtoA),45,25);
#endif
    g_signal_connect(G_OBJECT(buttonBtoA),"clicked",G_CALLBACK(vfoCallback),NULL);
    gtk_widget_show(buttonBtoA);
#ifdef NETBOOK
    gtk_fixed_put((GtkFixed*)vfoFixed,buttonBtoA,357,0);
#else
    gtk_fixed_put((GtkFixed*)vfoFixed,buttonBtoA,405,0);
#endif

    buttonSplit = gtk_button_new_with_label ("Split");
    //gtk_widget_modify_bg(buttonSplit, GTK_STATE_NORMAL, &buttonBackground);
    label=gtk_bin_get_child((GtkBin*)buttonSplit);
    //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
#ifdef NETBOOK
    gtk_widget_set_size_request(GTK_WIDGET(buttonSplit),50,20);
#else
    gtk_widget_set_size_request(GTK_WIDGET(buttonSplit),50,25);
#endif
    g_signal_connect(G_OBJECT(buttonSplit),"clicked",G_CALLBACK(vfoCallback),NULL);
    gtk_widget_show(buttonSplit);
#ifdef NETBOOK
    gtk_fixed_put((GtkFixed*)vfoFixed,buttonSplit,406,0);
#else
    gtk_fixed_put((GtkFixed*)vfoFixed,buttonSplit,450,0);
#endif

    buttonFrequencyUp = gtk_button_new_with_label ("^");
    //gtk_widget_modify_bg(buttonFrequencyUp, GTK_STATE_NORMAL, &buttonBackground);
    label=gtk_bin_get_child((GtkBin*)buttonFrequencyUp);
    //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
#ifdef NETBOOK
    gtk_widget_set_size_request(GTK_WIDGET(buttonFrequencyUp),30,20);
#else
    gtk_widget_set_size_request(GTK_WIDGET(buttonFrequencyUp),30,25);
#endif
    g_signal_connect(G_OBJECT(buttonFrequencyUp),"pressed",G_CALLBACK(frequencyUpCallback),NULL);
    g_signal_connect(G_OBJECT(buttonFrequencyUp),"released",G_CALLBACK(frequencyReleasedCallback),NULL);
    gtk_widget_show(buttonFrequencyUp);
#ifdef NETBOOK
    gtk_fixed_put((GtkFixed*)vfoFixed,buttonFrequencyUp,258,20);
#else
    gtk_fixed_put((GtkFixed*)vfoFixed,buttonFrequencyUp,300,25);
#endif

    buttonIncrementPlus = gtk_button_new_with_label ("+");
    //gtk_widget_modify_bg(buttonIncrementPlus, GTK_STATE_NORMAL, &buttonBackground);
    label=gtk_bin_get_child((GtkBin*)buttonIncrementPlus);
    //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
#ifdef NETBOOK
    gtk_widget_set_size_request(GTK_WIDGET(buttonIncrementPlus),20,20);
#else
    gtk_widget_set_size_request(GTK_WIDGET(buttonIncrementPlus),20,25);
#endif
    g_signal_connect(G_OBJECT(buttonIncrementPlus),"clicked",G_CALLBACK(buttonIncrementPlusCallback),NULL);
    gtk_widget_show(buttonIncrementPlus);
#ifdef NETBOOK
    gtk_fixed_put((GtkFixed*)vfoFixed,buttonIncrementPlus,288,20);
#else
    gtk_fixed_put((GtkFixed*)vfoFixed,buttonIncrementPlus,330,25);
#endif

    incrementDisplay=gtk_drawing_area_new();
#ifdef NETBOOK
    gtk_widget_set_size_request(GTK_WIDGET(incrementDisplay),98,20);
#else
    gtk_widget_set_size_request(GTK_WIDGET(incrementDisplay),100,25);
#endif
    gtk_widget_show(incrementDisplay);
    g_signal_connect(G_OBJECT (incrementDisplay),"configure_event",G_CALLBACK(incrementDisplay_configure_event),NULL);
    g_signal_connect(G_OBJECT (incrementDisplay),"expose_event",G_CALLBACK(incrementDisplay_expose_event),NULL);
    g_signal_connect(G_OBJECT(incrementDisplay),"scroll_event",G_CALLBACK(increment_scroll_event),NULL);
    gtk_widget_set_events(incrementDisplay,GDK_EXPOSURE_MASK|GDK_SCROLL_MASK);
    gtk_widget_show(incrementDisplay);
#ifdef NETBOOK
    gtk_fixed_put((GtkFixed*)vfoFixed,incrementDisplay,308,20);
#else
    gtk_fixed_put((GtkFixed*)vfoFixed,incrementDisplay,350,25);
#endif

    buttonIncrementMinus = gtk_button_new_with_label ("-");
    //gtk_widget_modify_bg(buttonIncrementMinus, GTK_STATE_NORMAL, &buttonBackground);
    label=gtk_bin_get_child((GtkBin*)buttonIncrementMinus);
    //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
#ifdef NETBOOK
    gtk_widget_set_size_request(GTK_WIDGET(buttonIncrementMinus),20,20);
#else
    gtk_widget_set_size_request(GTK_WIDGET(buttonIncrementMinus),20,25);
#endif
    g_signal_connect(G_OBJECT(buttonIncrementMinus),"clicked",G_CALLBACK(buttonIncrementMinusCallback),NULL);
    gtk_widget_show(buttonIncrementMinus);
#ifdef NETBOOK
    gtk_fixed_put((GtkFixed*)vfoFixed,buttonIncrementMinus,406,20);
#else
    gtk_fixed_put((GtkFixed*)vfoFixed,buttonIncrementMinus,450,25);
#endif

    buttonFrequencyDown = gtk_button_new_with_label ("v");
    //gtk_widget_modify_bg(buttonFrequencyDown, GTK_STATE_NORMAL, &buttonBackground);
    label=gtk_bin_get_child((GtkBin*)buttonFrequencyDown);
    //gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
#ifdef NETBOOK
    gtk_widget_set_size_request(GTK_WIDGET(buttonFrequencyDown),30,20);
#else
    gtk_widget_set_size_request(GTK_WIDGET(buttonFrequencyDown),30,25);
#endif
    g_signal_connect(G_OBJECT(buttonFrequencyDown),"pressed",G_CALLBACK(frequencyDownCallback),NULL);
    g_signal_connect(G_OBJECT(buttonFrequencyDown),"released",G_CALLBACK(frequencyReleasedCallback),NULL);
    gtk_widget_show(buttonFrequencyDown);
#ifdef NETBOOK
    gtk_fixed_put((GtkFixed*)vfoFixed,buttonFrequencyDown,426,20);
#else
    gtk_fixed_put((GtkFixed*)vfoFixed,buttonFrequencyDown,470,25);
#endif

#ifdef NETBOOK
    gtk_widget_set_size_request(GTK_WIDGET(vfoFixed),714,40);
#else
    gtk_widget_set_size_request(GTK_WIDGET(vfoFixed),800,50);
#endif
    gtk_widget_show(vfoFixed);

    return vfoFixed;

}
Exemplo n.º 9
0
/**************************************************************************
  Refresh info label
**************************************************************************/
void update_info_label(void)
{
  GtkWidget *label;
  const struct player *pplayer = client.conn.playing;

  label = gtk_frame_get_label_widget(GTK_FRAME(main_frame_civ_name));
  if (pplayer != NULL) {
    const gchar *name;
    gunichar c;

    /* Capitalize the first character of the translated nation
     * plural name so that the frame label looks good. */
    name = nation_plural_for_player(pplayer);
    c = g_utf8_get_char_validated(name, -1);
    if ((gunichar) -1 != c && (gunichar) -2 != c) {
      gchar nation[MAX_LEN_NAME];
      gchar *next;
      gint len;

      len = g_unichar_to_utf8(g_unichar_toupper(c), nation);
      nation[len] = '\0';
      next = g_utf8_find_next_char(name, NULL);
      if (NULL != next) {
        sz_strlcat(nation, next);
      }
      gtk_label_set_text(GTK_LABEL(label), nation);
    } else {
      gtk_label_set_text(GTK_LABEL(label), name);
    }
  } else {
    gtk_label_set_text(GTK_LABEL(label), "-");
  }

  gtk_label_set_text(GTK_LABEL(main_label_info),
                     get_info_label_text(!gui_gtk3_small_display_layout));

  set_indicator_icons(client_research_sprite(),
		      client_warming_sprite(),
		      client_cooling_sprite(),
		      client_government_sprite());

  if (NULL != client.conn.playing) {
    int d = 0;

    for (; d < client.conn.playing->economic.luxury /10; d++) {
      struct sprite *sprite = get_tax_sprite(tileset, O_LUXURY);

      gtk_pixcomm_set_from_sprite(GTK_PIXCOMM(econ_label[d]), sprite);
    }
 
    for (; d < (client.conn.playing->economic.science
		+ client.conn.playing->economic.luxury) / 10; d++) {
      struct sprite *sprite = get_tax_sprite(tileset, O_SCIENCE);

      gtk_pixcomm_set_from_sprite(GTK_PIXCOMM(econ_label[d]), sprite);
    }
 
    for (; d < 10; d++) {
      struct sprite *sprite = get_tax_sprite(tileset, O_GOLD);

      gtk_pixcomm_set_from_sprite(GTK_PIXCOMM(econ_label[d]), sprite);
    }
  }
 
  update_timeout_label();

  /* update tooltips. */
  gtk_widget_set_tooltip_text(econ_ebox,
		       _("Shows your current luxury/science/tax rates; "
			 "click to toggle them."));

  gtk_widget_set_tooltip_text(bulb_ebox, get_bulb_tooltip());
  gtk_widget_set_tooltip_text(sun_ebox, get_global_warming_tooltip());
  gtk_widget_set_tooltip_text(flake_ebox, get_nuclear_winter_tooltip());
  gtk_widget_set_tooltip_text(government_ebox, get_government_tooltip());
}
Exemplo n.º 10
0
static void fill_sample_table(DrMrUi* ui, int samples, char** names,GtkWidget** gain_sliders, GtkWidget** pan_sliders) {
  int row = 0;
  int col = 0;
  int si;
  gchar buf[64];
  int rows = (samples/ui->cols);
  if (samples % ui->cols != 0) rows++;
  gtk_table_resize(ui->sample_table,rows,ui->cols);

  switch (ui->startSamp) {
  case 1: // bottom left
    row = rows-1;
    break;
  case 2: // top right
    col = ui->cols-1;
    break;
  case 3: // bottom right
    row = rows-1;
    col = ui->cols-1;
    break;
  }

  for(si = 0;si<samples;si++) {
    GtkWidget *frame,*hbox,*gain_vbox,*pan_vbox;
    GtkWidget* gain_slider;
    GtkWidget* pan_slider;
    GtkWidget* gain_label;
    GtkWidget* pan_label;
    gboolean slide_expand;
    snprintf(buf,64,"<b>%s</b> (%i)",names[si],si);

    frame = gtk_frame_new(buf);
    gtk_label_set_use_markup(GTK_LABEL(gtk_frame_get_label_widget(GTK_FRAME(frame))),true);
    gtk_frame_set_shadow_type(GTK_FRAME(frame),GTK_SHADOW_OUT);
    hbox = gtk_hbox_new(false,0);

#ifdef NO_NKNOB
    gain_slider = gtk_vscale_new_with_range(GAIN_MIN,6.0,1.0);
    gtk_scale_set_value_pos(GTK_SCALE(gain_slider),GTK_POS_BOTTOM);
    gtk_scale_set_digits(GTK_SCALE(gain_slider),1);
    gtk_scale_add_mark(GTK_SCALE(gain_slider),0.0,GTK_POS_RIGHT,"0 dB");
    // Hrmm, -inf label is at top in ardour for some reason
    //gtk_scale_add_mark(GTK_SCALE(gain_slider),GAIN_MIN,GTK_POS_RIGHT,"-inf");
    gtk_range_set_inverted(GTK_RANGE(gain_slider),true);
    slide_expand = true;
#else
    gain_slider = n_knob_new_with_range(0.0,GAIN_MIN,6.0,1.0);
    n_knob_set_load_prefix(N_KNOB(gain_slider),ui->bundle_path);
    gtk_widget_set_has_tooltip(gain_slider,TRUE);
    slide_expand = false;
#endif
    g_object_set_qdata (G_OBJECT(gain_slider),ui->gain_quark,GINT_TO_POINTER(si));
    if (gain_sliders) gain_sliders[si] = gain_slider;
    if (si < 32)
      gtk_range_set_value(GTK_RANGE(gain_slider),ui->gain_vals[si]);
    else // things are gross if we have > 32 samples, what to do?
      gtk_range_set_value(GTK_RANGE(gain_slider),0.0);
    g_signal_connect(G_OBJECT(gain_slider),"change-value",G_CALLBACK(gain_callback),ui);
    gain_label = gtk_label_new("Gain");
    gain_vbox = gtk_vbox_new(false,0);

#ifdef NO_NKNOB
    pan_slider = gtk_hscale_new_with_range(-1.0,1.0,0.1);
    gtk_scale_add_mark(GTK_SCALE(pan_slider),0.0,GTK_POS_TOP,NULL);
#else
    pan_slider = n_knob_new_with_range(0.0,-1.0,1.0,0.1);
    n_knob_set_load_prefix(N_KNOB(pan_slider),ui->bundle_path);
    gtk_widget_set_has_tooltip(pan_slider,TRUE);
#endif
    if (pan_sliders) pan_sliders[si] = pan_slider;
    if (si < 32)
      gtk_range_set_value(GTK_RANGE(pan_slider),ui->pan_vals[si]);
    else
      gtk_range_set_value(GTK_RANGE(pan_slider),0);
    g_object_set_qdata (G_OBJECT(pan_slider),ui->pan_quark,GINT_TO_POINTER(si));
    g_signal_connect(G_OBJECT(pan_slider),"change-value",G_CALLBACK(pan_callback),ui);
    pan_label = gtk_label_new("Pan");
    pan_vbox = gtk_vbox_new(false,0);
    
    gtk_box_pack_start(GTK_BOX(gain_vbox),gain_slider,slide_expand,slide_expand,0);
    gtk_box_pack_start(GTK_BOX(gain_vbox),gain_label,false,false,0);

    gtk_box_pack_start(GTK_BOX(pan_vbox),pan_slider,slide_expand,slide_expand,0);
    gtk_box_pack_start(GTK_BOX(pan_vbox),pan_label,false,false,0);

    gtk_box_pack_start(GTK_BOX(hbox),gain_vbox,true,true,0);
    gtk_box_pack_start(GTK_BOX(hbox),pan_vbox,true,true,0);

    gtk_container_add(GTK_CONTAINER(frame),hbox);

    gtk_table_attach_defaults(ui->sample_table,frame,col,col+1,row,row+1);

    if (ui->startSamp > 1) {
      col--;
      if (col < 0) {
	if (ui->startSamp == 2)
	  row++;
	else
	  row--;
	col = ui->cols-1;
      }
    }
    else {
      col++;
      if (col >= ui->cols) {
	if (ui->startSamp == 0)
	  row++;
	else
	  row--;
	col = 0;
      }
    }
  }
  gtk_widget_queue_resize(GTK_WIDGET(ui->sample_table));
}
Exemplo n.º 11
0
GtkWidget *
gimp_proc_view_new (const gchar     *name,
                    const gchar     *menu_path,
                    const gchar     *blurb,
                    const gchar     *help,
                    const gchar     *author,
                    const gchar     *copyright,
                    const gchar     *date,
                    GimpPDBProcType  type,
                    gint             n_params,
                    gint             n_return_vals,
                    GimpParamDef    *params,
                    GimpParamDef    *return_vals)
{
  GtkWidget    *main_vbox;
  GtkWidget    *frame;
  GtkWidget    *vbox;
  GtkWidget    *table;
  GtkWidget    *label;
  GtkSizeGroup *name_group;
  GtkSizeGroup *type_group;
  GtkSizeGroup *desc_group;
  const gchar  *type_str;
  gint          row;

  if (blurb     && strlen (blurb) < 2)     blurb     = NULL;
  if (help      && strlen (help) < 2)      help      = NULL;
  if (author    && strlen (author) < 2)    author    = NULL;
  if (date      && strlen (date) < 2)      date      = NULL;
  if (copyright && strlen (copyright) < 2) copyright = NULL;

  if (blurb && help && ! strcmp (blurb, help))
    help = NULL;

  main_vbox = gtk_vbox_new (FALSE, 12);

  /* show the name */

  frame = gimp_frame_new (name);
  label = gtk_frame_get_label_widget (GTK_FRAME (frame));
  gtk_label_set_selectable (GTK_LABEL (label), TRUE);
  gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
  gtk_widget_show (frame);

  vbox = gtk_vbox_new (FALSE, 8);
  gtk_container_add (GTK_CONTAINER (frame), vbox);
  gtk_widget_show (vbox);

  if (! gimp_enum_get_value (GIMP_TYPE_PDB_PROC_TYPE, type,
                             NULL, NULL, &type_str, NULL))
    type_str = "UNKNOWN";

  label = gtk_label_new (type_str);
  gimp_label_set_attributes (GTK_LABEL (label),
                             PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC,
                             -1);
  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);
  gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
  gtk_widget_show (label);

  if (menu_path)
    {
      label = gtk_label_new_with_mnemonic (menu_path);
      gtk_label_set_selectable (GTK_LABEL (label), TRUE);
      gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);
      gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
      gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
      gtk_widget_show (label);
    }

  if (blurb)
    {
      label = gtk_label_new (blurb);
      gtk_label_set_selectable (GTK_LABEL (label), TRUE);
      gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);
      gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
      gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
      gtk_widget_show (label);
    }

  name_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
  type_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
  desc_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);

  /* in parameters */
  if (n_params)
    {
      frame = gimp_frame_new (_("Parameters"));
      gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
      gtk_widget_show (frame);

      table = gimp_proc_view_create_params (params, n_params,
                                            name_group, type_group, desc_group);
      gtk_container_add (GTK_CONTAINER (frame), table);
      gtk_widget_show (table);
    }

  /* out parameters */
  if (n_return_vals)
    {
      frame = gimp_frame_new (_("Return Values"));
      gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
      gtk_widget_show (frame);

      table = gimp_proc_view_create_params (return_vals, n_return_vals,
                                            name_group, type_group, desc_group);
      gtk_container_add (GTK_CONTAINER (frame), table);
      gtk_widget_show (table);
    }

  if (! help && ! author && ! date && ! copyright)
    return main_vbox;

  frame = gimp_frame_new (_("Additional Information"));
  gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
  gtk_widget_show (frame);

  vbox = gtk_vbox_new (FALSE, 8);
  gtk_container_add (GTK_CONTAINER (frame), vbox);
  gtk_widget_show (vbox);

  /* show the help */
  if (help)
    {
      label = gtk_label_new (help);
      gtk_label_set_selectable (GTK_LABEL (label), TRUE);
      gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);
      gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
      gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
      gtk_widget_show (label);
    }

  /* show the author & the copyright */

  if (! author && ! date && ! copyright)
    return main_vbox;

  table = gtk_table_new ((author != 0) + (date != 0) + (copyright != 0), 2,
                         FALSE);
  gtk_table_set_col_spacings (GTK_TABLE (table), 6);
  gtk_table_set_row_spacings (GTK_TABLE (table), 4);
  gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
  gtk_widget_show (table);

  row = 0;

  if (author)
    {
      label = gtk_label_new (author);
      gtk_label_set_selectable (GTK_LABEL (label), TRUE);
      gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);
      gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);

      gimp_table_attach_aligned (GTK_TABLE (table), 0, row++,
                                 _("Author:"), 0.0, 0.0,
                                 label, 3, FALSE);
    }

  if (date)
    {
      label = gtk_label_new (date);
      gtk_label_set_selectable (GTK_LABEL (label), TRUE);
      gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);
      gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);

      gimp_table_attach_aligned (GTK_TABLE (table), 0, row++,
                                 _("Date:"), 0.0, 0.0,
                                 label, 3, FALSE);
    }

  if (copyright)
    {
      label = gtk_label_new (copyright);
      gtk_label_set_selectable (GTK_LABEL (label), TRUE);
      gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);
      gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);

      gimp_table_attach_aligned (GTK_TABLE (table), 0, row++,
                                 _("Copyright:"), 0.0, 0.0,
                                 label, 3, FALSE);
    }

  return main_vbox;
}
Exemplo n.º 12
0
/* ----------------------------------------------------------------------------*/
GtkWidget* buildBandUI() {
    GtkWidget* label;

    bandFrame=gtk_frame_new("Band");
    gtk_widget_modify_bg(bandFrame,GTK_STATE_NORMAL,&background);
    gtk_widget_modify_fg(gtk_frame_get_label_widget(GTK_FRAME(bandFrame)),GTK_STATE_NORMAL,&white);

    bandTable=gtk_table_new(4,4,TRUE);

    // band selection
    buttonBand1 = gtk_button_new_with_label ("160");
    gtk_widget_modify_bg(buttonBand1, GTK_STATE_NORMAL, &bandButtonBackground);
    label=gtk_bin_get_child((GtkBin*)buttonBand1);
    gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black);
    gtk_widget_set_size_request(GTK_WIDGET(buttonBand1),50,25);
    g_signal_connect(G_OBJECT(buttonBand1),"clicked",G_CALLBACK(bandCallback),NULL);
    gtk_widget_show(buttonBand1);
    gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand1,0,1,0,1);

    buttonBand2 = gtk_button_new_with_label ("80");
    gtk_widget_modify_bg(buttonBand2, GTK_STATE_NORMAL, &bandButtonBackground);
    label=gtk_bin_get_child((GtkBin*)buttonBand2);
    gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black);
    gtk_widget_set_size_request(GTK_WIDGET(buttonBand2),50,25);
    g_signal_connect(G_OBJECT(buttonBand2),"clicked",G_CALLBACK(bandCallback),NULL);
    gtk_widget_show(buttonBand2);
    gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand2,1,2,0,1);

    buttonBand3 = gtk_button_new_with_label ("60");
    gtk_widget_modify_bg(buttonBand3, GTK_STATE_NORMAL, &bandButtonBackground);
    label=gtk_bin_get_child((GtkBin*)buttonBand3);
    gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black);
    gtk_widget_set_size_request(GTK_WIDGET(buttonBand3),50,25);
    g_signal_connect(G_OBJECT(buttonBand3),"clicked",G_CALLBACK(bandCallback),NULL);
    gtk_widget_show(buttonBand3);
    gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand3,2,3,0,1);

    buttonBand4 = gtk_button_new_with_label ("40");
    gtk_widget_modify_bg(buttonBand4, GTK_STATE_NORMAL, &bandButtonBackground);
    label=gtk_bin_get_child((GtkBin*)buttonBand4);
    gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black);
    gtk_widget_set_size_request(GTK_WIDGET(buttonBand4),50,25);
    g_signal_connect(G_OBJECT(buttonBand4),"clicked",G_CALLBACK(bandCallback),NULL);
    gtk_widget_show(buttonBand4);
    gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand4,3,4,0,1);

    buttonBand5 = gtk_button_new_with_label ("30");
    gtk_widget_modify_bg(buttonBand5, GTK_STATE_NORMAL, &bandButtonBackground);
    label=gtk_bin_get_child((GtkBin*)buttonBand5);
    gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black);
    gtk_widget_set_size_request(GTK_WIDGET(buttonBand5),50,25);
    g_signal_connect(G_OBJECT(buttonBand5),"clicked",G_CALLBACK(bandCallback),NULL);
    gtk_widget_show(buttonBand5);
    gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand5,0,1,1,2);

    buttonBand6 = gtk_button_new_with_label ("20");
    gtk_widget_modify_bg(buttonBand6, GTK_STATE_NORMAL, &bandButtonBackground);
    label=gtk_bin_get_child((GtkBin*)buttonBand6);
    gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black);
    gtk_widget_set_size_request(GTK_WIDGET(buttonBand6),50,25);
    g_signal_connect(G_OBJECT(buttonBand6),"clicked",G_CALLBACK(bandCallback),NULL);
    gtk_widget_show(buttonBand6);
    gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand6,1,2,1,2);

    buttonBand7 = gtk_button_new_with_label ("17");
    gtk_widget_modify_bg(buttonBand7, GTK_STATE_NORMAL, &bandButtonBackground);
    label=gtk_bin_get_child((GtkBin*)buttonBand7);
    gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black);
    gtk_widget_set_size_request(GTK_WIDGET(buttonBand7),50,25);
    g_signal_connect(G_OBJECT(buttonBand7),"clicked",G_CALLBACK(bandCallback),NULL);
    gtk_widget_show(buttonBand7);
    gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand7,2,3,1,2);

    buttonBand8 = gtk_button_new_with_label ("15");
    gtk_widget_modify_bg(buttonBand8, GTK_STATE_NORMAL, &bandButtonBackground);
    label=gtk_bin_get_child((GtkBin*)buttonBand8);
    gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black);
    gtk_widget_set_size_request(GTK_WIDGET(buttonBand8),50,25);
    g_signal_connect(G_OBJECT(buttonBand8),"clicked",G_CALLBACK(bandCallback),NULL);
    gtk_widget_show(buttonBand8);
    gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand8,3,4,1,2);

    buttonBand9 = gtk_button_new_with_label ("12");
    gtk_widget_modify_bg(buttonBand9, GTK_STATE_NORMAL, &bandButtonBackground);
    label=gtk_bin_get_child((GtkBin*)buttonBand9);
    gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black);
    gtk_widget_set_size_request(GTK_WIDGET(buttonBand9),50,25);
    g_signal_connect(G_OBJECT(buttonBand9),"clicked",G_CALLBACK(bandCallback),NULL);
    gtk_widget_show(buttonBand9);
    gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand9,0,1,2,3);

    buttonBand10 = gtk_button_new_with_label ("10");
    gtk_widget_modify_bg(buttonBand10, GTK_STATE_NORMAL, &bandButtonBackground);
    label=gtk_bin_get_child((GtkBin*)buttonBand10);
    gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black);
    gtk_widget_set_size_request(GTK_WIDGET(buttonBand10),50,25);
    g_signal_connect(G_OBJECT(buttonBand10),"clicked",G_CALLBACK(bandCallback),NULL);
    gtk_widget_show(buttonBand10);
    gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand10,1,2,2,3);

    buttonBand11 = gtk_button_new_with_label ("6");
    gtk_widget_modify_bg(buttonBand11, GTK_STATE_NORMAL, &bandButtonBackground);
    label=gtk_bin_get_child((GtkBin*)buttonBand11);
    gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black);
    gtk_widget_set_size_request(GTK_WIDGET(buttonBand11),50,25);
    g_signal_connect(G_OBJECT(buttonBand11),"clicked",G_CALLBACK(bandCallback),NULL);
    gtk_widget_show(buttonBand11);
    gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand11,2,3,2,3);

    buttonBand12 = gtk_button_new_with_label ("GEN");
    gtk_widget_modify_bg(buttonBand12, GTK_STATE_NORMAL, &bandButtonBackground);
    label=gtk_bin_get_child((GtkBin*)buttonBand12);
    gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black);
    gtk_widget_set_size_request(GTK_WIDGET(buttonBand12),50,25);
    g_signal_connect(G_OBJECT(buttonBand12),"clicked",G_CALLBACK(bandCallback),NULL);
    gtk_widget_show(buttonBand12);
    gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand12,3,4,2,3);

    buttonBand13 = gtk_button_new_with_label ("WWV");
    gtk_widget_modify_bg(buttonBand13, GTK_STATE_NORMAL, &bandButtonBackground);
    label=gtk_bin_get_child((GtkBin*)buttonBand13);
    gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black);
    gtk_widget_set_size_request(GTK_WIDGET(buttonBand13),50,25);
    g_signal_connect(G_OBJECT(buttonBand13),"clicked",G_CALLBACK(bandCallback),NULL);
    gtk_widget_show(buttonBand13);
    gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand13,0,1,3,4);

    buttonBand14 = gtk_button_new_with_label ("XVTR");
    gtk_widget_modify_bg(buttonBand14, GTK_STATE_NORMAL, &bandButtonBackground);
    label=gtk_bin_get_child((GtkBin*)buttonBand14);
    gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &black);
    gtk_widget_set_size_request(GTK_WIDGET(buttonBand14),50,25);
    g_signal_connect(G_OBJECT(buttonBand14),"clicked",G_CALLBACK(bandCallback),NULL);
    gtk_widget_show(buttonBand14);
    gtk_table_attach_defaults(GTK_TABLE(bandTable),buttonBand14,1,2,3,4);

    configureXVTRButton();

    if(!displayHF) {
        setXVTRTitles();
    }

    gtk_container_add(GTK_CONTAINER(bandFrame),bandTable);
    gtk_widget_show(bandTable);
    gtk_widget_show(bandFrame);


    return bandFrame;
  
}
Exemplo n.º 13
0
/** 
* @brief Build Transmit User Interface 
* 
* @return GtkWidget pointer 
*/
GtkWidget* buildSubRxUI() {

    GtkWidget* label;

    subrxFrame=gtk_frame_new("Sub RX");
    gtk_widget_modify_bg(subrxFrame,GTK_STATE_NORMAL,&background);
    gtk_widget_modify_fg(gtk_frame_get_label_widget(GTK_FRAME(subrxFrame)),GTK_STATE_NORMAL,&white);

#ifdef NETBOOK
    subrxTable=gtk_table_new(1,9,TRUE);
#else
    subrxTable=gtk_table_new(2,8,TRUE);
#endif

    // subrx settings

    subrxFrequencyDisplay=gtk_drawing_area_new();
    //gtk_widget_set_size_request(GTK_WIDGET(subrxFrequencyDisplay),250,35);
    g_signal_connect(G_OBJECT (subrxFrequencyDisplay),"configure_event",G_CALLBACK(subrxFrequencyDisplayConfigure),NULL);
    g_signal_connect(G_OBJECT (subrxFrequencyDisplay),"expose_event",G_CALLBACK(subrxFrequencyDisplayExpose),NULL);
    g_signal_connect(G_OBJECT(subrxFrequencyDisplay),"scroll_event",G_CALLBACK(subrx_frequency_scroll_event),NULL);
    gtk_widget_set_events(subrxFrequencyDisplay,GDK_EXPOSURE_MASK|GDK_SCROLL_MASK);
    gtk_widget_show(subrxFrequencyDisplay);
#ifdef NETBOOK
    gtk_table_attach_defaults(GTK_TABLE(subrxTable),subrxFrequencyDisplay,5,9,0,1);
#else
    gtk_table_attach_defaults(GTK_TABLE(subrxTable),subrxFrequencyDisplay,1,8,0,1);
#endif


    subrxEnabled = gtk_button_new_with_label ("SubRX");
    gtk_widget_modify_bg(subrxEnabled, GTK_STATE_NORMAL, &buttonBackground);
    label=gtk_bin_get_child((GtkBin*)subrxEnabled);

    if(subrx) {
        gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &buttonSelected);
        gtk_widget_modify_fg(label, GTK_STATE_PRELIGHT, &buttonSelected);
    } else {
        gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &white);
        gtk_widget_modify_fg(label, GTK_STATE_PRELIGHT, &black);
    }

    gtk_widget_set_size_request(GTK_WIDGET(subrxEnabled),BUTTON_WIDTH,BUTTON_HEIGHT);
    g_signal_connect(G_OBJECT(subrxEnabled),"clicked",G_CALLBACK(subrxEnabledButtonCallback),NULL);
    gtk_widget_show(subrxEnabled);
    gtk_table_attach_defaults(GTK_TABLE(subrxTable),subrxEnabled,0,1,0,1);

    // subrx gain
    subrxGainFrame=gtk_frame_new("AF Gain");
    gtk_widget_modify_bg(subrxGainFrame,GTK_STATE_NORMAL,&background);
    gtk_widget_modify_fg(gtk_frame_get_label_widget(GTK_FRAME(subrxGainFrame)),GTK_STATE_NORMAL,&white);

    subrxGainScale=gtk_hscale_new_with_range(0.0,100.0,10.0);
    g_signal_connect(G_OBJECT(subrxGainScale),"value-changed",G_CALLBACK(subrxGainChanged),NULL);
    gtk_range_set_value((GtkRange*)subrxGainScale,subrxGain);
#ifdef NETBOOK
    gtk_widget_set_size_request(GTK_WIDGET(subrxGainScale),80,37);
#else
    gtk_widget_set_size_request(GTK_WIDGET(subrxGainScale),150,30);
#endif
    gtk_widget_show(subrxGainScale);
    gtk_container_add(GTK_CONTAINER(subrxGainFrame),subrxGainScale);
    gtk_widget_show(subrxGainFrame);
#ifdef NETBOOK
    gtk_table_attach_defaults(GTK_TABLE(subrxTable),subrxGainFrame,1,3,0,1);
#else
    gtk_table_attach_defaults(GTK_TABLE(subrxTable),subrxGainFrame,0,4,1,2);
#endif

    // subrx pan
    subrxPanFrame=gtk_frame_new("AF Pan");
    gtk_widget_modify_bg(subrxPanFrame,GTK_STATE_NORMAL,&background);
    gtk_widget_modify_fg(gtk_frame_get_label_widget(GTK_FRAME(subrxPanFrame)),GTK_STATE_NORMAL,&white);

    subrxPanScale=gtk_hscale_new_with_range(0.0,1.0,0.1);
    g_signal_connect(G_OBJECT(subrxPanScale),"value-changed",G_CALLBACK(subrxPanChanged),NULL);
    gtk_range_set_value((GtkRange*)subrxPanScale,subrxPan);
#ifdef NETBOOK
    gtk_widget_set_size_request(GTK_WIDGET(subrxPanScale),80,37);
#else
    gtk_widget_set_size_request(GTK_WIDGET(subrxPanScale),150,30);
#endif
    gtk_widget_show(subrxPanScale);
    gtk_container_add(GTK_CONTAINER(subrxPanFrame),subrxPanScale);
    gtk_widget_show(subrxPanFrame);
#ifdef NETBOOK
    gtk_table_attach_defaults(GTK_TABLE(subrxTable),subrxPanFrame,3,5,0,1);
#else
    gtk_table_attach_defaults(GTK_TABLE(subrxTable),subrxPanFrame,4,8,1,2);
#endif

    if(running) {
        SetRXAPanelPan(CHANNEL_SUBRX, 1.0-subrxPan);
    }

    gtk_container_add(GTK_CONTAINER(subrxFrame),subrxTable);
    gtk_widget_show(subrxTable);
    gtk_widget_show(subrxFrame);

    return subrxFrame;

}