static void pattern_clist_sync_selection (void) {
GSList *list;
struct player_pattern *pp;
if (current_row >= 0) {
list = g_slist_nth (curplrs, current_row);
pp = (struct player_pattern *) list->data;
if (!GTK_WIDGET_REALIZED (comment_text))
gtk_widget_realize (comment_text);
gtk_text_freeze (GTK_TEXT (comment_text));
gtk_text_set_point (GTK_TEXT (comment_text), 0);
gtk_text_forward_delete (GTK_TEXT (comment_text),
gtk_text_get_length (GTK_TEXT (comment_text)));
gtk_text_set_point (GTK_TEXT (comment_text), 0);
if (pp->comment) {
gtk_text_insert (GTK_TEXT (comment_text), NULL, NULL, NULL,
pp->comment, strlen (pp->comment));
gtk_text_set_point (GTK_TEXT (comment_text), 0);
}
gtk_text_set_editable (GTK_TEXT (comment_text), TRUE);
gtk_text_thaw (GTK_TEXT (comment_text));
gtk_entry_set_text (GTK_ENTRY (pattern_entry),
(pp->pattern)? pp->pattern : "");
gtk_entry_set_editable (GTK_ENTRY (pattern_entry), TRUE);
gtk_widget_set_sensitive (mode_buttons[PATTERN_MODE_STRING], TRUE);
gtk_widget_set_sensitive (mode_buttons[PATTERN_MODE_SUBSTR], TRUE);
gtk_widget_set_sensitive (mode_buttons[PATTERN_MODE_REGEXP], TRUE);
gtk_toggle_button_set_active (
GTK_TOGGLE_BUTTON (mode_buttons[pp->mode]), TRUE);
gtk_widget_set_sensitive (delete_button, TRUE);
gtk_widget_set_sensitive (up_button, TRUE);
gtk_widget_set_sensitive (down_button, TRUE);
}
else {
gtk_text_freeze (GTK_TEXT (comment_text));
gtk_text_set_point (GTK_TEXT (comment_text), 0);
gtk_text_forward_delete (GTK_TEXT (comment_text),
gtk_text_get_length (GTK_TEXT (comment_text)));
gtk_text_set_editable (GTK_TEXT (comment_text), FALSE);
gtk_text_thaw (GTK_TEXT (comment_text));
gtk_entry_set_text (GTK_ENTRY (pattern_entry), "");
gtk_entry_set_editable (GTK_ENTRY (pattern_entry), FALSE);
gtk_widget_set_sensitive (mode_buttons[PATTERN_MODE_STRING], FALSE);
gtk_widget_set_sensitive (mode_buttons[PATTERN_MODE_SUBSTR], FALSE);
gtk_widget_set_sensitive (mode_buttons[PATTERN_MODE_REGEXP], FALSE);
gtk_widget_set_sensitive (delete_button, FALSE);
gtk_widget_set_sensitive (up_button, FALSE);
gtk_widget_set_sensitive (down_button, FALSE);
}
}
GtkWidget *
createGUI(int argc, char **argv)
{
GtkWidget *win;
GtkWidget *sw, *obox, *box1;
int i;
win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
obox = gtk_hbox_new(TRUE, 0);
box1 = gtk_hbox_new(TRUE, 0);
for(i = 0; i < 2; i++) {
sw = gtk_scrolled_window_new(NULL, NULL);
lists[i] = gtk_list_new();
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sw), lists[i]);
gtk_box_pack_start(GTK_BOX(box1), sw, TRUE, TRUE, 0);
}
gtk_box_pack_start(GTK_BOX(obox), box1, TRUE, TRUE, 0);
sw = gtk_scrolled_window_new(NULL, NULL);
textLog = gtk_text_new(NULL, NULL);
gtk_text_set_editable(GTK_TEXT(textLog), TRUE);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sw), textLog);
gtk_box_pack_end(GTK_BOX(obox), sw, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(win), obox);
gtk_widget_show_all(win);
return(win);
}
int main( int argc,char *argv[] )
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *entry;
GtkWidget *vscrollbar;
GtkWidget *text;
GtkWidget *table;
GtkWidget *check;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Demo_Entry_Text");
g_signal_connect (G_OBJECT (window), "destroy",G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect_swapped (G_OBJECT (window), "delete_event", G_CALLBACK (gtk_widget_destroy), G_OBJECT (window));
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
entry = gtk_entry_new ();
gtk_entry_set_max_length (GTK_ENTRY (entry), 30);
gtk_entry_set_text(GTK_ENTRY (entry), "hello");
gtk_box_pack_start (GTK_BOX (vbox), entry, TRUE, TRUE, 0);
check = gtk_check_button_new_with_label ("Visible");
gtk_box_pack_start (GTK_BOX (vbox), check, TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (check), "toggled",
G_CALLBACK (entry_toggle_visibility), (gpointer) entry);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
table = gtk_table_new (2, 2, FALSE);
gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0);
text = gtk_text_new (NULL, NULL);
gtk_text_set_editable (GTK_TEXT (text), TRUE);
gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1,
GTK_EXPAND | GTK_SHRINK | GTK_FILL,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
check = gtk_check_button_new_with_label ("Editable");
gtk_box_pack_start (GTK_BOX (vbox), check, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (check), "toggled",
G_CALLBACK (text_toggle_editable), text);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), TRUE);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
void
on_toolbar_compose_clicked (GtkButton * UNUSED(button), gpointer UNUSED(user_data))
{
GtkWidget *w;
w = create_compose ();
gtk_text_set_editable (GTK_TEXT (lookup_widget (w, "text2")), TRUE);
gtk_widget_show (w);
}
void wxTextCtrl::DoEnable( bool enable )
{
if (m_windowStyle & wxTE_MULTILINE)
{
gtk_text_set_editable( GTK_TEXT(m_text), enable );
}
else
{
gtk_widget_set_sensitive( m_text, enable );
}
}
void wxTextCtrl::SetEditable( bool editable )
{
wxCHECK_RET( m_text != NULL, wxT("invalid text ctrl") );
if (m_windowStyle & wxTE_MULTILINE)
{
gtk_text_set_editable( GTK_TEXT(m_text), editable );
}
else
{
gtk_entry_set_editable( GTK_ENTRY(m_text), editable );
}
}
void
on_toolbar_reply_clicked (GtkButton * UNUSED(button), gpointer UNUSED(user_data))
{
synopsis *s;
GtkCTreeNode *n;
GtkWidget *from, *subj, *date, *recipt, *body, *comp, *widget;
char *shtuff, buf[1024];
if ((widget = lookup_widget (gems, "mailbox")) == NULL)
return;
comp = create_compose ();
from = (GtkWidget *) gtk_object_get_data (GTK_OBJECT (comp), "entry1");
/* to = (GtkWidget *) gtk_object_get_data (GTK_OBJECT (comp), "entry5"); */
date = (GtkWidget *) gtk_object_get_data (GTK_OBJECT (comp), "entry2");
subj = (GtkWidget *) gtk_object_get_data (GTK_OBJECT (comp), "entry6");
recipt = (GtkWidget *) gtk_object_get_data (GTK_OBJECT (comp), "entry4");
body = (GtkWidget *) gtk_object_get_data (GTK_OBJECT (comp), "text2");
n = gtk_ctree_node_nth (GTK_CTREE (widget),
(&(GTK_CTREE (widget)->clist))->focus_row);
s = (synopsis *) gtk_ctree_node_get_row_data (GTK_CTREE (widget), n);
shtuff = replyify (s, (char *)db_read_body (s->id));
gtk_entry_set_text (GTK_ENTRY (from), s->sender);
/*
* if(!strncasecmp("re: ", s->subject, 4))
*/
if (tolower (s->subject[0]) == 'r' && tolower (s->subject[1]) == 'e'
&& s->subject[2] == ':' && s->subject[3] == ' ')
sprintf (buf, "%s", s->subject);
else
sprintf (buf, "Re: %s", s->subject);
gtk_entry_set_text (GTK_ENTRY (subj), buf);
gtk_entry_set_text (GTK_ENTRY (date), s->date);
gtk_text_freeze (GTK_TEXT (body));
gtk_text_set_point (GTK_TEXT (body), 0);
gtk_text_forward_delete (GTK_TEXT (body),
gtk_text_get_length (GTK_TEXT (body)));
gtk_text_insert (GTK_TEXT (body), NULL, NULL, NULL, shtuff, -1);
gtk_text_thaw (GTK_TEXT (body));
if (widget == NULL)
{
free (s);
free (shtuff);
}
gtk_text_set_editable (GTK_TEXT (body), TRUE);
gtk_widget_show (comp);
return;
}
EXPORT void wTextSetReadonly (
wText_p bt,
wBool_t ro )
{
#ifdef USE_TEXTVIEW
gtk_text_view_set_editable( GTK_TEXT_VIEW(bt->text), !ro );
#else
gtk_text_set_editable( GTK_TEXT(bt->text), !ro );
#endif
if (ro) {
bt->option |= BO_READONLY;
} else {
bt->option &= ~BO_READONLY;
}
}
InsetData *InsetDataTextareaNew (VisualWidget widget, Element *parent)
{
GtkWidget *w;
w = gtk_text_new (NULL, NULL);
/* gtk_signal_connect (GTK_OBJECT (w), "focus_out_event", */
/* textFocusOutCallback, parent); */
gtk_text_set_editable (GTK_TEXT (w), TRUE);
gtk_kino_put (GTK_KINO (widget), w, 0, 0);
if (GTK_KINO (widget)->document == parent->document &&
GTK_WIDGET_VISIBLE (widget))
{
gtk_widget_show (w);
}
return (InsetData *) w;
}
static GtkWidget *server_comment_page (struct server *s) {
GtkWidget *page_vbox;
GtkWidget *scrollwin;
struct server_props *props;
int sucks = 0;
char* comment = NULL;
props = properties (s);
if (props) {
sucks = props->sucks;
comment = props->comment;
}
page_vbox = gtk_vbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (page_vbox), 8);
sucks_check_button = gtk_check_button_new_with_label (_("This server sucks"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (sucks_check_button), sucks);
gtk_box_pack_start (GTK_BOX (page_vbox), sucks_check_button, FALSE, FALSE, 0);
gtk_widget_show (sucks_check_button);
scrollwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (page_vbox), scrollwin, TRUE, TRUE, 0);
comment_text = gtk_text_new (NULL, NULL);
// gtk_widget_set_usize (comment_text, -1, 80);
gtk_container_add (GTK_CONTAINER (scrollwin), comment_text);
gtk_widget_show (comment_text);
gtk_text_freeze (GTK_TEXT (comment_text));
if (comment) {
gtk_text_insert (GTK_TEXT (comment_text), NULL, NULL, NULL,
comment, strlen (comment));
gtk_text_set_point (GTK_TEXT (comment_text), 0);
}
gtk_text_set_editable (GTK_TEXT (comment_text), TRUE);
gtk_text_thaw (GTK_TEXT (comment_text));
gtk_widget_show (scrollwin);
gtk_widget_show (page_vbox);
return page_vbox;
}
bool wxTextCtrl::Enable( bool enable )
{
if (!wxWindowBase::Enable(enable))
{
// nothing to do
return false;
}
if (m_windowStyle & wxTE_MULTILINE)
{
gtk_text_set_editable( GTK_TEXT(m_text), enable );
OnParentEnable(enable);
}
else
{
gtk_widget_set_sensitive( m_text, enable );
}
return true;
}
EXPORT void wTextClear(
wText_p bt )
{
#ifdef USE_TEXTVIEW
GtkTextBuffer * tb;
#endif
if (bt->text == 0) abort();
#ifdef USE_TEXTVIEW
tb = gtk_text_view_get_buffer( GTK_TEXT_VIEW(bt->text) );
gtk_text_buffer_set_text( tb, "", -1 );
if (bt->option & BO_READONLY)
gtk_text_view_set_editable( GTK_TEXT_VIEW(bt->text), FALSE );
#else
gtk_text_set_point( GTK_TEXT(bt->text), 0 );
gtk_text_forward_delete( GTK_TEXT(bt->text), gtk_text_get_length( GTK_TEXT(bt->text) ) );
if (bt->option & BO_READONLY)
gtk_text_set_editable( GTK_TEXT(bt->text), FALSE );
#endif
bt->changed = FALSE;
}
GtkWidget*
create_dialog1 (void)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *scrolledwindow1;
GtkWidget *text1;
GtkWidget *dialog_action_area1;
dialog1 = gtk_dialog_new ();
gtk_object_set_data (GTK_OBJECT (dialog1), "dialog1", dialog1);
gtk_window_set_title (GTK_WINDOW (dialog1), _("dialog1"));
gtk_window_set_policy (GTK_WINDOW (dialog1), TRUE, TRUE, FALSE);
dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
gtk_object_set_data (GTK_OBJECT (dialog1), "dialog_vbox1", dialog_vbox1);
gtk_widget_show (dialog_vbox1);
scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_ref (scrolledwindow1);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "scrolledwindow1", scrolledwindow1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (scrolledwindow1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), scrolledwindow1, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
text1 = gtk_text_new (NULL, NULL);
gtk_widget_ref (text1);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "text1", text1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (text1);
gtk_container_add (GTK_CONTAINER (scrolledwindow1), text1);
gtk_text_set_editable (GTK_TEXT (text1), TRUE);
dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;
gtk_object_set_data (GTK_OBJECT (dialog1), "dialog_action_area1", dialog_action_area1);
gtk_widget_show (dialog_action_area1);
gtk_container_set_border_width (GTK_CONTAINER (dialog_action_area1), 10);
return dialog1;
}
static gint
hi_dialog_run(GtkWidget *parent, int itemid) {
history_item_dlg hidlg_actual = { 0 };
history_item_dlg *hidlg = &hidlg_actual;
GtkWidget *vbox, *button;
NetResult *result;
hidlg->itemid = itemid;
result = hi_request_run(hidlg, itemid);
if (result == NULL)
return 0;
hidlg->win = jam_dialog_new(parent, "History Item", 300, 300);
geometry_tie(hidlg->win, GEOM_HISTORY_ITEM);
g_signal_connect(G_OBJECT(hidlg->win), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
vbox = gtk_vbox_new(FALSE, 5); {
GtkWidget *hbox, *scroll;
hbox = gtk_hbox_new(FALSE, 5); {
gtk_box_pack_start(GTK_BOX(hbox), gtk_label_new("Subject:"),
FALSE, FALSE, 0);
hidlg->esubject = gtk_entry_new();
gtk_widget_set_usize(hidlg->esubject, 100, -1);
/* usize is just the minimum size... */
gtk_box_pack_start(GTK_BOX(hbox), hidlg->esubject, TRUE, TRUE, 0);
}
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 5); {
gtk_box_pack_start(GTK_BOX(hbox), gtk_label_new("Date:"),
FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), hi_dialog_date_hbox(hidlg),
FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), gtk_label_new("Time:"),
FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), hi_dialog_time_hbox(hidlg),
FALSE, FALSE, 0);
hidlg->security.type = conf.defaultsecurity;
hidlg->secmgr = secmgr_new(&hidlg->security);
gtk_box_pack_end(GTK_BOX(hbox), hidlg->secmgr, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hbox), gtk_label_new("Security:"),
FALSE, FALSE, 0);
}
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
scroll = gtk_scrolled_window_new(NULL, NULL); {
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
hidlg->eentry = gtk_text_new(NULL, NULL);
/* fixme gtkspell gtkspell_attach(GTK_TEXT(hidlg->eentry)); */
gtk_text_set_editable(GTK_TEXT(hidlg->eentry), TRUE);
gtk_text_set_word_wrap(GTK_TEXT(hidlg->eentry), TRUE);
gtk_container_add(GTK_CONTAINER(scroll), hidlg->eentry);
}
gtk_box_pack_start(GTK_BOX(vbox), scroll, TRUE, TRUE, 0);
hidlg->metamgr = metamgr_new(GTK_BOX(vbox));
gtk_box_pack_end(GTK_BOX(vbox), hidlg->metamgr, FALSE, FALSE, 0);
}
jam_dialog_set_contents(hidlg->win, vbox);
button = gtk_button_new_with_label(" Save Changes ");
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(hi_save_cb), (gpointer) hidlg);
jam_dialog_add_button(hidlg->win, button);
button = gtk_button_new_with_label(" Delete ");
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(hi_delete_cb), (gpointer) hidlg);
jam_dialog_add_button(hidlg->win, button);
jam_dialog_add_close(hidlg->win);
hi_load_result(hidlg, result);
gtk_widget_realize(hidlg->win);
gtk_widget_realize(hidlg->secmgr);
gtk_widget_show(hidlg->win);
gtk_main();
return 0;
}
GtkWidget * yank_app_new(EYank *yank)
{
yank_preferences *prefs;
static GtkTargetEntry drop_types[] =
{
{ "text/uri-list", 0, 1 },
};
static gint n_drop_types = sizeof (drop_types)/sizeof (drop_types [0]);
gchar *treetitle[] =
{
_("NoteTree"),
NULL
};
gchar *todotitles[] =
{
_("Deadline"),
_("Priority"),
_("Complete"),
_("Title"),
NULL
};
GtkWidget *app;
GtkWidget *scrolledwindow1;
GtkWidget *scrolledwindow2;
GtkWidget *scrolledwindow3;
GtkWidget *hbox;
GtkWidget *hbox3;
GtkWidget *vbox;
GtkWidget *label;
GdkFont *font;
GtkObject *prio_adjust;
/* gint got_crash; */
GtkWidget *b_toggle_ext_flags;
GtkWidget *hbox_ext_flags;
GtkWidget *hpaned;
hpaned = app = yank->priv->hpaned;
yank_main_app(app);
sp->edit_tree = NULL;
sp->title_entry =NULL;
sp->todo_check =NULL;
sp->prio_entry =NULL;
sp->de_deadline =NULL;
sp->ad_complete =NULL;
sp->tlabel_created =NULL;
sp->tlabel_changed =NULL;
sp->label_changes =NULL;
sp->tlabel_expire =NULL;
sp->note_id_entry =NULL;
sp->text_entry =NULL;
sp->note_tree =NULL;
sp->b_ok =NULL;
sp->b_apply =NULL;
sp->b_cancel =NULL;
sp->todolist =NULL;
sp->notebook =NULL;
sp->status =NULL;
sp->prio_date_box =NULL;
sp->edit_tree=NULL;
yank_root_win(GTK_WINDOW(app));
/*
* main tree
*/
scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow1),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
/* gtk_widget_show will be called later */
/* gtk_container_add(GTK_CONTAINER(hpaned), scrolledwindow1); */
e_paned_add1(E_PANED(hpaned), scrolledwindow1);
sp->note_tree = gtk_ctree_new_with_titles(1, 0, treetitle);
gtk_widget_show(sp->note_tree);
gtk_container_add(GTK_CONTAINER(scrolledwindow1), sp->note_tree);
gtk_clist_set_column_width(GTK_CLIST(sp->note_tree), 0, 80);
gtk_clist_set_column_auto_resize(GTK_CLIST(sp->note_tree), 0, TRUE);
gtk_clist_set_row_height(GTK_CLIST(sp->note_tree), 19);
gtk_clist_set_selection_mode(GTK_CLIST(sp->note_tree), GTK_SELECTION_EXTENDED);
gtk_clist_set_reorderable(GTK_CLIST(sp->note_tree), TRUE);
gtk_clist_set_use_drag_icons(GTK_CLIST(sp->note_tree), TRUE);
gtk_clist_column_titles_show(GTK_CLIST(sp->note_tree));
gtk_signal_connect(GTK_OBJECT(sp->note_tree), "tree_select_row",
GTK_SIGNAL_FUNC (note_tree_row_selected), NULL);
gtk_signal_connect(GTK_OBJECT(sp->note_tree), "tree_unselect_row",
GTK_SIGNAL_FUNC (note_tree_row_unselected), NULL);
gtk_signal_connect(GTK_OBJECT(sp->note_tree), "click_column",
GTK_SIGNAL_FUNC (cb_note_tree_col_selected), NULL);
gtk_signal_connect(GTK_OBJECT(sp->note_tree), "drag_data_received",
GTK_SIGNAL_FUNC(cb_note_tree_reordered), NULL);
/*
* FIXME:
* dnd on the note-tree disables reordering of notes by dnd
*/
/* gtk_signal_connect(GTK_OBJECT(sp->note_tree), "drag_data_received", */
/* GTK_SIGNAL_FUNC(cb_note_tree_drop), NULL); */
/* gtk_drag_dest_set(sp->note_tree, GTK_DEST_DEFAULT_MOTION | */
/* GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, */
/* drop_types, n_drop_types, GDK_ACTION_COPY); */
sp->notebook = gtk_notebook_new();
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(sp->notebook), FALSE);
gtk_notebook_set_show_border(GTK_NOTEBOOK(sp->notebook), FALSE);
gtk_widget_show(sp->notebook);
/* gtk_container_add(GTK_CONTAINER(hpaned), sp->notebook); */
e_paned_add2(E_PANED(hpaned), sp->notebook);
/*
* todo-list
*/
scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow2),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_show(scrolledwindow2);
gtk_container_add(GTK_CONTAINER(sp->notebook), scrolledwindow2);
sp->todolist = gtk_clist_new_with_titles(4, todotitles);
gtk_signal_connect(GTK_OBJECT(sp->todolist), "select_row",
GTK_SIGNAL_FUNC (cb_todo_row_selected), NULL);
gtk_signal_connect(GTK_OBJECT(sp->todolist), "click_column",
GTK_SIGNAL_FUNC (cb_todo_col_selected), NULL);
gtk_signal_connect(GTK_OBJECT(sp->todolist), "drag_data_received",
GTK_SIGNAL_FUNC(cb_todo_list_drop), NULL);
gtk_drag_dest_set(sp->todolist, GTK_DEST_DEFAULT_MOTION |
GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,
drop_types, n_drop_types, GDK_ACTION_COPY);
gtk_widget_show(sp->todolist);
gtk_container_add(GTK_CONTAINER(scrolledwindow2), sp->todolist);
gtk_clist_column_titles_show(GTK_CLIST(sp->todolist));
gtk_clist_set_column_auto_resize(GTK_CLIST(sp->todolist), 0 , TRUE);
gtk_clist_set_column_auto_resize(GTK_CLIST(sp->todolist), 3 , TRUE);
gtk_clist_set_column_justification(GTK_CLIST(sp->todolist), 1,
GTK_JUSTIFY_RIGHT);
gtk_clist_set_column_justification(GTK_CLIST(sp->todolist), 2,
GTK_JUSTIFY_RIGHT);
/*
* text/ data
*/
vbox = gtk_vbox_new(FALSE, 3);
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER (sp->notebook), vbox);
hbox = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3);
sp->prio_date_box = gtk_vbox_new(FALSE, 3);
gtk_widget_show(sp->prio_date_box);
gtk_box_pack_start(GTK_BOX(vbox), sp->prio_date_box, FALSE, FALSE, 0);
hbox_ext_flags = gui_ext_flags();
gtk_box_pack_start(GTK_BOX(vbox), hbox_ext_flags, FALSE, FALSE, 3);
label = gtk_label_new(_("Title:"));
font = gtk_widget_get_style(label)->font;
gtk_widget_set_usize(label, -1, gdk_string_height(font, "W") + 10);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
sp->title_entry = gtk_entry_new();
gtk_widget_set_usize(sp->title_entry, -1, gdk_string_height(font, "W") + 10);
gtk_widget_show(sp->title_entry);
gtk_box_pack_start(GTK_BOX(hbox), sp->title_entry, TRUE, TRUE, 5);
sp->todo_check = gtk_check_button_new_with_label(_("Done"));
gtk_widget_set_usize(sp->todo_check, -1, gdk_string_height(font, "W") + 10);
gtk_widget_show(sp->todo_check);
gtk_box_pack_start(GTK_BOX(hbox), sp->todo_check, FALSE, FALSE, 5);
/*
* button for extra flags& data
*/
b_toggle_ext_flags = gtk_button_new();
{
GtkWidget *p_up;
GtkWidget *p_down;
GtkWidget *box;
box = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(b_toggle_ext_flags), box);
gtk_widget_show(box);
p_up = gnome_stock_pixmap_widget_at_size(
GTK_WIDGET(yank_root_win(NULL)), GNOME_STOCK_BUTTON_UP, 12, 14);
p_down = gnome_stock_pixmap_widget_at_size(
GTK_WIDGET(yank_root_win(NULL)), GNOME_STOCK_BUTTON_DOWN, 12, 14);
gtk_widget_hide(p_up);
gtk_widget_show(p_down);
gtk_container_add(GTK_CONTAINER(box), p_up);
gtk_container_add(GTK_CONTAINER(box), p_down);
gtk_object_set_data(GTK_OBJECT(b_toggle_ext_flags), "up", p_up);
gtk_object_set_data(GTK_OBJECT(b_toggle_ext_flags), "down", p_down);
}
gtk_widget_show(b_toggle_ext_flags);
gtk_box_pack_start(GTK_BOX(hbox), b_toggle_ext_flags, FALSE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(b_toggle_ext_flags), "clicked",
GTK_SIGNAL_FUNC(cb_toggle_ext_flags), hbox_ext_flags);
/*
* deadline/ prio/ complete
*/
{
GtkWidget *prio_hbox1;
GtkWidget *prio_hbox2;
GtkWidget *sc_complete;
prio_hbox1 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(prio_hbox1);
gtk_box_pack_start(GTK_BOX(sp->prio_date_box), prio_hbox1, FALSE, FALSE,
0);
prio_hbox2 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(prio_hbox2);
gtk_box_pack_start(GTK_BOX(sp->prio_date_box), prio_hbox2, FALSE, FALSE,
0);
label = gtk_label_new(_("Deadline:"));
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(prio_hbox1), label, FALSE, FALSE, 5);
sp->de_deadline = gnome_date_edit_new(0, 1, 1);
gnome_date_edit_set_popup_range(GNOME_DATE_EDIT(sp->de_deadline), 0, 23);
gtk_widget_set_sensitive(GNOME_DATE_EDIT(sp->de_deadline)->date_entry,
FALSE);
gtk_widget_set_sensitive(GNOME_DATE_EDIT(sp->de_deadline)->time_entry,
FALSE);
gtk_widget_show(sp->de_deadline);
gtk_box_pack_start(GTK_BOX(prio_hbox1), sp->de_deadline, FALSE, FALSE, 0);
label = gtk_label_new(_("Priority:"));
gtk_widget_set_usize(label, -1, gdk_string_height(font, "W") + 10);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(prio_hbox1), label, FALSE, FALSE, 5);
prio_adjust = gtk_adjustment_new(0, 0, 9999, 1, 10, 10);
sp->prio_entry = gtk_spin_button_new(GTK_ADJUSTMENT(prio_adjust), 1, 0);
/* NOTE: this is note 100% ok */
gtk_widget_set_usize(GTK_WIDGET(sp->prio_entry),
gdk_string_width(font, "999999") + 10,
gdk_string_height(font, "W") + 10);
gtk_widget_show(sp->prio_entry);
gtk_box_pack_start(GTK_BOX(prio_hbox1), sp->prio_entry, FALSE, FALSE, 0);
label = gtk_label_new(_("Complete:"));
gtk_widget_set_usize(label, -1, gdk_string_height(font, "W") + 10);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(prio_hbox2), label, FALSE, FALSE, 5);
sp->ad_complete = gtk_adjustment_new(0, 0, 101, 1, 1, 1);
sc_complete = gtk_hscale_new(GTK_ADJUSTMENT(sp->ad_complete));
gtk_scale_set_digits(GTK_SCALE(sc_complete), 0);
gtk_scale_set_value_pos(GTK_SCALE(sc_complete), GTK_POS_LEFT);
gtk_widget_show(sc_complete);
gtk_box_pack_start(GTK_BOX(prio_hbox2), sc_complete, TRUE, TRUE, 5);
label = gtk_label_new(_("%"));
gtk_widget_set_usize(label, -1, gdk_string_height(font, "W") + 10);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(prio_hbox2), label, FALSE, FALSE, 5);
}
/*
* additional note data
*/
sp->note_id_entry = gtk_entry_new();
/* gtk_widget_show(sp->note_id_entry); */
gtk_widget_hide(sp->note_id_entry);
gtk_box_pack_start(GTK_BOX(hbox), sp->note_id_entry, FALSE, FALSE, 5);
/*
* note text
*/
scrolledwindow3 = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow3),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_show(scrolledwindow3);
gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow3, TRUE, TRUE, 0);
sp->text_entry = gtk_text_new(NULL, NULL);
gtk_text_set_editable(GTK_TEXT(sp->text_entry), TRUE);
gtk_widget_show(sp->text_entry);
gtk_container_add(GTK_CONTAINER(scrolledwindow3), sp->text_entry);
/* text dnd */
gtk_signal_connect(GTK_OBJECT(sp->text_entry), "drag_data_received",
GTK_SIGNAL_FUNC(cb_text_entry_drop), NULL);
gtk_drag_dest_set(sp->text_entry, GTK_DEST_DEFAULT_MOTION |
GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,
drop_types, n_drop_types, GDK_ACTION_COPY);
hbox3 = gtk_hbox_new(FALSE, 0);
gtk_widget_show(hbox3);
gtk_box_pack_start(GTK_BOX(vbox), hbox3, FALSE, FALSE, 3);
sp->b_ok = gnome_stock_button(GNOME_STOCK_BUTTON_OK);
gtk_widget_show(sp->b_ok);
gtk_box_pack_start(GTK_BOX(hbox3), sp->b_ok, TRUE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(sp->b_ok), "clicked",
GTK_SIGNAL_FUNC(cb_b_ok), NULL);
sp->b_apply = gnome_stock_button(GNOME_STOCK_BUTTON_APPLY);
gtk_widget_show(sp->b_apply);
gtk_box_pack_start(GTK_BOX(hbox3), sp->b_apply, TRUE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(sp->b_apply), "clicked",
GTK_SIGNAL_FUNC(cb_b_apply), NULL);
sp->b_cancel = gnome_stock_button(GNOME_STOCK_BUTTON_CANCEL);
gtk_widget_show(sp->b_cancel);
gtk_box_pack_start(GTK_BOX(hbox3), sp->b_cancel, TRUE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(sp->b_cancel), "clicked",
GTK_SIGNAL_FUNC(cb_b_cancel), NULL);
/*
* a bit suboptimal
*/
gtk_signal_connect(GTK_OBJECT(sp->title_entry), "changed",
GTK_SIGNAL_FUNC(note_changed), NULL);
gtk_signal_connect(GTK_OBJECT(sp->de_deadline), "date-changed",
GTK_SIGNAL_FUNC(note_changed), NULL);
gtk_signal_connect(GTK_OBJECT(sp->de_deadline), "time-changed",
GTK_SIGNAL_FUNC(note_changed), NULL);
gtk_signal_connect(GTK_OBJECT(sp->tlabel_expire), "time_changed",
GTK_SIGNAL_FUNC(note_changed), NULL);
gtk_signal_connect(GTK_OBJECT(sp->prio_entry), "changed",
GTK_SIGNAL_FUNC(note_changed), NULL);
gtk_signal_connect(GTK_OBJECT(sp->ad_complete), "value_changed",
GTK_SIGNAL_FUNC(note_changed), NULL);
gtk_signal_connect(GTK_OBJECT(sp->ad_complete), "value_changed",
GTK_SIGNAL_FUNC(cb_complete_updates_done), sp->todo_check);
gtk_signal_connect(GTK_OBJECT(sp->todo_check), "toggled",
GTK_SIGNAL_FUNC(note_changed), NULL);
gtk_signal_connect(GTK_OBJECT(sp->text_entry), "changed",
GTK_SIGNAL_FUNC(note_changed), NULL);
/*
* keyboard-control
*/
gtk_signal_connect(GTK_OBJECT(sp->title_entry), "activate",
GTK_SIGNAL_FUNC(cb_finished_note), NULL);
gtk_signal_connect(GTK_OBJECT(sp->text_entry), "activate",
GTK_SIGNAL_FUNC(cb_finished_note), NULL);
/*
* create pixmaps
*/
pix_text_xpm = gnome_pixmap_new_from_xpm_d(text_xpm);
gtk_widget_show(pix_text_xpm);
pix_box_xpm = gnome_pixmap_new_from_xpm_d(box_xpm);
gtk_widget_show(pix_box_xpm);
pix_box2_xpm = gnome_pixmap_new_from_xpm_d(box2_xpm);
gtk_widget_show(pix_box2_xpm);
pix_circle_xpm = gnome_pixmap_new_from_xpm_d(circle_xpm);
gtk_widget_show(pix_circle_xpm);
pix_circle2_xpm = gnome_pixmap_new_from_xpm_d(circle2_xpm);
gtk_widget_show(pix_circle2_xpm);
/*
* menus
*/
/* gnome_app_set_contents(GNOME_APP(app), hpaned); */
/* sp->status = gnome_appbar_new(FALSE, TRUE, GNOME_PREFERENCES_USER); */
/* gnome_app_set_statusbar(GNOME_APP(app), sp->status); */
/* yank_install_menus_and_toolbar(app); */
yank_tree_item_context_menu(sp->note_tree);
yank_todo_item_context_menu(sp->todolist);
yank_text_item_context_menu(sp->title_entry);
yank_text_item_context_menu(sp->text_entry);
/* gtk_signal_connect(GTK_OBJECT(app), "delete_event", */
/* GTK_SIGNAL_FUNC(cb_delete_event), NULL); */
/*
* initialize preferences
* also preloads plugins
*/
load_preferences();
prefs = get_preferences();
gtk_text_set_word_wrap(GTK_TEXT(sp->text_entry), prefs->wordwrap);
gtk_text_set_line_wrap(GTK_TEXT(sp->text_entry), prefs->linewrap);
/* if (prefs->yank_width * prefs->yank_height) */
/* { */
/* gtk_window_set_default_size(GTK_WINDOW(app), prefs->yank_width, */
/* prefs->yank_height); */
/* } */
/* else */
/* { */
/* gtk_window_set_default_size(GTK_WINDOW(app), 600, 400); */
/* } */
if (prefs->use_custom_font)
{
if (prefs->note_font)
{
set_note_font_str(prefs->note_font);
}
if (prefs->note_tree_font)
{
set_note_tree_font_str(prefs->note_tree_font);
}
if (prefs->todolist_font)
{
set_todolist_font_str(prefs->todolist_font);
}
}
else
{
set_default_font();
}
/*
* parse geometry if given
*/
/* if (geometry != NULL) */
/* { */
/* gint x, y, w, h; */
/* if (gnome_parse_geometry(geometry, &x, &y, &w, &h )) */
/* { */
/* if (x != -1) */
/* { */
/* gtk_widget_set_uposition(app, x, y); */
/* } */
/* */
/* if (w != -1) */
/* { */
/* gtk_window_set_default_size(GTK_WINDOW(app), w, h); */
/* } */
/* } */
/* else */
/* { */
/* g_error(_("Could not parse geometry string `%s'"), geometry); */
/* } */
/* } */
/* */
/* if (prefs->note_tree_width) */
/* { */
/* gtk_widget_set_usize(scrolledwindow1, prefs->note_tree_width, -1); */
/* } */
/* else */
/* { */
/* gtk_widget_set_usize(scrolledwindow1, 200, -1); */
/* } */
/* gtk_widget_show(scrolledwindow1); */
/*
* try to read files from killed sessions
*/
/* got_crash = get_crash_file(); */
/*
* load file from the command-line
*/
/* if (file != NULL && ! got_crash) */
/* { */
/* load_notes_from_cli((gchar *)file, GTK_CTREE(sp->note_tree), NULL); */
/* } */
/*
* read default file
*/
/* if (file == NULL && ! got_crash) */
/* { */
/* get_def_file(); */
/* } */
/*
* register some signal-handlers
*/
/* if (signal(SIGTERM, handle_sigterm) == SIG_ERR) */
/* { */
/* g_warning("Can't handle SIGTERM"); */
/* } */
/* if (signal(SIGCHLD, handle_sigchild) == SIG_ERR) */
/* { */
/* g_warning("Can't handle SIGCHILD"); */
/* } */
/* if (signal(SIGPIPE, handle_sigpipe) == SIG_ERR) */
/* { */
/* g_warning("Can't handle SIGPIPE"); */
/* } */
/*
* init autosave
*/
/* if (prefs->auto_save_minutes) */
/* { */
/* autosave_notes(NULL); */
/* } */
return (hpaned);
}
void text_toggle_editable (GtkWidget *checkbutton,
GtkWidget *text)
{
gtk_text_set_editable (GTK_TEXT (text),
GTK_TOGGLE_BUTTON (checkbutton)->active);
}
int
nsWelcomeDlg::Show()
{
int err = OK;
if (!mShowDlg)
{
gCtx->ldlg->Show();
return err;
}
char *readmeContents = NULL;
XI_VERIFY(gCtx);
XI_VERIFY(gCtx->notebook);
if (mWidgetsInit == FALSE) // static widget init
{
// create a new table and add it as a page of the notebook
mTable = gtk_table_new(1, 3, FALSE);
gtk_notebook_append_page(GTK_NOTEBOOK(gCtx->notebook), mTable, NULL);
mPageNum = gtk_notebook_get_current_page(GTK_NOTEBOOK(gCtx->notebook));
// gtk_table_set_row_spacing(GTK_TABLE(mTable), 0, 0);
gtk_table_set_col_spacing(GTK_TABLE(mTable), 1, 0);
gtk_widget_show(mTable);
// read the readme file contents into memory
readmeContents = GetReadmeContents();
if (!readmeContents)
{
err = ErrorHandler(E_EMPTY_README);
goto BAIL;
}
// create a new scrollable textarea and add it to the table
#if defined(MOZ_WIDGET_GTK)
GtkWidget *text = gtk_text_new(NULL, NULL);
GdkFont *font = gdk_font_load( README_FONT );
gtk_text_set_editable(GTK_TEXT(text), FALSE);
gtk_table_attach(GTK_TABLE(mTable), text, 1, 2, 0, 1,
static_cast<GtkAttachOptions>(GTK_FILL | GTK_EXPAND),
static_cast<GtkAttachOptions>(GTK_FILL | GTK_EXPAND),
0, 0);
gtk_text_freeze(GTK_TEXT(text));
gtk_text_insert (GTK_TEXT(text), font, &text->style->black, NULL,
readmeContents, -1);
gtk_text_thaw(GTK_TEXT(text));
gtk_text_set_word_wrap(GTK_TEXT(text), TRUE);
gtk_widget_show(text);
// Add a vertical scrollbar to the GtkText widget
GtkWidget *vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
gtk_table_attach(GTK_TABLE(mTable), vscrollbar, 2, 3, 0, 1, GTK_FILL,
static_cast<GtkAttachOptions>(GTK_EXPAND | GTK_SHRINK | GTK_FILL),
0, 0);
gtk_widget_show(vscrollbar);
#elif defined(MOZ_WIDGET_GTK2)
GtkWidget *text = gtk_scrolled_window_new (NULL, NULL);
GtkWidget *textview = gtk_text_view_new();
GtkTextBuffer *textbuffer;
textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
gtk_text_buffer_set_text (textbuffer, readmeContents, -1);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (text),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (text), textview);
gtk_text_view_set_editable(GTK_TEXT_VIEW(textview), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW(textview), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_WORD);
gtk_table_attach_defaults(GTK_TABLE(mTable), text, 1, 2, 0, 1);
gtk_widget_show_all(text);
#endif
mWidgetsInit = TRUE;
}
else
{
gtk_notebook_set_page(GTK_NOTEBOOK(gCtx->notebook), mPageNum);
gtk_widget_show(mTable);
}
// signal connect the buttons
gCtx->nextID = gtk_signal_connect(GTK_OBJECT(gCtx->next), "clicked",
GTK_SIGNAL_FUNC(nsWelcomeDlg::Next), gCtx->wdlg);
GTK_WIDGET_SET_FLAGS(gCtx->next, GTK_CAN_DEFAULT);
gtk_widget_grab_default(gCtx->next);
gtk_widget_grab_focus(gCtx->next);
// show the Next button
gCtx->nextLabel = gtk_label_new(gCtx->Res("NEXT"));
gtk_container_add(GTK_CONTAINER(gCtx->next), gCtx->nextLabel);
gtk_widget_show(gCtx->nextLabel);
gtk_widget_show(gCtx->next);
BAIL:
XI_IF_FREE(readmeContents);
return err;
}
void
about_dialog (gpointer data)
{
GtkWidget * tempwid, * notebook, * box, * label, * view, * vscroll, * dialog;
char *tempstr, *temp1str, *no_license_agreement, *str, buf[255], *share_dir;
size_t len;
FILE * fd;
#if GTK_MAJOR_VERSION > 1
GtkTextBuffer * textbuf;
GtkTextIter iter;
gint textlen;
#endif
share_dir = gftp_get_share_dir ();
no_license_agreement = g_strdup_printf (_("Cannot find the license agreement file COPYING. Please make sure it is in either %s or in %s"), BASE_CONF_DIR, share_dir);
#if GTK_MAJOR_VERSION == 1
dialog = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog), _("About gFTP"));
gtk_container_border_width (GTK_CONTAINER
(GTK_DIALOG (dialog)->action_area), 5);
gtk_box_set_homogeneous (GTK_BOX (GTK_DIALOG (dialog)->action_area), TRUE);
#else
dialog = gtk_dialog_new_with_buttons (_("About gFTP"), NULL, 0,
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE,
NULL);
#endif
gtk_window_set_wmclass (GTK_WINDOW(dialog), "about", "gFTP");
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
gtk_container_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), 10);
gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 5);
gtk_widget_realize (dialog);
if (gftp_icon != NULL)
{
gdk_window_set_icon (dialog->window, NULL, gftp_icon->pixmap,
gftp_icon->bitmap);
gdk_window_set_icon_name (dialog->window, gftp_version);
}
notebook = gtk_notebook_new ();
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), notebook, TRUE,
TRUE, 0);
gtk_widget_show (notebook);
box = gtk_vbox_new (TRUE, 5);
gtk_container_border_width (GTK_CONTAINER (box), 10);
gtk_widget_show (box);
tempwid = toolbar_pixmap (dialog, "gftp-logo.xpm");
gtk_box_pack_start (GTK_BOX (box), tempwid, FALSE, FALSE, 0);
gtk_widget_show (tempwid);
tempstr = g_strdup_printf (_("%s\nCopyright (C) 1998-2007 Brian Masney <*****@*****.**>\nOfficial Homepage: http://www.gftp.org/\n"), gftp_version);
str = _("Translated by");
if (strcmp (str, "Translated by") != 0)
{
tempstr = g_realloc (tempstr,
(gulong) (strlen (tempstr) + strlen (str) + 1));
strcat (tempstr, str);
}
tempwid = gtk_label_new (tempstr);
g_free (tempstr);
gtk_box_pack_start (GTK_BOX (box), tempwid, FALSE, FALSE, 0);
gtk_widget_show (tempwid);
label = gtk_label_new (_("About"));
gtk_widget_show (label);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), box, label);
box = gtk_vbox_new (FALSE, 5);
gtk_container_border_width (GTK_CONTAINER (box), 10);
gtk_widget_show (box);
tempwid = gtk_table_new (1, 2, FALSE);
gtk_box_pack_start (GTK_BOX (box), tempwid, TRUE, TRUE, 0);
gtk_widget_show (tempwid);
#if GTK_MAJOR_VERSION == 1
view = gtk_text_new (NULL, NULL);
gtk_text_set_editable (GTK_TEXT (view), FALSE);
gtk_text_set_word_wrap (GTK_TEXT (view), TRUE);
gtk_table_attach (GTK_TABLE (tempwid), view, 0, 1, 0, 1,
GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK,
0, 0);
gtk_widget_show (view);
vscroll = gtk_vscrollbar_new (GTK_TEXT (view)->vadj);
gtk_table_attach (GTK_TABLE (tempwid), vscroll, 1, 2, 0, 1,
GTK_FILL, GTK_EXPAND | GTK_FILL | GTK_SHRINK, 0, 0);
gtk_widget_show (vscroll);
#else
view = gtk_text_view_new ();
gtk_text_view_set_editable (GTK_TEXT_VIEW (view), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (view), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (view), GTK_WRAP_WORD);
vscroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (vscroll),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (vscroll), view);
gtk_widget_show (view);
gtk_table_attach (GTK_TABLE (tempwid), vscroll, 0, 1, 0, 1,
GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK,
0, 0);
gtk_widget_show (vscroll);
textbuf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
#endif
label = gtk_label_new (_("License Agreement"));
gtk_widget_show (label);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), box, label);
#if GTK_MAJOR_VERSION == 1
tempwid = gtk_button_new_with_label (_(" Close "));
GTK_WIDGET_SET_FLAGS (tempwid, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area), tempwid,
FALSE, FALSE, 0);
gtk_signal_connect_object (GTK_OBJECT (tempwid), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (dialog));
gtk_widget_grab_default (tempwid);
gtk_widget_show (tempwid);
#else
g_signal_connect_swapped (GTK_OBJECT (dialog), "response",
G_CALLBACK (gtk_widget_destroy),
GTK_OBJECT (dialog));
#endif
tempstr = g_strconcat ("/usr/share/common-licenses/GPL", NULL);
if (access (tempstr, F_OK) != 0)
{
g_free (tempstr);
temp1str = g_strconcat (share_dir, "/COPYING", NULL);
tempstr = gftp_expand_path (NULL, temp1str);
g_free (temp1str);
if (access (tempstr, F_OK) != 0)
{
g_free (tempstr);
tempstr = gftp_expand_path (NULL, BASE_CONF_DIR "/COPYING");
if (access (tempstr, F_OK) != 0)
{
#if GTK_MAJOR_VERSION == 1
gtk_text_insert (GTK_TEXT (view), NULL, NULL, NULL,
no_license_agreement, -1);
#else
textlen = gtk_text_buffer_get_char_count (textbuf);
gtk_text_buffer_get_iter_at_offset (textbuf, &iter, textlen);
gtk_text_buffer_insert (textbuf, &iter, no_license_agreement, -1);
#endif
gtk_widget_show (dialog);
return;
}
}
}
if ((fd = fopen (tempstr, "r")) == NULL)
{
#if GTK_MAJOR_VERSION == 1
gtk_text_insert (GTK_TEXT (view), NULL, NULL, NULL,
no_license_agreement, -1);
#else
textlen = gtk_text_buffer_get_char_count (textbuf);
gtk_text_buffer_get_iter_at_offset (textbuf, &iter, textlen);
gtk_text_buffer_insert (textbuf, &iter, no_license_agreement, -1);
#endif
gtk_widget_show (dialog);
g_free (tempstr);
return;
}
g_free (tempstr);
memset (buf, 0, sizeof (buf));
while ((len = fread (buf, 1, sizeof (buf) - 1, fd)))
{
buf[len] = '\0';
#if GTK_MAJOR_VERSION == 1
gtk_text_insert (GTK_TEXT (view), NULL, NULL, NULL, buf, -1);
#else
textlen = gtk_text_buffer_get_char_count (textbuf);
gtk_text_buffer_get_iter_at_offset (textbuf, &iter, textlen);
gtk_text_buffer_insert (textbuf, &iter, buf, -1);
#endif
}
fclose (fd);
gtk_widget_show (dialog);
g_free (no_license_agreement);
gftp_free_pixmap ("gftp-logo.xpm");
}
int main( int argc,
char *argv[] )
{
GtkWidget *window;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *hbox;
GtkWidget *button;
GtkWidget *check;
GtkWidget *separator;
GtkWidget *table;
GtkWidget *vscrollbar;
GtkWidget *text;
GdkColormap *cmap;
GdkColor color;
GdkFont *fixed_font;
FILE *infile;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_usize (window, 600, 500);
gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, FALSE);
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC(close_application),
NULL);
gtk_window_set_title (GTK_WINDOW (window), "Text Widget Example");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_show (box1);
box2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
table = gtk_table_new (2, 2, FALSE);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
gtk_box_pack_start (GTK_BOX (box2), table, TRUE, TRUE, 0);
gtk_widget_show (table);
/* Create the GtkText widget */
text = gtk_text_new (NULL, NULL);
gtk_text_set_editable (GTK_TEXT (text), TRUE);
gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1,
GTK_EXPAND | GTK_SHRINK | GTK_FILL,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (text);
/* Add a vertical scrollbar to the GtkText widget */
vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (vscrollbar);
/* Get the system color map and allot the color red */
cmap = gdk_colormap_get_system();
color.red = 0xffff;
color.green = 0;
color.blue = 0;
if (!gdk_color_allot(cmap, &color)) {
g_error("couldn't allot color");
}
/* Load a fixed font */
fixed_font = gdk_font_load ("-misc-fixed-medium-r-*-*-*-140-*-*-*-*-*-*");
/* Realizing a widget creates a window for it,
* * ready for us to insert some text */
gtk_widget_realize (text);
/* Freeze the text widget, ready for multiple updates */
gtk_text_freeze (GTK_TEXT (text));
/* Insert some colored text */
gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
"Supports ", -1);
gtk_text_insert (GTK_TEXT (text), NULL, &color, NULL,
"colored ", -1);
gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
"text and different ", -1);
gtk_text_insert (GTK_TEXT (text), fixed_font, &text->style->black, NULL,
"fonts\n\n", -1);
/* Load the file text.c into the text window */
infile = fopen("text.c", "r");
if (infile) {
char buffer[1024];
int nchars;
while (1)
{
nchars = fread(buffer, 1, 1024, infile);
gtk_text_insert (GTK_TEXT (text), fixed_font, NULL,
NULL, buffer, nchars);
if (nchars < 1024)
break;
}
fclose (infile);
}
/* Thaw the text widget, allowing the updates to become visible */
gtk_text_thaw (GTK_TEXT (text));
hbox = gtk_hbutton_box_new ();
gtk_box_pack_start (GTK_BOX (box2), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
check = gtk_check_button_new_with_label("Editable");
gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT(check), "toggled",
GTK_SIGNAL_FUNC(text_toggle_editable), text);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), TRUE);
gtk_widget_show (check);
check = gtk_check_button_new_with_label("Wrap Words");
gtk_box_pack_start (GTK_BOX (hbox), check, FALSE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT(check), "toggled",
GTK_SIGNAL_FUNC(text_toggle_word_wrap), text);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), FALSE);
gtk_widget_show (check);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
box2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
gtk_widget_show (box2);
button = gtk_button_new_with_label ("close");
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC(close_application),
NULL);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
gtk_widget_set_flags (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
gtk_widget_show (button);
gtk_widget_show (window);
gtk_main ();
return(0);
}
int GTcreatewidget(Gwidget_t * parent, Gwidget_t * widget,
int attrn, Gwattr_t * attrp)
{
PIXsize_t ps;
char *s;
int ai;
int color;
GdkColor c;
if (!parent) {
Gerr(POS, G_ERRNOPARENTWIDGET);
return -1;
}
WTU->func = NULL;
ps.x = ps.y = MINTWSIZE;
s = "oneline";
for (ai = 0; ai < attrn; ai++) {
switch (attrp[ai].id) {
case G_ATTRSIZE:
GETSIZE(attrp[ai].u.s, ps, MINTWSIZE);
break;
case G_ATTRBORDERWIDTH:
break;
case G_ATTRTEXT:
break;
case G_ATTRAPPENDTEXT:
Gerr(POS, G_ERRCANNOTSETATTR1, "appendtext");
return -1;
case G_ATTRMODE:
s = attrp[ai].u.t;
break;
case G_ATTRCOLOR:
color = attrp[ai].u.c.index;
if (color != 0 && color != 1) {
Gerr(POS, G_ERRBADCOLORINDEX, color);
return -1;
}
c.red = attrp[ai].u.c.r * 257;
c.green = attrp[ai].u.c.g * 257;
c.blue = attrp[ai].u.c.b * 257;
/* if (XAllocColor (
Gdisplay, DefaultColormap (Gdisplay, Gscreenn), &c
)) {
if (color == 0)
ADD2ARGS (XtNbackground, c.pixel);
else
ADD2ARGS (XtNforeground, c.pixel);
}
*/ break;
case G_ATTRWINDOWID:
Gerr(POS, G_ERRCANNOTSETATTR1, "windowid");
return -1;
case G_ATTRNEWLINECB:
WTU->func = (Gtwnewlinecb) attrp[ai].u.func;
break;
case G_ATTRUSERDATA:
widget->udata = attrp[ai].u.u;
break;
default:
Gerr(POS, G_ERRBADATTRID, attrp[ai].id);
return -1;
}
}
widget->w = gtk_text_new(NULL, NULL);
gtk_text_set_editable(widget->w, TRUE);
gtk_box_pack_start(GTK_BOX(parent->w), widget->w, TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(widget->w), "key_press_event",
GTK_SIGNAL_FUNC(keyevent), NULL);
gtk_widget_show(widget->w);
return 0;
}
/* Create a scrolled text area that displays a "message" */
static GtkWidget *create_log_text (GtkWidget **textpnt)
{
GtkWidget *text;
GtkWidget *table;
GtkWidget *vscrollbar;
/* Create a table to hold the text widget and scrollbars */
table = gtk_table_new (1, 16, FALSE);
/* Put a text widget in the upper left hand corner. Note the use of
* GTK_SHRINK in the y direction */
#if defined(WAVE_USE_GTK2) && !defined(GTK_ENABLE_BROKEN)
text = gtk_text_view_new ();
gtk_text_buffer_get_start_iter (gtk_text_view_get_buffer(GTK_TEXT_VIEW (text)), &GLOBALS->iter_logfile_c_2);
GLOBALS->bold_tag_logfile_c_2 = gtk_text_buffer_create_tag (GTK_TEXT_VIEW (text)->buffer, "bold",
"weight", PANGO_WEIGHT_BOLD, NULL);
GLOBALS->mono_tag_logfile_c_1 = gtk_text_buffer_create_tag (GTK_TEXT_VIEW (text)->buffer, "monospace", "family", "monospace", NULL);
GLOBALS->size_tag_logfile_c_1 = gtk_text_buffer_create_tag (GTK_TEXT_VIEW (text)->buffer, "fsiz",
"size", (GLOBALS->use_big_fonts ? 12 : 8) * PANGO_SCALE, NULL);
#else
text = gtk_text_new (NULL, NULL);
#endif
*textpnt = text;
gtk_table_attach (GTK_TABLE (table), text, 0, 14, 0, 1,
GTK_FILL | GTK_EXPAND,
GTK_FILL | GTK_SHRINK | GTK_EXPAND, 0, 0);
gtk_widget_set_usize(GTK_WIDGET(text), 100, 100);
#if defined(WAVE_USE_GTK2) && !defined(GTK_ENABLE_BROKEN)
gtk_text_view_set_editable(GTK_TEXT_VIEW(text), TRUE);
#else
gtk_text_set_editable(GTK_TEXT(text), TRUE);
#endif
gtk_widget_show (text);
/* And a VScrollbar in the upper right */
#if defined(WAVE_USE_GTK2) && !defined(GTK_ENABLE_BROKEN)
{
GtkTextViewClass *tc = (GtkTextViewClass*)GTK_OBJECT_GET_CLASS(GTK_OBJECT(text));
tc->set_scroll_adjustments(GTK_TEXT_VIEW (text), NULL, NULL);
vscrollbar = gtk_vscrollbar_new (GTK_TEXT_VIEW (text)->vadjustment);
}
#else
vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
#endif
gtk_table_attach (GTK_TABLE (table), vscrollbar, 15, 16, 0, 1,
GTK_FILL, GTK_FILL | GTK_SHRINK | GTK_EXPAND, 0, 0);
gtk_widget_show (vscrollbar);
/* Add a handler to put a message in the text widget when it is realized */
gtk_signal_connect (GTK_OBJECT (text), "realize", GTK_SIGNAL_FUNC (log_realize_text), NULL);
gtk_signal_connect(GTK_OBJECT(text), "button_release_event", GTK_SIGNAL_FUNC(button_release_event), NULL);
#if defined(WAVE_USE_GTK2) && !defined(GTK_ENABLE_BROKEN)
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_CHAR);
#else
gtk_text_set_word_wrap(GTK_TEXT(text), FALSE);
gtk_text_set_line_wrap(GTK_TEXT(text), TRUE);
#endif
return(table);
}
void Help (void)
{
if ((ifilestuff == 0) && ((biscomputer == 0) || (wiscomputer == 0))
&& (iyesno == 0))
{
helpwindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (helpwindow), "help");
gtk_signal_connect (GTK_OBJECT (helpwindow), "delete_event",
GTK_SIGNAL_FUNC (DestroyHelp), NULL);
gtk_window_set_policy (GTK_WINDOW (helpwindow), 0, 0, 1);
gtk_container_border_width (GTK_CONTAINER (helpwindow), 0);
gtk_widget_realize (helpwindow);
helpbox1 = gtk_vbox_new (FALSE, 0);
gtk_container_border_width (GTK_CONTAINER (helpbox1), 0);
gtk_container_add (GTK_CONTAINER (helpwindow), helpbox1);
gtk_widget_show (helpbox1);
helpbox2 = gtk_hbox_new (FALSE, 0);
gtk_container_border_width (GTK_CONTAINER (helpbox2), 0);
gtk_box_pack_start (GTK_BOX (helpbox1), helpbox2, TRUE, TRUE, 5);
gtk_widget_show (helpbox2);
helpbox3 = gtk_vbox_new (FALSE, 0);
gtk_container_border_width (GTK_CONTAINER (helpbox3), 0);
gtk_box_pack_start (GTK_BOX (helpbox2), helpbox3, TRUE, TRUE, 0);
gtk_widget_show (helpbox3);
helptable1 = gtk_table_new (2, 1, FALSE);
gtk_widget_show (helptable1);
gtk_box_pack_start (GTK_BOX (helpbox3), helptable1, TRUE, TRUE, 0);
helptable2 = gtk_table_new (1, 3, FALSE);
gtk_widget_show (helptable2);
gtk_box_pack_start (GTK_BOX (helpbox3), helptable2, TRUE, TRUE, 0);
texth = gtk_text_new (NULL, NULL);
gtk_widget_set_usize (texth, 535, 266);
gtk_text_set_editable (GTK_TEXT (texth), FALSE);
gtk_table_attach (GTK_TABLE (helptable1), texth, 0, 1, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 0);
gtk_widget_show (texth);
vscrollbarh = gtk_vscrollbar_new (GTK_TEXT (texth)->vadj);
gtk_table_attach (GTK_TABLE (helptable1), vscrollbarh, 1, 2, 0, 1,
GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 0);
gtk_widget_show (vscrollbarh);
gtk_widget_realize (texth);
wrapcheckh = gtk_check_button_new_with_label ("wrap");
gtk_table_attach (GTK_TABLE (helptable2), wrapcheckh, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 5, 10);
gtk_signal_connect (GTK_OBJECT (wrapcheckh), "toggled",
GTK_SIGNAL_FUNC (ToggleWrapH), texth);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wrapcheckh), FALSE);
gtk_widget_show (wrapcheckh);
helpsep = gtk_hseparator_new ();
gtk_table_attach (GTK_TABLE (helptable2), helpsep, 0, 1, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (helpsep);
#ifdef USE_GNOME
helpbutton = gnome_stock_button (GNOME_STOCK_BUTTON_CLOSE);
#else
helpbutton = gtk_button_new_with_label ("Close");
#endif
gtk_signal_connect (GTK_OBJECT (helpbutton), "clicked",
GTK_SIGNAL_FUNC (DestroyHelp), NULL);
GTK_WIDGET_SET_FLAGS (helpbutton, GTK_CAN_DEFAULT);
gtk_window_set_default (GTK_WINDOW (helpwindow), helpbutton);
gtk_table_attach (GTK_TABLE (helptable2), helpbutton, 0, 1, 2, 3,
GTK_EXPAND | GTK_FILL, GTK_FILL, 2, 2);
gtk_widget_show (helpbutton);
gtk_text_freeze (GTK_TEXT (texth));
ihelpdes = open (PKGDATADIR"help/README", O_RDONLY, 0600);
if (ihelpdes == -1)
{
Message ("Could not open README file.", 3, 0);
}
else
{
while (1)
{
nchars = read (ihelpdes, buffer, 1024);
gtk_text_insert (GTK_TEXT (texth), fixed_font, NULL, NULL, buffer,
nchars);
if (nchars < 1024)
{
break;
}
}
}
close (ihelpdes);
gtk_text_thaw (GTK_TEXT (texth));
gtk_widget_show (helpwindow);
iyesno = 1;
if (ichangestuff == 0)
{
Play ("open.mp3", 0);
}
}
else
{
if (ichangestuff == 0)
{
Play ("click.mp3", 0);
}
}
}
bool wxTextCtrl::Create( wxWindow *parent,
wxWindowID id,
const wxString &value,
const wxPoint &pos,
const wxSize &size,
long style,
const wxValidator& validator,
const wxString &name )
{
m_needParent = true;
m_acceptsFocus = true;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxTextCtrl creation failed") );
return false;
}
m_vScrollbarVisible = false;
bool multi_line = (style & wxTE_MULTILINE) != 0;
if (multi_line)
{
// create our control ...
m_text = gtk_text_new( NULL, NULL );
// ... and put into the upper left hand corner of the table
bool bHasHScrollbar = false;
m_widget = gtk_table_new(bHasHScrollbar ? 2 : 1, 2, FALSE);
GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
gtk_table_attach( GTK_TABLE(m_widget), m_text, 0, 1, 0, 1,
(GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
(GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK),
0, 0);
// always wrap words
gtk_text_set_word_wrap( GTK_TEXT(m_text), TRUE );
// finally, put the vertical scrollbar in the upper right corner
m_vScrollbar = gtk_vscrollbar_new( GTK_TEXT(m_text)->vadj );
GTK_WIDGET_UNSET_FLAGS( m_vScrollbar, GTK_CAN_FOCUS );
gtk_table_attach(GTK_TABLE(m_widget), m_vScrollbar, 1, 2, 0, 1,
GTK_FILL,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL | GTK_SHRINK),
0, 0);
}
else
{
// a single-line text control: no need for scrollbars
m_widget =
m_text = gtk_entry_new();
}
m_parent->DoAddChild( this );
m_focusWidget = m_text;
PostCreation(size);
if (multi_line)
gtk_widget_show(m_text);
if (multi_line)
{
gtk_signal_connect(GTK_OBJECT(GTK_TEXT(m_text)->vadj), "changed",
(GtkSignalFunc) gtk_scrollbar_changed_callback, (gpointer) this );
// only initialize gs_gtk_text_draw once, starting from the next the
// klass::draw will already be wxgtk_text_draw
if ( !gs_gtk_text_draw )
{
GtkDrawCallback&
draw = GTK_WIDGET_CLASS(GTK_OBJECT(m_text)->klass)->draw;
gs_gtk_text_draw = draw;
draw = wxgtk_text_draw;
}
}
if (!value.empty())
{
#if !GTK_CHECK_VERSION(1, 2, 0)
// if we don't realize it, GTK 1.0.6 dies with a SIGSEGV in
// gtk_editable_insert_text()
gtk_widget_realize(m_text);
#endif // GTK 1.0
gint tmp = 0;
#if wxUSE_UNICODE
wxWX2MBbuf val = value.mbc_str();
gtk_editable_insert_text( GTK_EDITABLE(m_text), val, strlen(val), &tmp );
#else
gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.length(), &tmp );
#endif
if (multi_line)
{
// Bring editable's cursor uptodate. Bug in GTK.
SET_EDITABLE_POS(m_text, gtk_text_get_point( GTK_TEXT(m_text) ));
}
}
if (style & wxTE_PASSWORD)
{
if (!multi_line)
gtk_entry_set_visibility( GTK_ENTRY(m_text), FALSE );
}
if (style & wxTE_READONLY)
{
if (!multi_line)
gtk_entry_set_editable( GTK_ENTRY(m_text), FALSE );
}
else
{
if (multi_line)
gtk_text_set_editable( GTK_TEXT(m_text), 1 );
}
// We want to be notified about text changes.
gtk_signal_connect( GTK_OBJECT(m_text), "changed",
GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this);
m_cursor = wxCursor( wxCURSOR_IBEAM );
wxTextAttr attrDef(GetForegroundColour(), GetBackgroundColour(), GetFont());
SetDefaultStyle( attrDef );
return true;
}
void InternetGo (void)
{
if ((ifilestuff == 0) && (inet == 0))
{
shost = gtk_entry_get_text (GTK_ENTRY (connectentry1));
theaddress = atoaddr (shost);
iport = atoi (gtk_entry_get_text (GTK_ENTRY (connectentry2)));
gtk_widget_destroy (connectwindow);
iyesno = 0;
bzero ((char *) &host_addr, sizeof (host_addr));
host_addr.sin_family = AF_INET;
host_addr.sin_addr.s_addr = inet_addr (inet_ntoa (*theaddress));
host_addr.sin_port = htons (iport);
if ((sockfd = socket (AF_INET, SOCK_STREAM, 0)) < 0)
{
Message ("Unable to open socket.", 3, 0);
}
itheerror = connect (sockfd, (struct sockaddr *) &host_addr, sizeof
(host_addr));
if (itheerror < 0)
{
sprintf (serrortemp, "Unable to connect to host (%s).", strerror
(errno));
Message (serrortemp, 3, 0);
}
else
{
fcntl (sockfd, F_SETFL, O_NONBLOCK);
biscomputer = 0;
sprintf (bplayername, "%s", "unknown");
wiscomputer = 0;
sprintf (wplayername, "%s", "unknown");
StatusBar ();
if (ichangestuff == 0)
{
Play ("open.mp3", 0);
}
internetwindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (internetwindow), "Internet window");
gtk_signal_connect (GTK_OBJECT (internetwindow), "delete_event",
GTK_SIGNAL_FUNC (CloseSocket), NULL);
gtk_window_set_policy (GTK_WINDOW (internetwindow), 0, 0, 1);
gtk_container_border_width (GTK_CONTAINER (internetwindow), 0);
gtk_widget_realize (internetwindow);
internetbox1 = gtk_vbox_new (FALSE, 0);
gtk_container_border_width (GTK_CONTAINER (internetbox1), 0);
gtk_container_add (GTK_CONTAINER (internetwindow), internetbox1);
gtk_widget_show (internetbox1);
internetbox2 = gtk_hbox_new (FALSE, 0);
gtk_container_border_width (GTK_CONTAINER (internetbox2), 0);
gtk_box_pack_start (GTK_BOX (internetbox1), internetbox2, TRUE, TRUE, 5);
gtk_widget_show (internetbox2);
internetbox3 = gtk_vbox_new (FALSE, 0);
gtk_container_border_width (GTK_CONTAINER (internetbox3), 0);
gtk_box_pack_start (GTK_BOX (internetbox2), internetbox3, TRUE, TRUE, 0);
gtk_widget_show (internetbox3);
internettable1 = gtk_table_new (2, 1, FALSE);
gtk_widget_show (internettable1);
gtk_box_pack_start (GTK_BOX (internetbox3), internettable1, TRUE, TRUE,
0);
internettable2 = gtk_table_new (2, 3, FALSE);
gtk_widget_show (internettable2);
gtk_box_pack_start (GTK_BOX (internetbox3), internettable2, TRUE, TRUE,
0);
text = gtk_text_new (NULL, NULL);
gtk_widget_set_usize (text, 535, 266);
gtk_text_set_editable (GTK_TEXT (text), FALSE);
gtk_table_attach (GTK_TABLE (internettable1), text, 0, 1, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 0);
gtk_widget_show (text);
vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
adj = (GTK_TEXT (text))->vadj;
gtk_table_attach (GTK_TABLE (internettable1), vscrollbar, 1, 2, 0, 1,
GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 0);
gtk_widget_show (vscrollbar);
cmap = gdk_colormap_get_system ();
color.red = 0xffff;
color.green = 0;
color.blue = 0;
if (!gdk_color_alloc (cmap, &color))
{
Message ("Could not allocate color.", 3, 0);
}
gtk_widget_realize (text);
wrapcheck = gtk_check_button_new_with_label ("wrap");
gtk_table_attach (GTK_TABLE (internettable2), wrapcheck, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 5, 10);
gtk_signal_connect (GTK_OBJECT (wrapcheck), "toggled",
GTK_SIGNAL_FUNC (ToggleWrap), text);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wrapcheck), FALSE);
gtk_widget_show (wrapcheck);
internetentry = gtk_entry_new_with_max_length (50);
gtk_signal_connect (GTK_OBJECT (internetentry), "activate",
GTK_SIGNAL_FUNC (SendData), NULL);
gtk_table_attach (GTK_TABLE (internettable2), internetentry, 1, 2, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 5, 10);
gtk_widget_grab_focus (internetentry);
gtk_widget_show (internetentry);
inetsep = gtk_hseparator_new ();
gtk_table_attach (GTK_TABLE (internettable2), inetsep, 0, 2, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (inetsep);
inetbutton = gtk_button_new_with_label ("Disconnect");
gtk_signal_connect (GTK_OBJECT (inetbutton), "clicked",
GTK_SIGNAL_FUNC (CloseSocket), NULL);
GTK_WIDGET_SET_FLAGS (inetbutton, GTK_CAN_DEFAULT);
gtk_window_set_default (GTK_WINDOW (internetwindow), inetbutton);
gtk_table_attach (GTK_TABLE (internettable2), inetbutton, 0, 2, 2, 3,
GTK_EXPAND | GTK_FILL, GTK_FILL, 2, 2);
gtk_widget_show (inetbutton);
gtk_widget_show (internetwindow);
inet = 1;
ReceiveData ();
}
}
}
void
view_file (char *filename, int fd, unsigned int viewedit, unsigned int del_file,
unsigned int start_pos, unsigned int dontupload,
char *remote_filename, gftp_window_data * wdata)
{
GtkWidget * dialog, * view, * table, * tempwid;
char buf[8192], *view_program, *edit_program;
gftp_config_list_vars * tmplistvar;
gftp_file_extensions * tempext;
gftp_viewedit_data * newproc;
GtkAdjustment * vadj;
GList * templist;
size_t stlen;
int doclose;
ssize_t n;
char * non_utf8;
#if GTK_MAJOR_VERSION > 1
GtkTextBuffer * textbuf;
GtkTextIter iter;
#endif
doclose = 1;
stlen = strlen (filename);
gftp_lookup_global_option ("ext", &tmplistvar);
for (templist = tmplistvar->list; templist != NULL; templist = templist->next)
{
tempext = templist->data;
if (stlen >= tempext->stlen &&
strcmp (&filename[stlen - tempext->stlen], tempext->ext) == 0)
{
if (*tempext->view_program == '\0')
break;
ftp_log (gftp_logging_misc, NULL, _("Opening %s with %s\n"),
filename, tempext->view_program);
fork_process (tempext->view_program, filename, fd, remote_filename,
viewedit, del_file, dontupload, wdata);
return;
}
}
if (wdata != NULL)
{
gftp_lookup_request_option (wdata->request, "view_program", &view_program);
gftp_lookup_request_option (wdata->request, "edit_program", &edit_program);
if ((non_utf8 = gftp_filename_from_utf8 (wdata->request, filename, NULL)) == NULL) /* freeme later! */
non_utf8 = filename;
}
else
{
gftp_lookup_global_option ("view_program", &view_program);
gftp_lookup_global_option ("edit_program", &edit_program);
non_utf8 = filename;
}
if (viewedit && *view_program != '\0')
{
/* Open the file with the default file viewer */
fork_process (view_program, filename, fd, remote_filename, viewedit,
del_file, dontupload, wdata);
if (non_utf8 != filename && non_utf8)
g_free (non_utf8);
return;
}
else if (!viewedit && *edit_program != '\0')
{
/* Open the file with the default file editor */
newproc = fork_process (edit_program, filename, fd, remote_filename,
viewedit, del_file, dontupload, wdata);
stat (non_utf8, &newproc->st);
if (non_utf8 != filename && non_utf8)
g_free (non_utf8);
return;
}
ftp_log (gftp_logging_misc, NULL, _("Viewing file %s\n"), filename);
if (fd == 0)
{
if ((fd = open (non_utf8, O_RDONLY)) < 0)
{
ftp_log (gftp_logging_error, NULL,
_("View: Cannot open file %s: %s\n"), non_utf8,
g_strerror (errno));
if (non_utf8 != filename && non_utf8)
g_free (non_utf8);
return;
}
doclose = 1;
}
else
{
lseek (fd, 0, SEEK_SET);
doclose = 0;
}
if (del_file)
{
if (unlink (non_utf8) == 0)
ftp_log (gftp_logging_misc, NULL, _("Successfully removed %s\n"),
filename);
else
ftp_log (gftp_logging_error, NULL,
_("Error: Could not remove file %s: %s\n"), filename,
g_strerror (errno));
}
if (non_utf8 != filename && non_utf8)
g_free (non_utf8);
#if GTK_MAJOR_VERSION == 1
dialog = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog), filename);
gtk_container_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->action_area),
5);
gtk_box_set_homogeneous (GTK_BOX (GTK_DIALOG (dialog)->action_area), TRUE);
#else
dialog = gtk_dialog_new_with_buttons (filename, NULL, 0,
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE,
NULL);
#endif
gtk_window_set_wmclass (GTK_WINDOW(dialog), "fileview", "gFTP");
gtk_container_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), 5);
gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 5);
gtk_widget_realize (dialog);
if (gftp_icon != NULL)
{
gdk_window_set_icon (dialog->window, NULL, gftp_icon->pixmap,
gftp_icon->bitmap);
gdk_window_set_icon_name (dialog->window, gftp_version);
}
table = gtk_table_new (1, 2, FALSE);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), table, TRUE, TRUE, 0);
#if GTK_MAJOR_VERSION == 1
view = gtk_text_new (NULL, NULL);
gtk_text_set_editable (GTK_TEXT (view), FALSE);
gtk_text_set_word_wrap (GTK_TEXT (view), TRUE);
gtk_table_attach (GTK_TABLE (table), view, 0, 1, 0, 1,
GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK,
0, 0);
gtk_widget_show (view);
tempwid = gtk_vscrollbar_new (GTK_TEXT (view)->vadj);
gtk_table_attach (GTK_TABLE (table), tempwid, 1, 2, 0, 1,
GTK_FILL, GTK_EXPAND | GTK_FILL | GTK_SHRINK, 0, 0);
gtk_widget_show (tempwid);
vadj = GTK_TEXT (view)->vadj;
#else
view = gtk_text_view_new ();
gtk_text_view_set_editable (GTK_TEXT_VIEW (view), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (view), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (view), GTK_WRAP_WORD);
tempwid = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (tempwid),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (tempwid), view);
gtk_widget_show (view);
gtk_table_attach (GTK_TABLE (table), tempwid, 0, 1, 0, 1,
GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK,
0, 0);
gtk_widget_show (tempwid);
vadj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (tempwid));
#endif
gtk_widget_set_size_request (table, 500, 400);
gtk_widget_show (table);
#if GTK_MAJOR_VERSION == 1
tempwid = gtk_button_new_with_label (_(" Close "));
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area), tempwid,
FALSE, FALSE, 0);
gtk_signal_connect_object (GTK_OBJECT (tempwid), "clicked",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (dialog));
gtk_widget_show (tempwid);
#else
g_signal_connect_swapped (GTK_OBJECT (dialog), "response",
G_CALLBACK (gtk_widget_destroy),
GTK_OBJECT (dialog));
#endif
buf[sizeof (buf) - 1] = '\0';
while ((n = read (fd, buf, sizeof (buf) - 1)) > 0)
{
buf[n] = '\0';
#if GTK_MAJOR_VERSION == 1
gtk_text_insert (GTK_TEXT (view), NULL, NULL, NULL, buf, -1);
#else
textbuf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
gtk_text_buffer_get_iter_at_offset (textbuf, &iter, -1);
gtk_text_buffer_insert (textbuf, &iter, buf, -1);
#endif
}
if (doclose)
close (fd);
gtk_widget_show (dialog);
if (!start_pos)
gtk_adjustment_set_value (vadj, vadj->upper);
}
EXPORT wText_p wTextCreate(
wWin_p parent,
wPos_t x,
wPos_t y,
const char * helpStr,
const char * labelStr,
long option,
wPos_t width,
wPos_t height )
{
wText_p bt;
#ifdef USE_TEXTVIEW
GtkTextBuffer * tb;
#else
GtkRequisition requisition;
#endif
bt = gtkAlloc( parent, B_MULTITEXT, x, y, labelStr, sizeof *bt, NULL );
gtkComputePos( (wControl_p)bt );
bt->width = width;
bt->height = height;
bt->option = option;
gtkComputePos( (wControl_p)bt );
#ifdef USE_TEXTVIEW
bt->widget = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (bt->widget),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
bt->text = gtk_text_view_new();
if (bt->text == 0) abort();
gtk_container_add (GTK_CONTAINER (bt->widget), bt->text);
tb = gtk_text_view_get_buffer( GTK_TEXT_VIEW(bt->text) );
gtk_text_buffer_create_tag( tb, "bold", "weight", PANGO_WEIGHT_BOLD, NULL);
/* gtk_text_buffer_create_tag( tb, "italic", "style", PANGO_STYLE_ITALIC, NULL); */
/* gtk_text_buffer_create_tag( tb, "bolditalic", "weight", PANGO_WEIGHT_BOLD, "style", PANGO_STYLE_ITALIC, NULL); */
bt->vscroll = gtk_vscrollbar_new( GTK_TEXT_VIEW(bt->text)->vadjustment );
if (bt->vscroll == 0) abort();
#else
bt->widget = gtk_hbox_new( FALSE, 0 );
bt->text = gtk_text_new( NULL, NULL );
if (bt->text == 0) abort();
gtk_box_pack_start( GTK_BOX(bt->widget), bt->text, FALSE, FALSE, 0 );
bt->vscroll = gtk_vscrollbar_new( GTK_TEXT(bt->text)->vadj );
if (bt->vscroll == 0) abort();
gtk_box_pack_start( GTK_BOX(bt->widget), bt->vscroll, FALSE, FALSE, 0 );
#endif
if (option&BT_CHARUNITS) {
width *= 7;
height *= 14;
}
gtk_widget_show( bt->text );
gtk_widget_show( bt->vscroll );
gtk_widget_show( bt->widget );
#ifdef USE_TEXTVIEW
// gtk_widget_set_size_request( GTK_WIDGET(bt->text), width, height );
// gtk_widget_set_size_request( GTK_WIDGET(bt->vscroll), -1, height );
gtk_widget_set_size_request( GTK_WIDGET(bt->widget), width+15/*requisition.width*/, height );
#else
gtk_widget_set_usize( GTK_WIDGET(bt->text), width, height );
gtk_widget_set_usize( GTK_WIDGET(bt->vscroll), -1, height );
gtk_widget_size_request( GTK_WIDGET(bt->vscroll), &requisition );
gtk_widget_set_usize( GTK_WIDGET(bt->widget), width+15/*requisition.width*/, height );
#endif
if (bt->option&BO_READONLY) {
#ifdef USE_TEXTVIEW
gtk_text_view_set_editable( GTK_TEXT_VIEW(bt->text), FALSE );
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(bt->text), FALSE);
#else
gtk_text_set_editable( GTK_TEXT(bt->text), FALSE );
#endif
}
#ifdef USE_TEXTVIEW
gtk_fixed_put( GTK_FIXED(parent->widget), bt->widget, bt->realX, bt->realY );
#else
gtk_container_add( GTK_CONTAINER(parent->widget), bt->widget );
gtk_widget_set_uposition( bt->widget, bt->realX, bt->realY );
#endif
gtkControlGetSize( (wControl_p)bt );
if (labelStr)
bt->labelW = gtkAddLabel( (wControl_p)bt, labelStr );
#ifdef USE_TEXTVIEW
gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW(bt->text), GTK_WRAP_WORD );
#else
gtk_text_set_word_wrap( GTK_TEXT(bt->text), TRUE );
#endif
gtk_widget_realize( bt->text );
gtkAddButton( (wControl_p)bt );
gtkAddHelpString( bt->widget, helpStr );
#ifdef USE_TEXTVIEW
g_signal_connect( G_OBJECT(tb), "changed", GTK_SIGNAL_FUNC(textChanged), bt );
#else
gtk_signal_connect( GTK_OBJECT(bt->text), "changed", GTK_SIGNAL_FUNC(textChanged), bt );
#endif
return bt;
}
void
start(void* v)
{
GtkWidget *scrolled_win, *tree, *hpanes, *vbox, *menu, *list;
/*static gchar *itemnames[] = {"One", "Two", "Three", "Four", "Five"};*/
GtkItemFactory *item_factory;
GtkAccelGroup *accel_group;
gint nmenu_items;
gint i;
GtkWidget *table;
GtkWidget *name_label, *info_vbox;
GtkWidget *type_label;
GtkWidget *annot_label, *annot_hbox, *annot_vscroll;
GtkWidget *sep1;
GtkWidget *props_hbox, *props_scrollwin;
GtkWidget *menu_item;
gtk_init (&SFE_Globals.ArgC, &SFE_Globals.ArgV);
SFE_Globals.Data = stCreateStruct("new","x-unknown/x-unknown");
SFE_Globals.Modified = 0;
SFE_Globals.HideColTitles = 0;
/* a generic toplevel window */
SFE_Globals.Window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(SFE_Globals.Window), "Centrallix Structure File Editor");
gtk_signal_connect (GTK_OBJECT(SFE_Globals.Window), "delete_event", GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
gtk_widget_set_usize(SFE_Globals.Window, 600, 350);
/** Build the Open File... dialog box **/
SFE_Globals.OpenDialog = gtk_file_selection_new("Open File...");
gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(SFE_Globals.OpenDialog)->cancel_button),
"clicked", (GtkSignalFunc)sfe_ui_FileOpenCancel, GTK_OBJECT(SFE_Globals.OpenDialog));
gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(SFE_Globals.OpenDialog)->ok_button),
"clicked", (GtkSignalFunc)sfe_ui_FileOpenOk, GTK_OBJECT(SFE_Globals.OpenDialog));
/* vertical box organizing the menu vs. rest of app */
vbox = gtk_vbox_new(FALSE,1);
gtk_container_add(GTK_CONTAINER(SFE_Globals.Window), vbox);
gtk_widget_show(vbox);
/* menu */
nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
accel_group = gtk_accel_group_new();
item_factory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>", accel_group);
gtk_item_factory_create_items(item_factory, nmenu_items, menu_items, NULL);
gtk_window_add_accel_group(GTK_WINDOW(SFE_Globals.Window), accel_group);
menu = gtk_item_factory_get_widget(item_factory, "<main>");
gtk_box_pack_start(GTK_BOX(vbox), menu, FALSE, TRUE, 0);
/*menu_item = gtk_item_factory_get_widget(GTK_ITEM_FACTORY(item_factory),"/View/Column Titles");
gtk_menu_item_activate(GTK_MENU_ITEM(menu_item));*/
gtk_widget_show(menu);
/* horizontal layout box organizing the treeview and the data view pane */
hpanes = gtk_hpaned_new();
gtk_container_add(GTK_CONTAINER(vbox), hpanes);
gtk_container_set_border_width (GTK_CONTAINER(hpanes), 5);
gtk_paned_set_gutter_size(GTK_PANED(hpanes), 16);
gtk_widget_show(hpanes);
/* A generic scrolled window - for the treeview. */
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_set_usize (scrolled_win, 150, 200);
gtk_container_add (GTK_CONTAINER(hpanes), scrolled_win);
gtk_widget_show (scrolled_win);
/* Create the root tree and add it to the scrolled window */
tree = gtk_tree_new();
gtk_signal_connect (GTK_OBJECT(tree), "select_child",
GTK_SIGNAL_FUNC(cb_select_child), tree);
gtk_signal_connect (GTK_OBJECT(tree), "unselect_child",
GTK_SIGNAL_FUNC(cb_unselect_child), tree);
gtk_signal_connect (GTK_OBJECT(tree), "selection_changed",
GTK_SIGNAL_FUNC(sfe_ui_TreeSelectionChanged), tree);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_win), tree);
gtk_tree_set_selection_mode (GTK_TREE(tree), GTK_SELECTION_SINGLE);
gtk_tree_set_view_mode(GTK_TREE(tree), GTK_TREE_VIEW_ITEM);
gtk_widget_show (tree);
SFE_Globals.TreeView = tree;
/** build the item name section **/
info_vbox = gtk_vbox_new(FALSE,1);
gtk_container_add(GTK_CONTAINER(hpanes), info_vbox);
gtk_widget_show(info_vbox);
table = gtk_table_new(3,2,FALSE);
gtk_box_pack_start(GTK_BOX(info_vbox), table, FALSE, TRUE, 0);
gtk_widget_show(table);
name_label = gtk_label_new("Name:");
gtk_label_set_justify(GTK_LABEL(name_label), GTK_JUSTIFY_LEFT);
gtk_table_attach(GTK_TABLE(table), name_label, 0, 1, 0, 1, 0, 0, 0, 0);
gtk_widget_show(name_label);
SFE_Globals.NameEdit = gtk_entry_new_with_max_length(63);
gtk_table_attach(GTK_TABLE(table), SFE_Globals.NameEdit, 1, 2, 0, 1, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0, 0);
gtk_widget_show(SFE_Globals.NameEdit);
/** Item type **/
type_label = gtk_label_new("Type:");
gtk_label_set_justify(GTK_LABEL(type_label), GTK_JUSTIFY_LEFT);
gtk_table_attach(GTK_TABLE(table), type_label, 0, 1, 1, 2, 0, 0, 0, 0);
gtk_widget_show(type_label);
SFE_Globals.TypeCombo = gtk_combo_new();
gtk_table_attach(GTK_TABLE(table), SFE_Globals.TypeCombo, 1, 2, 1, 2, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0, 8);
gtk_widget_show(SFE_Globals.TypeCombo);
/** Annotation/description/comments section **/
annot_label = gtk_label_new("Desc:");
gtk_label_set_justify(GTK_LABEL(annot_label), GTK_JUSTIFY_LEFT);
gtk_table_attach(GTK_TABLE(table), annot_label, 0, 1, 2, 3, 0, 0, 0, 0);
gtk_widget_show(annot_label);
annot_hbox = gtk_hbox_new(FALSE,1);
gtk_table_attach(GTK_TABLE(table), annot_hbox, 1, 2, 2, 3, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0, 0);
gtk_widget_show(annot_hbox);
SFE_Globals.AnnotText = gtk_text_new(NULL,NULL);
gtk_text_set_editable(GTK_TEXT(SFE_Globals.AnnotText), TRUE);
gtk_widget_set_usize(SFE_Globals.AnnotText, 100, 48);
gtk_container_add(GTK_CONTAINER(annot_hbox), SFE_Globals.AnnotText);
gtk_widget_show(SFE_Globals.AnnotText);
annot_vscroll = gtk_vscrollbar_new(GTK_TEXT(SFE_Globals.AnnotText)->vadj);
gtk_box_pack_end(GTK_BOX(annot_hbox), annot_vscroll, FALSE, TRUE, 0);
gtk_widget_show(annot_vscroll);
sep1 = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(info_vbox), sep1, FALSE, TRUE, 8);
gtk_widget_show(sep1);
/** Add a columnar list box for the attributes **/
props_scrollwin = gtk_scrolled_window_new(NULL,NULL);
gtk_container_add(GTK_CONTAINER(info_vbox), props_scrollwin);
gtk_widget_show(props_scrollwin);
SFE_Globals.AttrsCList = gtk_clist_new_with_titles(2, props_clist_titles);
gtk_clist_set_selection_mode(GTK_CLIST(SFE_Globals.AttrsCList), GTK_SELECTION_SINGLE);
gtk_container_add(GTK_CONTAINER(props_scrollwin), SFE_Globals.AttrsCList);
gtk_widget_show(SFE_Globals.AttrsCList);
gtk_signal_connect (GTK_OBJECT(SFE_Globals.AttrsCList), "select_row",
GTK_SIGNAL_FUNC(sfe_ui_CListAttrSelected), SFE_Globals.AttrsCList);
#if 0
/** Put some cruft in the treeview **/
for (i = 0; i < 5; i++)
{
GtkWidget *subtree, *item;
gint j;
/* Create a tree item */
item = gtk_tree_item_new_with_label (itemnames[i]);
/* Add it to the parent tree */
gtk_tree_append (GTK_TREE(tree), item);
gtk_widget_show (item);
subtree = gtk_tree_new();
/* This is still necessary if you want these signals to be called
* for the subtree's children. Note that selection_change will be
* signalled for the root tree regardless.
*/
gtk_signal_connect (GTK_OBJECT(subtree), "select_child",
GTK_SIGNAL_FUNC(cb_select_child), subtree);
gtk_signal_connect (GTK_OBJECT(subtree), "unselect_child",
GTK_SIGNAL_FUNC(cb_unselect_child), subtree);
/* Set this item's subtree - note that you cannot do this until
* AFTER the item has been added to its parent tree!
*/
gtk_tree_item_set_subtree (GTK_TREE_ITEM(item), subtree);
for (j = 0; j < 5; j++)
{
GtkWidget *subitem;
/* Create a subtree item, in much the same way */
subitem = gtk_tree_item_new_with_label (itemnames[j]);
gtk_tree_append (GTK_TREE(subtree), subitem);
gtk_widget_show (subitem);
}
}
#endif
/** Open the main window **/
gtk_widget_show (SFE_Globals.Window);
/** Load any file specified on the command line **/
if (SFE_Globals.ArgC == 2 && SFE_Globals.ArgV[1])
sfeLoadFile(SFE_Globals.ArgV[1]);
else
sfeRebuildUI(SFE_Globals.Data, GTK_TREE(tree));
/** Create the attribute editing window **/
SFE_Globals.AttrEditWindow = sfe_ui_CreateAttrDialog();
/** Enter the event loop for GTK **/
gtk_main();
thExit();
}
/*!
*\brief show crash dialog
*
*\param text Description
*\param debug_output Output text by gdb
*
*\return GtkWidget * Dialog widget
*/
static GtkWidget *crash_dialog_show(const gchar *text, const gchar *debug_output)
{
GtkWidget *window1;
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *label1;
GtkWidget *frame1;
GtkWidget *scrolledwindow1;
GtkWidget *text1;
GtkWidget *hbuttonbox3;
GtkWidget *hbuttonbox4;
GtkWidget *button3;
GtkWidget *button4;
GtkWidget *button5;
gchar *crash_report;
window1 = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(window1), 5);
gtk_window_set_title(GTK_WINDOW(window1), _("Sylpheed has crashed"));
gtk_window_set_position(GTK_WINDOW(window1), GTK_WIN_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(window1), TRUE);
gtk_window_set_default_size(GTK_WINDOW(window1), 460, 272);
vbox1 = gtk_vbox_new(FALSE, 2);
gtk_widget_show(vbox1);
gtk_container_add(GTK_CONTAINER(window1), vbox1);
hbox1 = gtk_hbox_new(FALSE, 4);
gtk_widget_show(hbox1);
gtk_box_pack_start(GTK_BOX(vbox1), hbox1, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbox1), 4);
label1 = gtk_label_new
(g_strdup_printf(_("%s.\nPlease file a bug report and include the information below."), text));
gtk_widget_show(label1);
gtk_box_pack_start(GTK_BOX(hbox1), label1, TRUE, TRUE, 0);
gtk_misc_set_alignment(GTK_MISC(label1), 7.45058e-09, 0.5);
frame1 = gtk_frame_new(_("Debug log"));
gtk_widget_show(frame1);
gtk_box_pack_start(GTK_BOX(vbox1), frame1, TRUE, TRUE, 0);
scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow1);
gtk_container_add(GTK_CONTAINER(frame1), scrolledwindow1);
gtk_container_set_border_width(GTK_CONTAINER(scrolledwindow1), 3);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow1),
GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
text1 = gtk_text_new(NULL, NULL);
gtk_text_set_editable(GTK_TEXT(text1), FALSE);
gtk_widget_show(text1);
gtk_container_add(GTK_CONTAINER(scrolledwindow1), text1);
crash_report = g_strdup_printf(
"Sylpheed version %s\nGTK+ version %d.%d.%d\nFeatures:%s\nOperating system: %s\nC Library: %s\n--\n%s",
VERSION,
gtk_major_version, gtk_minor_version, gtk_micro_version,
get_compiled_in_features(),
get_operating_system(),
get_lib_version(),
debug_output);
gtk_text_insert(GTK_TEXT(text1), NULL, NULL, NULL, crash_report, -1);
hbuttonbox3 = gtk_hbutton_box_new();
gtk_widget_show(hbuttonbox3);
gtk_box_pack_start(GTK_BOX(vbox1), hbuttonbox3, FALSE, FALSE, 0);
hbuttonbox4 = gtk_hbutton_box_new();
gtk_widget_show(hbuttonbox4);
gtk_box_pack_start(GTK_BOX(vbox1), hbuttonbox4, FALSE, FALSE, 0);
button3 = gtk_button_new_with_label(_("Close"));
gtk_widget_show(button3);
gtk_container_add(GTK_CONTAINER(hbuttonbox4), button3);
GTK_WIDGET_SET_FLAGS(button3, GTK_CAN_DEFAULT);
button4 = gtk_button_new_with_label(_("Save..."));
gtk_widget_show(button4);
gtk_container_add(GTK_CONTAINER(hbuttonbox4), button4);
GTK_WIDGET_SET_FLAGS(button4, GTK_CAN_DEFAULT);
button5 = gtk_button_new_with_label(_("Create bug report"));
gtk_widget_show(button5);
gtk_container_add(GTK_CONTAINER(hbuttonbox4), button5);
GTK_WIDGET_SET_FLAGS(button5, GTK_CAN_DEFAULT);
gtk_signal_connect(GTK_OBJECT(window1), "delete_event",
GTK_SIGNAL_FUNC(gtk_main_quit), NULL);
gtk_signal_connect(GTK_OBJECT(button3), "clicked",
GTK_SIGNAL_FUNC(gtk_main_quit), NULL);
gtk_signal_connect(GTK_OBJECT(button4), "clicked",
GTK_SIGNAL_FUNC(crash_save_crash_log),
crash_report);
gtk_signal_connect(GTK_OBJECT(button5), "clicked",
GTK_SIGNAL_FUNC(crash_create_bug_report),
NULL);
gtk_widget_show(window1);
gtk_main();
return window1;
}
/*-----------------------------------------------------------------------------------------------------------------------*/
int main(int argc,char *argv[])
{
GtkWidget *Win,*VBox,*VBox2,*HBox,*MenuBox,*MenuBar,*But;
gint i;
static GdkColor White = {0,0xFFFF,0xFFFF,0xFFFF};
static GdkColor Red = {0,0xFFFF,0x0000,0x0000};
static GdkColor Blue = {0,0x0000,0x0000,0xFFFF};
GtkStyle *RedStyle,*BlueStyle;
g_thread_init(NULL); gdk_threads_init(); gdk_threads_enter();
gtk_init(&argc,&argv);
AcqOn=FALSE; strcpy(SetupFName,""); StnNo=1; NScalers=4;
for (i=0;i<4;++i) SubA[i]=i;
Interval[0]=1; Interval[1]=5; Interval[2]=60;
Duration[0]=10; Duration[1]=60;
RedStyle=gtk_style_copy(gtk_widget_get_default_style());
for (i=0;i<5;i++) { RedStyle->fg[i]=RedStyle->text[i]=Red; RedStyle->bg[i]=White; }
BlueStyle=gtk_style_copy(gtk_widget_get_default_style());
for (i=0;i<5;i++) { BlueStyle->fg[i]=BlueStyle->text[i]=Blue; BlueStyle->bg[i]=White; }
Win=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_signal_connect(GTK_OBJECT(Win),"delete_event",GTK_SIGNAL_FUNC(DeleteMain),NULL);
gtk_signal_connect(GTK_OBJECT(Win),"destroy",GTK_SIGNAL_FUNC(DestroyMain),NULL);
gtk_window_set_title(GTK_WINDOW(Win),"SCALER (07 Aug 2009)");
gtk_widget_set_uposition(GTK_WIDGET(Win),100,50);
gtk_widget_set_usize(GTK_WIDGET(Win),845,600);
VBox=gtk_vbox_new(FALSE,0); gtk_container_add(GTK_CONTAINER(Win),VBox);
MenuBox=gtk_vbox_new(FALSE,1);
gtk_box_pack_start(GTK_BOX(VBox),MenuBox,FALSE,FALSE,0);
GetMainMenu(Win,&MenuBar);
gtk_box_pack_start(GTK_BOX(MenuBox),MenuBar,FALSE,TRUE,0);
VBox2=gtk_vbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(VBox),VBox2,FALSE,FALSE,0);
gtk_container_set_border_width(GTK_CONTAINER(VBox2),10);
HBox=gtk_hbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(VBox2),HBox,FALSE,FALSE,0);
S_Start=gtk_label_new("Start:\n"); gtk_box_pack_start(GTK_BOX(HBox),S_Start,FALSE,FALSE,0);
HBox=gtk_hbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(VBox2),HBox,FALSE,FALSE,0);
S_Stop=gtk_label_new("Stop:\n"); gtk_box_pack_start(GTK_BOX(HBox),S_Stop,FALSE,FALSE,0);
HBox=gtk_hbox_new(FALSE,0); gtk_box_pack_start(GTK_BOX(VBox),HBox,FALSE,FALSE,0);
But=gtk_button_new_with_label("Elapsed"); SetStyleRecursively(But,BlueStyle);
gtk_box_pack_start(GTK_BOX(HBox),But,FALSE,FALSE,0);
gtk_widget_set_usize(But,56,24);
But=gtk_button_new_with_label("Scaler1"); SetStyleRecursively(But,BlueStyle);
gtk_box_pack_start(GTK_BOX(HBox),But,FALSE,FALSE,40);
gtk_widget_set_usize(But,50,24);
But=gtk_button_new_with_label("Rate1"); SetStyleRecursively(But,BlueStyle);
gtk_box_pack_start(GTK_BOX(HBox),But,FALSE,FALSE,-20);
gtk_widget_set_usize(But,50,24);
But=gtk_button_new_with_label("Scaler2"); SetStyleRecursively(But,BlueStyle);
gtk_box_pack_start(GTK_BOX(HBox),But,FALSE,FALSE,70);
gtk_widget_set_usize(But,50,24);
But=gtk_button_new_with_label("Rate2"); SetStyleRecursively(But,BlueStyle);
gtk_box_pack_start(GTK_BOX(HBox),But,FALSE,FALSE,-50);
gtk_widget_set_usize(But,50,24);
But=gtk_button_new_with_label("Scaler3"); SetStyleRecursively(But,BlueStyle);
gtk_box_pack_start(GTK_BOX(HBox),But,FALSE,FALSE,100);
gtk_widget_set_usize(But,50,24);
But=gtk_button_new_with_label("Rate3"); SetStyleRecursively(But,BlueStyle);
gtk_box_pack_start(GTK_BOX(HBox),But,FALSE,FALSE,-80);
gtk_widget_set_usize(But,50,24);
But=gtk_button_new_with_label("Scaler4"); SetStyleRecursively(But,BlueStyle);
gtk_box_pack_start(GTK_BOX(HBox),But,FALSE,FALSE,135);
gtk_widget_set_usize(But,50,24);
But=gtk_button_new_with_label("Rate4"); SetStyleRecursively(But,BlueStyle);
gtk_box_pack_start(GTK_BOX(HBox),But,FALSE,FALSE,-120);
gtk_widget_set_usize(But,50,24);
S_Output=gtk_text_new(NULL,NULL); gtk_widget_set_usize(GTK_WIDGET(S_Output),0,430);
SetStyleRecursively(S_Output,RedStyle);
gtk_box_pack_start(GTK_BOX(VBox),S_Output,FALSE,FALSE,0);
gtk_text_set_word_wrap(GTK_TEXT(S_Output),TRUE); gtk_text_set_editable(GTK_TEXT(S_Output),FALSE);
gtk_widget_show_all(Win);
//gdk_threads_enter();
gtk_main(); gdk_threads_leave();
gtk_style_unref(RedStyle); gtk_style_unref(BlueStyle);
return(0);
}
void
cheat_sheet_dialog (void)
{
GtkWidget *mainbox, *scrolled_window, *text, *hbox, *thing;
GdkFont *font;
if(cheat_sheet_window != NULL) {
gdk_window_raise(cheat_sheet_window->window);
return;
}
#ifdef USE_GNOME
cheat_sheet_window = gnome_app_new("SoundTracker", _("XM Effects Cheat Sheet"));
#else
cheat_sheet_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(cheat_sheet_window), _("XM Effects Cheat Sheet"));
#endif
g_signal_connect (GTK_OBJECT (cheat_sheet_window), "delete_event",
GTK_SIGNAL_FUNC (cheat_sheet_close_requested), NULL);
mainbox = gtk_vbox_new(FALSE, 2);
gtk_container_border_width(GTK_CONTAINER(mainbox), 4);
#ifdef USE_GNOME
gnome_app_set_contents(GNOME_APP(cheat_sheet_window), mainbox);
#else
gtk_container_add(GTK_CONTAINER(cheat_sheet_window), mainbox);
#endif
gtk_widget_show(mainbox);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (mainbox), scrolled_window, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_NEVER,
GTK_POLICY_ALWAYS);
gtk_widget_show (scrolled_window);
/* Close button */
thing = gtk_hseparator_new();
gtk_widget_show(thing);
gtk_box_pack_start(GTK_BOX(mainbox), thing, FALSE, TRUE, 0);
hbox = gtk_hbutton_box_new ();
gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbox), 4);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbox), GTK_BUTTONBOX_END);
gtk_box_pack_start (GTK_BOX (mainbox), hbox,
FALSE, FALSE, 0);
gtk_widget_show (hbox);
thing = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
GTK_WIDGET_SET_FLAGS(thing, GTK_CAN_DEFAULT);
gtk_window_set_default(GTK_WINDOW(cheat_sheet_window), thing);
g_signal_connect (GTK_OBJECT (thing), "clicked",
GTK_SIGNAL_FUNC (cheat_sheet_close_requested), NULL);
gtk_box_pack_start (GTK_BOX (hbox), thing, FALSE, FALSE, 0);
gtk_widget_show (thing);
text = gtk_text_new (NULL, NULL);
gtk_text_set_editable (GTK_TEXT (text), FALSE);
gtk_text_set_word_wrap (GTK_TEXT (text), FALSE);
gtk_container_add (GTK_CONTAINER (scrolled_window), text);
gtk_widget_grab_focus (text);
gtk_widget_show (text);
gtk_widget_set_usize(text, 42 * 12, 46 * 12);
font = gdk_font_load ("-adobe-courier-medium-r-normal--*-120-*-*-*-*-*-*");
gtk_text_insert(GTK_TEXT(text), font, NULL, NULL, cheat_sheet_string, -1);
/* The Text widget will reference count the font, so we
* unreference it here
*/
gdk_font_unref (font);
gtk_widget_show (cheat_sheet_window);
}
