void getnamepwd_dialog(GtkWidget *widget,gpointer data)
{
LOGIN_DATA *login_data=g_malloc0(sizeof(LOGIN_DATA));
GtkWidget *hbox_name,*hbox_pwd;
GtkWidget *button_ok,*button_cancel;
GtkWidget *editor1,*editor2;
GtkWidget *label_name,*label_pwd;
GtkWidget *getnamepwd_dialog;
getnamepwd_dialog=gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(getnamepwd_dialog),"登陆");
editor1 = gtk_entry_new();
editor2 = gtk_entry_new();
gtk_entry_set_visibility( (GtkEntry *)editor2, FALSE );
login_data->e1=editor1;
login_data->e2=editor2;
login_data->e3=getnamepwd_dialog;
button_ok = gtk_button_new_with_label("登陆");
button_cancel = gtk_button_new_with_label("取消");
label_name=gtk_label_new("用户昵称：");
label_pwd=gtk_label_new("用户密码：");
hbox_name=gtk_hbox_new(FALSE, 0);
hbox_pwd=gtk_hbox_new(FALSE, 0);
gtk_box_pack_start (GTK_BOX(hbox_name),label_name,FALSE,FALSE,5);
gtk_box_pack_start (GTK_BOX(hbox_name),editor1,FALSE,FALSE,5);
gtk_box_pack_start (GTK_BOX(hbox_pwd),label_pwd,FALSE,FALSE,5);
gtk_box_pack_start (GTK_BOX(hbox_pwd),editor2,FALSE,FALSE,5);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (getnamepwd_dialog)->vbox),hbox_name, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (getnamepwd_dialog)->vbox),hbox_pwd, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (getnamepwd_dialog)->action_area),button_cancel, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (getnamepwd_dialog)->action_area),button_ok, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(button_ok), "clicked",G_CALLBACK(getnamepwd),login_data);
g_signal_connect(G_OBJECT(button_cancel), "clicked",G_CALLBACK(cancel),(gpointer)getnamepwd_dialog);
gtk_widget_show_all(getnamepwd_dialog);
gtk_dialog_run(GTK_DIALOG(getnamepwd_dialog));
}
static void
panda_combo_build_children (GladeXML *xml, GtkWidget *w,
GladeWidgetInfo *info, const char *longname)
{
GList *tmp;
GladeWidgetInfo *cinfo = NULL;
GtkEntry *entry;
for (tmp = info->children; tmp; tmp = tmp->next) {
GList *tmp2;
gchar *child_name = NULL;
cinfo = tmp->data;
for (tmp2 = cinfo->attributes; tmp2; tmp2 = tmp2->next) {
GladeAttribute *attr = tmp2->data;
if (!strcmp(attr->name, "child_name")) {
child_name = attr->value;
break;
}
}
if (child_name && !strcmp(child_name, "GtkPandaCombo:entry"))
break;
}
if (!tmp)
return;
#if 1
entry = GTK_ENTRY(GTK_PANDA_COMBO(w)->entry);
for (tmp = cinfo->attributes; tmp; tmp = tmp->next) {
GladeAttribute *attr = tmp->data;
if (!strcmp(attr->name, "editable")) {
gtk_entry_set_editable(entry, attr->value[0] == 'T');
} else if (!strcmp(attr->name, "text_visible")) {
gtk_entry_set_visibility(entry, attr->value[0] == 'T');
} else if (!strcmp(attr->name, "text_max_length")) {
gtk_entry_set_max_length(entry, strtol(attr->value,NULL, 0));
} else if (!strcmp(attr->name, "max_length")) {
gtk_entry_set_max_length(entry, strtol(attr->value,NULL, 0));
} else if (!strcmp(attr->name, "text")) {
gtk_entry_set_text(entry, attr->value);
}
}
#endif
glade_xml_set_common_params(xml, GTK_PANDA_COMBO(w)->entry, cinfo, longname);
}
static int Gtk3Gui_WLineEdit_Setup(GWEN_WIDGET *w) {
GtkWidget *g;
const char *s;
uint32_t flags;
GWEN_WIDGET *wParent;
gulong deleted_text_handler_id;
gulong inserted_text_handler_id;
gboolean text_is_visible;
flags=GWEN_Widget_GetFlags(w);
text_is_visible = (flags & GWEN_WIDGET_FLAGS_PASSWORD) == 0;
wParent=GWEN_Widget_Tree_GetParent(w);
s=GWEN_Widget_GetText(w, 0);
/* create widget */
g=gtk_entry_new();
if (s && *s)
gtk_entry_set_text(GTK_ENTRY(g), s);
gtk_entry_set_visibility(GTK_ENTRY(g), text_is_visible);
GWEN_Widget_SetImplData(w, GTK3_DIALOG_WIDGET_REAL, (void*) g);
GWEN_Widget_SetImplData(w, GTK3_DIALOG_WIDGET_CONTENT, (void*) g);
GWEN_Widget_SetSetIntPropertyFn(w, Gtk3Gui_WLineEdit_SetIntProperty);
GWEN_Widget_SetGetIntPropertyFn(w, Gtk3Gui_WLineEdit_GetIntProperty);
GWEN_Widget_SetSetCharPropertyFn(w, Gtk3Gui_WLineEdit_SetCharProperty);
GWEN_Widget_SetGetCharPropertyFn(w, Gtk3Gui_WLineEdit_GetCharProperty);
deleted_text_handler_id=g_signal_connect(gtk_entry_get_buffer(GTK_ENTRY(g)),
"deleted-text",
G_CALLBACK (Gtk3Gui_WLineEdit_Deleted_text_handler),
w);
inserted_text_handler_id=g_signal_connect(gtk_entry_get_buffer(GTK_ENTRY(g)),
"inserted-text",
G_CALLBACK (Gtk3Gui_WLineEdit_Inserted_text_handler),
w);
if (wParent)
GWEN_Widget_AddChildGuiWidget(wParent, w);
return 0;
}
void create_entry_field(gchar *text, gboolean hidden)
{
GtkWidget *entry, *label, *box;
char tmp_text[BUFSIZ];
gboolean no_margen=FALSE;
entry = gtk_entry_new();
if (!entry) quit (RETURN_ERROR_NOMEM);
if (hidden) gtk_entry_set_visibility ((GtkEntry*)entry, FALSE);
gtk_signal_connect ((GtkObject*)entry, key_press_event,
GTK_SIGNAL_FUNC (keypress_cb), NULL);
if(text) {
if(*text=='^') {
no_margen=TRUE;
strcpy(tmp_text,text+1);
strcpy(text,tmp_text);
}
box = gtk_hbox_new(FALSE, 1);
if (!box) quit (RETURN_ERROR_NOMEM);
#if GTK_MAJOR_VERSION < 2
label = gtk_label_new(text);
if (!label) quit (RETURN_ERROR_NOMEM);
#else
label = gtk_label_new_with_mnemonic(text);
if (!label) quit (RETURN_ERROR_NOMEM);
gtk_label_set_mnemonic_widget((GtkLabel *)label, entry);
#endif
if(no_margen) {
gtk_box_pack_start((GtkBox *)box, label, FALSE, FALSE, 0);
gtk_box_pack_end((GtkBox *)box, entry, TRUE, TRUE, 0);
}
else {
gtk_box_pack_start((GtkBox *)box, label, FALSE, TRUE, 0);
gtk_box_pack_end((GtkBox *)box, entry, FALSE, TRUE, 0);
}
add_to_vbox(box);
} else {
add_to_vbox(entry);
}
widgets = g_slist_append(widgets, entry);
};
static void test_hash_func_digest(const enum hash_func_e id, const char *text,
const char *hmac, const char *digest)
{
gtk_entry_set_text(gui.entry_check_text, digest);
gtk_entry_set_text(gui.entry_text, text);
if (hmac) {
gtk_toggle_button_set_active(gui.togglebutton_hmac_text, true);
gtk_entry_set_visibility(gui.entry_hmac_text, true);
gtk_entry_set_text(gui.entry_hmac_text, hmac);
} else {
gtk_toggle_button_set_active(gui.togglebutton_hmac_text, false);
gtk_entry_set_text(gui.entry_hmac_text, "");
}
delay();
const char *output = gtk_entry_get_text(gui.hash_widgets[id].entry_text);
g_assert_cmpstr(output, ==, digest);
}
gchar *input_dialog_with_invisible(const gchar *title, const gchar *message,
const gchar *default_string)
{
if (dialog && gtk_widget_get_visible(dialog)) return NULL;
if (!dialog)
input_dialog_create(TRUE);
type = INPUT_DIALOG_INVISIBLE;
gtk_widget_hide(combo);
gtk_widget_show(entry);
gtk_widget_hide(remember_checkbtn);
gtk_widget_hide(icon_q);
gtk_widget_show(icon_p);
is_pass = TRUE;
gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE);
return input_dialog_open(title, message, NULL, default_string, FALSE, NULL);
}
/**
lw_create:
create login window.
Return value: The widget pointer of login window.
*/
GtkWidget*
lw_create(void)
{
GtkBuilder *builder;
GError* error = NULL;
builder = gtk_builder_new ();
if (!gtk_builder_add_from_file (builder, UI_FILE, &error))
{
g_error (_("Couldn't load builder file: %s"), error->message);
g_error_free (error);
_exit(1);
}
/* This is important */
gtk_builder_connect_signals (builder, NULL);
/* get gtk widget from builder */
window = GTK_WIDGET (gtk_builder_get_object (builder, "window"));
ety_pwd = GTK_WIDGET (gtk_builder_get_object (builder, "ety_pwd"));
cbb_usr = GTK_WIDGET (gtk_builder_get_object (builder, "cbb_usr"));
chb_svpwd=GTK_WIDGET (gtk_builder_get_object (builder, "chb_svpwd"));
chb_apoffline=GTK_WIDGET (gtk_builder_get_object (builder,"chb_apoffline"));
/* set up window */
gtk_window_set_position (GTK_WINDOW(window), GTK_WIN_POS_CENTER_ALWAYS);
/* set up password entry */
gtk_entry_set_visibility (GTK_ENTRY(ety_pwd), FALSE);
/* set up user combo box */
GtkListStore *usr_lst = gtk_list_store_new (1, G_TYPE_STRING);
gtk_combo_box_set_model (GTK_COMBO_BOX (cbb_usr), GTK_TREE_MODEL (usr_lst));
gtk_combo_box_entry_set_text_column(GTK_COMBO_BOX_ENTRY(cbb_usr), 0);
cfg_get_lists_usrlist (&get_usrlist_cb);
g_object_unref (builder);
//dbg_print("DBG: Login Window is created.");
return window;
}
void
bisho_pane_username_add_entry (BishoPaneUsername *pane, const char *label, const char *key, gboolean visible)
{
BishoPaneUsernamePrivate *priv;
GtkWidget *label_w, *entry;
char *gconf_key, *value;
ServiceInfo *info;
g_return_if_fail (BISHO_IS_PANE_USERNAME (pane));
g_return_if_fail (label);
g_return_if_fail (key);
priv = pane->priv;
g_object_get (pane, "service", &info, NULL);
g_assert (info);
label_w = gtk_label_new (label);
gtk_widget_show (label_w);
gtk_table_attach (GTK_TABLE (priv->table), label_w,
0, 1, priv->rows, priv->rows + 1, GTK_FILL, GTK_FILL, 0, 0);
entry = gtk_entry_new ();
gtk_entry_set_visibility (GTK_ENTRY (entry), visible);
gtk_entry_set_width_chars (GTK_ENTRY (entry), 30);
g_signal_connect (entry, "focus-out-event", G_CALLBACK (on_entry_left), pane);
gtk_widget_show (entry);
gtk_table_attach (GTK_TABLE (priv->table), entry,
1, 2, priv->rows, priv->rows + 1, GTK_FILL, GTK_FILL, 0, 0);
gconf_key = g_strdup_printf ("/apps/libsocialweb/services/%s/%s", info->name, key);
g_object_set_data_full (G_OBJECT (entry), DATA_GCONF_KEY, gconf_key, g_free);
value = gconf_client_get_string (priv->gconf, gconf_key, NULL);
if (value) {
gtk_entry_set_text (GTK_ENTRY (entry), value);
g_free (value);
}
priv->rows++;
}
void execute_replies()
{
GtkWidget *table, *label1;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), MSG_7);
gtk_signal_connect (GTK_OBJECT (window), "delete_event",
GTK_SIGNAL_FUNC (delete_event), NULL);
table = gtk_table_new(3,2,FALSE);
gtk_container_add(GTK_CONTAINER(window),table);
label1 = gtk_label_new(MSG_24);
gtk_table_attach_defaults(GTK_TABLE(table),label1,0,1,0,1);
quit_message_entry = gtk_entry_new();
gtk_table_attach_defaults(GTK_TABLE(table),quit_message_entry,0,1,1,2);
gtk_entry_set_visibility(GTK_ENTRY(quit_message_entry),TRUE);
GtkWidget *button1 = gtk_button_new_with_label (MSG_23);
gtk_signal_connect (GTK_OBJECT (button1), "clicked", GTK_SIGNAL_FUNC (replies), (gpointer) NULL);
gtk_box_pack_start(GTK_BOX(table), button1, TRUE, TRUE, 0);
gtk_table_attach_defaults(GTK_TABLE(table),button1,1,2,1,2);
gtk_container_add(GTK_CONTAINER(window),table);
gtk_widget_show_all(window);
gtk_main();
}
int main( int argc, char **argv ) {
gtk_init( &argc, &argv );
GtkWidget *window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_window_set_title( GTK_WINDOW( window ), "Ex0601" );
gtk_container_set_border_width( GTK_CONTAINER( window ), 20 );
gtk_widget_set_size_request( window, 480, 320 );
GtkWidget *entry = gtk_entry_new();
gtk_entry_set_visibility( GTK_ENTRY( entry ), TRUE );
GtkWidget *button = gtk_button_new_with_mnemonic( "_Write to File" );
gtk_widget_set_sensitive( button, FALSE );
gtk_widget_set_sensitive( entry, FALSE );
Data data;
data.text = '\0';
data.filename = '\0';
data.entry = entry;
data.button = button;
GtkWidget *chooser = gtk_file_chooser_button_new( "Chooser a folder",
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
/* gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( chooser ), g_get_home_dir() ); */
g_signal_connect( G_OBJECT( chooser ), "selection_changed", G_CALLBACK( file_selected ),
(gpointer) &data );
g_signal_connect( G_OBJECT( entry ), "changed", G_CALLBACK( text_entered ), (gpointer) &data );
g_signal_connect( G_OBJECT( button ), "clicked", G_CALLBACK( button_clicked ), (gpointer) &data );
g_signal_connect( G_OBJECT( window ), "destroy", G_CALLBACK( destroy ), (gpointer) &data );
/* arragne all widgets together in a container */
GtkWidget *vbox = gtk_vbox_new( FALSE, 5 );
gtk_box_pack_start( GTK_BOX( vbox ), chooser, FALSE, FALSE, 10 );
gtk_box_pack_start( GTK_BOX( vbox ), entry, FALSE, FALSE, 10 );
gtk_box_pack_start( GTK_BOX( vbox ), button, FALSE, FALSE, 10 );
gtk_container_add( GTK_CONTAINER( window ), vbox );
gtk_widget_show_all( window );
gtk_main();
return 0;
}
char *get_input_string(const char *msg)
{
GtkWidget *entry;
GtkWidget *dialog;
dialog=gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(dialog),msg);
entry=gtk_entry_new();
/*如果传过来的字符为Password则设置密码输入不可见*/
if(strcmp(msg,"Password")==0)
gtk_entry_set_visibility(GTK_ENTRY(entry),FALSE);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),entry,FALSE,FALSE,10);
gtk_widget_show(entry);
gtk_dialog_add_button(GTK_DIALOG(dialog),GTK_STOCK_OK,GTK_RESPONSE_OK);
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_hide(dialog);
return gtk_entry_get_text(GTK_ENTRY(entry));
}
static char * get_password (rfbClient *client)
{
GtkWidget *dialog, *entry;
char *password;
gtk_widget_destroy (dialog_connecting);
dialog_connecting = NULL;
dialog = gtk_dialog_new_with_buttons ("Password",
NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
NULL);
entry = gtk_entry_new ();
gtk_entry_set_visibility (GTK_ENTRY (entry),
FALSE);
g_signal_connect (GTK_OBJECT(entry), "key-press-event",
G_CALLBACK(on_entry_key_press_event),
GTK_OBJECT (dialog));
gtk_widget_show (entry);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox),
entry);
gtk_widget_show (dialog);
switch (gtk_dialog_run (GTK_DIALOG (dialog))) {
case GTK_RESPONSE_ACCEPT:
password = strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
break;
default:
password = NULL;
break;
}
gtk_widget_destroy (dialog);
return password;
}
void login_popup(){
GtkWidget *window_login;
GtkWidget *table_login;
GtkWidget *button_login;
GtkWidget *label_name;
GtkWidget *label_pass;
GtkWidget *label_result;
window_login = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(window_login), GTK_WIN_POS_CENTER);
gtk_window_set_title(GTK_WINDOW(window_login), "Log In");
gtk_window_set_modal(GTK_WINDOW(window_login),TRUE);
gtk_container_set_border_width(GTK_CONTAINER(window_login),10);
table_login = gtk_table_new(4,2, FALSE);
label_result = gtk_label_new(NULL);
gtk_table_attach(GTK_TABLE(table_login), label_result, 0,2,0,1,
GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5);
label_name = gtk_label_new("Tai khoan : ");
gtk_table_attach(GTK_TABLE(table_login), label_name, 0,1,1,2,
GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5);
entry1 = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table_login), entry1, 1,2,1,2,
GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5);
label_pass = gtk_label_new("Mat Khau :");
gtk_table_attach(GTK_TABLE(table_login), label_pass, 0,1,2,3,
GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5);
entry2 = gtk_entry_new();
gtk_entry_set_visibility((GtkEntry *)entry2,FALSE);
gtk_table_attach(GTK_TABLE(table_login),entry2, 1,2,2,3,
GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5);
button_login = gtk_button_new_with_label("LOG IN");
gtk_table_attach(GTK_TABLE(table_login),button_login,1,2,3,4,
GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 5, 5);
g_signal_connect(GTK_BUTTON(button_login),"clicked",G_CALLBACK(login_funtion),label_result);
gtk_container_add(GTK_CONTAINER(window_login),table_login);
gtk_widget_show_all(window_login);
}
static void create_window()
{
GtkWidget *window;
GtkWidget *label;
GtkWidget *entry;
GtkWidget *button;
window = gtk_dialog_new_with_buttons("Renewing authentication",
NULL, 0,
GTK_STOCK_OK,
GTK_RESPONSE_OK,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
NULL);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
label = gtk_label_new("Type your password now to renew your authentication "
"to the system, which expires every 10 hours.");
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_CENTER);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox), label, TRUE, TRUE, 0);
gtk_widget_show(label);
entry = gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox), entry, TRUE, TRUE, 0);
gtk_widget_grab_focus(entry);
gtk_widget_show(entry);
g_signal_connect_object(G_OBJECT(entry), "activate",
G_CALLBACK(do_renew), entry, 0);
g_signal_connect_object(G_OBJECT(window), "response",
G_CALLBACK(dialog_response_cb), entry, 0);
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(quit), NULL);
gtk_widget_show(window);
}
static void process_single_field(
GtkWidget * container,
int row_index,
const char * label,
const char * value,
int is_password) {
GtkWidget * label_widget = gtk_label_new(label);
gtk_widget_set_halign(GTK_WIDGET(label_widget), GTK_ALIGN_END);
gtk_widget_set_margin_end(GTK_WIDGET(label_widget), 5);
GtkWidget * value_widget = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(value_widget), value);
gtk_widget_set_hexpand(GTK_WIDGET(value_widget), TRUE);
g_object_set(G_OBJECT(value_widget),
"editable", FALSE,
NULL
);
GtkWidget * copy_button = NULL, *reveal_button = NULL;
if(is_password) {
gtk_entry_set_visibility(GTK_ENTRY(value_widget), FALSE);
copy_button = gtk_button_new_with_mnemonic("_Copy");
g_signal_connect(G_OBJECT(copy_button), "clicked",
G_CALLBACK(handle_copy_button), value_widget);
reveal_button = gtk_button_new_with_mnemonic("_Reveal");
g_signal_connect(G_OBJECT(reveal_button), "clicked",
G_CALLBACK(handle_reveal_button), value_widget);
}
gtk_grid_attach(GTK_GRID(container), label_widget, 0, row_index, 1, 1);
gtk_grid_attach(GTK_GRID(container), value_widget, 1, row_index, copy_button == NULL ? 3 : 1, 1);
if(copy_button) {
gtk_grid_attach(GTK_GRID(container), copy_button, 2, row_index, 1, 1);
gtk_grid_attach(GTK_GRID(container), reveal_button, 3, row_index, 1, 1);
}
}
void osm_login_widgets (GtkWidget *user_entry, GtkWidget *password_entry)
{
if (!user_entry || !password_entry)
return;
const gchar *default_user = get_default_user();
const gchar *pref_user = a_preferences_get(VIKING_OSM_TRACES_PARAMS_NAMESPACE "username")->s;
const gchar *pref_password = a_preferences_get(VIKING_OSM_TRACES_PARAMS_NAMESPACE "password")->s;
if (osm_user != NULL && osm_user[0] != '\0')
gtk_entry_set_text(GTK_ENTRY(user_entry), osm_user);
else if (pref_user != NULL && pref_user[0] != '\0')
gtk_entry_set_text(GTK_ENTRY(user_entry), pref_user);
else if (default_user != NULL)
gtk_entry_set_text(GTK_ENTRY(user_entry), default_user);
if (osm_password != NULL && osm_password[0] != '\0')
gtk_entry_set_text(GTK_ENTRY(password_entry), osm_password);
else if (pref_password != NULL)
gtk_entry_set_text(GTK_ENTRY(password_entry), pref_password);
/* This is a password -> invisible */
gtk_entry_set_visibility(GTK_ENTRY(password_entry), FALSE);
}
void osm_login_widgets (GtkWidget *user_entry, GtkWidget *password_entry)
{
if (!user_entry || !password_entry)
return;
const gchar *default_user = get_default_user();
VikLayerParamData *pref_user = a_preferences_get ( OSM_USERNAME );
VikLayerParamData *pref_password = a_preferences_get ( OSM_PASSWORD );
if (osm_user != NULL && osm_user[0] != '\0')
gtk_entry_set_text(GTK_ENTRY(user_entry), osm_user);
else if (pref_user && pref_user->s && pref_user->s[0] != '\0')
gtk_entry_set_text(GTK_ENTRY(user_entry), pref_user->s);
else if (default_user != NULL)
gtk_entry_set_text(GTK_ENTRY(user_entry), default_user);
if (osm_password != NULL && osm_password[0] != '\0')
gtk_entry_set_text(GTK_ENTRY(password_entry), osm_password);
else if (pref_password && pref_password->s)
gtk_entry_set_text(GTK_ENTRY(password_entry), pref_password->s);
/* This is a password -> invisible */
gtk_entry_set_visibility(GTK_ENTRY(password_entry), FALSE);
}
void
html_text_input_init (HTMLTextInput *ti,
HTMLTextInputClass *klass,
GtkWidget *parent,
gchar *name,
gchar *value,
gint size,
gint maxlen,
gboolean password)
{
HTMLEmbedded *element;
GtkWidget *entry;
element = HTML_EMBEDDED (ti);
html_embedded_init (element, HTML_EMBEDDED_CLASS (klass),
parent, name, value);
entry = gtk_entry_new ();
html_embedded_set_widget (element, entry);
g_signal_connect_after (entry, "key_press_event", G_CALLBACK (html_text_input_key_pressed), element);
if (strlen (element->value))
gtk_entry_set_text (GTK_ENTRY (element->widget), element->value);
ti->default_text = g_strdup (element->value);
if (maxlen != -1)
gtk_entry_set_max_length (GTK_ENTRY (element->widget), maxlen);
gtk_entry_set_visibility (GTK_ENTRY (element->widget), !password);
gtk_entry_set_width_chars (GTK_ENTRY (element->widget), size);
ti->size = size;
ti->maxlen = maxlen;
}
static void remmina_file_editor_create_password(RemminaFileEditor* gfe, GtkWidget* table, gint row)
{
GtkWidget* widget;
gchar* s;
widget = gtk_label_new(_("Password"));
gtk_widget_show(widget);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), widget, 0, 1, row, row + 1, GTK_FILL, 0, 0, 0);
widget = gtk_entry_new();
gtk_widget_show(widget);
gtk_table_attach_defaults(GTK_TABLE(table), widget, 1, 2, row, row + 1);
gtk_entry_set_max_length(GTK_ENTRY(widget), 100);
gtk_entry_set_visibility(GTK_ENTRY(widget), FALSE);
gfe->priv->password_entry = widget;
s = remmina_file_get_secret(gfe->priv->remmina_file, "password");
if (s)
{
gtk_entry_set_text(GTK_ENTRY(widget), s);
g_free(s);
}
}
static void ug_proxy_form_std_init (UgProxyForm* pform)
{
GtkGrid* grid;
GtkWidget* widget;
GtkWidget* hbox;
pform->changed.host = FALSE;
pform->changed.port = FALSE;
pform->changed.user = FALSE;
pform->changed.password = FALSE;
pform->std = gtk_grid_new ();
grid = (GtkGrid*) pform->std;
// host label & entry
widget = gtk_label_new_with_mnemonic (_("Host:"));
pform->host = gtk_entry_new ();
gtk_entry_set_width_chars (GTK_ENTRY (pform->host), 8);
gtk_entry_set_activates_default (GTK_ENTRY (pform->host), TRUE);
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), pform->host);
g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
g_object_set (pform->host, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (grid, widget, 0, 0, 1, 1);
gtk_grid_attach (grid, pform->host, 1, 0, 1, 1);
// port label & entry
widget = gtk_label_new_with_mnemonic (_("Port:"));
pform->port = gtk_spin_button_new_with_range (0.0, 65535.0, 1.0);
gtk_entry_set_width_chars (GTK_ENTRY (pform->port), 5);
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), pform->port);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), pform->port, FALSE, FALSE, 0);
g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
g_object_set (hbox, "margin", 1, NULL);
gtk_grid_attach (grid, widget, 0, 1, 1, 1);
gtk_grid_attach (grid, hbox, 1, 1, 1, 1);
// center separator
widget = gtk_separator_new (GTK_ORIENTATION_VERTICAL);
g_object_set (widget, "margin", 1, NULL);
gtk_grid_attach (grid, widget, 2, 0, 1, 2);
// user label & entry
widget = gtk_label_new_with_mnemonic (_("User:"******"margin-left", 3, "margin-right", 3, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
g_object_set (pform->user, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (grid, widget, 3, 0, 1, 1);
gtk_grid_attach (grid, pform->user, 4, 0, 1, 1);
// password label & entry
widget = gtk_label_new_with_mnemonic (_("Password:"******"margin-left", 3, "margin-right", 3, NULL);
g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
g_object_set (pform->password, "margin", 1, "hexpand", TRUE, NULL);
gtk_grid_attach (grid, widget, 3, 1, 1, 1);
gtk_grid_attach (grid, pform->password, 4, 1, 1, 1);
g_signal_connect (GTK_EDITABLE (pform->user), "changed",
G_CALLBACK (on_entry_std_changed), pform);
g_signal_connect (GTK_EDITABLE (pform->password), "changed",
G_CALLBACK (on_entry_std_changed), pform);
g_signal_connect (GTK_EDITABLE (pform->host), "changed",
G_CALLBACK (on_entry_std_changed), pform);
g_signal_connect (GTK_EDITABLE (pform->port), "changed",
G_CALLBACK (on_entry_std_changed), pform);
gtk_widget_show_all (pform->std);
}
static void
tweet_auth_dialog_constructed (GObject *gobject)
{
TweetAuthDialog *dialog = TWEET_AUTH_DIALOG (gobject);
TweetAuthDialogPrivate *priv = dialog->priv;
GtkWidget *main_hbox;
GtkWidget *hbox, *vbox;
GtkWidget *label;
GtkWidget *image;
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 2);
gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
g_signal_connect (dialog, "response", G_CALLBACK (on_response), NULL);
main_hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
main_hbox,
FALSE, FALSE, 0);
gtk_widget_show (main_hbox);
image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_AUTHENTICATION,
GTK_ICON_SIZE_DIALOG);
gtk_box_pack_start (GTK_BOX (main_hbox), image, TRUE, TRUE, 0);
gtk_widget_show (image);
vbox = gtk_vbox_new (FALSE, 12);
gtk_box_pack_end (GTK_BOX (main_hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
priv->size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
label = gtk_label_new (_("Please insert the email address and password\n"
"used when registering the account on Twitter."));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 1.0);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
/* email entry */
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Email address:"));
gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_size_group_add_widget (priv->size_group, label);
gtk_widget_show (label);
priv->email_entry = gtk_entry_new ();
g_signal_connect (priv->email_entry,
"changed", G_CALLBACK (on_email_changed),
dialog);
gtk_box_pack_end (GTK_BOX (hbox), priv->email_entry, TRUE, TRUE, 0);
gtk_widget_show (priv->email_entry);
/* password entry */
hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Password:"******"changed", G_CALLBACK (on_password_changed),
dialog);
gtk_box_pack_end (GTK_BOX (hbox), priv->password_entry, TRUE, TRUE, 0);
gtk_widget_show (priv->password_entry);
priv->verify_label = gtk_label_new ("");
gtk_box_pack_end (GTK_BOX (vbox), priv->verify_label, FALSE, FALSE, 0);
gtk_widget_show (priv->verify_label);
/* buttons */
priv->ok_button = gtk_dialog_add_button (GTK_DIALOG (dialog),
GTK_STOCK_OK,
GTK_RESPONSE_OK);
gtk_widget_set_sensitive (priv->ok_button, FALSE);
priv->verify_button = gtk_dialog_add_button (GTK_DIALOG (dialog),
_("Verify credentials"),
1);
gtk_widget_set_sensitive (priv->verify_button, FALSE);
gtk_dialog_add_button (GTK_DIALOG (dialog),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
}
/****************************************************************************************************
* construct the widget
****************************************************************************************************/
config_widget_construct(ConfigWidget * config_widget, Config * config)
{
GtkWidget *box_v = GTK_WIDGET(config_widget);
int count = config -> num_entries;
GtkWidget * labels[count];
config_widget -> entries = malloc(sizeof(GtkWidget*) * count);
GtkWidget ** entries = config_widget -> entries;
int i; char buf[100];
for (i = 0; i < count; i++){
ConfEntry ce = config -> entries[i];
labels[i] = gtk_label_new(ce.name);
switch (ce.type){
case TYPE_STRING:
case TYPE_DIR:
case TYPE_IP:{
sprintf(buf, "%s", (char*)ce.data);
entries[i] = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(entries[i]), buf) ;
break;
}
case TYPE_PASSWORD:{
sprintf(buf, "%s", (char*)ce.data);
entries[i] = gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(entries[i]), FALSE);
gtk_entry_set_text(GTK_ENTRY(entries[i]), buf) ;
break;
}
case TYPE_COLOR:{
sprintdouble(buf, ((ColorQuadriple*)ce.data) -> r, 2);
sprintf(buf+strlen(buf), "%s", ",");
sprintdouble(buf+strlen(buf), ((ColorQuadriple*)ce.data) -> g, 2);
sprintf(buf+strlen(buf), "%s", ",");
sprintdouble(buf+strlen(buf), ((ColorQuadriple*)ce.data) -> b, 2);
sprintf(buf+strlen(buf), "%s", ",");
sprintdouble(buf+strlen(buf), ((ColorQuadriple*)ce.data) -> a, 2);
entries[i] = color_box_new();
color_box_set_current_value(GOSM_COLOR_BOX(entries[i]), buf);
break;
}
case TYPE_INT:{
sprintf(buf, "%d", *(int*)ce.data);
entries[i] = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(entries[i]), buf);
break;
}
case TYPE_DOUBLE:{
sprintdouble(buf, *(double*)ce.data, 4);
entries[i] = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(entries[i]), buf);
break;
}
case TYPE_BOOLEAN:{
entries[i] = gtk_check_button_new();
gboolean active = *(gboolean*)ce.data;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(entries[i]), active);
break;
}
default:{
entries[i] = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(entries[i]), ce.data_str);
}
}
}
GtkWidget * table = gtk_table_new(2, 9, FALSE);
for (i = 0; i < count; i++){
GtkWidget * box = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(box), labels[i], FALSE, FALSE, 0);
gtk_table_attach(GTK_TABLE(table), box, 0, 1, i, i+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_table_attach(GTK_TABLE(table), entries[i], 1, 2, i, i+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
}
GtkWidget * scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled), table);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
GtkWidget * box_buttons = gtk_hbox_new(FALSE, 0);
config_widget -> button_confirm = gtk_button_new_from_stock("gtk-apply");
config_widget -> button_cancel = gtk_button_new_from_stock("gtk-cancel");
gtk_box_pack_start(GTK_BOX(box_buttons), config_widget -> button_confirm, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(box_buttons), config_widget -> button_cancel , FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(box_v), scrolled, TRUE, TRUE, 0);
gtk_box_pack_end (GTK_BOX(box_v), box_buttons, FALSE, FALSE, 0);
}
/* Public VpnPasswordDialog methods */
GtkWidget *
vpn_password_dialog_new (const char *title,
const char *message,
const char *password)
{
GtkWidget *dialog;
VpnPasswordDialogPrivate *priv;
GtkLabel *message_label;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *main_vbox;
GtkWidget *dialog_icon;
GtkBox *content, *action_area;
dialog = gtk_widget_new (VPN_TYPE_PASSWORD_DIALOG, NULL);
if (!dialog)
return NULL;
priv = VPN_PASSWORD_DIALOG_GET_PRIVATE (dialog);
gtk_window_set_title (GTK_WINDOW (dialog), title);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
#if !GTK_CHECK_VERSION(3,10,0)
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
#else
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
_Cancel, GTK_RESPONSE_CANCEL,
_OK, GTK_RESPONSE_OK,
NULL);
#endif
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
content = GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog)));
action_area = GTK_BOX (gtk_dialog_get_action_area (GTK_DIALOG (dialog)));
/* Set up the dialog */
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_box_set_spacing (content, 2); /* 2 * 5 + 2 = 12 */
gtk_container_set_border_width (GTK_CONTAINER (action_area), 5);
gtk_box_set_spacing (action_area, 6);
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
g_signal_connect (dialog, "show",
G_CALLBACK (dialog_show_callback),
dialog);
g_signal_connect (dialog, "close",
G_CALLBACK (dialog_close_callback),
dialog);
/* The grid that holds the captions */
priv->grid_alignment = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
priv->group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
priv->grid = gtk_grid_new ();
gtk_grid_set_column_spacing (GTK_GRID (priv->grid), 12);
gtk_grid_set_row_spacing (GTK_GRID (priv->grid), 6);
gtk_container_add (GTK_CONTAINER (priv->grid_alignment), priv->grid);
priv->password_entry = gtk_entry_new ();
priv->password_entry_secondary = gtk_entry_new ();
priv->show_passwords_checkbox = gtk_check_button_new_with_mnemonic (_("Sh_ow passwords"));
/* We want to hold on to these during the grid rearrangement */
g_object_ref_sink (priv->password_entry);
g_object_ref_sink (priv->password_entry_secondary);
g_object_ref_sink (priv->show_passwords_checkbox);
gtk_entry_set_visibility (GTK_ENTRY (priv->password_entry), FALSE);
gtk_entry_set_visibility (GTK_ENTRY (priv->password_entry_secondary), FALSE);
g_signal_connect_swapped (priv->password_entry, "activate",
G_CALLBACK (gtk_window_activate_default),
dialog);
g_signal_connect_swapped (priv->password_entry_secondary, "activate",
G_CALLBACK (gtk_window_activate_default),
dialog);
g_signal_connect (priv->show_passwords_checkbox, "toggled",
G_CALLBACK (show_passwords_toggled_cb),
dialog);
add_grid_rows (VPN_PASSWORD_DIALOG (dialog));
/* Adds some eye-candy to the dialog */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
#if !GTK_CHECK_VERSION(3,10,0)
dialog_icon = gtk_image_new_from_stock(GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG);
#else
dialog_icon = gtk_image_new_from_icon_name("dialog-password", GTK_ICON_SIZE_DIALOG);
#endif
gtk_misc_set_alignment (GTK_MISC (dialog_icon), 0.5, 0.0);
gtk_box_pack_start (GTK_BOX (hbox), dialog_icon, FALSE, FALSE, 0);
/* Fills the vbox */
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18);
if (message) {
message_label = GTK_LABEL (gtk_label_new (message));
gtk_label_set_justify (message_label, GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap (message_label, TRUE);
gtk_label_set_max_width_chars (message_label, 35);
gtk_size_group_add_widget (priv->group, GTK_WIDGET (message_label));
gtk_box_pack_start (GTK_BOX (main_vbox), GTK_WIDGET (message_label), FALSE, FALSE, 0);
gtk_size_group_add_widget (priv->group, priv->grid_alignment);
}
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), priv->grid_alignment, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), main_vbox, FALSE, FALSE, 0);
gtk_box_pack_start (content, hbox, FALSE, FALSE, 0);
gtk_widget_show_all (GTK_WIDGET (content));
vpn_password_dialog_set_password (VPN_PASSWORD_DIALOG (dialog), password);
return GTK_WIDGET (dialog);
}
static void entry_toggle_visibility( GtkWidget *checkbutton,
GtkWidget *entry )
{
gtk_entry_set_visibility (GTK_ENTRY (entry),
GTK_TOGGLE_BUTTON (checkbutton)->active);
}
GtkWidget* dialogPasswordCreate(void) {
GtkWidget *dailogPassword;
GtkWidget *vbox1;
GtkWidget *label1;
GtkWidget *hbox1;
GtkWidget *button1;
dailogPassword = gtk_window_new (GTK_WINDOW_DIALOG);
gtk_object_set_data (GTK_OBJECT (dailogPassword), "dailogPassword", dailogPassword);
gtk_container_set_border_width (GTK_CONTAINER (dailogPassword), 7);
gtk_window_set_title (GTK_WINDOW (dailogPassword), "Password");
gtk_window_set_modal (GTK_WINDOW (dailogPassword), TRUE);
gtk_window_set_policy (GTK_WINDOW (dailogPassword), FALSE, FALSE, FALSE);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (vbox1);
gtk_object_set_data_full (GTK_OBJECT (dailogPassword), "vbox1", vbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (dailogPassword), vbox1);
gtk_container_set_border_width (GTK_CONTAINER (vbox1), 4);
label1 = gtk_label_new ("This game is password protected.\nEnter the correct password to join:");
gtk_widget_ref (label1);
gtk_object_set_data_full (GTK_OBJECT (dailogPassword), "label1", label1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label1);
gtk_box_pack_start (GTK_BOX (vbox1), label1, FALSE, FALSE, 0);
gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (hbox1);
gtk_object_set_data_full (GTK_OBJECT (dailogPassword), "hbox1", hbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 0);
idc_passwordtxt = gtk_entry_new ();
gtk_widget_ref (idc_passwordtxt);
gtk_object_set_data_full (GTK_OBJECT (dailogPassword), "idc_passwordtxt", idc_passwordtxt,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (idc_passwordtxt);
gtk_box_pack_start (GTK_BOX (hbox1), idc_passwordtxt, TRUE, TRUE, 0);
gtk_entry_set_visibility (GTK_ENTRY (idc_passwordtxt), FALSE);
button1 = gtk_button_new_with_label ("OK");
gtk_widget_ref (button1);
gtk_object_set_data_full (GTK_OBJECT (dailogPassword), "button1", button1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button1);
gtk_box_pack_start (GTK_BOX (hbox1), button1, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT);
gtk_widget_grab_focus (idc_passwordtxt);
gtk_widget_grab_default (button1);
gtk_signal_connect(GTK_OBJECT(dailogPassword), "delete_event", GTK_SIGNAL_FUNC (dialogPasswordClose), NULL);
gtk_signal_connect(GTK_OBJECT(button1), "clicked", GTK_SIGNAL_FUNC(dialogPasswordClose), 0);
gtk_signal_connect(GTK_OBJECT(idc_passwordtxt), "key-press-event", GTK_SIGNAL_FUNC(dialogPasswordKey), 0);
dialogPasswordUs = dailogPassword;
return dailogPassword;
}
//Fonction de création de la fenêtre principale
void creer_fenetre_principale (struct main* m)
{
//LOCK GTK OK
GtkWidget *p_window = NULL;
GtkWidget *p_main_box = NULL;
GtkWidget *p_menu_bar = NULL;
GtkWidget *p_menu_item = NULL;
GtkWidget *p_menu = NULL;
GtkWidget *p_instruction = NULL;
GtkWidget *p_box_boutons = NULL;
GtkWidget *p_bouton_valider = NULL;
GtkWidget *p_bouton_quitter = NULL;
/* Creation de la fenêtre principale */
p_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
m->fenetre_principale.sig_destroy = g_signal_connect (G_OBJECT (p_window), "destroy", G_CALLBACK (arret), m);
gtk_window_set_title (GTK_WINDOW (p_window), "Puissance 5 en réseau");
/*Création du conteneur principal*/
p_main_box = gtk_vbox_new (FALSE, 10);
gtk_container_add (GTK_CONTAINER (p_window), p_main_box);
/*Création de la barre menu*/
p_menu_bar = gtk_menu_bar_new ();
gtk_box_pack_start (GTK_BOX (p_main_box), p_menu_bar, FALSE, FALSE, 0);
/*Création du menu Quitter*/
p_menu = gtk_menu_new ();
p_menu_item = gtk_menu_item_new_with_mnemonic ("_Fichier");
menu_item_new (GTK_MENU(p_menu), "Quitter", G_CALLBACK(arret), m);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (p_menu_item), p_menu);
gtk_menu_shell_append (GTK_MENU_SHELL (p_menu_bar), p_menu_item);
/*Création de la ligne de boutons*/
p_box_boutons = gtk_hbox_new (FALSE, 20); //gtk_hbutton_box_new ();
gtk_box_pack_end (GTK_BOX (p_main_box), p_box_boutons, FALSE, FALSE, 0);
/*Création du bouton quitter*/
p_bouton_quitter = gtk_button_new_from_stock (GTK_STOCK_QUIT);
g_signal_connect (G_OBJECT (p_bouton_quitter), "clicked", G_CALLBACK (arret), m);
gtk_box_pack_end (GTK_BOX (p_box_boutons), p_bouton_quitter, FALSE, FALSE, 0);
/*Création du bouton Valider*/
p_bouton_valider = gtk_button_new_from_stock (GTK_STOCK_OK); //gtk_button_new_with_label("Valider");
g_signal_connect (G_OBJECT (p_bouton_valider), "clicked", G_CALLBACK (signal_traitement_champs), (gpointer) m);
gtk_box_pack_end (GTK_BOX (p_box_boutons), p_bouton_valider, FALSE, FALSE, 0);
//Création du champ de mot de passe
m->fenetre_principale.mdp = add_new_champ_end("Mot de passe :", p_main_box, 0);
gtk_entry_set_visibility(m->fenetre_principale.mdp.entry, FALSE);
g_signal_connect(GTK_OBJECT(m->fenetre_principale.mdp.entry), "activate", G_CALLBACK(signal_traitement_champs), (gpointer) m);
//Création du champ de login
m->fenetre_principale.login = add_new_champ_end("Login :"******"activate", G_CALLBACK(signal_traitement_champs), (gpointer) m);
//Création du champ de port
m->fenetre_principale.port = add_new_champ_end("Port :", p_main_box, 0);
g_signal_connect(GTK_OBJECT(m->fenetre_principale.port.entry), "activate", G_CALLBACK(signal_traitement_champs), (gpointer) m);
//Création du champ de IP
m->fenetre_principale.ip = add_new_champ_end("IP :", p_main_box, 16);
g_signal_connect(GTK_OBJECT(m->fenetre_principale.ip.entry), "activate", G_CALLBACK(signal_traitement_champs), (gpointer) m);
//Création de l'instruction
p_instruction = gtk_label_new("Veuillez rentrer les informations pour vous connecter :");
gtk_box_pack_end (GTK_BOX (p_main_box), p_instruction, FALSE, FALSE, 0);
m->fenetre_principale.instruction = GTK_LABEL(p_instruction);
m->fenetre_principale.open = 1;
m->fenetre_principale.adresse = p_window;
}
void zenity_forms_dialog (ZenityData *data, ZenityFormsData *forms_data)
{
GtkBuilder *builder = NULL;
GtkWidget *dialog;
GtkWidget *grid;
GtkWidget *text;
GtkWidget *button;
GSList *tmp;
int list_count = 0;
int combo_count = 0;
int i = 0;
zen_data = data;
builder = zenity_util_load_ui_file("zenity_forms_dialog", NULL);
if (builder == NULL) {
data->exit_code = zenity_util_return_exit_code (ZENITY_ERROR);
return;
}
gtk_builder_connect_signals(builder, NULL);
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_forms_dialog"));
g_signal_connect (G_OBJECT(dialog), "response",
G_CALLBACK (zenity_forms_dialog_response), forms_data);
if (data->dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
if (data->width > -1 || data->height > -1)
gtk_window_set_default_size (GTK_WINDOW (dialog), data->width, data->height);
if (data->extra_label) {
gint i=0;
while(data->extra_label[i]!=NULL){
gtk_dialog_add_button (GTK_DIALOG (dialog), data->extra_label[i], i);
i++;
}
}
if (data->ok_label) {
button = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_forms_ok_button"));
gtk_button_set_label (GTK_BUTTON (button), data->ok_label);
}
if (data->cancel_label) {
button = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_forms_cancel_button"));
gtk_button_set_label (GTK_BUTTON (button), data->cancel_label);
}
text = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_forms_text"));
if (forms_data->dialog_text)
gtk_label_set_markup (GTK_LABEL (text), g_strcompress (forms_data->dialog_text));
grid = GTK_WIDGET (gtk_builder_get_object (builder, "zenity_forms_grid"));
for (tmp = forms_data->list; tmp; tmp = tmp->next) {
ZenityFormsValue *zenity_value = (ZenityFormsValue *) tmp->data;
GtkWidget *label;
gchar **values = g_strsplit_set (zenity_value->option_value, "|", 2);
gchar *label_text = values[0];
gchar *prefill_text = values[1];
label = gtk_label_new(label_text);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (grid),
label,
0, i,
1, 1);
switch(zenity_value->type)
{
case ZENITY_FORMS_ENTRY:
zenity_value->forms_widget = gtk_entry_new();
if (prefill_text) {
gtk_entry_set_text(GTK_ENTRY(zenity_value->forms_widget),
prefill_text);
}
break;
case ZENITY_FORMS_PASSWORD:
zenity_value->forms_widget = gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(zenity_value->forms_widget),
FALSE);
break;
case ZENITY_FORMS_CALENDAR:
zenity_value->forms_widget = gtk_calendar_new();
break;
case ZENITY_FORMS_LIST:
zenity_value->forms_widget = zenity_forms_create_and_fill_list (forms_data, list_count,
zenity_value->option_value);
list_count++;
break;
case ZENITY_FORMS_COMBO:
zenity_value->forms_widget = zenity_forms_create_and_fill_combo (forms_data, combo_count);
combo_count++;
break;
default:
zenity_value->forms_widget = gtk_entry_new();
break;
}
g_strfreev(values);
gtk_grid_attach_next_to (GTK_GRID (grid),
GTK_WIDGET (zenity_value->forms_widget),
label,
GTK_POS_RIGHT,
1, 1);
i++;
}
gtk_widget_show_all (GTK_WIDGET (dialog));
g_object_unref (builder);
if (data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay, (GSourceFunc) zenity_util_timeout_handle, dialog);
}
gtk_main();
}
GtkWidget *a_uibuilder_new_widget ( VikLayerParam *param, VikLayerParamData data )
{
// Perform pre conversion if necessary
VikLayerParamData vlpd = data;
if ( param->convert_to_display )
vlpd = param->convert_to_display ( data );
GtkWidget *rv = NULL;
switch ( param->widget_type )
{
case VIK_LAYER_WIDGET_COLOR:
if ( param->type == VIK_LAYER_PARAM_COLOR )
rv = gtk_color_button_new_with_color ( &(vlpd.c) );
break;
case VIK_LAYER_WIDGET_CHECKBUTTON:
if ( param->type == VIK_LAYER_PARAM_BOOLEAN )
{
//rv = gtk_check_button_new_with_label ( //param->title );
rv = gtk_check_button_new ();
if ( vlpd.b )
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON(rv), TRUE );
}
break;
case VIK_LAYER_WIDGET_COMBOBOX:
if ( param->type == VIK_LAYER_PARAM_UINT && param->widget_data )
{
/* Build a simple combobox */
gchar **pstr = param->widget_data;
rv = vik_combo_box_text_new ();
while ( *pstr )
vik_combo_box_text_append ( rv, *(pstr++) );
if ( param->extra_widget_data ) /* map of alternate uint values for options */
{
/* Set the effective default value */
int i;
for ( i = 0; ((const char **)param->widget_data)[i]; i++ )
if ( ((guint *)param->extra_widget_data)[i] == vlpd.u )
{
/* Match default value */
gtk_combo_box_set_active ( GTK_COMBO_BOX(rv), i );
break;
}
}
else
gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), vlpd.u );
}
else if ( param->type == VIK_LAYER_PARAM_STRING && param->widget_data && !param->extra_widget_data )
{
/* Build a combobox with editable text */
gchar **pstr = param->widget_data;
#if GTK_CHECK_VERSION (2, 24, 0)
rv = gtk_combo_box_text_new_with_entry ();
#else
rv = gtk_combo_box_entry_new_text ();
#endif
if ( vlpd.s )
vik_combo_box_text_append ( rv, vlpd.s );
while ( *pstr )
vik_combo_box_text_append ( rv, *(pstr++) );
if ( vlpd.s )
gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), 0 );
}
else if ( param->type == VIK_LAYER_PARAM_STRING && param->widget_data && param->extra_widget_data)
{
/* Build a combobox with fixed selections without editable text */
gchar **pstr = param->widget_data;
rv = GTK_WIDGET ( vik_combo_box_text_new () );
while ( *pstr )
vik_combo_box_text_append ( rv, *(pstr++) );
if ( vlpd.s )
{
/* Set the effective default value */
/* In case of value does not exist, set the first value */
gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), 0 );
int i;
for ( i = 0; ((const char **)param->widget_data)[i]; i++ )
if ( strcmp(((const char **)param->extra_widget_data)[i], vlpd.s) == 0 )
{
/* Match default value */
gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), i );
break;
}
}
else
gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), 0 );
}
break;
case VIK_LAYER_WIDGET_RADIOGROUP:
/* widget_data and extra_widget_data are GList */
if ( param->type == VIK_LAYER_PARAM_UINT && param->widget_data )
{
rv = vik_radio_group_new ( param->widget_data );
if ( param->extra_widget_data ) /* map of alternate uint values for options */
{
int i;
int nb_elem = g_list_length(param->widget_data);
for ( i = 0; i < nb_elem; i++ )
if ( GPOINTER_TO_UINT ( g_list_nth_data(param->extra_widget_data, i) ) == vlpd.u )
{
vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), i );
break;
}
}
else if ( vlpd.u ) /* zero is already default */
vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), vlpd.u );
}
break;
case VIK_LAYER_WIDGET_RADIOGROUP_STATIC:
if ( param->type == VIK_LAYER_PARAM_UINT && param->widget_data )
{
rv = vik_radio_group_new_static ( (const gchar **) param->widget_data );
if ( param->extra_widget_data ) /* map of alternate uint values for options */
{
int i;
for ( i = 0; ((const char **)param->widget_data)[i]; i++ )
if ( ((guint *)param->extra_widget_data)[i] == vlpd.u )
{
vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), i );
break;
}
}
else if ( vlpd.u ) /* zero is already default */
vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), vlpd.u );
}
break;
case VIK_LAYER_WIDGET_SPINBUTTON:
if ( (param->type == VIK_LAYER_PARAM_DOUBLE || param->type == VIK_LAYER_PARAM_UINT
|| param->type == VIK_LAYER_PARAM_INT) && param->widget_data )
{
gdouble init_val = (param->type == VIK_LAYER_PARAM_DOUBLE) ? vlpd.d : (param->type == VIK_LAYER_PARAM_UINT ? vlpd.u : vlpd.i);
VikLayerParamScale *scale = (VikLayerParamScale *) param->widget_data;
rv = gtk_spin_button_new ( GTK_ADJUSTMENT(gtk_adjustment_new( init_val, scale->min, scale->max, scale->step, scale->step, 0 )), scale->step, scale->digits );
}
break;
case VIK_LAYER_WIDGET_ENTRY:
if ( param->type == VIK_LAYER_PARAM_STRING )
{
rv = gtk_entry_new ();
if ( vlpd.s )
gtk_entry_set_text ( GTK_ENTRY(rv), vlpd.s );
}
break;
case VIK_LAYER_WIDGET_PASSWORD:
if ( param->type == VIK_LAYER_PARAM_STRING )
{
rv = gtk_entry_new ();
gtk_entry_set_visibility ( GTK_ENTRY(rv), FALSE );
if ( vlpd.s )
gtk_entry_set_text ( GTK_ENTRY(rv), vlpd.s );
gtk_widget_set_tooltip_text ( GTK_WIDGET(rv),
_("Take care that this password will be stored clearly in a plain file.") );
}
break;
case VIK_LAYER_WIDGET_FILEENTRY:
if ( param->type == VIK_LAYER_PARAM_STRING )
{
rv = vik_file_entry_new (GTK_FILE_CHOOSER_ACTION_OPEN);
if ( vlpd.s )
vik_file_entry_set_filename ( VIK_FILE_ENTRY(rv), vlpd.s );
}
break;
case VIK_LAYER_WIDGET_FOLDERENTRY:
if ( param->type == VIK_LAYER_PARAM_STRING )
{
rv = vik_file_entry_new (GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
if ( vlpd.s )
vik_file_entry_set_filename ( VIK_FILE_ENTRY(rv), vlpd.s );
}
break;
case VIK_LAYER_WIDGET_FILELIST:
if ( param->type == VIK_LAYER_PARAM_STRING_LIST )
{
rv = vik_file_list_new ( _(param->title) );
vik_file_list_set_files ( VIK_FILE_LIST(rv), vlpd.sl );
}
break;
case VIK_LAYER_WIDGET_HSCALE:
if ( (param->type == VIK_LAYER_PARAM_DOUBLE || param->type == VIK_LAYER_PARAM_UINT
|| param->type == VIK_LAYER_PARAM_INT) && param->widget_data )
{
gdouble init_val = (param->type == VIK_LAYER_PARAM_DOUBLE) ? vlpd.d : (param->type == VIK_LAYER_PARAM_UINT ? vlpd.u : vlpd.i);
VikLayerParamScale *scale = (VikLayerParamScale *) param->widget_data;
rv = gtk_hscale_new_with_range ( scale->min, scale->max, scale->step );
gtk_scale_set_digits ( GTK_SCALE(rv), scale->digits );
gtk_range_set_value ( GTK_RANGE(rv), init_val );
}
}
if ( rv && !gtk_widget_get_tooltip_text ( rv ) ) {
if ( param->tooltip )
gtk_widget_set_tooltip_text ( rv, _(param->tooltip) );
}
return rv;
}
void fx_proxy_initialize(FxProxy *fxproxy)
{
GtkBox *vbox = NULL;
GtkBox *action_area = NULL;
GtkWidget *hostLabel = NULL;
GtkWidget *portLabel = NULL;
GtkWidget *userLabel = NULL;
GtkWidget *passLabel = NULL;
GtkWidget *fixed = NULL;
GtkWidget *okBtn = NULL;
GtkWidget *cancelBtn = NULL;
GdkPixbuf *pb = NULL;
char text[128];
Proxy *proxy = fxproxy->fxlogin->proxy;
fxproxy->dialog = gtk_dialog_new();
gtk_widget_set_usize(fxproxy->dialog , 350 , 220);
gtk_window_set_resizable(GTK_WINDOW(fxproxy->dialog) , FALSE);
gtk_window_set_title(GTK_WINDOW(fxproxy->dialog) , _("Set HTTP Proxy"));
pb = gdk_pixbuf_new_from_file(SKIN_DIR"proxy.png" , NULL);
gtk_window_set_icon(GTK_WINDOW(fxproxy->dialog) , pb);
vbox = GTK_BOX(GTK_DIALOG(fxproxy->dialog)->vbox);
action_area = GTK_BOX(GTK_DIALOG(fxproxy->dialog)->action_area);
fixed = gtk_fixed_new();
fxproxy->enableBtn = gtk_check_button_new_with_label(_("Trun on HTTP proxy"));
g_signal_connect(fxproxy->enableBtn , "toggled"
, G_CALLBACK(fx_proxy_enable_toggled) , fxproxy);
gtk_fixed_put(GTK_FIXED(fixed) , fxproxy->enableBtn , 20 , 20);
fxproxy->errorLabel = gtk_label_new(NULL);
gtk_fixed_put(GTK_FIXED(fixed) , fxproxy->errorLabel , 180 , 22);
hostLabel = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(hostLabel) , _("<b>Proxy host</b>"));
gtk_fixed_put(GTK_FIXED(fixed) , hostLabel , 20 , 55);
portLabel = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(portLabel) , _("<b>Port</b>"));
gtk_fixed_put(GTK_FIXED(fixed) , portLabel , 190 , 55);
fxproxy->hostEntry = gtk_entry_new();
gtk_widget_set_usize(fxproxy->hostEntry , 140 , 25);
gtk_fixed_put(GTK_FIXED(fixed) , fxproxy->hostEntry , 20 , 75);
fxproxy->portEntry = gtk_entry_new();
gtk_widget_set_usize(fxproxy->portEntry , 140 , 25);
gtk_fixed_put(GTK_FIXED(fixed) , fxproxy->portEntry , 190 , 75);
userLabel = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(userLabel) , _("<b>Uesrname</b>"));
gtk_fixed_put(GTK_FIXED(fixed) , userLabel , 20 , 110);
passLabel = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(passLabel) , _("<b>Password</b>"));
gtk_fixed_put(GTK_FIXED(fixed) , passLabel , 190 , 110);
fxproxy->userEntry = gtk_entry_new();
gtk_widget_set_usize(fxproxy->userEntry , 140 , 25);
gtk_fixed_put(GTK_FIXED(fixed) , fxproxy->userEntry , 20 , 130);
fxproxy->passEntry = gtk_entry_new();
gtk_widget_set_usize(fxproxy->passEntry , 140 , 25);
gtk_entry_set_visibility(GTK_ENTRY(fxproxy->passEntry) , FALSE);
gtk_fixed_put(GTK_FIXED(fixed) , fxproxy->passEntry , 190 , 130);
okBtn = gtk_button_new_with_label(_("OK"));
g_signal_connect(okBtn , "clicked"
, G_CALLBACK(fx_proxy_on_ok_clicked) , fxproxy);
cancelBtn = gtk_button_new_with_label(_("Cancel"));
g_signal_connect(cancelBtn , "clicked"
, G_CALLBACK(fx_proxy_on_cancel_clicked) , fxproxy);
gtk_box_pack_start_defaults(vbox , fixed);
gtk_box_pack_start_defaults(action_area , okBtn);
gtk_box_pack_start_defaults(action_area , cancelBtn);
/* bind data*/
if(proxy != NULL && proxy->proxyEnabled)
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fxproxy->enableBtn) , TRUE);
fx_proxy_set_sensitive(fxproxy , TRUE);
}
else
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fxproxy->enableBtn) , FALSE);
fx_proxy_set_sensitive(fxproxy , FALSE);
}
if(proxy != NULL)
{
gtk_entry_set_text(GTK_ENTRY(fxproxy->hostEntry) , proxy->proxyHost);
snprintf(text, sizeof(text) - 1 , "%d" , proxy->proxyPort);
gtk_entry_set_text(GTK_ENTRY(fxproxy->portEntry) , text);
gtk_entry_set_text(GTK_ENTRY(fxproxy->userEntry) , proxy->proxyUser);
gtk_entry_set_text(GTK_ENTRY(fxproxy->passEntry) , proxy->proxyPass);
}
/* show widgets*/
gtk_widget_show_all(fxproxy->dialog);
}
int main(int argc, char **argv)
{
int fd;
char raw_data[150];
if ((fd = open("gsd.config", O_RDONLY)) >= 0) {
read(fd, raw_data, 150);
close(fd);
int y = 0;
for (int i = 0; i < 3; i++) {
for (int x = 0; x < 32; x++) {
data[i][x] = '\0';
}
for (int x = 0; raw_data[y] != '\n' && x < 32; x++) {
data[i][x] = raw_data[y];
y++;
}
y++;
}
gtk_init(&argc, &argv);
password_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(password_window), "Iniciando Sesión");
gtk_signal_connect (GTK_OBJECT (password_window), "delete_event",
GTK_SIGNAL_FUNC (delete_event), NULL);
GtkWidget *box1 = gtk_table_new(3,2,FALSE);
GtkWidget *button1 = gtk_button_new_with_label (MSG_11);
gtk_signal_connect (GTK_OBJECT (button1), "clicked", GTK_SIGNAL_FUNC (password_load), (gpointer) "button 1");
gtk_box_pack_start(GTK_BOX(box1), button1, TRUE, TRUE, 0);
gtk_table_attach_defaults(GTK_TABLE(box1),button1,0,2,9,10);
GtkWidget *label1 = gtk_label_new(MSG_6);
gtk_table_attach_defaults(GTK_TABLE(box1),label1,0,1,2,3);
entry[3] = gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(entry[3]),FALSE);
gtk_table_attach_defaults(GTK_TABLE(box1),entry[3],1,2,2,3);
gtk_container_add(GTK_CONTAINER(password_window), box1);
gtk_widget_show(box1);
gtk_widget_show_all(password_window);
gtk_main();
}
else {
GdkPixbuf *pixbuf;
GtkWidget *picture;
GtkWidget *box1;
GtkWidget *button1;
GtkWidget *label, *label1, *label2, *label3, *label4;
gtk_init(&argc, &argv);
/* Creo la ventana */
first_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
/* Le pongo un título */
gtk_window_set_title(GTK_WINDOW(first_window), "GSD");
gtk_signal_connect (GTK_OBJECT (first_window), "delete_event",
GTK_SIGNAL_FUNC (delete_event), NULL);
box1 = gtk_table_new(3,2,FALSE);
/* Cargamos el logo. */
pixbuf = gdk_pixbuf_new_from_file_at_scale("logo.png",350,110,FALSE,NULL);
picture=gtk_image_new_from_pixbuf(pixbuf);
gtk_table_attach_defaults(GTK_TABLE(box1),picture,0,2,0,1);
/* Mensaje de Bienvenida ;) */
label = gtk_label_new(MSG_12);
gtk_table_attach_defaults(GTK_TABLE(box1),label,0,2,1,2);
/* Botón 1 */
button1 = gtk_button_new_with_label (MSG_11);
gtk_signal_connect (GTK_OBJECT (button1), "clicked", GTK_SIGNAL_FUNC (create_account), (gpointer) "button 1");
gtk_box_pack_start(GTK_BOX(box1), button1, TRUE, TRUE, 0);
gtk_table_attach_defaults(GTK_TABLE(box1),button1,0,2,9,10);
label1 = gtk_label_new(MSG_3);
gtk_table_attach_defaults(GTK_TABLE(box1),label1,0,1,2,3);
entry[0] = gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(entry[0]),TRUE);
gtk_table_attach_defaults(GTK_TABLE(box1),entry[0],1,2,2,3);
label2 = gtk_label_new(MSG_4);
gtk_table_attach_defaults(GTK_TABLE(box1),label2,0,1,3,4);
entry[1] = gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(entry[1]),TRUE);
gtk_table_attach_defaults(GTK_TABLE(box1),entry[1],1,2,3,4);
label3 = gtk_label_new(MSG_5);
gtk_table_attach_defaults(GTK_TABLE(box1),label3,0,1,5,6);
entry[2] = gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(entry[2]),TRUE);
gtk_table_attach_defaults(GTK_TABLE(box1),entry[2],1,2,5,6);
label4 = gtk_label_new(MSG_6);
gtk_table_attach_defaults(GTK_TABLE(box1),label4,0,1,7,8);
entry[3] = gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(entry[3]),FALSE);
gtk_table_attach_defaults(GTK_TABLE(box1),entry[3],1,2,7,8);
gtk_container_add(GTK_CONTAINER(first_window), box1);
gtk_widget_show(box1);
gtk_widget_show_all(first_window);
/* Finalmente entramos en el bucle principal. */
gtk_main();
}
return 0;
}