bool wxNotebook::InsertPage( size_t position,
wxNotebookPage* win,
const wxString& text,
bool select,
int imageId )
{
wxCHECK_MSG( m_widget != NULL, FALSE, wxT("invalid notebook") );
wxCHECK_MSG( win->GetParent() == this, FALSE,
wxT("Can't add a page whose parent is not the notebook!") );
wxCHECK_MSG( position <= GetPageCount(), FALSE,
wxT("invalid page index in wxNotebookPage::InsertPage()") );
// Hack Alert! (Part II): See above in wxInsertChildInNotebook callback
// why this has to be done. NOTE: using gtk_widget_unparent here does not
// work as it seems to undo too much and will cause errors in the
// gtk_notebook_insert_page below, so instead just clear the parent by
// hand here.
win->m_widget->parent = NULL;
// don't receive switch page during addition
gtk_signal_disconnect_by_func( GTK_OBJECT(m_widget),
GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer) this );
if (m_themeEnabled)
win->SetThemeEnabled(true);
GtkNotebook *notebook = GTK_NOTEBOOK(m_widget);
wxGtkNotebookPage *nb_page = new wxGtkNotebookPage();
if ( position == GetPageCount() )
m_pagesData.Append( nb_page );
else
m_pagesData.Insert( position, nb_page );
m_pages.Insert(win, position);
nb_page->m_box = gtk_hbox_new( FALSE, 1 );
gtk_container_border_width( GTK_CONTAINER(nb_page->m_box), 2 );
gtk_signal_connect( GTK_OBJECT(win->m_widget), "size_allocate",
GTK_SIGNAL_FUNC(gtk_page_size_callback), (gpointer)win );
gtk_notebook_insert_page( notebook, win->m_widget, nb_page->m_box, position );
nb_page->m_page = (GtkNotebookPage*) g_list_last(notebook->children)->data;
/* set the label image */
nb_page->m_image = imageId;
if (imageId != -1)
{
wxASSERT( HasImageList() );
const wxBitmap *bmp = GetImageList()->GetBitmapPtr(imageId);
GdkPixmap *pixmap = bmp->GetPixmap();
GdkBitmap *mask = NULL;
if ( bmp->GetMask() )
{
mask = bmp->GetMask()->GetBitmap();
}
GtkWidget *pixmapwid = gtk_pixmap_new (pixmap, mask );
gtk_box_pack_start(GTK_BOX(nb_page->m_box), pixmapwid, FALSE, FALSE, m_padding);
gtk_widget_show(pixmapwid);
}
/* set the label text */
nb_page->m_text = text;
if (nb_page->m_text.empty()) nb_page->m_text = wxEmptyString;
nb_page->m_label = GTK_LABEL( gtk_label_new(wxGTK_CONV(nb_page->m_text)) );
gtk_box_pack_end( GTK_BOX(nb_page->m_box), GTK_WIDGET(nb_page->m_label), FALSE, FALSE, m_padding );
/* apply current style */
GtkRcStyle *style = CreateWidgetStyle();
if ( style )
{
gtk_widget_modify_style(GTK_WIDGET(nb_page->m_label), style);
gtk_rc_style_unref(style);
}
/* show the label */
gtk_widget_show( GTK_WIDGET(nb_page->m_label) );
if (select && (m_pagesData.GetCount() > 1))
{
SetSelection( position );
}
gtk_signal_connect( GTK_OBJECT(m_widget), "switch_page",
GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer)this );
InvalidateBestSize();
return true;
}
static void
thunar_sbr_number_renamer_init (ThunarSbrNumberRenamer *number_renamer)
{
AtkRelationSet *relations;
AtkRelation *relation;
GEnumClass *klass;
AtkObject *object;
GtkWidget *combo;
GtkWidget *entry;
GtkWidget *label;
GtkWidget *hbox;
guint n;
hbox = gtk_hbox_new (FALSE, 12);
gtk_box_pack_start (GTK_BOX (number_renamer), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new_with_mnemonic (_("_Number Format:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
combo = gtk_combo_box_new_text ();
klass = g_type_class_ref (THUNAR_SBR_TYPE_NUMBER_MODE);
for (n = 0; n < klass->n_values; ++n)
gtk_combo_box_append_text (GTK_COMBO_BOX (combo), _(klass->values[n].value_nick));
exo_mutual_binding_new (G_OBJECT (number_renamer), "mode", G_OBJECT (combo), "active");
gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
g_type_class_unref (klass);
gtk_widget_show (combo);
/* set Atk label relation for the combo */
object = gtk_widget_get_accessible (combo);
relations = atk_object_ref_relation_set (gtk_widget_get_accessible (label));
relation = atk_relation_new (&object, 1, ATK_RELATION_LABEL_FOR);
atk_relation_set_add (relations, relation);
g_object_unref (G_OBJECT (relation));
number_renamer->start_entry = gtk_entry_new ();
gtk_entry_set_max_length (GTK_ENTRY (number_renamer->start_entry), 4);
gtk_entry_set_width_chars (GTK_ENTRY (number_renamer->start_entry), 3);
gtk_entry_set_alignment (GTK_ENTRY (number_renamer->start_entry), 1.0f);
gtk_entry_set_activates_default (GTK_ENTRY (number_renamer->start_entry), TRUE);
exo_mutual_binding_new (G_OBJECT (number_renamer->start_entry), "text", G_OBJECT (number_renamer), "start");
gtk_box_pack_end (GTK_BOX (hbox), number_renamer->start_entry, TRUE, TRUE, 0);
gtk_widget_show (number_renamer->start_entry);
label = gtk_label_new_with_mnemonic (_("_Start With:"));
gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), number_renamer->start_entry);
gtk_widget_show (label);
/* set Atk label relation for the entry */
object = gtk_widget_get_accessible (number_renamer->start_entry);
relations = atk_object_ref_relation_set (gtk_widget_get_accessible (label));
relation = atk_relation_new (&object, 1, ATK_RELATION_LABEL_FOR);
atk_relation_set_add (relations, relation);
g_object_unref (G_OBJECT (relation));
hbox = gtk_hbox_new (FALSE, 12);
gtk_box_pack_end (GTK_BOX (number_renamer), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new_with_mnemonic (_("Text _Format:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
combo = gtk_combo_box_new_text ();
klass = g_type_class_ref (THUNAR_SBR_TYPE_TEXT_MODE);
for (n = 0; n < klass->n_values; ++n)
gtk_combo_box_append_text (GTK_COMBO_BOX (combo), _(klass->values[n].value_nick));
exo_mutual_binding_new (G_OBJECT (number_renamer), "text-mode", G_OBJECT (combo), "active");
gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
g_type_class_unref (klass);
gtk_widget_show (combo);
/* set Atk label relation for the combo */
object = gtk_widget_get_accessible (combo);
relations = atk_object_ref_relation_set (gtk_widget_get_accessible (label));
relation = atk_relation_new (&object, 1, ATK_RELATION_LABEL_FOR);
atk_relation_set_add (relations, relation);
g_object_unref (G_OBJECT (relation));
entry = gtk_entry_new ();
gtk_entry_set_width_chars (GTK_ENTRY (entry), 4);
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
exo_mutual_binding_new (G_OBJECT (entry), "text", G_OBJECT (number_renamer), "text");
gtk_box_pack_end (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
gtk_widget_show (entry);
label = gtk_label_new_with_mnemonic (_("_Text:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0f, 0.5f);
gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);
gtk_widget_show (label);
/* set Atk label relation for the entry */
object = gtk_widget_get_accessible (entry);
relations = atk_object_ref_relation_set (gtk_widget_get_accessible (label));
relation = atk_relation_new (&object, 1, ATK_RELATION_LABEL_FOR);
atk_relation_set_add (relations, relation);
g_object_unref (G_OBJECT (relation));
}
void fenetre_principale( ELEMENT *Element )
{
// Variables
gint i = 0;
// Widget
// Widgets des boites
GtkWidget *p_Hboite[1] = {NULL};
// Widgets des cadres
GtkWidget *p_Cadre[3] = {NULL};
// Widgets des tableaux pour cadre
GtkWidget *p_Tableau[3] = {NULL};
// Widgets des boites à bouton
GtkWidget *p_Bouton_boite[1] = {NULL};
// création
// Création des boites
Element -> p_Vboite[0] = gtk_vbox_new ( FALSE,5);
Element -> p_Vboite[1] = gtk_vbox_new ( FALSE,5);
Element -> p_Vboite[2] = gtk_vbox_new ( FALSE,5);
p_Hboite[0] = gtk_hbox_new ( TRUE,5);
// création des cadres
p_Cadre[0] = gtk_frame_new ("Vos revenus");
p_Cadre[1] = gtk_frame_new ("Votre prêt");
p_Cadre[2] = gtk_frame_new ("Résultats");
// création des tableaux
p_Tableau[0] = gtk_table_new ( 3,2,FALSE );
p_Tableau[1] = gtk_table_new ( 3,3,FALSE );
p_Tableau[2] = gtk_table_new ( 3,6,FALSE );
// création des sélecteurs numériques
Element -> p_Selecteur[0] = gtk_spin_button_new_with_range (10,99999,10);
gtk_spin_button_set_value
(GTK_SPIN_BUTTON(Element -> p_Selecteur[0]),1000);
Element -> p_Selecteur[1] = gtk_spin_button_new_with_range (10,99999,10);
gtk_spin_button_set_value
(GTK_SPIN_BUTTON(Element -> p_Selecteur[1]),1000);
Element -> p_Selecteur[2] = gtk_spin_button_new_with_range (0.00,99.99,0.01);
gtk_spin_button_set_value
(GTK_SPIN_BUTTON(Element -> p_Selecteur[2]),5.0);
Element -> p_Selecteur[3] = gtk_spin_button_new_with_range (1,30,1);
gtk_spin_button_set_value
(GTK_SPIN_BUTTON(Element -> p_Selecteur[3]),15);
Element -> p_Selecteur[4] = gtk_spin_button_new_with_range (1,9999999,100);
gtk_spin_button_set_value
(GTK_SPIN_BUTTON(Element -> p_Selecteur[4]),100000);
// création des étiquettes
Element -> p_Etiq[0] = gtk_label_new("Salaire net emprunteur n°1 : ");
gtk_misc_set_alignment(GTK_MISC(Element -> p_Etiq[0]),1.0,0.5);
Element -> p_Etiq[1] = gtk_label_new("Salaire net emprunteur n°2 : ");
gtk_misc_set_alignment(GTK_MISC(Element -> p_Etiq[1]),1.0,0.5);
Element -> p_Etiq[2] = gtk_label_new(" € ");
Element -> p_Etiq[3] = gtk_label_new(" € ");
Element -> p_Etiq[4] = gtk_label_new("Taux d'intérêt annuel : ");
gtk_misc_set_alignment(GTK_MISC(Element -> p_Etiq[4]),1.0,0.5);
Element -> p_Etiq[5] = gtk_label_new("Durée de l'emprunt : ");
gtk_misc_set_alignment(GTK_MISC(Element -> p_Etiq[5]),1.0,0.5);
Element -> p_Etiq[6] = gtk_label_new("Somme empruntée : ");
gtk_misc_set_alignment(GTK_MISC(Element -> p_Etiq[6]),1.0,0.5);
Element -> p_Etiq[7] = gtk_label_new(" % ");
Element -> p_Etiq[8] = gtk_label_new(" ans ");
Element -> p_Etiq[9] = gtk_label_new(" € ");
Element -> p_Etiq[10] = gtk_label_new(" Votre mensualité :");
gtk_misc_set_alignment(GTK_MISC(Element -> p_Etiq[10]),1.0,0.5);
Element -> p_Etiq[11] = gtk_label_new(" Votre mensualité maxi :");
gtk_misc_set_alignment(GTK_MISC(Element -> p_Etiq[11]),1.0,0.5);
Element -> p_Etiq[12] = gtk_label_new(" Votre endettement :");
gtk_misc_set_alignment(GTK_MISC(Element -> p_Etiq[12]),1.0,0.5);
Element -> p_Etiq[13] = gtk_label_new(" Votre capacité d'emprunt :");
gtk_misc_set_alignment(GTK_MISC(Element -> p_Etiq[13]),1.0,0.5);
Element -> p_Etiq[14] = gtk_label_new(" Le montant des intérêts :");
gtk_misc_set_alignment(GTK_MISC(Element -> p_Etiq[14]),1.0,0.5);
Element -> p_Etiq[15] = gtk_label_new(" Le coût total du crédit :");
gtk_misc_set_alignment(GTK_MISC(Element -> p_Etiq[15]),1.0,0.5);
Element -> p_Etiq[16] = gtk_label_new(" 0000 € ");
Element -> p_Etiq[17] = gtk_label_new(" 0000 € ");
Element -> p_Etiq[18] = gtk_label_new(" 00 % ");
Element -> p_Etiq[19] = gtk_label_new(" € ");
Element -> p_Etiq[20] = gtk_label_new(" € ");
Element -> p_Etiq[21] = gtk_label_new(" € ");
Element -> p_Etiq[22] = gtk_label_new("- TABLEAU D'AMORTISSEMENT -");
// création des boites à bouton
p_Bouton_boite[0] = gtk_hbutton_box_new();
// création des boutons
Element -> p_Bouton[0] = gtk_button_new_with_label("CALCULER");
Element -> p_Bouton[1] = gtk_button_new_with_label("QUITTER");
// construction de la fenêtre principale
Element -> p_Fenetre[0] = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(Element -> p_Fenetre[0]),
GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(Element -> p_Fenetre[0]),
LARGEUR_FENETRE, HAUTEUR_FENETRE);
gtk_window_set_title(GTK_WINDOW(Element -> p_Fenetre[0]),TITRE_FENETRE);
gtk_window_set_icon_from_file(GTK_WINDOW(Element -> p_Fenetre[0]),
ICONE,NULL);
// Assemblage des boites
gtk_container_add(GTK_CONTAINER(Element -> p_Fenetre[0]), Element -> p_Vboite[0]);
gtk_box_pack_start(GTK_BOX(Element -> p_Vboite[0]), p_Hboite[0], FALSE,FALSE,5);
gtk_box_pack_start(GTK_BOX(p_Hboite[0]), Element -> p_Vboite[1], TRUE,TRUE,5);
gtk_box_pack_start(GTK_BOX(p_Hboite[0]), Element -> p_Vboite[2], TRUE,TRUE,5);
gtk_box_pack_end(GTK_BOX(Element -> p_Vboite[0]), p_Bouton_boite[0], FALSE,FALSE,5);
// Cadre pour les revenus
gtk_box_pack_start(GTK_BOX(Element -> p_Vboite[1]), p_Cadre[0], TRUE,TRUE,5);
gtk_container_add(GTK_CONTAINER(p_Cadre[0]), p_Tableau[0]);
// premier tableau
for (i = 0; i < 2 ; i++ )
{
gtk_table_attach(GTK_TABLE(p_Tableau[0]), Element -> p_Etiq[i],
0, 1, i, i+1,GTK_EXPAND | GTK_FILL ,GTK_EXPAND,
5, 5);
gtk_table_attach(GTK_TABLE(p_Tableau[0]), Element -> p_Selecteur[i],
1, 2, i, i+1,GTK_FILL, GTK_EXPAND,
0, 0);
gtk_table_attach(GTK_TABLE(p_Tableau[0]), Element -> p_Etiq[i+2],
2, 3, i, i+1,GTK_FILL, GTK_EXPAND,
0, 0);
}
// Cadre pour le prêt
gtk_box_pack_start(GTK_BOX(Element -> p_Vboite[1]), p_Cadre[1], TRUE,TRUE,5);
gtk_container_add(GTK_CONTAINER(p_Cadre[1]), p_Tableau[1]);
// deuxième tableau
for (i = 2; i < 5 ; i++ )
{
gtk_table_attach(GTK_TABLE(p_Tableau[1]), Element -> p_Etiq[i+2],
0, 1, i-2, i-1,GTK_EXPAND | GTK_FILL ,GTK_EXPAND,
5, 5);
gtk_table_attach(GTK_TABLE(p_Tableau[1]), Element -> p_Selecteur[i],
1, 2, i-2, i-1,GTK_FILL, GTK_EXPAND,
0, 0);
gtk_table_attach(GTK_TABLE(p_Tableau[1]), Element -> p_Etiq[i+5],
2, 3, i-2, i-1,GTK_FILL, GTK_EXPAND,
0, 0);
}
// Cadre pour les résultats
gtk_box_pack_start(GTK_BOX(Element -> p_Vboite[2]), p_Cadre[2], TRUE,TRUE,5);
gtk_container_add(GTK_CONTAINER(p_Cadre[2]), p_Tableau[2]);
// troisième tableau
for (i = 10; i < 16 ; i++ )
{
gtk_table_attach(GTK_TABLE(p_Tableau[2]), Element -> p_Etiq[i],
0, 1, i-10, i-9,GTK_EXPAND | GTK_FILL ,GTK_EXPAND,
5, 5);
gtk_table_attach(GTK_TABLE(p_Tableau[2]), Element -> p_Etiq[i+6],
1, 3, i-10, i-9,GTK_EXPAND | GTK_FILL ,GTK_EXPAND,
5, 5);
}
// Ajoute des boutons dans la boite spécifique
gtk_button_box_set_layout
(GTK_BUTTON_BOX(p_Bouton_boite[0]),GTK_BUTTONBOX_CENTER);
gtk_box_pack_start(GTK_BOX(p_Bouton_boite[0]), Element -> p_Bouton[0], FALSE,FALSE,5);
gtk_box_pack_end(GTK_BOX(p_Bouton_boite[0]), Element -> p_Bouton[1], FALSE,FALSE,5);
// Définition des callbacks
g_signal_connect (
G_OBJECT (Element -> p_Fenetre[0]),
"destroy",G_CALLBACK(gtk_main_quit),NULL
);
g_signal_connect (
G_OBJECT (Element -> p_Bouton[1]),
"clicked",G_CALLBACK(gtk_main_quit),NULL
);
g_signal_connect (
G_OBJECT (Element -> p_Bouton[0]),
"clicked",G_CALLBACK(Calcul_pret),Element
);
}
GtkWidget *
gimp_thumb_box_new (GimpContext *context)
{
GimpThumbBox *box;
GtkWidget *vbox;
GtkWidget *vbox2;
GtkWidget *ebox;
GtkWidget *hbox;
GtkWidget *button;
GtkWidget *label;
gchar *str;
gint h, v;
GtkRequisition info_requisition;
GtkRequisition progress_requisition;
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
box = g_object_new (GIMP_TYPE_THUMB_BOX, NULL);
box->context = context;
ebox = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (box), ebox);
gtk_widget_show (ebox);
g_signal_connect (ebox, "button-press-event",
G_CALLBACK (gimp_thumb_box_ebox_button_press),
box);
str = g_strdup_printf (_("Click to update preview\n"
"%s-Click to force update even "
"if preview is up-to-date"),
gimp_get_mod_string (gimp_get_toggle_behavior_mask ()));
gimp_help_set_help_data (ebox, str, NULL);
g_free (str);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (ebox), vbox);
gtk_widget_show (vbox);
button = gtk_button_new ();
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
label = gtk_label_new_with_mnemonic (_("Pr_eview"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_container_add (GTK_CONTAINER (button), label);
gtk_widget_show (label);
g_signal_connect (button, "button-press-event",
G_CALLBACK (gtk_true),
NULL);
g_signal_connect (button, "button-release-event",
G_CALLBACK (gtk_true),
NULL);
g_signal_connect (button, "enter-notify-event",
G_CALLBACK (gtk_true),
NULL);
g_signal_connect (button, "leave-notify-event",
G_CALLBACK (gtk_true),
NULL);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_set_border_width (GTK_CONTAINER (vbox2), 2);
gtk_box_pack_start (GTK_BOX (vbox), vbox2, TRUE, TRUE, 0);
gtk_widget_show (vbox2);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
box->imagefile = gimp_imagefile_new (context->gimp, NULL);
g_signal_connect (box->imagefile, "info-changed",
G_CALLBACK (gimp_thumb_box_imagefile_info_changed),
box);
g_signal_connect (gimp_imagefile_get_thumbnail (box->imagefile),
"notify::thumb-state",
G_CALLBACK (gimp_thumb_box_thumb_state_notify),
box);
gimp_view_renderer_get_frame_size (&h, &v);
box->preview = gimp_view_new (context,
GIMP_VIEWABLE (box->imagefile),
/* add padding for the shadow frame */
context->gimp->config->thumbnail_size +
MAX (h, v),
0, FALSE);
gtk_box_pack_start (GTK_BOX (hbox), box->preview, TRUE, FALSE, 2);
gtk_widget_show (box->preview);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), box->preview);
g_signal_connect (box->preview, "clicked",
G_CALLBACK (gimp_thumb_box_thumbnail_clicked),
box);
box->filename = gtk_label_new (_("No selection"));
gtk_label_set_ellipsize (GTK_LABEL (box->filename), PANGO_ELLIPSIZE_MIDDLE);
gtk_label_set_justify (GTK_LABEL (box->filename), GTK_JUSTIFY_CENTER);
gimp_label_set_attributes (GTK_LABEL (box->filename),
PANGO_ATTR_STYLE, PANGO_STYLE_OBLIQUE,
-1);
gtk_box_pack_start (GTK_BOX (vbox2), box->filename, FALSE, FALSE, 0);
gtk_widget_show (box->filename);
box->info = gtk_label_new (" \n \n \n ");
gtk_misc_set_alignment (GTK_MISC (box->info), 0.5, 0.0);
gtk_label_set_justify (GTK_LABEL (box->info), GTK_JUSTIFY_CENTER);
gtk_label_set_line_wrap (GTK_LABEL (box->info), TRUE);
gimp_label_set_attributes (GTK_LABEL (box->info),
PANGO_ATTR_SCALE, PANGO_SCALE_SMALL,
-1);
gtk_box_pack_start (GTK_BOX (vbox2), box->info, FALSE, FALSE, 0);
gtk_widget_show (box->info);
box->progress = gtk_progress_bar_new ();
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (box->progress), "Fog");
gtk_box_pack_end (GTK_BOX (vbox2), box->progress, FALSE, FALSE, 0);
gtk_widget_set_no_show_all (box->progress, TRUE);
/* don't gtk_widget_show (box->progress); */
/* eek */
gtk_widget_size_request (box->info, &info_requisition);
gtk_widget_size_request (box->progress, &progress_requisition);
gtk_widget_set_size_request (box->info,
-1, info_requisition.height);
gtk_widget_set_size_request (box->filename,
progress_requisition.width, -1);
gtk_widget_set_size_request (box->progress,
-1, progress_requisition.height);
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (box->progress), "");
return GTK_WIDGET (box);
}
static void
anjuta_app_instance_init (AnjutaApp *app)
{
gint merge_id;
GtkWidget *menubar, *about_menu;
GtkWidget *view_menu, *hbox;
GtkWidget *main_box;
GtkWidget *dockbar;
GtkAction* action;
GList *plugins_dirs = NULL;
gchar* style;
GdkGeometry size_hints = {
100, 100, 0, 0, 100, 100, 1, 1, 0.0, 0.0, GDK_GRAVITY_NORTH_WEST
};
DEBUG_PRINT ("%s", "Initializing Anjuta...");
gtk_window_set_geometry_hints (GTK_WINDOW (app), GTK_WIDGET (app),
&size_hints, GDK_HINT_RESIZE_INC);
gtk_window_set_resizable (GTK_WINDOW (app), TRUE);
/*
* Main box
*/
main_box = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (app), main_box);
gtk_widget_show (main_box);
app->values = NULL;
app->widgets = NULL;
/* Status bar */
app->status = ANJUTA_STATUS (anjuta_status_new ());
anjuta_status_set_title_window (app->status, GTK_WIDGET (app));
gtk_widget_show (GTK_WIDGET (app->status));
gtk_box_pack_end (GTK_BOX (main_box),
GTK_WIDGET (app->status), FALSE, TRUE, 0);
g_object_ref (G_OBJECT (app->status));
g_object_add_weak_pointer (G_OBJECT (app->status), (gpointer)&app->status);
/* configure dock */
hbox = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox);
app->dock = gdl_dock_new ();
gtk_widget_show (app->dock);
gtk_box_pack_end(GTK_BOX (hbox), app->dock, TRUE, TRUE, 0);
dockbar = gdl_dock_bar_new (GDL_DOCK(app->dock));
gtk_widget_show (dockbar);
gtk_box_pack_start(GTK_BOX (hbox), dockbar, FALSE, FALSE, 0);
app->layout_manager = gdl_dock_layout_new (GDL_DOCK (app->dock));
g_signal_connect (app->layout_manager, "notify::dirty",
G_CALLBACK (on_layout_dirty_notify), app);
g_signal_connect (app->layout_manager->master, "notify::locked",
G_CALLBACK (on_layout_locked_notify), app);
/* UI engine */
app->ui = anjuta_ui_new ();
g_object_add_weak_pointer (G_OBJECT (app->ui), (gpointer)&app->ui);
/* show tooltips in the statusbar */
g_signal_connect (app->ui,
"connect_proxy",
G_CALLBACK (connect_proxy_cb),
app);
g_signal_connect (app->ui,
"disconnect_proxy",
G_CALLBACK (disconnect_proxy_cb),
app);
/* Plugin Manager */
plugins_dirs = g_list_prepend (plugins_dirs, PACKAGE_PLUGIN_DIR);
app->plugin_manager = anjuta_plugin_manager_new (G_OBJECT (app),
app->status,
plugins_dirs);
app->profile_manager = anjuta_profile_manager_new (app->plugin_manager);
g_list_free (plugins_dirs);
/* Preferences */
app->preferences = anjuta_preferences_new (app->plugin_manager);
g_object_add_weak_pointer (G_OBJECT (app->preferences),
(gpointer)&app->preferences);
anjuta_preferences_notify_add_string (app->preferences, "anjuta.gdl.style",
on_gdl_style_changed, app, NULL);
style = anjuta_preferences_get (app->preferences, "anjuta.gdl.style");
on_gdl_style_changed (app->preferences, NULL,
style, app);
g_free (style);
/* Register actions */
anjuta_ui_add_action_group_entries (app->ui, "ActionGroupFile", _("File"),
menu_entries_file,
G_N_ELEMENTS (menu_entries_file),
GETTEXT_PACKAGE, TRUE, app);
anjuta_ui_add_action_group_entries (app->ui, "ActionGroupEdit", _("Edit"),
menu_entries_edit,
G_N_ELEMENTS (menu_entries_edit),
GETTEXT_PACKAGE, TRUE, app);
anjuta_ui_add_action_group_entries (app->ui, "ActionGroupView", _("View"),
menu_entries_view,
G_N_ELEMENTS (menu_entries_view),
GETTEXT_PACKAGE, TRUE, app);
anjuta_ui_add_toggle_action_group_entries (app->ui, "ActionGroupToggleView",
_("View"),
menu_entries_toggle_view,
G_N_ELEMENTS (menu_entries_toggle_view),
GETTEXT_PACKAGE, TRUE, app);
anjuta_ui_add_action_group_entries (app->ui, "ActionGroupHelp", _("Help"),
menu_entries_help,
G_N_ELEMENTS (menu_entries_help),
GETTEXT_PACKAGE, TRUE, app);
/* Merge UI */
merge_id = anjuta_ui_merge (app->ui, UI_FILE);
/* Adding accels group */
gtk_window_add_accel_group (GTK_WINDOW (app),
gtk_ui_manager_get_accel_group (GTK_UI_MANAGER (app->ui)));
/* create main menu */
menubar = gtk_ui_manager_get_widget (GTK_UI_MANAGER (app->ui),
"/MenuMain");
gtk_box_pack_start (GTK_BOX (main_box), menubar, FALSE, FALSE, 0);
gtk_widget_show (menubar);
/* create toolbar */
app->toolbar = gtk_ui_manager_get_widget (GTK_UI_MANAGER (app->ui),
"/ToolbarMain");
if (!anjuta_preferences_get_bool (app->preferences, "anjuta.toolbar.visible"))
gtk_widget_hide (app->toolbar);
gtk_box_pack_start (GTK_BOX (main_box), app->toolbar, FALSE, FALSE, 0);
action = gtk_ui_manager_get_action (GTK_UI_MANAGER (app->ui),
"/MenuMain/MenuView/Toolbar");
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION(action),
anjuta_preferences_get_bool_with_default (app->preferences,
"anjuta.toolbar.visible",
TRUE));
anjuta_preferences_notify_add_string (app->preferences, "anjuta.toolbar.style",
on_toolbar_style_changed, app, NULL);
style = anjuta_preferences_get (app->preferences, "anjuta.toolbar.style");
on_toolbar_style_changed (app->preferences, NULL, style, app);
g_free (style);
/* Create widgets menu */
view_menu =
gtk_ui_manager_get_widget (GTK_UI_MANAGER(app->ui),
"/MenuMain/MenuView");
app->view_menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (view_menu));
/* Disable unavailible tutorials */
action = anjuta_ui_get_action(app->ui, "ActionGroupHelp", "ActionHelpTutorial");
g_object_set(G_OBJECT(action), "visible", FALSE, NULL);
action = anjuta_ui_get_action(app->ui, "ActionGroupHelp", "ActionHelpAdvancedTutorial");
g_object_set(G_OBJECT(action), "visible", FALSE, NULL);
/* Create about plugins menu */
about_menu =
gtk_ui_manager_get_widget (GTK_UI_MANAGER(app->ui),
"/MenuMain/PlaceHolderHelpMenus/MenuHelp/"
"PlaceHolderHelpAbout/AboutPlugins");
about_create_plugins_submenu (ANJUTA_SHELL (app), about_menu);
/* Add main view */
gtk_box_pack_start (GTK_BOX (main_box), hbox, TRUE, TRUE, 0);
/* Connect to session */
g_signal_connect (G_OBJECT (app), "save_session",
G_CALLBACK (on_session_save), app);
g_signal_connect (G_OBJECT (app), "load_session",
G_CALLBACK (on_session_load), app);
/* Loading accels */
anjuta_ui_load_accels (NULL);
app->save_count = 0;
}
GtkWidget *
gtkam_main_new (void)
{
GtkamMain *m;
GdkPixbuf *pixbuf;
GtkActionGroup *action_group;
GtkUIManager *ui_manager;
GtkAccelGroup *accel_group;
GtkWidget *widget, *vbox, *scrolled, *hpaned, *t;
m = g_object_new (GTKAM_TYPE_MAIN, NULL);
gtk_window_set_title (GTK_WINDOW (m), PACKAGE);
pixbuf = gdk_pixbuf_new_from_file (IMAGE_DIR "/gtkam-camera.png", NULL);
if (pixbuf != NULL) {
gtk_window_set_icon (GTK_WINDOW (m), pixbuf);
gdk_pixbuf_unref (pixbuf);
}
m->priv->view_thumbs = TRUE;
vbox = gtk_vbox_new (FALSE, 1);
gtk_widget_show (vbox);
gtk_container_add (GTK_CONTAINER (m), vbox);
/* Menu */
action_group = gtk_action_group_new ("MenuActions");
#ifdef GETTEXT_PACKAGE
gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
#endif
gtk_action_group_add_actions (action_group, entries, G_N_ELEMENTS (entries), m);
gtk_action_group_add_toggle_actions (action_group, toggle_entries, G_N_ELEMENTS (toggle_entries), m);
ui_manager = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group (ui_manager, action_group, 0);
accel_group = gtk_ui_manager_get_accel_group (ui_manager);
gtk_window_add_accel_group (GTK_WINDOW (m), accel_group);
gtk_ui_manager_add_ui_from_string(ui_manager, ui_description, -1, NULL);
widget = gtk_ui_manager_get_widget (ui_manager, "/MainMenu");
gtk_widget_show (widget);
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
m->priv->ui_manager = GTK_UI_MANAGER (ui_manager);
/* Toolbar */
t = gtk_ui_manager_get_widget (ui_manager, "/MainToolbar");
gtk_toolbar_set_style (GTK_TOOLBAR (t), GTK_TOOLBAR_BOTH);
gtk_box_pack_start (GTK_BOX (vbox), t, FALSE, FALSE, 0);
/*
* Context information
*/
m->priv->status = gtk_vbox_new (FALSE, 0);
gtk_widget_show (m->priv->status);
gtk_box_pack_end (GTK_BOX (vbox), m->priv->status, FALSE, FALSE, 0);
/*
* Main content
*/
hpaned = gtk_hpaned_new ();
gtk_widget_show (hpaned);
gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hpaned), 2);
gtk_paned_set_position (GTK_PANED (hpaned), 200);
/*
* Left
*/
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolled);
gtk_paned_pack1 (GTK_PANED (hpaned), scrolled, TRUE, TRUE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
m->priv->tree = gtkam_tree_new ();
gtk_widget_show (m->priv->tree);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled),
m->priv->tree);
g_signal_connect (G_OBJECT (m->priv->tree), "folder_selected",
G_CALLBACK (on_folder_selected), m);
g_signal_connect (G_OBJECT (m->priv->tree), "folder_unselected",
G_CALLBACK (on_folder_unselected), m);
g_signal_connect (G_OBJECT (m->priv->tree), "new_status",
G_CALLBACK (on_new_status), m);
g_signal_connect (G_OBJECT (m->priv->tree), "new_error",
G_CALLBACK (on_tree_new_error), m);
g_signal_connect (G_OBJECT (m->priv->tree), "file_added",
G_CALLBACK (on_tree_file_added), m);
g_signal_connect (G_OBJECT (m->priv->tree), "new_dialog",
G_CALLBACK (on_new_dialog), m);
/*
* Right
*/
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolled);
gtk_paned_pack2 (GTK_PANED (hpaned), scrolled, TRUE, TRUE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
m->priv->list = gtkam_list_new ();
gtk_widget_show (m->priv->list);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled),
m->priv->list);
g_signal_connect (G_OBJECT (m->priv->list), "file_selected",
G_CALLBACK (on_file_selected), m);
g_signal_connect (G_OBJECT (m->priv->list), "file_unselected",
G_CALLBACK (on_file_unselected), m);
g_signal_connect (G_OBJECT (m->priv->list), "new_status",
G_CALLBACK (on_new_status), m);
g_signal_connect (G_OBJECT (m->priv->list), "new_dialog",
G_CALLBACK (on_new_dialog), m);
gtkam_main_update_sensitivity (m);
return (GTK_WIDGET (m));
}
gint main (gint argc, gchar **argv)
{
GFile *file;
GXPSFile *xps;
GXPSView *view;
GtkWidget *win;
GtkWidget *hbox, *vbox, *sw;
GtkWidget *button;
guint page = 0;
GError *error = NULL;
if (argc < 2) {
g_printerr ("Use: test-xps file\n");
return 1;
}
gtk_init (&argc, &argv);
file = g_file_new_for_commandline_arg (argv[1]);
xps = gxps_file_new (file, &error);
g_object_unref (file);
if (error) {
g_printerr ("Error creating file: %s\n", error->message);
g_error_free (error);
g_object_unref (xps);
return 1;
}
view = g_new0 (GXPSView, 1);
view->doc = gxps_file_get_document (xps, 0, &error);
if (error) {
g_printerr ("Error getting document 0: %s\n", error->message);
g_error_free (error);
g_object_unref (xps);
return 1;
}
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (win), 600, 600);
g_signal_connect (win, "delete-event",
G_CALLBACK (gtk_main_quit),
NULL);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
view->spin_button = gtk_spin_button_new_with_range (0,
gxps_document_get_n_pages (view->doc) - 1,
1);
g_signal_connect (view->spin_button,
"value-changed",
G_CALLBACK (page_changed_callback),
view);
gtk_box_pack_end (GTK_BOX (hbox), view->spin_button, FALSE, TRUE, 0);
gtk_widget_show (view->spin_button);
button = gtk_button_new ();
g_signal_connect (button, "clicked",
G_CALLBACK (properties_button_clicked),
xps);
gtk_button_set_image (GTK_BUTTON (button),
gtk_image_new_from_icon_name ("document-properties", GTK_ICON_SIZE_SMALL_TOOLBAR));
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
view->darea = gtk_drawing_area_new ();
g_signal_connect (view->darea, "draw",
G_CALLBACK (drawing_area_draw),
view);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (sw), view->darea);
gtk_widget_show (view->darea);
gtk_box_pack_end (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
gtk_widget_show (sw);
gtk_container_add (GTK_CONTAINER (win), vbox);
gtk_widget_show (vbox);
gtk_widget_show (win);
if (argc > 2)
page = atoi (argv[2]);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (view->spin_button), page);
if (page == 0)
page_changed_callback (GTK_SPIN_BUTTON (view->spin_button), view);
gtk_main ();
g_object_unref (view->doc);
g_object_unref (xps);
cairo_surface_destroy (view->surface);
g_free (view);
return 0;
}
//
// Object hierarchy:
// parentWindow
// |-- background (event-box)
// |-- screen_alignment
// |-- topLevelVBox (vbox)
// |-- title_hbox
// | |-- title_padding (event box)
// | |-- title_background (event box)
// | |-- g_titleItem (label)
// |-- g_settingsArea (event box)
//
static GtkWidget *bg_screen_create(GtkWidget *parentWindow)
{
GtkWidget *background;
GtkWidget *topLevelVBox;
GtkWidget *title_background;
GtkWidget *title_hbox;
GtkWidget *title_padding;
GtkWidget *screen_alignment;
// background
background = gtk_event_box_new();
gtk_widget_set_name(GTK_WIDGET(background), "screen_background");
gtk_container_add(GTK_CONTAINER(parentWindow), background);
// screen_alignment
screen_alignment = gtk_alignment_new(0.0, 0.0, 1.0, 1.0);
gtk_widget_set_name(GTK_WIDGET(screen_alignment), "screen_background");
gtk_alignment_set_padding(GTK_ALIGNMENT(screen_alignment),
SCREEN_BORDER_TOP,
SCREEN_BORDER_BOTTOM,
1,
SCREEN_BORDER_RIGHT);
gtk_container_add(GTK_CONTAINER(background), screen_alignment);
// topLevelVBox
topLevelVBox = gtk_vbox_new(FALSE, SCREEN_ITEM_SPACING);
gtk_container_add(GTK_CONTAINER(screen_alignment), topLevelVBox);
// title_hbox
title_hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(topLevelVBox), title_hbox, FALSE, FALSE, 0);
// title_padding
title_padding = gtk_event_box_new();
gtk_widget_set_name(GTK_WIDGET(title_padding), "title_padding");
gtk_widget_set_size_request(GTK_WIDGET(title_padding),
SCREEN_BORDER_LEFT, -1);
gtk_box_pack_start(GTK_BOX(title_hbox), title_padding, FALSE, FALSE, 0);
// title_background
title_background = gtk_event_box_new();
gtk_widget_set_name(GTK_WIDGET(title_background), "title_background");
gtk_widget_set_size_request(GTK_WIDGET(title_background),
TITLE_MIN_WIDTH, TITLE_MIN_HEIGHT);
gtk_box_pack_start(GTK_BOX(title_hbox), title_background,
FALSE, FALSE, 0);
// g_titleItem: screen title text
g_titleItem = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(g_titleItem), 0.0, 0.5);
gtk_misc_set_padding(GTK_MISC(g_titleItem), BACKGROUND_TITLE_OFFSET, 0);
gtk_widget_set_name(GTK_WIDGET(g_titleItem), "title_item");
gtk_container_add(GTK_CONTAINER(title_background), g_titleItem);
// g_settingsArea: area to place remaining objects
g_settingsArea = gtk_event_box_new();
gtk_widget_set_name(GTK_WIDGET(g_settingsArea), "settings_area");
gtk_box_pack_end(GTK_BOX(topLevelVBox), g_settingsArea, TRUE, TRUE, 0);
gtk_widget_show_all(background);
return g_settingsArea;
}
void l_poimatdok(const char *nomdok,GtkWidget *wpredok)
{
char strsql[512];
iceb_u_str soob;
class poimatdok_data data;
data.nomdok_p.new_plus(nomdok);
data.window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(data.window),TRUE);
sprintf(strsql,"%s %s",name_system,gettext("Поиск документа по номеру"));
gtk_window_set_title (GTK_WINDOW (data.window),strsql);
gtk_container_set_border_width (GTK_CONTAINER (data.window), 5);
gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
if(wpredok != NULL)
{
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
//Удерживать окно над породившем его окном всегда
gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok));
//Закрыть окно если окно предок удалено
gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE);
}
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(poimatdok_key_press),&data);
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_release_event",GTK_SIGNAL_FUNC(iceb_key_release),&data.kl_shift);
GtkWidget *hbox = gtk_hbox_new (FALSE, 1);
gtk_container_add (GTK_CONTAINER (data.window), hbox);
GtkWidget *vbox1 = gtk_vbox_new (FALSE, 1);
GtkWidget *vbox2 = gtk_vbox_new (FALSE, 1);
gtk_box_pack_start (GTK_BOX (hbox), vbox1, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
gtk_widget_show(hbox);
soob.new_plus("");
data.label_kolstr=gtk_label_new (soob.ravno_toutf());
gtk_box_pack_start (GTK_BOX (vbox2),data.label_kolstr,FALSE, FALSE, 0);
gtk_widget_show(vbox1);
gtk_widget_show(vbox2);
data.sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_usize(GTK_WIDGET(data.sw),400,300);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (data.sw),GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (data.sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
//gtk_box_pack_start (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0);
//Кнопки
GtkTooltips *tooltips[KOL_F_KL];
sprintf(strsql,"F2 %s",gettext("Просмотр"));
data.knopka[FK2]=gtk_button_new_with_label(strsql);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK2],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]), "clicked",GTK_SIGNAL_FUNC(poimatdok_knopka),&data);
tooltips[FK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Просмотр выбранного документа"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2);
gtk_widget_show(data.knopka[FK2]);
sprintf(strsql,"F10 %s",gettext("Выход"));
data.knopka[FK10]=gtk_button_new_with_label(strsql);
gtk_box_pack_start(GTK_BOX(vbox1),data.knopka[FK10],TRUE,TRUE, 0);
tooltips[FK10]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]), "clicked",GTK_SIGNAL_FUNC(poimatdok_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10);
gtk_widget_show(data.knopka[FK10]);
gtk_widget_realize(data.window);
gdk_window_set_cursor(data.window->window,gdk_cursor_new(ICEB_CURSOR));
gtk_widget_grab_focus(data.knopka[FK10]);
poimatdok_create_list(&data);
gtk_widget_show(data.window);
gtk_window_maximize(GTK_WINDOW(data.window));
//gtk_window_fullscreen(GTK_WINDOW(data.window));
gtk_main();
printf("l_poimatdok end\n");
if(wpredok != NULL)
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));
}
static void home_window_construct (GenesisController *controller)
{
GtkWidget *window;
GtkWidget *hbox, *vbox;
GtkWidget *app_treeview, *cat_treeview;
GtkWidget *scrolledwindow;
GtkTreeModel *app_model, *cat_model;
GtkTreeSelection *app_selection, *cat_selection;
GtkWidget *textview, *button;
GenesisAppEntry *entry = NULL;
guint n = 0;
GList *cat_list;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Genesis Face");
g_signal_connect (G_OBJECT (window), "delete-event", (GCallback) gtk_main_quit, NULL);
hbox = gtk_hbox_new (FALSE,0);
gtk_container_add (GTK_CONTAINER (window), hbox);
vbox = gtk_vbox_new (FALSE,0);
gtk_box_pack_end (GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
textview = gtk_text_view_new ();
gtk_box_pack_start (GTK_BOX(vbox), textview, FALSE, FALSE, 0);
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_box_pack_end (GTK_BOX(hbox), scrolledwindow, FALSE, FALSE, 0);
app_treeview = gtk_tree_view_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (app_treeview),
-1, "Applications",
gtk_cell_renderer_text_new(),
"text", 0, NULL);
app_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (app_treeview));
gtk_tree_selection_set_mode (app_selection, GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT (app_selection), "changed",
G_CALLBACK (app_selection_changed_callback), textview);
gtk_container_add (GTK_CONTAINER (scrolledwindow), app_treeview);
app_model = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING));
gtk_tree_view_set_model (GTK_TREE_VIEW(app_treeview), app_model);
do
{
entry = genesis_controller_get_nth_entry (controller, n++);
if (entry)
{
gchar *entry_name = genesis_app_entry_get_name (entry);
tree_view_append_entry (app_model, entry_name);
}
}while (entry);
cat_list = genesis_controller_get_categories (controller);
if (!cat_list)
g_print ("failed to get categories list.\n");
else
{
GList *tmp;
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_box_pack_end (GTK_BOX(hbox), scrolledwindow, FALSE, FALSE, 0);
cat_treeview = gtk_tree_view_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (cat_treeview),
-1, "Categories",
gtk_cell_renderer_text_new(),
"text", 0, NULL);
cat_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (cat_treeview));
gtk_tree_selection_set_mode (cat_selection, GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT (cat_selection), "changed",
G_CALLBACK (cat_selection_changed_callback), app_treeview);
gtk_container_add (GTK_CONTAINER (scrolledwindow), cat_treeview);
cat_model = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING));
gtk_tree_view_set_model (GTK_TREE_VIEW(cat_treeview), cat_model);
tmp = cat_list;
while (tmp)
{
GenesisCategory *category = tmp->data;
tree_view_append_entry (cat_model, category->name);
tmp = tmp->next;
}
g_list_free(cat_list);
}
button = gtk_button_new_with_label ("Start");
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (start_button_clicked_callback), app_treeview);
gtk_box_pack_start (GTK_BOX(vbox), button, FALSE, FALSE, 0);
gtk_widget_show_all (window);
}
static void
gimp_container_popup_create_view (GimpContainerPopup *popup)
{
GimpEditor *editor;
GtkWidget *button;
popup->editor = g_object_new (GIMP_TYPE_CONTAINER_EDITOR,
"view-type", popup->view_type,
"container", popup->container,
"context", popup->context,
"view-size", popup->view_size,
"view-border-width", popup->view_border_width,
NULL);
gimp_container_view_set_reorderable (GIMP_CONTAINER_VIEW (popup->editor->view),
FALSE);
if (popup->view_type == GIMP_VIEW_TYPE_LIST)
{
GtkWidget *search_entry;
search_entry = gtk_entry_new ();
gtk_box_pack_end (GTK_BOX (popup->editor->view), search_entry,
FALSE, FALSE, 0);
gtk_tree_view_set_search_entry (GTK_TREE_VIEW (GIMP_CONTAINER_TREE_VIEW (GIMP_CONTAINER_VIEW (popup->editor->view))->view),
GTK_ENTRY (search_entry));
gtk_widget_show (search_entry);
}
gimp_container_box_set_size_request (GIMP_CONTAINER_BOX (popup->editor->view),
6 * (popup->default_view_size +
2 * popup->view_border_width),
10 * (popup->default_view_size +
2 * popup->view_border_width));
if (GIMP_IS_EDITOR (popup->editor->view))
gimp_editor_set_show_name (GIMP_EDITOR (popup->editor->view), FALSE);
gtk_container_add (GTK_CONTAINER (popup->frame), GTK_WIDGET (popup->editor));
gtk_widget_show (GTK_WIDGET (popup->editor));
editor = GIMP_EDITOR (popup->editor->view);
gimp_editor_add_button (editor, "zoom-out",
_("Smaller Previews"), NULL,
G_CALLBACK (gimp_container_popup_smaller_clicked),
NULL,
popup);
gimp_editor_add_button (editor, "zoom-in",
_("Larger Previews"), NULL,
G_CALLBACK (gimp_container_popup_larger_clicked),
NULL,
popup);
button = gimp_editor_add_icon_box (editor, GIMP_TYPE_VIEW_TYPE, "gimp",
G_CALLBACK (gimp_container_popup_view_type_toggled),
popup);
gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (button), popup->view_type);
if (popup->dialog_factory)
gimp_editor_add_button (editor, popup->dialog_icon_name,
popup->dialog_tooltip, NULL,
G_CALLBACK (gimp_container_popup_dialog_clicked),
NULL,
popup);
gtk_widget_grab_focus (GTK_WIDGET (popup->editor));
}
static void
start (void)
{
GtkWidget *button;
GtkWidget *vbox;
window = GTK_WINDOW (gtk_window_new (GTK_WINDOW_TOPLEVEL));
g_signal_connect (G_OBJECT (window), "delete_event",
G_CALLBACK (delete_event), NULL);
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (destroy), NULL);
g_signal_connect (G_OBJECT (window), "key-press-event",
G_CALLBACK (key_press), NULL);
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (vbox);
controls = gtk_hbox_new (FALSE, 0);
gtk_box_pack_end (GTK_BOX (vbox), controls, FALSE, FALSE, 2);
gtk_widget_show (controls);
{
GdkColor color;
gdk_color_parse ("black", &color);
video_output = gtk_drawing_area_new ();
gtk_widget_modify_bg (GTK_WIDGET (video_output), GTK_STATE_NORMAL, &color);
gtk_box_pack_start (GTK_BOX (vbox), video_output, TRUE, TRUE, 0);
gtk_widget_set_size_request (video_output, 0x200, 0x100);
gtk_widget_show (video_output);
}
{
button = gtk_button_new_with_label ("Pause");
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (pause_cb), NULL);
gtk_box_pack_start (GTK_BOX (controls), button, FALSE, FALSE, 2);
gtk_widget_show (button);
pause_button = button;
}
{
button = gtk_button_new_with_label ("Reset");
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (reset_cb), NULL);
gtk_box_pack_start (GTK_BOX (controls), button, FALSE, FALSE, 2);
gtk_widget_show (button);
}
{
GtkObject *adjustment;
adjustment = gtk_adjustment_new (0, 0, 101, 1, 5, 1);
scale = gtk_hscale_new (GTK_ADJUSTMENT (adjustment));
gtk_box_pack_end (GTK_BOX (controls), scale, TRUE, TRUE, 2);
g_signal_connect (G_OBJECT (scale), "change-value",
G_CALLBACK (seek_cb), NULL);
gtk_widget_show (scale);
}
gtk_widget_show (GTK_WIDGET (window));
{
DBusError error;
dbus_error_init (&error);
session = dbus_bus_get (DBUS_BUS_SESSION, &error);
if (!session)
g_warning ("%s: %s\n", error.name, error.message);
}
}
static void
gimp_histogram_editor_init (GimpHistogramEditor *editor)
{
GimpHistogramView *view;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *menu;
GtkWidget *table;
gint i;
const gchar *gimp_histogram_editor_labels[] =
{
N_("Mean:"),
N_("Std dev:"),
N_("Median:"),
N_("Pixels:"),
N_("Count:"),
N_("Percentile:")
};
editor->drawable = NULL;
editor->histogram = NULL;
editor->bg_histogram = NULL;
editor->valid = FALSE;
editor->idle_id = 0;
editor->box = gimp_histogram_box_new ();
gimp_editor_set_show_name (GIMP_EDITOR (editor), TRUE);
view = GIMP_HISTOGRAM_BOX (editor->box)->view;
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (editor), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Channel:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
editor->menu = menu = gimp_prop_enum_combo_box_new (G_OBJECT (view),
"histogram-channel",
0, 0);
gimp_enum_combo_box_set_stock_prefix (GIMP_ENUM_COMBO_BOX (menu),
"gimp-channel");
gimp_int_combo_box_set_sensitivity (GIMP_INT_COMBO_BOX (editor->menu),
gimp_histogram_menu_sensitivity,
editor, NULL);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (editor->menu),
view->channel);
gtk_box_pack_start (GTK_BOX (hbox), menu, FALSE, FALSE, 0);
gtk_widget_show (menu);
menu = gimp_prop_enum_stock_box_new (G_OBJECT (view),
"histogram-scale", "gimp-histogram",
0, 0);
gtk_box_pack_end (GTK_BOX (hbox), menu, FALSE, FALSE, 0);
gtk_widget_show (menu);
gtk_box_pack_start (GTK_BOX (editor), editor->box, TRUE, TRUE, 0);
gtk_widget_show (GTK_WIDGET (editor->box));
g_signal_connect_swapped (view, "range-changed",
G_CALLBACK (gimp_histogram_editor_info_update),
editor);
g_signal_connect_swapped (view, "notify::histogram-channel",
G_CALLBACK (gimp_histogram_editor_info_update),
editor);
g_signal_connect_swapped (view, "expose-event",
G_CALLBACK (gimp_histogram_view_expose),
editor);
table = gtk_table_new (3, 4, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 2);
gtk_table_set_col_spacing (GTK_TABLE (table), 1, 6);
gtk_box_pack_start (GTK_BOX (editor), table, FALSE, FALSE, 0);
gtk_widget_show (table);
for (i = 0; i < 6; i++)
{
gint x = (i / 3) * 2;
gint y = (i % 3);
label = gtk_label_new (gettext (gimp_histogram_editor_labels[i]));
gimp_label_set_attributes (GTK_LABEL (label),
PANGO_ATTR_WEIGHT, PANGO_WEIGHT_BOLD,
PANGO_ATTR_SCALE, PANGO_SCALE_SMALL,
-1);
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, x, x + 1, y, y + 1,
GTK_FILL | GTK_EXPAND, GTK_FILL, 2, 2);
gtk_widget_show (label);
editor->labels[i] =
label = g_object_new (GTK_TYPE_LABEL,
"xalign", 0.0,
"yalign", 0.5,
"width-chars", i > 2 ? 9 : 5,
NULL);
gimp_label_set_attributes (GTK_LABEL (editor->labels[i]),
PANGO_ATTR_SCALE, PANGO_SCALE_SMALL,
-1);
gtk_table_attach (GTK_TABLE (table), label, x + 1, x + 2, y, y + 1,
GTK_FILL, GTK_FILL, 2, 2);
gtk_widget_show (label);
}
}
static void
construct_widgets (GpaCardManager *cardman)
{
GtkWidget *vbox;
GtkWidget *hbox, *hbox1, *hbox2;
GtkWidget *label;
GtkWidget *icon;
gchar *markup;
GtkWidget *menubar;
GtkWidget *toolbar;
GtkWidget *statusbar;
/* Set a default size for the main window. */
gtk_window_set_default_size (GTK_WINDOW (cardman), 680, 480);
/* Realize the window so that we can create pixmaps without warnings. */
gtk_widget_realize (GTK_WIDGET (cardman));
/* Use a vbox to show the menu, toolbar and the file container. */
vbox = gtk_vbox_new (FALSE, 0);
/* Get the menu and the toolbar. */
cardman_action_new (cardman, &menubar, &toolbar);
gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, TRUE, 0);
/* Add a fancy label that tells us: This is the card manager. */
hbox1 = gtk_hbox_new (FALSE, 0);
icon = gtk_image_new_from_stock (GPA_STOCK_CARDMAN, GTK_ICON_SIZE_DND);
gtk_box_pack_start (GTK_BOX (hbox1), icon, FALSE, TRUE, 0);
label = gtk_label_new (NULL);
markup = g_strdup_printf ("<span font_desc=\"16\">%s</span>",
_("Card Manager"));
gtk_label_set_markup (GTK_LABEL (label), markup);
g_free (markup);
gtk_box_pack_start (GTK_BOX (hbox1), label, TRUE, TRUE, 10);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
/* Add a application selection box. */
hbox2 = gtk_hbox_new (FALSE, 0);
label = gtk_label_new (_("Application selection:"));
gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 5);
cardman->app_selector = gtk_combo_box_new_text ();
gtk_combo_box_append_text (GTK_COMBO_BOX (cardman->app_selector),
_("Auto"));
gtk_combo_box_set_active (GTK_COMBO_BOX (cardman->app_selector), 0);
gtk_box_pack_start (GTK_BOX (hbox2), cardman->app_selector, FALSE, TRUE, 0);
/* Put Card Manager label and application selector into the same line. */
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), hbox1, FALSE, FALSE, 0);
gtk_box_pack_end (GTK_BOX (hbox), hbox2, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 5);
/* Create a container (a scolled window) which will take the actual
card widget. This container is required so that we can easily
change to a differet card widget. */
cardman->card_container = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy
(GTK_SCROLLED_WINDOW (cardman->card_container),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), cardman->card_container, TRUE, TRUE, 0);
/* Update the container using the current card application. */
update_card_widget (cardman, NULL);
statusbar = statusbar_new (cardman);
gtk_box_pack_start (GTK_BOX (vbox), statusbar, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (cardman), vbox);
}
static void
GyahtzeeCreateMainWindow (GApplication *app, gpointer user_data)
{
GtkWidget *hbox, *vbox;
GtkWidget *toolbar;
GtkWidget *tmp;
GtkWidget *dicebox;
GtkWidget *undo_button;
GtkWidget *menu_button;
GtkWidget *icon;
GtkBuilder *builder;
GMenuModel *appmenu;
int i, j;
window = gtk_application_window_new (application);
gtk_window_set_application (GTK_WINDOW (window), application);
gtk_window_set_title (GTK_WINDOW (window), _(appName));
gtk_window_set_hide_titlebar_when_maximized (GTK_WINDOW (window), FALSE);
gtk_window_set_icon_name (GTK_WINDOW (window), "org.gnome.Tali");
//games_conf_add_window (GTK_WINDOW (window), NULL);
g_signal_connect (GTK_WIDGET (window), "key_press_event",
G_CALLBACK (key_press), NULL);
g_action_map_add_action_entries (G_ACTION_MAP (application), app_entries, G_N_ELEMENTS (app_entries), application);
const gchar *vaccels_help[] = {"F1", NULL};
const gchar *vaccels_new[] = {"<Primary>n", NULL};
const gchar *vaccels_roll[] = {"<Primary>r", NULL};
const gchar *vaccels_undo[] = {"<Primary>z", NULL};
gtk_application_set_accels_for_action (application, "app.help", vaccels_help);
gtk_application_set_accels_for_action (application, "app.new-game", vaccels_new);
gtk_application_set_accels_for_action (application, "app.roll", vaccels_roll);
gtk_application_set_accels_for_action (application, "app.undo", vaccels_undo);
scores_action = g_action_map_lookup_action (G_ACTION_MAP (application), "scores");
undo_action = g_action_map_lookup_action (G_ACTION_MAP (application), "undo");
update_undo_sensitivity ();
/*--- Headerbar ---*/
hbar = gtk_header_bar_new ();
gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (hbar), TRUE);
gtk_header_bar_set_title (GTK_HEADER_BAR (hbar), _(appName));
gtk_widget_show (hbar);
gtk_window_set_titlebar (GTK_WINDOW (window), hbar);
if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
undo_button = gtk_button_new_from_icon_name ("edit-undo-rtl-symbolic", GTK_ICON_SIZE_BUTTON);
else
undo_button = gtk_button_new_from_icon_name ("edit-undo-symbolic", GTK_ICON_SIZE_BUTTON);
gtk_widget_set_valign (undo_button, GTK_ALIGN_CENTER);
gtk_actionable_set_action_name (GTK_ACTIONABLE (undo_button), "app.undo");
gtk_widget_set_tooltip_text (undo_button, _("Undo your most recent move"));
gtk_widget_show (undo_button);
gtk_header_bar_pack_start (GTK_HEADER_BAR (hbar), undo_button);
builder = gtk_builder_new_from_resource ("/org/gnome/Tali/ui/menus.ui");
appmenu = (GMenuModel *) gtk_builder_get_object (builder, "app-menu");
menu_button = gtk_menu_button_new();
icon = gtk_image_new_from_icon_name ("open-menu-symbolic", GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON (menu_button), icon);
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (menu_button), appmenu);
gtk_widget_show (menu_button);
gtk_header_bar_pack_end (GTK_HEADER_BAR (hbar), menu_button);
/*---- Content ----*/
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
/* Retreive dice pixmaps from memory or files */
LoadDicePixmaps ();
/* Put all the dice in a vertical column */
dicebox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), dicebox, FALSE, TRUE, 0);
gtk_widget_show (dicebox);
rollLabel = gtk_label_new (NULL);
gtk_label_set_use_markup (GTK_LABEL (rollLabel), TRUE);
gtk_widget_show (rollLabel);
gtk_box_pack_start (GTK_BOX (dicebox), rollLabel, FALSE, TRUE, 5);
mbutton = gtk_button_new_with_label (_("Roll!"));
gtk_box_pack_end (GTK_BOX (dicebox), mbutton, FALSE, FALSE, 5);
g_signal_connect (GTK_BUTTON (mbutton), "clicked",
G_CALLBACK (roll_button_pressed_cb), NULL);
gtk_widget_show (GTK_WIDGET (mbutton));
toolbar = gtk_toolbar_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (toolbar),
GTK_ORIENTATION_VERTICAL);
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
gtk_toolbar_set_show_arrow (GTK_TOOLBAR (toolbar), FALSE);
gtk_box_pack_end (GTK_BOX (dicebox), toolbar, TRUE, TRUE, 0);
for (i = 0; i < NUMBER_OF_DICE; i++) {
tmp = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
for (j = 0; j < NUMBER_OF_PIXMAPS; j++) {
gtk_box_pack_start (GTK_BOX (tmp), dicePixmaps[i][j][GAME_YAHTZEE], FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (tmp), dicePixmaps[i][j][GAME_KISMET], FALSE, FALSE, 0);
}
diceBox[i] = gtk_toggle_tool_button_new ();
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (diceBox[i]), tmp);
g_signal_connect (GTK_TOOL_BUTTON (diceBox[i]), "clicked",
G_CALLBACK (modify_dice), &DiceValues[i]);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar),
GTK_TOOL_ITEM (diceBox[i]), -1);
gtk_widget_show (GTK_WIDGET (diceBox[i]));
gtk_widget_show (tmp);
/*gtk_widget_show (dicePixmaps[i][0][game_type]);*/
}
gtk_widget_show (toolbar);
/* Scores displayed in score list */
ScoreList = create_score_list ();
gtk_box_pack_end (GTK_BOX (hbox), ScoreList, TRUE, TRUE, 0);
setup_score_list (ScoreList);
gtk_widget_show (ScoreList);
gtk_widget_show (hbox);
gtk_widget_show (vbox);
}
GtkWidget* ctk_display_device_tv_new(NvCtrlAttributeHandle *handle,
CtkConfig *ctk_config,
CtkEvent *ctk_event,
char *name)
{
GObject *object;
CtkDisplayDeviceTv *ctk_display_device_tv;
GtkWidget *banner;
GtkWidget *frame;
GtkWidget *eventbox;
GtkWidget *tmpbox;
GtkWidget *hbox;
GtkWidget *alignment;
object = g_object_new(CTK_TYPE_DISPLAY_DEVICE_TV, NULL);
if (!object) return NULL;
ctk_display_device_tv = CTK_DISPLAY_DEVICE_TV(object);
ctk_display_device_tv->handle = handle;
ctk_display_device_tv->ctk_config = ctk_config;
ctk_display_device_tv->ctk_event = ctk_event;
ctk_display_device_tv->name = g_strdup(name);
gtk_box_set_spacing(GTK_BOX(object), 10);
/* banner */
banner = ctk_banner_image_new(BANNER_ARTWORK_TV);
gtk_box_pack_start(GTK_BOX(object), banner, FALSE, FALSE, 0);
/* Information */
frame = gtk_frame_new(NULL);
gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0);
ctk_display_device_tv->info_frame = frame;
hbox = gtk_hbox_new(FALSE, FRAME_PADDING);
gtk_container_set_border_width(GTK_CONTAINER(hbox), FRAME_PADDING);
gtk_container_add(GTK_CONTAINER(frame), hbox);
tmpbox = gtk_vbox_new(FALSE, 5);
gtk_container_add(GTK_CONTAINER(hbox), tmpbox);
ctk_display_device_tv->txt_encoder_name = gtk_label_new("");
ctk_display_device_tv->txt_refresh_rate = gtk_label_new("");
/* pack the Refresh Rate Label */
{
typedef struct {
GtkWidget *label;
GtkWidget *txt;
const gchar *tooltip;
} TextLineInfo;
TextLineInfo lines[] = {
{
gtk_label_new("TV Encoder:"),
ctk_display_device_tv->txt_encoder_name,
__tv_encoder_name_help,
},
{
gtk_label_new("TV Refresh Rate:"),
ctk_display_device_tv->txt_refresh_rate,
__tv_refresh_rate_help,
},
{ NULL, NULL, NULL }
};
int i;
GtkRequisition req;
int max_width;
/* Compute max width of lables and setup text alignments */
max_width = 0;
for (i = 0; lines[i].label; i++) {
gtk_misc_set_alignment(GTK_MISC(lines[i].label), 0.0f, 0.5f);
gtk_misc_set_alignment(GTK_MISC(lines[i].txt), 0.0f, 0.5f);
gtk_widget_size_request(lines[i].label, &req);
if (max_width < req.width) {
max_width = req.width;
}
}
/* Pack labels */
for (i = 0; lines[i].label; i++) {
GtkWidget *tmphbox;
/* Add separators */
if (i == 1) {
GtkWidget *separator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(tmpbox), separator,
FALSE, FALSE, 0);
}
/* Set the label's width */
gtk_widget_set_size_request(lines[i].label, max_width, -1);
/* add the widgets for this line */
tmphbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(tmphbox), lines[i].label,
FALSE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(tmphbox), lines[i].txt,
FALSE, TRUE, 5);
/* Include tooltips */
if (!lines[i].tooltip) {
gtk_box_pack_start(GTK_BOX(tmpbox), tmphbox, FALSE, FALSE, 0);
} else {
eventbox = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(eventbox), tmphbox);
ctk_config_set_tooltip(ctk_config, eventbox, lines[i].tooltip);
gtk_box_pack_start(GTK_BOX(tmpbox), eventbox, FALSE, FALSE, 0);
}
}
}
/* NV_CTRL_REFRESH_RATE */
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_REFRESH_RATE),
G_CALLBACK(info_update_received),
(gpointer) ctk_display_device_tv);
/* NV_CTRL_TV_OVERSCAN */
ctk_display_device_tv->overscan =
add_scale(ctk_display_device_tv, NV_CTRL_TV_OVERSCAN,
"TV OverScan", __tv_overscan_help);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_TV_OVERSCAN),
G_CALLBACK(value_received),
(gpointer) ctk_display_device_tv);
/* NV_CTRL_TV_FLICKER_FILTER */
ctk_display_device_tv->flicker_filter =
add_scale(ctk_display_device_tv, NV_CTRL_TV_FLICKER_FILTER,
"TV Flicker Filter", __tv_flicker_filter_help);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_TV_FLICKER_FILTER),
G_CALLBACK(value_received),
(gpointer) ctk_display_device_tv);
/* NV_CTRL_TV_BRIGHTNESS */
ctk_display_device_tv->brightness =
add_scale(ctk_display_device_tv, NV_CTRL_TV_BRIGHTNESS,
"TV Brightness", __tv_brightness_help);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_TV_BRIGHTNESS),
G_CALLBACK(value_received),
(gpointer) ctk_display_device_tv);
/* NV_CTRL_TV_HUE */
ctk_display_device_tv->hue =
add_scale(ctk_display_device_tv, NV_CTRL_TV_HUE,
"TV Hue", __tv_hue_help);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_TV_HUE),
G_CALLBACK(value_received),
(gpointer) ctk_display_device_tv);
/* NV_CTRL_TV_CONTRAST */
ctk_display_device_tv->contrast =
add_scale(ctk_display_device_tv, NV_CTRL_TV_CONTRAST,
"TV Contrast", __tv_contrast_help);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_TV_CONTRAST),
G_CALLBACK(value_received),
(gpointer) ctk_display_device_tv);
/* NV_CTRL_TV_SATURATION */
ctk_display_device_tv->saturation =
add_scale(ctk_display_device_tv, NV_CTRL_TV_SATURATION,
"TV Saturation", __tv_saturation_help);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_TV_SATURATION),
G_CALLBACK(value_received),
(gpointer) ctk_display_device_tv);
/* Create the reset button here so it can be used by the image sliders */
ctk_display_device_tv->reset_button =
gtk_button_new_with_label("Reset TV Hardware Defaults");
/* create and pack the image sliders */
ctk_display_device_tv->image_sliders =
ctk_image_sliders_new(handle, ctk_config, ctk_event,
ctk_display_device_tv->reset_button,
name);
if (ctk_display_device_tv->image_sliders) {
gtk_box_pack_start(GTK_BOX(object),
ctk_display_device_tv->image_sliders,
FALSE, FALSE, 0);
}
/* reset button */
g_signal_connect(G_OBJECT(ctk_display_device_tv->reset_button), "clicked",
G_CALLBACK(reset_button_clicked),
(gpointer) ctk_display_device_tv);
alignment = gtk_alignment_new(1, 1, 0, 0);
gtk_container_add(GTK_CONTAINER(alignment),
ctk_display_device_tv->reset_button);
gtk_box_pack_end(GTK_BOX(object), alignment, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_TV_RESET_SETTINGS),
G_CALLBACK(value_received),
(gpointer) ctk_display_device_tv);
ctk_config_set_tooltip(ctk_config, ctk_display_device_tv->reset_button,
ctk_help_create_reset_hardware_defaults_text("TV", name));
/* EDID button box */
ctk_display_device_tv->edid =
ctk_edid_new(ctk_display_device_tv->handle,
ctk_display_device_tv->ctk_config,
ctk_display_device_tv->ctk_event,
ctk_display_device_tv->name);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(object), hbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), ctk_display_device_tv->edid,
TRUE, TRUE, 0);
/* finally, display the widget */
gtk_widget_show_all(GTK_WIDGET(object));
/* update the GUI */
update_display_enabled_flag(ctk_display_device_tv->handle,
&ctk_display_device_tv->display_enabled);
ctk_display_device_tv_setup(ctk_display_device_tv);
/* handle enable/disable events on the display device */
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_ENABLED_DISPLAYS),
G_CALLBACK(enabled_displays_received),
(gpointer) ctk_display_device_tv);
return GTK_WIDGET(object);
} /* ctk_display_device_tv_new() */
static void
action_about (GtkAction *action, gpointer callback_data)
{
GtkamMain *m = GTKAM_MAIN (callback_data);
GtkWidget *d;
const gchar *comments =
N_("gtkam is a program that lets you download\n"
"images from many digital cameras. It uses\n"
"libgphoto2. More info is available at\n"
"http://www.gphoto.org.\n"
"\n"
"Enjoy the wonderful world of gphoto!");
#ifdef HAVE_GNOME
GtkWidget *w;
const gchar *authors[] = {
"Scott Fritzinger <*****@*****.**>",
"Lutz Mueller <*****@*****.**>",
_("Many others"), NULL
};
const gchar *documenters[] = {
"Michael J. Rensing <*****@*****.**>", NULL
};
const gchar *translator_credits =
"Keld Simonsen <*****@*****.**>\n"
"Marcus Meissner <*****@*****.**>\n"
"Fabian Mandelbaum <*****@*****.**>\n"
"Kjartan Maraas <*****@*****.**>\n"
"Andraz Tori <*****@*****.**>";
GdkPixbuf *p;
#else
gchar *buf;
#endif
gchar *gcomments = NULL;
int n;
for (n = 0; module_versions[n].name != NULL; n++) {
gchar *features;
const char **v = NULL;
char *name = module_versions[n].name;
GPVersionFunc func = module_versions[n].version_func;
CHECK_NULL (name);
CHECK_NULL (func);
v = func(GP_VERSION_SHORT);
CHECK_NULL (v);
CHECK_NULL (v[0]);
CHECK_NULL (v[1]);
/* FIXME: implicit conversion from char to gchar */
features = g_strjoinv(", ", &v[1]);
if (gcomments == NULL) {
gcomments = g_strdup_printf(_("%s\n\n%s %s with options:\n %s\n"),
_(comments), name, v[0], features);
} else {
gchar *old = gcomments;
gcomments = g_strdup_printf(_("%s\n%s %s with options:\n %s\n"),
gcomments, name, v[0], features);
free(old);
}
free(features);
}
#ifdef HAVE_GNOME
p = gdk_pixbuf_new_from_file (IMAGE_DIR "/gtkam-camera.png", NULL);
d = gnome_about_new (PACKAGE, VERSION, "GPL", gcomments, authors,
documenters, translator_credits, p);
g_object_unref (G_OBJECT (p));
w = gnome_href_new ("http://www.gphoto.org", "http://www.gphoto.org");
gtk_widget_show (w);
gtk_box_pack_end (GTK_BOX (GTK_DIALOG (d)->vbox), w, FALSE, FALSE, 0);
#else
buf = g_strdup_printf ("%s-%s\n\n%s", PACKAGE, VERSION, gcomments);
d = gtkam_close_new (buf);
g_free (buf);
#endif
gtk_window_set_transient_for (GTK_WINDOW (d), GTK_WINDOW (m));
gtk_widget_show (d);
/* FIXME free(gcomments); */
}
int l_zkartmat1(const char *skl,const char *n_kart,GtkWidget *wpredok)
{
zkartmat_data data;
char strsql[512];
char bros[512];
GdkColor color;
SQL_str row;
SQLCURSOR cur;
iceb_u_str soob;
short ddd,mmm,ggg;
iceb_u_poltekdat(&ddd,&mmm,&ggg);
//Чтаем наименование склада
sprintf(strsql,"select naik from Sklad where kod=%s",skl);
if(iceb_sql_readkey(strsql,&row,&cur,wpredok) != 1)
{
iceb_u_str repl;
repl.plus(gettext("Не найден код склада"));
repl.plus(" ");
repl.plus(skl);
repl.plus(" !");
iceb_menu_soob(&repl,wpredok);
data.rk.naimskl.new_plus("");
}
else
data.rk.naimskl.new_plus(row[0]);
//читаем реквизиты карточки
sprintf(strsql,"select * from Kart where sklad=%s and nomk=%s",skl,n_kart);
if(iceb_sql_readkey(strsql,&row,&cur,wpredok) != 1)
{
iceb_u_str repl;
repl.plus(gettext("Не найдена карточка"));
repl.plus(" ");
repl.plus(n_kart);
repl.ps_plus(gettext("Склад"));
repl.plus(skl);
iceb_menu_soob(&repl,wpredok);
return(1);
}
data.rk.kodm.plus(row[2]);
data.rk.skl.plus(skl);
data.rk.n_kart.plus(n_kart);
data.rk.shet.plus(row[5]);
data.rk.cena.plus(row[6]);
data.rk.ei.plus(row[4]);
data.rk.nds.plus(row[9]);
data.rk.krat.plus(row[8]);
data.rk.cenapr.plus(row[7]);
data.rk.innom.plus(row[15]);
data.rk.rnd.plus(row[16]);
data.rk.nomzak.plus(row[17]);
data.rk.mnds.plus(row[3]);
data.rk.fas.plus(row[10]);
data.rk.kodtar.plus(row[11]);
short d,m,g;
if(iceb_u_rsdat(&d,&m,&g,row[14],2) == 0)
{
sprintf(strsql,"%d.%d.%d",d,m,g);
data.rk.datv.plus(strsql);
}
else
data.rk.datv.plus("");
data.rk.data_kon_is.plus_sqldata(row[18]);
data.dn=1;
data.mn=1;
data.gn=startgod;
if(startgod == 0)
data.gn=ggg;
data.dk=ddd;
data.mk=mmm;
data.gk=ggg;
sprintf(strsql,"%d.%d.%d",data.dn,data.mn,data.gn);
data.poi.datan.new_plus(strsql);
sprintf(strsql,"%d.%d.%d",data.dk,data.mk,data.gk);
data.poi.datak.new_plus(strsql);
//Читаем наименование материалла
sprintf(strsql,"select kodgr,naimat from Material where kodm=%s",data.rk.kodm.ravno());
if(iceb_sql_readkey(strsql,&row,&cur,wpredok) == 1)
{
data.rk.kodgr.plus(row[0]);
data.rk.naimat.plus(row[1]);
}
else
{
data.rk.kodgr.plus("");
data.rk.naimat.plus("");
}
//читаем наименование группы
sprintf(strsql,"select naik from Grup where kod=%s",data.rk.kodgr.ravno());
if(iceb_sql_readkey(strsql,&row,&cur,wpredok) == 1)
data.rk.naimgr.plus(row[0]);
else
data.rk.naimgr.plus("");
data.window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(data.window),TRUE);
//gtk_window_set_default_size (GTK_WINDOW (data.window),400,-1);
//gdk_color_parse("black",&color);
//gtk_widget_modify_bg(data.window,GTK_STATE_NORMAL,&color);
sprintf(bros,"%s %s",name_system,gettext("Просмотр карточки"));
gtk_window_set_title (GTK_WINDOW (data.window),bros);
gtk_container_set_border_width (GTK_CONTAINER (data.window), 5);
gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
if(wpredok != NULL)
{
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
//Удерживать окно над породившем его окном всегда
gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok));
//Закрыть окно если окно предок удалено
gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE);
}
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(zkartmat_key_press),&data);
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_release_event",GTK_SIGNAL_FUNC(iceb_key_release),&data.kl_shift);
GtkWidget *hbox = gtk_hbox_new (FALSE, 1);
gtk_container_add (GTK_CONTAINER (data.window), hbox);
GtkWidget *vbox1 = gtk_vbox_new (FALSE, 1);
GtkWidget *vbox2 = gtk_vbox_new (FALSE, 1);
gtk_box_pack_start (GTK_BOX (hbox), vbox1, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
gtk_widget_show(hbox);
soob.new_plus(gettext("Просмотр карточки"));
soob.ps_plus(data.rk.kodm.ravno());
soob.plus(" ");
soob.plus(data.rk.naimat.ravno());
data.label_kolstr=gtk_label_new (soob.ravno_toutf());
gtk_box_pack_start (GTK_BOX (vbox2),data.label_kolstr,FALSE, FALSE, 0);
gtk_widget_show(vbox1);
gtk_widget_show(vbox2);
data.label_poisk=gtk_label_new ("");
data.label_ost=gtk_label_new ("");
PangoFontDescription *font_pango=pango_font_description_from_string(shrift_ravnohir.ravno());
gtk_widget_modify_font(GTK_WIDGET(data.label_ost),font_pango);
pango_font_description_free(font_pango);
gdk_color_parse("red",&color);
gtk_widget_modify_fg(data.label_poisk,GTK_STATE_NORMAL,&color);
gtk_box_pack_start (GTK_BOX (vbox2),data.label_ost,FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox2),data.label_poisk,FALSE, FALSE, 0);
data.sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_usize(GTK_WIDGET(data.sw),-1,200);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (data.sw),GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (data.sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
//gtk_box_pack_start (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0);
//Кнопки
GtkTooltips *tooltips[KOL_F_KL];
sprintf(bros,"F2 %s",gettext("Корректировать"));
data.knopka[FK2]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK2],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]), "clicked",GTK_SIGNAL_FUNC(zkartmat_knopka),&data);
tooltips[FK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Корректировка реквизитов карточки материалла"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2);
gtk_widget_show(data.knopka[FK2]);
sprintf(bros,"F3 %s",gettext("Удалить"));
data.knopka[FK3]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK3],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK3]), "clicked",GTK_SIGNAL_FUNC(zkartmat_knopka),&data);
tooltips[FK3]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK3],data.knopka[FK3],gettext("Удаление выбранной записи"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK3]),(gpointer)FK3);
gtk_widget_show(data.knopka[FK3]);
sprintf(bros,"F4 %s",gettext("Поиск"));
data.knopka[FK4]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK4],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]), "clicked",GTK_SIGNAL_FUNC(zkartmat_knopka),&data);
tooltips[FK4]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Поиск нужных записей"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4);
gtk_widget_show(data.knopka[FK4]);
sprintf(bros,"F5 %s",gettext("Печать"));
data.knopka[FK5]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK5],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK5]), "clicked",GTK_SIGNAL_FUNC(zkartmat_knopka),&data);
tooltips[FK5]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK5],data.knopka[FK5],gettext("Распечатка записей"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK5]),(gpointer)FK5);
gtk_widget_show(data.knopka[FK5]);
sprintf(bros,"F6 %s",gettext("Смена даты"));
data.knopka[FK6]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK6],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK6]), "clicked",GTK_SIGNAL_FUNC(zkartmat_knopka),&data);
tooltips[FK6]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK6],data.knopka[FK6],gettext("Включение/выключение просмотра записей за текущий месяц"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK6]),(gpointer)FK6);
gtk_widget_show(data.knopka[FK6]);
sprintf(bros,"F7 %s",gettext("Остаток"));
data.knopka[FK7]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK7],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK7]), "clicked",GTK_SIGNAL_FUNC(zkartmat_knopka),&data);
tooltips[FK7]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK7],data.knopka[FK7],gettext("Показать остатки по карточке или по записям в документах"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK7]),(gpointer)FK7);
gtk_widget_show(data.knopka[FK7]);
sprintf(bros,"F8 %s",gettext("Слияние"));
data.knopka[FK8]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK8],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK8]), "clicked",GTK_SIGNAL_FUNC(zkartmat_knopka),&data);
tooltips[FK8]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK8],data.knopka[FK8],gettext("Слияние записей из нужной карточки в текущюю с удалением первой"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK8]),(gpointer)FK8);
gtk_widget_show(data.knopka[FK8]);
sprintf(bros,"F10 %s",gettext("Выход"));
data.knopka[FK10]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1),data.knopka[FK10],TRUE,TRUE, 0);
tooltips[FK10]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]), "clicked",GTK_SIGNAL_FUNC(zkartmat_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10);
gtk_widget_show(data.knopka[FK10]);
gtk_widget_realize(data.window);
gdk_window_set_cursor(data.window->window,gdk_cursor_new(ICEB_CURSOR));
gtk_widget_grab_focus(data.knopka[FK10]);
zkartmat_create_list(&data);
//gtk_window_maximize(GTK_WINDOW(data.window));
//gtk_window_fullscreen(GTK_WINDOW(data.window));
gtk_widget_show(data.window);
gtk_main();
printf("l_zkartmat end\n");
if(wpredok != NULL)
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));
return(data.metka_voz);
}
static GtkWidget*
create_prefs_dialog(GtkWidget* parent, GConfClient* client)
{
GConfChangeSet* cs;
GtkWidget* dialog;
GtkWidget* bbox;
GtkWidget* apply;
GtkWidget* revert;
GtkWidget* ok;
GtkWidget* cancel;
GtkWidget* vbox_outer;
GtkWidget* vbox_inner;
GtkWidget* entry;
dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL);
apply = gtk_button_new_with_label("Apply");
revert = gtk_button_new_with_label("Revert");
ok = gtk_button_new_with_label("OK");
cancel = gtk_button_new_with_label("Cancel");
g_object_set_data(dialog, "apply", apply);
g_object_set_data(dialog, "revert", revert);
g_object_set_data(dialog, "ok", ok);
g_object_set_data(dialog, "cancel", cancel);
bbox = gtk_hbutton_box_new();
vbox_outer = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
vbox_inner = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
gtk_container_add(GTK_CONTAINER(dialog), vbox_outer);
gtk_box_pack_start(GTK_BOX(vbox_outer), vbox_inner, TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(vbox_outer), bbox, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(bbox), apply);
gtk_container_add(GTK_CONTAINER(bbox), revert);
gtk_container_add(GTK_CONTAINER(bbox), ok);
gtk_container_add(GTK_CONTAINER(bbox), cancel);
cs = gconf_change_set_new();
g_object_set_data(dialog, "changeset", cs);
g_object_set_data(dialog, "client", client);
/* Grab a reference */
g_object_ref(G_OBJECT(client));
g_signal_connect(dialog, "destroy",
G_CALLBACK(prefs_dialog_destroy_callback),
NULL);
prefs_dialog_update_sensitivity(dialog);
g_signal_connect(apply, "clicked",
G_CALLBACK(apply_button_callback),
dialog);
g_signal_connect(revert, "clicked",
G_CALLBACK(revert_button_callback),
dialog);
g_signal_connect(ok, "clicked",
G_CALLBACK(ok_button_callback),
dialog);
g_signal_connect(cancel, "clicked",
G_CALLBACK(cancel_button_callback),
dialog);
gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(parent));
entry = create_config_entry(dialog, client, "/apps/basic-gconf-app/foo");
gtk_box_pack_start(GTK_BOX(vbox_inner), entry,
FALSE, FALSE, 0);
entry = create_config_entry(dialog, client, "/apps/basic-gconf-app/bar");
gtk_box_pack_start(GTK_BOX(vbox_inner), entry,
FALSE, FALSE, 0);
entry = create_config_entry(dialog, client, "/apps/basic-gconf-app/baz");
gtk_box_pack_start(GTK_BOX(vbox_inner), entry,
FALSE, FALSE, 0);
entry = create_config_entry(dialog, client, "/apps/basic-gconf-app/blah");
gtk_box_pack_start(GTK_BOX(vbox_inner), entry,
FALSE, FALSE, 0);
return dialog;
}
MetaTabPopup*
meta_ui_tab_popup_new (const MetaTabEntry *entries,
int screen_number,
int entry_count,
int width,
gboolean outline)
{
MetaTabPopup *popup;
int i, left, right, top, bottom;
int height;
GtkWidget *table;
GtkWidget *vbox;
GtkWidget *align;
GList *tmp;
GtkWidget *frame;
int max_label_width; /* the actual max width of the labels we create */
AtkObject *obj;
GdkScreen *screen;
int screen_width;
popup = g_new (MetaTabPopup, 1);
popup->outline_window = gtk_window_new (GTK_WINDOW_POPUP);
screen = gdk_display_get_screen (gdk_display_get_default (),
screen_number);
gtk_window_set_screen (GTK_WINDOW (popup->outline_window),
screen);
gtk_widget_set_app_paintable (popup->outline_window, TRUE);
gtk_widget_realize (popup->outline_window);
g_signal_connect (G_OBJECT (popup->outline_window), "draw",
G_CALLBACK (outline_window_draw), popup);
popup->window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_window_set_screen (GTK_WINDOW (popup->window),
screen);
gtk_window_set_position (GTK_WINDOW (popup->window),
GTK_WIN_POS_CENTER_ALWAYS);
/* enable resizing, to get never-shrink behavior */
gtk_window_set_resizable (GTK_WINDOW (popup->window),
TRUE);
popup->current = NULL;
popup->entries = NULL;
popup->current_selected_entry = NULL;
popup->outline = outline;
screen_width = gdk_screen_get_width (screen);
for (i = 0; i < entry_count; ++i)
{
TabEntry* new_entry = tab_entry_new (&entries[i], screen_width, outline);
popup->entries = g_list_prepend (popup->entries, new_entry);
}
popup->entries = g_list_reverse (popup->entries);
g_assert (width > 0);
height = i / width;
if (i % width)
height += 1;
table = gtk_table_new (height, width, FALSE);
vbox = gtk_vbox_new (FALSE, 0);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT);
gtk_container_set_border_width (GTK_CONTAINER (table), 1);
gtk_container_add (GTK_CONTAINER (popup->window),
frame);
gtk_container_add (GTK_CONTAINER (frame),
vbox);
align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
gtk_box_pack_start (GTK_BOX (vbox), align, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (align),
table);
popup->label = gtk_label_new ("");
/* Set the accessible role of the label to a status bar so it
* will emit name changed events that can be used by screen
* readers.
*/
obj = gtk_widget_get_accessible (popup->label);
atk_object_set_role (obj, ATK_ROLE_STATUSBAR);
gtk_misc_set_padding (GTK_MISC (popup->label), 3, 3);
gtk_box_pack_end (GTK_BOX (vbox), popup->label, FALSE, FALSE, 0);
max_label_width = 0;
top = 0;
bottom = 1;
tmp = popup->entries;
while (tmp && top < height)
{
left = 0;
right = 1;
while (tmp && left < width)
{
GtkWidget *image;
GtkRequisition req;
TabEntry *te;
te = tmp->data;
if (te->blank)
{
/* just stick a widget here to avoid special cases */
image = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
}
else if (outline)
{
if (te->dimmed_icon)
{
image = selectable_image_new (te->dimmed_icon);
}
else
{
image = selectable_image_new (te->icon);
}
gtk_misc_set_padding (GTK_MISC (image),
INSIDE_SELECT_RECT + OUTSIDE_SELECT_RECT + 1,
INSIDE_SELECT_RECT + OUTSIDE_SELECT_RECT + 1);
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.5);
}
else
{
image = selectable_workspace_new ((MetaWorkspace *) te->key);
}
te->widget = image;
gtk_table_attach (GTK_TABLE (table),
te->widget,
left, right, top, bottom,
0, 0,
0, 0);
/* Efficiency rules! */
gtk_label_set_markup (GTK_LABEL (popup->label),
te->title);
gtk_widget_size_request (popup->label, &req);
max_label_width = MAX (max_label_width, req.width);
tmp = tmp->next;
++left;
++right;
}
++top;
++bottom;
}
/* remove all the temporary text */
gtk_label_set_text (GTK_LABEL (popup->label), "");
/* Make it so that we ellipsize if the text is too long */
gtk_label_set_ellipsize (GTK_LABEL (popup->label), PANGO_ELLIPSIZE_END);
/* Limit the window size to no bigger than screen_width/4 */
if (max_label_width>(screen_width/4))
{
max_label_width = screen_width/4;
}
max_label_width += 20; /* add random padding */
gtk_window_set_default_size (GTK_WINDOW (popup->window),
max_label_width,
-1);
return popup;
}
GtkWidget *create_main_win(void)
{
GtkWidget *win_main;
GtkWidget *main_box;
GtkWidget *menubar;
GtkWidget *black_label;
GtkWidget *black_label_frame;
GtkWidget *white_label;
GtkWidget *white_label_frame;
GtkWidget *label_box;
GtkWidget *again_button;
GtkWidget *drawingarea;
GtkWidget *statusbar;
GtkAccelGroup *accel_group;
accel_group = gtk_accel_group_new();
win_main = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_object_set_data(G_OBJECT(win_main), "main_win", win_main);
gtk_window_set_title(GTK_WINDOW(win_main), _("Reversi"));
main_box = gtk_vbox_new(FALSE, 0);
gtk_widget_ref(main_box);
g_object_set_data_full(G_OBJECT(win_main), "main_box", main_box,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(main_box);
gtk_container_add(GTK_CONTAINER(win_main), main_box);
menubar = create_menus(win_main);
gtk_widget_ref(menubar);
g_object_set_data_full(G_OBJECT(win_main), "menubar", menubar,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(menubar);
gtk_box_pack_start(GTK_BOX(main_box), menubar, FALSE, FALSE, 0);
// Create labels frames
white_label_frame = gtk_frame_new(NULL);
gtk_widget_ref(white_label_frame);
g_object_set_data_full(G_OBJECT(win_main), "white_label_frame",
white_label_frame,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(white_label_frame);
black_label_frame = gtk_frame_new(NULL);
gtk_widget_ref(black_label_frame);
g_object_set_data_full(G_OBJECT(win_main), "black_label_frame",
black_label_frame,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(black_label_frame);
// Create labels
white_label = gtk_label_new("White: 0");
// Why is that? Really don't know, but all the other scripts have it!
gtk_widget_ref(white_label);
g_object_set_data_full(G_OBJECT(win_main), "white_label",
white_label,
(GtkDestroyNotify) gtk_widget_unref);
black_label = gtk_label_new("Black: 0");
gtk_widget_ref(black_label);
g_object_set_data_full(G_OBJECT(win_main), "black_label",
black_label,
(GtkDestroyNotify) gtk_widget_unref);
gtk_container_add(GTK_CONTAINER(white_label_frame), white_label);
gtk_container_add(GTK_CONTAINER(black_label_frame), black_label);
gtk_widget_show(white_label);
gtk_widget_show(black_label);
// Play again button
again_button = gtk_button_new_with_label("Play again");
gtk_widget_ref(again_button);
g_object_set_data_full(G_OBJECT(win_main), "again_button",
again_button,
(GtkDestroyNotify) gtk_widget_unref);
//gtk_container_add(GTK_CONTAINER(win_main), again_button);
// Label box
label_box = gtk_hbox_new(TRUE, 5);
gtk_widget_ref(label_box);
g_object_set_data_full(G_OBJECT(win_main), "label_box", label_box,
(GtkDestroyNotify) gtk_widget_unref);
gtk_box_pack_start(GTK_BOX(label_box), black_label_frame, FALSE,
TRUE, 0);
gtk_box_pack_start(GTK_BOX(label_box), again_button, TRUE, TRUE,
0);
gtk_box_pack_end(GTK_BOX(label_box), white_label_frame, FALSE,
TRUE, 0);
gtk_widget_show(label_box);
gtk_box_pack_start(GTK_BOX(main_box), label_box, FALSE, TRUE, 0);
// Drawing area
drawingarea = gtk_drawing_area_new();
gtk_widget_ref(drawingarea);
g_object_set_data_full(G_OBJECT(win_main), "drawingarea",
drawingarea,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(drawingarea);
gtk_box_pack_start(GTK_BOX(main_box), drawingarea, TRUE, TRUE, 0);
gtk_widget_set_size_request(drawingarea, 48 * 8, 48 * 8);
gtk_widget_set_events(drawingarea,
GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK);
// Status bar
statusbar = gtk_statusbar_new();
gtk_widget_ref(statusbar);
g_object_set_data_full(G_OBJECT(win_main), "statusbar", statusbar,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show(statusbar);
gtk_box_pack_start(GTK_BOX(main_box), statusbar, FALSE, FALSE, 0);
g_signal_connect(GTK_OBJECT(win_main), "delete_event",
GTK_SIGNAL_FUNC(main_exit), NULL);
g_signal_connect(GTK_OBJECT(win_main), "realize",
GTK_SIGNAL_FUNC(on_main_win_realize), NULL);
g_signal_connect(GTK_OBJECT(drawingarea), "configure_event",
GTK_SIGNAL_FUNC(configure_handle), NULL);
g_signal_connect(GTK_OBJECT(drawingarea), "expose_event",
GTK_SIGNAL_FUNC(expose_handle), NULL);
g_signal_connect(GTK_OBJECT(drawingarea), "button_press_event",
GTK_SIGNAL_FUNC(handle_move), NULL);
g_signal_connect(GTK_OBJECT(again_button), "clicked",
GTK_SIGNAL_FUNC(play_again), NULL);
gtk_window_add_accel_group(GTK_WINDOW(win_main), accel_group);
return win_main;
}
static void
add_provider_to_list (GisGoaPage *page, const char *provider_type)
{
GisGoaPagePrivate *priv = gis_goa_page_get_instance_private (page);
GtkWidget *row;
GtkWidget *box;
GtkWidget *image;
GtkWidget *label;
GtkWidget *checkmark;
GtkWidget *account_label;
GIcon *icon;
gchar *markup, *provider_name;
GoaProvider *provider;
ProviderWidget *provider_widget;
provider = goa_provider_get_for_provider_type (provider_type);
if (provider == NULL)
return;
row = gtk_list_box_row_new ();
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
g_object_set (box, "margin", 4, NULL);
gtk_widget_set_hexpand (box, TRUE);
icon = goa_provider_get_provider_icon (provider, NULL);
image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG);
g_object_unref (icon);
provider_name = goa_provider_get_provider_name (provider, NULL);
markup = g_strdup_printf ("<b>%s</b>", provider_name);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), markup);
g_free (markup);
g_free (provider_name);
checkmark = gtk_image_new_from_icon_name ("object-select-symbolic", GTK_ICON_SIZE_MENU);
account_label = gtk_label_new (NULL);
gtk_box_pack_start (GTK_BOX (box), image, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
gtk_box_pack_end (GTK_BOX (box), checkmark, FALSE, FALSE, 8);
gtk_box_pack_end (GTK_BOX (box), account_label, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (row), box);
gtk_widget_show (label);
gtk_widget_show (image);
gtk_widget_show (box);
gtk_widget_show (row);
provider_widget = g_new0 (ProviderWidget, 1);
provider_widget->page = page;
provider_widget->provider = provider;
provider_widget->row = row;
provider_widget->checkmark = checkmark;
provider_widget->account_label = account_label;
g_object_set_data_full (G_OBJECT (row), "widget", provider_widget, g_free);
g_hash_table_insert (priv->providers, (char *) provider_type, provider_widget);
gtk_container_add (GTK_CONTAINER (priv->accounts_list), row);
}
int main(int argc, char **argv)
{
int i;
GtkWidget *win;
GtkWidget *divelist;
GtkWidget *table;
GtkWidget *notebook;
GtkWidget *frame;
GtkWidget *menubar;
GtkWidget *vbox;
parse_xml_init();
gtk_init(&argc, &argv);
for (i = 1; i < argc; i++) {
const char *a = argv[i];
if (a[0] == '-') {
parse_argument(a);
continue;
}
parse_xml_file(a);
}
report_dives();
win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(G_OBJECT(win), "destroy", G_CALLBACK(on_destroy), NULL);
main_window = win;
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(win), vbox);
menubar = get_menubar_menu(win);
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
/* Table for the list of dives, cairo window, and dive info */
table = gtk_table_new(2, 2, FALSE);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
gtk_box_pack_end(GTK_BOX(vbox), table, TRUE, TRUE, 0);
gtk_widget_show(table);
/* Create the atual divelist */
divelist = create_dive_list();
gtk_table_attach(GTK_TABLE(table), divelist, 0, 1, 0, 2,
0, GTK_FILL | GTK_SHRINK | GTK_EXPAND, 0, 0);
/* Frame for minimal dive info */
frame = dive_info_frame();
gtk_table_attach(GTK_TABLE(table), frame, 1, 2, 0, 1,
GTK_FILL | GTK_SHRINK | GTK_EXPAND, 0, 0, 0);
/* Notebook for dive info vs profile vs .. */
notebook = gtk_notebook_new();
gtk_table_attach_defaults(GTK_TABLE(table), notebook, 1, 2, 1, 2);
/* Frame for dive profile */
frame = dive_profile_frame();
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), frame, gtk_label_new("Dive Profile"));
dive_profile = frame;
/* Frame for extended dive info */
frame = extended_dive_info_frame();
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), frame, gtk_label_new("Extended dive Info"));
gtk_widget_set_app_paintable(win, TRUE);
gtk_widget_show_all(win);
gtk_main();
return 0;
}
static void
cw_window_init (CWWindow *cw_window)
{
CWWindowPrivate *priv = CW_WINDOW_GET_PRIVATE(cw_window);
cw_window_screen_changed(GTK_WIDGET(cw_window), NULL, NULL);
//gtk_window_set_type_hint(GTK_WINDOW(cw_window),
//GDK_WINDOW_TYPE_HINT_DOCK);
gtk_window_set_decorated(GTK_WINDOW(cw_window), FALSE);
//gtk_window_set_resizable(GTK_WINDOW(cw_window), FALSE);
//gtk_window_set_position(GTK_WINDOW(cw_window), GTK_WIN_POS_CENTER_ALWAYS);
//gtk_window_set_skip_taskbar_hint(GTK_WINDOW(cw_window), FALSE);
//gtk_window_set_skip_pager_hint(GTK_WINDOW(cw_window), FALSE);
//gtk_window_set_default_size(GTK_WINDOW(cw_window), 800, 480);
cw_window_set_pos_size(GTK_WIDGET(cw_window), priv);
//gtk_window_maximize(GTK_WINDOW(cw_window));
gtk_widget_add_events(GTK_WIDGET(cw_window),
GDK_POINTER_MOTION_MASK
| GDK_KEY_RELEASE_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK);
priv->picture_window = cw_picture_window_new();
//priv->picture_alignment = gtk_alignment_new(0.5, 0.5, 1, 1);
//gtk_alignment_set_padding(
//GTK_ALIGNMENT(priv->picture_alignment),
//0, 0, 0, 0);
//gtk_container_add(
//GTK_CONTAINER(priv->picture_alignment),
//priv->picture_window);
priv->thumbnails_window = cw_thumbnails_window_new();
priv->thumbnails_alignment = gtk_alignment_new(0.5, 0.5, 1, 1);
gtk_alignment_set_padding(
GTK_ALIGNMENT(priv->thumbnails_alignment),
THUMBNAIL_WINDOW_SIDE_SIZE,
THUMBNAIL_WINDOW_SIDE_SIZE,
THUMBNAIL_WINDOW_SIDE_SIZE,
THUMBNAIL_WINDOW_SIDE_SIZE);
gtk_container_add(
GTK_CONTAINER(priv->thumbnails_alignment),
priv->thumbnails_window);
priv->main_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_end(
GTK_BOX(priv->main_box),
priv->thumbnails_alignment,
TRUE,
TRUE,
0);
gtk_box_pack_end(
GTK_BOX(priv->main_box),
priv->picture_window,
TRUE,
TRUE,
0);
gtk_container_add(
GTK_CONTAINER(cw_window),
priv->main_box);
GdkRGBA rgba = { 1, 1, 1, 0.0};
gtk_widget_override_background_color(GTK_WIDGET(cw_window),
GTK_STATE_FLAG_NORMAL, &rgba);
gtk_widget_override_background_color(GTK_WIDGET(priv->main_box),
GTK_STATE_FLAG_NORMAL, &rgba);
gtk_widget_show_all(GTK_WIDGET (priv->thumbnails_alignment));
gtk_widget_show(GTK_WIDGET (priv->main_box));
gtk_widget_show(GTK_WIDGET (cw_window));
cw_window_set_child_window(GTK_WIDGET(cw_window), priv);
gtk_widget_shape_combine_region(GTK_WIDGET(cw_window), NULL);
g_signal_connect(
priv->picture_window,
"picture-switch",
G_CALLBACK(cw_thumbnails_window_on_picture_switch),
priv->thumbnails_window);
g_signal_connect(
priv->thumbnails_window,
"active_large_image",
G_CALLBACK(cw_window_active_large_image),
cw_window);
/* TODO: Add initialization code here */
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_splittoning_gui_data_t));
dt_iop_splittoning_gui_data_t *g = (dt_iop_splittoning_gui_data_t *)self->gui_data;
dt_iop_splittoning_params_t *p = (dt_iop_splittoning_params_t *)self->params;
self->widget = GTK_WIDGET(gtk_vbox_new(FALSE, 0));
// Shadows
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(dtgtk_label_new(_("shadows"),DARKTABLE_LABEL_TAB|DARKTABLE_LABEL_ALIGN_RIGHT)), FALSE, FALSE, 5);
g->colorpick1 = DTGTK_BUTTON(dtgtk_button_new(dtgtk_cairo_paint_color,CPF_IGNORE_FG_STATE|CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER));
gtk_widget_set_size_request(GTK_WIDGET(g->colorpick1),32,32);
GtkWidget *hbox=GTK_WIDGET(gtk_hbox_new(FALSE, 0));
g->vbox1 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
g->vbox2 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->vbox1), FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->vbox2), TRUE, TRUE, 5);
gtk_box_pack_end(GTK_BOX(hbox),GTK_WIDGET(g->colorpick1),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 5);
g->label1 = dtgtk_reset_label_new (_("hue"), self, &p->shadow_hue, sizeof(float));
g->label2 = dtgtk_reset_label_new (_("saturation"), self, &p->shadow_saturation, sizeof(float));
gtk_box_pack_start(GTK_BOX(g->vbox1), GTK_WIDGET(g->label1), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox1), GTK_WIDGET(g->label2), TRUE, TRUE, 0);
int lightness=32768;
g->gslider1=DTGTK_GRADIENT_SLIDER(dtgtk_gradient_slider_new_with_color((GdkColor)
{
0,lightness,0,0
},(GdkColor)
{
0,lightness,0,0
}));
dtgtk_gradient_slider_set_stop(g->gslider1,0.166,(GdkColor)
{
0,lightness,lightness,0
});
dtgtk_gradient_slider_set_stop(g->gslider1,0.332,(GdkColor)
{
0,0,lightness,0
});
dtgtk_gradient_slider_set_stop(g->gslider1,0.498,(GdkColor)
{
0,0,lightness,lightness
});
dtgtk_gradient_slider_set_stop(g->gslider1,0.664,(GdkColor)
{
0,0,0,lightness
});
dtgtk_gradient_slider_set_stop(g->gslider1,0.83,(GdkColor)
{
0,lightness,0,lightness
});
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->gslider1), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->gslider1), "tooltip-text", _("select the hue tone for shadows"), (char *)NULL);
g->gslider2=DTGTK_GRADIENT_SLIDER(dtgtk_gradient_slider_new_with_color((GdkColor)
{
0,lightness,lightness,lightness
},(GdkColor)
{
0,lightness,lightness,lightness
}));
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->gslider2), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->gslider2), "tooltip-text", _("select the saturation shadow tone"), (char *)NULL);
// Highlights
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(dtgtk_label_new(_("highlights"),DARKTABLE_LABEL_TAB|DARKTABLE_LABEL_ALIGN_RIGHT)), FALSE, FALSE, 5);
g->colorpick2 = DTGTK_BUTTON(dtgtk_button_new(dtgtk_cairo_paint_color,CPF_IGNORE_FG_STATE|CPF_STYLE_FLAT|CPF_DO_NOT_USE_BORDER));
gtk_widget_set_size_request(GTK_WIDGET(g->colorpick2),32,32);
hbox=GTK_WIDGET(gtk_hbox_new(FALSE, 0));
g->vbox1 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
g->vbox2 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->vbox1), FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->vbox2), TRUE, TRUE, 5);
gtk_box_pack_end(GTK_BOX(hbox),GTK_WIDGET(g->colorpick2),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 5);
g->label3 = dtgtk_reset_label_new (_("hue"), self, &p->highlight_hue, sizeof(float));
g->label4 = dtgtk_reset_label_new (_("saturation"), self, &p->highlight_saturation, sizeof(float));
gtk_box_pack_start(GTK_BOX(g->vbox1), GTK_WIDGET(g->label3), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox1), GTK_WIDGET(g->label4), TRUE, TRUE, 0);
g->gslider3=DTGTK_GRADIENT_SLIDER(dtgtk_gradient_slider_new_with_color((GdkColor)
{
0,lightness,0,0
},(GdkColor)
{
0,lightness,0,0
}));
dtgtk_gradient_slider_set_stop(g->gslider3,0.166,(GdkColor)
{
0,lightness,lightness,0
});
dtgtk_gradient_slider_set_stop(g->gslider3,0.332,(GdkColor)
{
0,0,lightness,0
});
dtgtk_gradient_slider_set_stop(g->gslider3,0.498,(GdkColor)
{
0,0,lightness,lightness
});
dtgtk_gradient_slider_set_stop(g->gslider3,0.664,(GdkColor)
{
0,0,0,lightness
});
dtgtk_gradient_slider_set_stop(g->gslider3,0.83,(GdkColor)
{
0,lightness,0,lightness
});
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->gslider3), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->gslider3), "tooltip-text", _("select the hue tone for highlights"), (char *)NULL);
g->gslider4=DTGTK_GRADIENT_SLIDER(dtgtk_gradient_slider_new_with_color((GdkColor)
{
0,lightness,lightness,lightness
},(GdkColor)
{
0,lightness,lightness,lightness
}));
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->gslider4), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->gslider4), "tooltip-text", _("select the saturation highlights tone"), (char *)NULL);
// Additional paramters
hbox=GTK_WIDGET(gtk_hbox_new(FALSE, 0));
g->vbox2 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->vbox2), TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 5);
g->scale1 = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 0.1, p->balance*100.0, 2);
dt_bauhaus_slider_set_format(g->scale1, "%.2f");
dt_bauhaus_widget_set_label(g->scale1, _("balance"));
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->scale1), TRUE, TRUE, 0);
g->scale2 = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 1.0, p->compress, 2);
dt_bauhaus_slider_set_format(g->scale2, "%.2f%%");
dt_bauhaus_widget_set_label(g->scale2,_("compress"));
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->scale2), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->scale1), "tooltip-text", _("the balance of center of splittoning"), (char *)NULL);
g_object_set(G_OBJECT(g->scale2), "tooltip-text", _("compress the effect on highlighs/shadows and\npreserve midtones"), (char *)NULL);
g_signal_connect (G_OBJECT (g->gslider1), "value-changed",
G_CALLBACK (hue_callback), self);
g_signal_connect (G_OBJECT (g->gslider3), "value-changed",
G_CALLBACK (hue_callback), self);
g_signal_connect (G_OBJECT (g->gslider2), "value-changed",
G_CALLBACK (saturation_callback), self);
g_signal_connect (G_OBJECT (g->gslider4), "value-changed",
G_CALLBACK (saturation_callback), self);
g_signal_connect (G_OBJECT (g->scale1), "value-changed",
G_CALLBACK (balance_callback), self);
g_signal_connect (G_OBJECT (g->scale2), "value-changed",
G_CALLBACK (compress_callback), self);
g_signal_connect (G_OBJECT (g->colorpick1), "clicked",
G_CALLBACK (colorpick_callback), self);
g_signal_connect (G_OBJECT (g->colorpick2), "clicked",
G_CALLBACK (colorpick_callback), self);
}
GimpColorProfilePolicy
color_profile_import_dialog_run (GimpImage *image,
GimpContext *context,
GtkWidget *parent,
GimpColorProfile **dest_profile,
gboolean *dont_ask)
{
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *frame;
GtkWidget *label;
GtkWidget *toggle;
GimpColorProfile *src_profile;
GimpColorProfilePolicy policy;
const gchar *title;
const gchar *frame_title;
gchar *text;
g_return_val_if_fail (GIMP_IS_IMAGE (image), GIMP_COLOR_PROFILE_POLICY_KEEP);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), GIMP_COLOR_PROFILE_POLICY_KEEP);
g_return_val_if_fail (parent == NULL || GTK_IS_WIDGET (parent),
GIMP_COLOR_PROFILE_POLICY_KEEP);
g_return_val_if_fail (dest_profile != NULL, GIMP_COLOR_PROFILE_POLICY_KEEP);
src_profile = gimp_image_get_color_profile (image);
*dest_profile = gimp_image_get_builtin_color_profile (image);
if (gimp_image_get_base_type (image) == GIMP_GRAY)
{
title = _("Convert to Grayscale Working Space?");
frame_title = _("Convert the image to the grayscale working space?");
}
else
{
title = _("Convert to RGB Working Space?");
frame_title = _("Convert the image to the RGB working space?");
}
dialog =
gimp_viewable_dialog_new (GIMP_VIEWABLE (image), context,
title,
"gimp-image-color-profile-import",
NULL,
_("Import the image from a color profile"),
parent,
gimp_standard_help_func,
GIMP_HELP_IMAGE_COLOR_PROFILE_IMPORT,
_("Keep"), GTK_RESPONSE_CANCEL,
_("Convert"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
main_vbox, TRUE, TRUE, 0);
gtk_widget_show (main_vbox);
text = g_strdup_printf (_("The image '%s' has an embedded color profile"),
gimp_image_get_display_name (image));
frame = gimp_frame_new (text);
g_free (text);
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
label = gimp_color_profile_label_new (src_profile);
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_widget_show (label);
frame = gimp_frame_new (frame_title);
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
label = gimp_color_profile_label_new (*dest_profile);
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_widget_show (label);
if (dont_ask)
{
toggle = gtk_check_button_new_with_mnemonic (_("_Don't ask me again"));
gtk_box_pack_end (GTK_BOX (main_vbox), toggle, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), FALSE);
gtk_widget_show (toggle);
}
switch (gtk_dialog_run (GTK_DIALOG (dialog)))
{
case GTK_RESPONSE_OK:
policy = GIMP_COLOR_PROFILE_POLICY_CONVERT;
g_object_ref (*dest_profile);
break;
default:
policy = GIMP_COLOR_PROFILE_POLICY_KEEP;
break;
}
if (dont_ask)
{
*dont_ask = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle));
}
gtk_widget_destroy (dialog);
return policy;
}
static void
run_filebrowser_gtk2style(gboolean play_button, gboolean show)
{
static GtkWidget *window = NULL;
GtkWidget *vbox, *hbox, *bbox;
GtkWidget *chooser;
GtkWidget *action_button, *close_button;
GtkWidget *toggle;
gchar *window_title, *toggle_text;
gpointer action_stock, storage;
if (!show) {
if (window){
gtk_widget_hide(window);
return;
}
else
return;
}
else {
if (window) {
gtk_window_present(GTK_WINDOW(window)); /* raise filebrowser */
return;
}
}
window_title = play_button ? _("Open Files") : _("Add Files");
toggle_text = play_button ?
_("Close dialog on Open") : _("Close dialog on Add");
action_stock = play_button ? GTK_STOCK_OPEN : GTK_STOCK_ADD;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_type_hint (GTK_WINDOW (window), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_title(GTK_WINDOW(window), window_title);
gtk_window_set_default_size(GTK_WINDOW(window), 700, 450);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
chooser = gtk_file_chooser_widget_new(GTK_FILE_CHOOSER_ACTION_OPEN);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(chooser), TRUE);
gchar * path = aud_get_string ("audgui", "filesel_path");
if (path[0])
gtk_file_chooser_set_current_folder ((GtkFileChooser *) chooser, path);
g_free (path);
gtk_box_pack_start(GTK_BOX(vbox), chooser, TRUE, TRUE, 3);
hbox = gtk_hbox_new(TRUE, 0);
gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 3);
toggle = gtk_check_button_new_with_label(toggle_text);
gtk_toggle_button_set_active ((GtkToggleButton *) toggle, aud_get_bool
("audgui", "close_dialog_open"));
gtk_box_pack_start(GTK_BOX(hbox), toggle, TRUE, TRUE, 3);
bbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(bbox), 6);
gtk_box_pack_end(GTK_BOX(hbox), bbox, TRUE, TRUE, 3);
close_button = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
action_button = gtk_button_new_from_stock(action_stock);
gtk_container_add(GTK_CONTAINER(bbox), close_button);
gtk_container_add(GTK_CONTAINER(bbox), action_button);
gtk_widget_set_can_default (action_button, TRUE);
gtk_widget_grab_default (action_button);
/* this storage object holds several other objects which are used in the
* callback functions
*/
storage = g_object_new(G_TYPE_OBJECT, NULL);
g_object_set_data(storage, "window", window);
g_object_set_data(storage, "chooser", chooser);
g_object_set_data(storage, "toggle-button", toggle);
g_object_set_data(storage, "play-button", GINT_TO_POINTER(play_button));
g_signal_connect(chooser, "file-activated",
G_CALLBACK(action_button_cb), storage);
g_signal_connect(action_button, "clicked",
G_CALLBACK(action_button_cb), storage);
g_signal_connect(close_button, "clicked",
G_CALLBACK(close_button_cb), window);
g_signal_connect(window, "destroy",
G_CALLBACK(gtk_widget_destroyed), &window);
audgui_destroy_on_escape (window);
gtk_widget_show_all (window);
}
void anypaper_window_create (AnypaperWindow *self)
{
AnypaperWindowPrivate *priv = self->priv;
GtkWidget *window;
GtkWidget *label;
GtkWidget *image, *background;
GtkWidget *rmenu;
GtkWidget *button;
GtkWidget *note, *vbox1, *vbox2, *hbox1, *table, *halign;
gchar *filename, *buffer;
GdkPixbuf *tempbuf;
GdkColor color;
self->priv->window = window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "anyPaper " VERSION);
gtk_window_set_default_size(GTK_WINDOW(window), 500, 100);
gtk_window_set_icon_from_file (GTK_WINDOW(window), ANYPAPER_DATA "anypaper.png", NULL);
g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (gtk_main_quit), NULL);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox2);
note = gtk_notebook_new ();
vbox1 = gtk_vbox_new (FALSE, 10);
label = gtk_label_new ("Wallpaper");
gtk_notebook_append_page (GTK_NOTEBOOK(note), vbox1, label);
gtk_widget_show (label);
table = gtk_table_new (3, 4, FALSE);
label = gtk_label_new ("File: ");
gtk_misc_set_alignment (GTK_MISC(label), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
priv->file_entry = gtk_entry_new();
gtk_entry_set_text (GTK_ENTRY (priv->file_entry), self->parameters->file);
g_signal_connect (G_OBJECT (priv->file_entry), "activate", G_CALLBACK (set_image_file_cb), self);
gtk_table_attach (GTK_TABLE (table), priv->file_entry, 1, 3, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (priv->file_entry);
button = gtk_button_new_from_stock (GTK_STOCK_OPEN);
image = gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON(button), image);
gtk_widget_show (image);
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (open_image_file_cb), self);
gtk_table_attach (GTK_TABLE (table), button, 3, 4, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (button);
label = gtk_label_new ("Style: ");
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment (GTK_MISC(label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
halign = gtk_alignment_new(0, 1, 0, 0);
priv->combo = gtk_combo_box_new_text ();
gtk_container_add(GTK_CONTAINER(halign), priv->combo);
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->combo), "Fullscreen");
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->combo), "Normal");
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->combo), "Tiled");
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->combo), "Adjusted");
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->combo), "Scaled");
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->combo), "Custom Scale");
gtk_combo_box_set_active (GTK_COMBO_BOX (priv->combo), self->parameters->style);
g_signal_connect (G_OBJECT (priv->combo), "changed", G_CALLBACK (set_image_style_cb), self);
gtk_table_attach (GTK_TABLE (table), halign, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (priv->combo);
gtk_widget_show (halign);
priv->custom_table = gtk_table_new (2, 3, FALSE);
label = gtk_label_new ("Scale x: ");
gtk_misc_set_alignment (GTK_MISC(label), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (priv->custom_table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
priv->spin5 = gtk_spin_button_new_with_range (0, 100, .1);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (priv->spin5), 4);
gtk_spin_button_set_value(GTK_SPIN_BUTTON (priv->spin5), self->parameters->scalex);
g_signal_connect (G_OBJECT (priv->spin5), "value-changed", G_CALLBACK (change_other_scale_cb), self);
g_signal_connect_after (G_OBJECT (priv->spin5), "value-changed", G_CALLBACK (set_image_scale_cb), self);
gtk_table_attach (GTK_TABLE (priv->custom_table), priv->spin5, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (priv->spin5);
button = gtk_toggle_button_new_with_mnemonic("linked");
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(button), priv->custom_scale_connect_state);
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (connect_custom_scale_cb), self);
gtk_table_attach (GTK_TABLE (priv->custom_table), button, 2, 3, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (button);
label = gtk_label_new ("Scale y: ");
gtk_misc_set_alignment (GTK_MISC(label), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (priv->custom_table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
priv->spin6 = gtk_spin_button_new_with_range (0, 100, .1);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (priv->spin6), 4);
gtk_spin_button_set_value(GTK_SPIN_BUTTON (priv->spin6), self->parameters->scaley);
g_signal_connect (G_OBJECT (priv->spin6), "value-changed", G_CALLBACK (change_other_scale_cb), self);
g_signal_connect_after (G_OBJECT (priv->spin6), "value-changed", G_CALLBACK (set_image_scale_cb), self);
gtk_table_attach (GTK_TABLE (priv->custom_table), priv->spin6, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (priv->spin6);
gtk_table_attach (GTK_TABLE (table), priv->custom_table, 2, 4, 1, 3, GTK_FILL, GTK_FILL, 0, 0);
if (self->parameters->style == 5) gtk_widget_show (priv->custom_table);
else gtk_widget_hide (priv->custom_table);
label = gtk_label_new ("Background: ");
gtk_misc_set_alignment (GTK_MISC(label), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
gdk_color_parse (self->parameters->background, &color);
halign = gtk_alignment_new(0, 1, 0, 0);
priv->cbutton = gtk_color_button_new_with_color (&color);
gtk_container_add(GTK_CONTAINER(halign), priv->cbutton);
g_signal_connect (G_OBJECT (priv->cbutton), "color-set", G_CALLBACK (set_image_background_cb), self);
gtk_table_attach (GTK_TABLE (table), halign, 1, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (priv->cbutton);
gtk_widget_show (halign);
gtk_box_pack_start (GTK_BOX(vbox1), table, FALSE, TRUE, 0);
gtk_widget_show (table);
hbox1 = gtk_hbox_new (FALSE, 0);
priv->preview = gtk_image_new_from_pixbuf(self->image->preview);
gtk_box_pack_start (GTK_BOX(hbox1), priv->preview, TRUE, FALSE, 2);
gtk_widget_show (priv->preview);
table = gtk_table_new (5, 2, FALSE);
priv->label1 = gtk_label_new ("Position x: ");
gtk_misc_set_alignment (GTK_MISC(priv->label1), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (priv->label1), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), priv->label1, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (priv->label1);
priv->spin1 = gtk_spin_button_new_with_range (-65535, 65535, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON (priv->spin1), self->parameters->positionx);
g_signal_connect (G_OBJECT (priv->spin1), "value-changed", G_CALLBACK (set_image_position_cb), self);
gtk_table_attach (GTK_TABLE (table), priv->spin1, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (priv->spin1);
priv->label2 = gtk_label_new ("Position y: ");
gtk_misc_set_alignment (GTK_MISC(priv->label2), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (priv->label2), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), priv->label2, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (priv->label2);
priv->spin2 = gtk_spin_button_new_with_range (-65535, 65535, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON (priv->spin2), self->parameters->positiony);
g_signal_connect (G_OBJECT (priv->spin2), "value-changed", G_CALLBACK (set_image_position_cb), self);
gtk_table_attach (GTK_TABLE (table), priv->spin2, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (priv->spin2);
label = gtk_label_new ("Width: ");
gtk_misc_set_alignment (GTK_MISC(label), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
priv->spin3 = gtk_spin_button_new_with_range (0, 65535, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON (priv->spin3), self->parameters->width);
g_signal_connect (G_OBJECT (priv->spin3), "value-changed", G_CALLBACK (set_image_size_cb), self);
gtk_table_attach (GTK_TABLE (table), priv->spin3, 1, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (priv->spin3);
label = gtk_label_new ("Height: ");
gtk_misc_set_alignment (GTK_MISC(label), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
priv->spin4 = gtk_spin_button_new_with_range (0, 65535, 1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON (priv->spin4), self->parameters->height);
g_signal_connect (G_OBJECT (priv->spin4), "value-changed", G_CALLBACK (set_image_size_cb), self);
gtk_table_attach (GTK_TABLE (table), priv->spin4, 1, 2, 3, 4, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (priv->spin4);
button = gtk_button_new_with_mnemonic ("_Center");
g_signal_connect (G_OBJECT(button), "clicked", G_CALLBACK(center_image_cb), self);
gtk_table_attach (GTK_TABLE (table), button, 0, 2, 4, 5, GTK_SHRINK, GTK_SHRINK, 0, 0);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX(hbox1), table, FALSE, TRUE, 0);
gtk_widget_show (table);
gtk_box_pack_start (GTK_BOX(vbox1), hbox1, FALSE, TRUE, 2);
gtk_widget_show (hbox1);
hbox1 = gtk_hbox_new (FALSE, 0);
button = gtk_button_new_with_mnemonic ("Show _Preview");
g_signal_connect (G_OBJECT(button), "clicked", G_CALLBACK(show_window_preview_cb), self);
gtk_box_pack_start (GTK_BOX(hbox1), button, FALSE, FALSE, 2);
gtk_widget_show (button);
button = gtk_button_new_with_mnemonic ("Load lastwallpaper file");
image = gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON(button), image);
gtk_widget_show (image);
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (load_lastwallpaperfile_cb), self);
gtk_box_pack_end (GTK_BOX(hbox1), button, FALSE, FALSE, 2);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX(vbox1), hbox1, FALSE, TRUE, 2);
gtk_widget_show (hbox1);
gtk_widget_show (vbox1);
vbox1 = gtk_vbox_new (FALSE, 2);
label = gtk_label_new ("Configuration");
gtk_notebook_append_page (GTK_NOTEBOOK(note), vbox1, label);
gtk_widget_show (label);
table = gtk_table_new (3, 3, FALSE);
label = gtk_label_new ("Default output file: ");
gtk_misc_set_alignment (GTK_MISC(label), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
priv->def_entry = gtk_entry_new();
gtk_entry_set_text (GTK_ENTRY (priv->def_entry), self->parameters->defaultfile);
gtk_table_attach_defaults (GTK_TABLE (table), priv->def_entry, 1, 2, 0, 1);
gtk_widget_show (priv->def_entry);
button = gtk_button_new_from_stock (GTK_STOCK_SAVE);
image = gtk_image_new_from_stock (GTK_STOCK_SAVE, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON(button), image);
gtk_widget_show (image);
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (save_default_file_cb), self);
gtk_table_attach (GTK_TABLE (table), button, 2, 3, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (button);
label = gtk_label_new ("Command (Wallpapersetter): ");
gtk_misc_set_alignment (GTK_MISC(label), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
button = gtk_button_new_with_mnemonic ("Detect");
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (detect_popup_cb), self);
gtk_table_attach (GTK_TABLE (table), button, 2, 3, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (button);
priv->com_entry = gtk_entry_new();
gtk_entry_set_text (GTK_ENTRY (priv->com_entry), self->parameters->command);
gtk_table_attach_defaults (GTK_TABLE (table), priv->com_entry, 1, 2, 1, 2);
gtk_widget_show (priv->com_entry);
label = gtk_label_new ("Interpolation: ");
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment (GTK_MISC(label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
halign = gtk_alignment_new(0, 1, 0, 0);
priv->combo_interpolation = gtk_combo_box_new_text ();
gtk_container_add(GTK_CONTAINER(halign), priv->combo_interpolation);
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->combo_interpolation), "GDK_INTERP_NEAREST");
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->combo_interpolation), "GDK_INTERP_TILES");
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->combo_interpolation), "GDK_INTERP_BILINEAR");
gtk_combo_box_append_text (GTK_COMBO_BOX (priv->combo_interpolation), "GDK_INTERP_HYPER");
gtk_combo_box_set_active (GTK_COMBO_BOX (priv->combo_interpolation), interpolation_int (self->parameters->interpolation));
g_signal_connect (G_OBJECT (priv->combo_interpolation), "changed", G_CALLBACK (set_image_interpolation_cb), self);
gtk_table_attach (GTK_TABLE (table), halign, 1, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (priv->combo_interpolation);
gtk_widget_show (halign);
gtk_box_pack_start (GTK_BOX(vbox1), table, FALSE, TRUE, 0);
gtk_widget_show (table);
hbox1 = gtk_hbox_new (FALSE, 0);
button = gtk_button_new_with_mnemonic ("Load anypaperrc file");
image = gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON(button), image);
gtk_widget_show (image);
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (load_rcfile_cb), self);
gtk_box_pack_end (GTK_BOX(hbox1), button, FALSE, FALSE, 2);
gtk_widget_show (button);
gtk_box_pack_end (GTK_BOX(vbox1), hbox1, FALSE, TRUE, 2);
gtk_widget_show (hbox1);
gtk_widget_show (vbox1);
gtk_box_pack_start (GTK_BOX(vbox2), note, FALSE, TRUE, 0);
hbox1 = gtk_hbox_new (FALSE, 0);
if (no_set == FALSE)
{
button = gtk_button_new_from_stock (GTK_STOCK_OK);
image = gtk_image_new_from_stock (GTK_STOCK_OK, GTK_ICON_SIZE_BUTTON);
}
else
{
button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_BUTTON);
}
gtk_button_set_image (GTK_BUTTON(button), image);
gtk_widget_show (image);
if (no_set == FALSE)
{
g_signal_connect (G_OBJECT(button), "clicked", G_CALLBACK(ok_cb), self);
}
else g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (delete_event), NULL);
gtk_box_pack_end (GTK_BOX(hbox1), button, FALSE, FALSE, 2);
gtk_widget_show (button);
if (no_set == FALSE)
{
button = gtk_button_new_from_stock (GTK_STOCK_APPLY);
image = gtk_image_new_from_stock (GTK_STOCK_APPLY, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON(button), image);
gtk_widget_show (image);
g_signal_connect (G_OBJECT(button), "clicked", G_CALLBACK(apply_cb), self);
gtk_box_pack_end (GTK_BOX(hbox1), button, FALSE, FALSE, 2);
gtk_widget_show (button);
button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
image = gtk_image_new_from_stock (GTK_STOCK_CANCEL, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON(button), image);
gtk_widget_show (image);
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (delete_event), NULL);
gtk_box_pack_end (GTK_BOX(hbox1), button, FALSE, FALSE, 2);
gtk_widget_show (button);
}
button = gtk_button_new_from_stock (GTK_STOCK_SAVE_AS);
image = gtk_image_new_from_stock (GTK_STOCK_SAVE_AS, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON(button), image);
gtk_widget_show (image);
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (save_file_as_cb), self);
gtk_box_pack_end (GTK_BOX(hbox1), button, FALSE, FALSE, 2);
gtk_widget_show (button);
button = gtk_button_new_from_stock (GTK_STOCK_ABOUT);
image = gtk_image_new_from_stock (GTK_STOCK_ABOUT, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON(button), image);
gtk_widget_show (image);
g_signal_connect (G_OBJECT(button), "clicked", G_CALLBACK(about_window_cb), G_OBJECT (window));
gtk_box_pack_start (GTK_BOX(hbox1), button, FALSE, FALSE, 2);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX(vbox2), hbox1, FALSE, TRUE, 0);
gtk_widget_show (hbox1);
gtk_widget_show (vbox2);
gtk_widget_show (note);
gtk_widget_show (window);
}
static PanelAddtoDialog *
panel_addto_dialog_new (PanelWidget *panel_widget)
{
PanelAddtoDialog *dialog;
GtkWidget *dialog_vbox;
#if !GTK_CHECK_VERSION (3, 0, 0)
GtkWidget *vbox;
#endif
GtkWidget *inner_vbox;
GtkWidget *find_hbox;
GtkWidget *sw;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
dialog = g_new0 (PanelAddtoDialog, 1);
g_object_set_qdata_full (G_OBJECT (panel_widget->toplevel),
panel_addto_dialog_quark,
dialog,
(GDestroyNotify) panel_addto_dialog_free);
dialog->panel_widget = panel_widget;
g_signal_connect (dialog->panel_widget->toplevel->settings,
"changed::" PANEL_TOPLEVEL_NAME_KEY,
G_CALLBACK (panel_addto_name_notify),
dialog);
dialog->addto_dialog = gtk_dialog_new ();
gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog),
GTK_STOCK_HELP, GTK_RESPONSE_HELP);
dialog->back_button = gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog),
GTK_STOCK_GO_BACK,
PANEL_ADDTO_RESPONSE_BACK);
dialog->add_button = gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog),
GTK_STOCK_ADD,
PANEL_ADDTO_RESPONSE_ADD);
gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog),
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE);
gtk_widget_set_sensitive (GTK_WIDGET (dialog->add_button), FALSE);
gtk_dialog_set_default_response (GTK_DIALOG (dialog->addto_dialog),
PANEL_ADDTO_RESPONSE_ADD);
gtk_container_set_border_width (GTK_CONTAINER (dialog->addto_dialog), 5);
dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog->addto_dialog));
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_box_set_spacing (GTK_BOX (dialog_vbox), 12);
gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5);
#else
gtk_box_set_spacing (GTK_BOX (dialog_vbox), 2);
#endif
g_signal_connect (G_OBJECT (dialog->addto_dialog), "response",
G_CALLBACK (panel_addto_dialog_response), dialog);
g_signal_connect (dialog->addto_dialog, "destroy",
G_CALLBACK (panel_addto_dialog_destroy), dialog);
#if !GTK_CHECK_VERSION (3, 0, 0)
vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
gtk_container_add (GTK_CONTAINER (dialog_vbox), vbox);
#endif
inner_vbox = gtk_vbox_new (FALSE, 6);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_box_pack_start (GTK_BOX (dialog_vbox), inner_vbox, TRUE, TRUE, 0);
#else
gtk_box_pack_start (GTK_BOX (vbox), inner_vbox, TRUE, TRUE, 0);
#endif
find_hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (inner_vbox), find_hbox, FALSE, FALSE, 0);
dialog->label = gtk_label_new_with_mnemonic ("");
gtk_misc_set_alignment (GTK_MISC (dialog->label), 0.0, 0.5);
gtk_label_set_use_markup (GTK_LABEL (dialog->label), TRUE);
gtk_box_pack_start (GTK_BOX (find_hbox), dialog->label,
FALSE, FALSE, 0);
dialog->search_entry = gtk_entry_new ();
g_signal_connect (G_OBJECT (dialog->search_entry), "changed",
G_CALLBACK (panel_addto_search_entry_changed), dialog);
g_signal_connect (G_OBJECT (dialog->search_entry), "activate",
G_CALLBACK (panel_addto_search_entry_activated), dialog);
gtk_box_pack_end (GTK_BOX (find_hbox), dialog->search_entry,
TRUE, TRUE, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (dialog->label),
dialog->search_entry);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (inner_vbox), sw, TRUE, TRUE, 0);
dialog->tree_view = gtk_tree_view_new ();
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (dialog->tree_view),
FALSE);
gtk_tree_view_expand_all (GTK_TREE_VIEW (dialog->tree_view));
renderer = g_object_new (GTK_TYPE_CELL_RENDERER_PIXBUF,
"xpad", 4,
"ypad", 4,
NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (dialog->tree_view),
-1, NULL,
renderer,
"pixbuf", COLUMN_ICON,
NULL);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (dialog->tree_view),
-1, NULL,
renderer,
"markup", COLUMN_TEXT,
NULL);
//FIXME use the same search than the one for the search entry?
gtk_tree_view_set_search_column (GTK_TREE_VIEW (dialog->tree_view),
COLUMN_SEARCH);
gtk_tree_view_set_row_separator_func (GTK_TREE_VIEW (dialog->tree_view),
panel_addto_separator_func,
GINT_TO_POINTER (COLUMN_TEXT),
NULL);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tree_view));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (dialog->tree_view),
COLUMN_TEXT);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
g_signal_connect (selection, "changed",
G_CALLBACK (panel_addto_selection_changed),
dialog);
g_signal_connect (dialog->tree_view, "row-activated",
G_CALLBACK (panel_addto_selection_activated),
dialog);
gtk_container_add (GTK_CONTAINER (sw), dialog->tree_view);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_show_all (dialog_vbox);
#else
gtk_widget_show_all (vbox);
#endif
panel_toplevel_push_autohide_disabler (dialog->panel_widget->toplevel);
panel_widget_register_open_dialog (panel_widget,
dialog->addto_dialog);
panel_addto_name_change (dialog,
panel_toplevel_get_name (dialog->panel_widget->toplevel));
return dialog;
}
static void
tree_menu (void)
{
GtkWidget *window, *widget;
GtkWidget *menubar, *vbox;
GtkCellArea *area;
GtkTreeModel *store;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "GtkTreeMenu");
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
gtk_widget_show (vbox);
menubar = gtk_menu_bar_new ();
gtk_widget_show (menubar);
store = simple_tree_model ();
area = create_cell_area ();
#if _GTK_TREE_MENU_WAS_A_PUBLIC_CLASS_
menuitem = gtk_menu_item_new_with_label ("Grid");
menu = create_menu_grid_demo ();
gtk_widget_show (menu);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
menuitem = gtk_menu_item_new_with_label ("Tree");
menu = simple_tree_menu ();
gtk_widget_show (menu);
gtk_widget_show (menuitem);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menubar), menuitem);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
g_signal_connect (menu, "menu-activate", G_CALLBACK (menu_activated_cb), NULL);
gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, FALSE, 0);
#endif
/* Add a combo box with the same menu ! */
widget = gtk_combo_box_new_with_area (area);
gtk_combo_box_set_model (GTK_COMBO_BOX (widget), store);
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
gtk_widget_show (widget);
gtk_box_pack_end (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
/* Now add some controls */
widget = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Horizontal");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Vertical");
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
gtk_widget_show (widget);
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "changed",
G_CALLBACK (orientation_changed), area);
widget = gtk_check_button_new_with_label ("Align 2nd Cell");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
gtk_widget_show (widget);
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (align_cell_2_toggled), area);
widget = gtk_check_button_new_with_label ("Align 3rd Cell");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
gtk_widget_show (widget);
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (align_cell_3_toggled), area);
widget = gtk_check_button_new_with_label ("Expand 1st Cell");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
gtk_widget_show (widget);
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (expand_cell_1_toggled), area);
widget = gtk_check_button_new_with_label ("Expand 2nd Cell");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
gtk_widget_show (widget);
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (expand_cell_2_toggled), area);
widget = gtk_check_button_new_with_label ("Expand 3rd Cell");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
gtk_widget_show (widget);
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (expand_cell_3_toggled), area);
#if _GTK_TREE_MENU_WAS_A_PUBLIC_CLASS_
widget = gtk_check_button_new_with_label ("Submenu Headers");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
gtk_widget_show (widget);
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (submenu_headers_toggled), menu);
widget = gtk_check_button_new_with_label ("Tearoff menu");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE);
gtk_widget_show (widget);
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (widget), "toggled",
G_CALLBACK (tearoff_toggled), menu);
#endif
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (window);
}