GtkWidget *
do_textview (GtkWidget *do_widget)
{
static GtkWidget *window = NULL;
if (!window)
{
GtkWidget *vpaned;
GtkWidget *view1;
GtkWidget *view2;
GtkWidget *sw;
GtkTextBuffer *buffer;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (do_widget));
gtk_window_set_default_size (GTK_WINDOW (window),
450, 450);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
gtk_window_set_title (GTK_WINDOW (window), "TextView");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
vpaned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_container_set_border_width (GTK_CONTAINER(vpaned), 5);
gtk_container_add (GTK_CONTAINER (window), vpaned);
/* For convenience, we just use the autocreated buffer from
* the first text view; you could also create the buffer
* by itself with gtk_text_buffer_new(), then later create
* a view widget.
*/
view1 = gtk_text_view_new ();
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view1));
view2 = gtk_text_view_new_with_buffer (buffer);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_paned_add1 (GTK_PANED (vpaned), sw);
gtk_container_add (GTK_CONTAINER (sw), view1);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_paned_add2 (GTK_PANED (vpaned), sw);
gtk_container_add (GTK_CONTAINER (sw), view2);
create_tags (buffer);
insert_text (buffer);
attach_widgets (GTK_TEXT_VIEW (view1));
attach_widgets (GTK_TEXT_VIEW (view2));
gtk_widget_show_all (vpaned);
}
if (!gtk_widget_get_visible (window))
{
gtk_widget_show (window);
}
else
{
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
int main(int argc, char *argv[]) {
GtkWidget *main_window, *scroll;
GtkWidget *treeview;
GtkTreeViewColumn *column;
GtkCellRenderer *name_renderer, *size_renderer;
GtkTreeStore *store;
GtkTreeIter categories[14];
GValue value = { 0, };
gint offset;
uint32 res_counts[14];
uint32 res_sizes[14];
int i;
Common::File in;
uint32 index_pos;
uint32 pos, len;
gtk_init(&argc, &argv);
if (argc != 2) {
printf("Usage: %s filename\n", argv[0]);
return EXIT_FAILURE;
}
in.open(argv[1], "rb");
if (!in.isOpen()) {
printf("Couldn't open %s for reading\n", argv[1]);
return EXIT_FAILURE;
}
/* Create the main window, scrollable in both directions */
main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(main_window), "CLUster Explorer");
gtk_window_set_default_size(GTK_WINDOW(main_window), 400, 400);
g_signal_connect(G_OBJECT(main_window), "destroy", G_CALLBACK(main_window_destroy_cb), NULL);
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
/* Create the tree view */
for (i = 0; i < ARRAYSIZE(res_counts); i++) {
res_counts[i] = 0;
res_sizes[i] = 0;
}
store = gtk_tree_store_new(N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT);
gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(store), compare_items, NULL, NULL);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
index_pos = in.readUint32LE();
in.seek(index_pos, SEEK_SET);
for (;;) {
GtkTreeIter iter;
byte type;
gchar *utf8_name;
gchar name[34];
gchar *size;
try {
pos = in.readUint32LE();
len = in.readUint32LE();
} catch (...) {
break;
}
size = make_size(len);
index_pos = in.pos();
in.seek(pos, SEEK_SET);
type = in.readByte();
in.readByte(); /* compType */
in.readUint32LE(); /* compSize */
in.readUint32LE(); /* decompSize */
in.read_noThrow(name, sizeof(name));
/*
* We need to convert from Latin-1 to UTF-8. Otherwise the text
* "CAFÉ" won't be displayed properly.
*/
utf8_name = g_convert(name, -1, "UTF-8", "ISO-8859-1", NULL, NULL, NULL);
if (!res_counts[type]) {
gtk_tree_store_append(store, &categories[type], NULL);
gtk_tree_store_set(store, &categories[type],
NAME_COLUMN, getType(type),
SIZE_COLUMN, "",
TYPE_COLUMN, -1,
POSITION_COLUMN, -1,
LENGTH_COLUMN, -1,
-1);
}
res_counts[type]++;
res_sizes[type] += len;
gtk_tree_store_append(store, &iter, &categories[type]);
gtk_tree_store_set(store, &iter,
NAME_COLUMN, utf8_name,
SIZE_COLUMN, size,
TYPE_COLUMN, type,
POSITION_COLUMN, pos,
LENGTH_COLUMN, len);
in.seek(index_pos, SEEK_SET);
}
in.close();
for (i = 0; i < ARRAYSIZE(res_counts); i++) {
if (res_counts[i]) {
gchar size[80];
sprintf(size, "%s [%d]", make_size(res_sizes[i]), res_counts[i]);
gtk_tree_store_set(store, &categories[i],
SIZE_COLUMN, size,
-1);
}
}
treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), TRUE);
g_signal_connect(G_OBJECT(treeview), "button-press-event", G_CALLBACK(tree_view_button_cb), argv[1]);
/* The view now holds a reference. We can get rid of our own. */
g_object_unref(G_OBJECT(store));
name_renderer = gtk_cell_renderer_text_new();
size_renderer = gtk_cell_renderer_text_new();
g_value_init(&value, G_TYPE_FLOAT);
g_value_set_float(&value, 1.0);
g_object_set_property(G_OBJECT(size_renderer), "xalign", &value);
gtk_tree_view_insert_column_with_attributes(
GTK_TREE_VIEW(treeview), -1, "Name", name_renderer,
"text", NAME_COLUMN,
NULL);
offset = gtk_tree_view_insert_column_with_attributes(
GTK_TREE_VIEW(treeview), -1, "Size", size_renderer,
"text", SIZE_COLUMN,
NULL);
column = gtk_tree_view_get_column(GTK_TREE_VIEW(treeview), offset - 1);
gtk_tree_view_column_set_alignment(column, 1.0);
gtk_container_add(GTK_CONTAINER(scroll), GTK_WIDGET(treeview));
gtk_container_add(GTK_CONTAINER(main_window), scroll);
gtk_widget_show_all(GTK_WIDGET(main_window));
gtk_main();
return EXIT_SUCCESS;
}
/*
static void cb_scroll_event(GtkAdjustment *adj, GtkWidget *view)
{
gtk_text_view_place_cursor_onscreen(GTK_TEXT_VIEW(view));
}
*/
MainWin *create_main_window(void)
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *menubar;
GtkWidget *sw;
GtkWidget *view;
// gint size;
// GtkAdjustment *hadj, *vadj;
MainWin *mw = g_malloc(sizeof(MainWin));
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
// gtk_window_set_title(GTK_WINDOW(window), PACKAGE_NAME);
gtk_widget_set_name(window, PACKAGE_NAME);
/*
#if GTK_CHECK_VERSION(2, 4, 0)
// size = gtk_icon_size_lookup(GTK_ICON_SIZE_LARGE_TOOLBAR, &size, NULL);
icon = gtk_icon_theme_load_icon(
gtk_icon_theme_get_default(),
PACKAGE,
16, // size
0, // flags
NULL);
gtk_window_set_default_icon(icon);
*/
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_window_set_default_icon_name(PACKAGE);
#else
GdkPixbuf *icon = gdk_pixbuf_new_from_file(
ICONDIR G_DIR_SEPARATOR_S PACKAGE ".png", NULL);
gtk_window_set_icon(GTK_WINDOW(window), icon);
if (icon)
g_object_unref(icon);
#endif
g_signal_connect(G_OBJECT(window), "delete-event",
G_CALLBACK(on_file_quit), NULL);
g_signal_connect_after(G_OBJECT(window), "delete-event",
G_CALLBACK(gtk_widget_hide_on_delete), NULL);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
menubar = create_menu_bar(window);
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
view = create_text_view();
gtk_container_add(GTK_CONTAINER(sw), view);
/*
hadj = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(sw));
vadj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(sw));
g_signal_connect_after(G_OBJECT(hadj), "value-changed",
G_CALLBACK(cb_scroll_event), view);
g_signal_connect_after(G_OBJECT(vadj), "value-changed",
G_CALLBACK(cb_scroll_event), view);
*/
mw->window = window;
mw->menubar = menubar;
mw->view = view;
mw->buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
return mw;
}
/**
* Statistic Viewer's constructor
*
* This constructor is used to create StatisticViewerData data structure.
* @return The Statistic viewer data created.
*/
StatisticViewerData *
gui_statistic(LttvPluginTab *ptab)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
StatisticViewerData* statistic_viewer_data = g_new(StatisticViewerData,1);
statistic_viewer_data->live_trace_count = 0;
Tab *tab = ptab->tab;
statistic_viewer_data->tab = tab;
statistic_viewer_data->ptab = ptab;
// statistic_viewer_data->stats =
// lttvwindow_get_traceset_stats(statistic_viewer_data->tab);
// statistic_viewer_data->calculate_stats =
// statistic_insert_traceset_stats((void *)statistic_viewer_data->stats);
lttvwindow_register_traceset_notify(statistic_viewer_data->tab,
statistic_traceset_changed,
statistic_viewer_data);
statistic_viewer_data->statistic_hash = g_hash_table_new_full(g_str_hash,
g_str_equal,
statistic_destroy_hash_key,
NULL);
statistic_viewer_data->hpaned_v = gtk_hpaned_new();
statistic_viewer_data->store_m = gtk_tree_store_new (N_COLUMNS, G_TYPE_STRING);
statistic_viewer_data->tree_v =
gtk_tree_view_new_with_model (
GTK_TREE_MODEL (statistic_viewer_data->store_m));
g_object_unref (G_OBJECT (statistic_viewer_data->store_m));
// Setup the selection handler
statistic_viewer_data->select_c = gtk_tree_view_get_selection (GTK_TREE_VIEW (statistic_viewer_data->tree_v));
gtk_tree_selection_set_mode (statistic_viewer_data->select_c, GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT (statistic_viewer_data->select_c), "changed",
G_CALLBACK (tree_selection_changed_cb),
statistic_viewer_data);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Statistic Name",
renderer,
"text", NAME_COLUMN,
NULL);
gtk_tree_view_column_set_alignment (column, 0.0);
// gtk_tree_view_column_set_fixed_width (column, 45);
gtk_tree_view_append_column (GTK_TREE_VIEW (statistic_viewer_data->tree_v), column);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW (statistic_viewer_data->tree_v), FALSE);
statistic_viewer_data->scroll_win_tree = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(statistic_viewer_data->scroll_win_tree),
GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (statistic_viewer_data->scroll_win_tree), statistic_viewer_data->tree_v);
gtk_paned_pack1(GTK_PANED(statistic_viewer_data->hpaned_v),statistic_viewer_data->scroll_win_tree, TRUE, FALSE);
gtk_paned_set_position(GTK_PANED(statistic_viewer_data->hpaned_v), 160);
statistic_viewer_data->scroll_win_text = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(statistic_viewer_data->scroll_win_text),
GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
statistic_viewer_data->text_v = gtk_text_view_new ();
gtk_text_view_set_editable(GTK_TEXT_VIEW(statistic_viewer_data->text_v),FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(statistic_viewer_data->text_v),FALSE);
gtk_container_add (GTK_CONTAINER (statistic_viewer_data->scroll_win_text), statistic_viewer_data->text_v);
gtk_paned_pack2(GTK_PANED(statistic_viewer_data->hpaned_v), statistic_viewer_data->scroll_win_text, TRUE, FALSE);
gtk_container_set_border_width(
GTK_CONTAINER(statistic_viewer_data->hpaned_v), 1);
gtk_widget_show(statistic_viewer_data->scroll_win_tree);
gtk_widget_show(statistic_viewer_data->scroll_win_text);
gtk_widget_show(statistic_viewer_data->tree_v);
gtk_widget_show(statistic_viewer_data->text_v);
gtk_widget_show(statistic_viewer_data->hpaned_v);
g_object_set_data_full(
G_OBJECT(guistatistic_get_widget(statistic_viewer_data)),
"statistic_viewer_data",
statistic_viewer_data,
(GDestroyNotify)gui_statistic_destructor);
/* Add the object's information to the module's array */
g_statistic_viewer_data_list = g_slist_append(
g_statistic_viewer_data_list,
statistic_viewer_data);
request_background_data(statistic_viewer_data);
return statistic_viewer_data;
}
static GtkWidget *
servlist_open_edit (GtkWidget *parent, ircnet *net)
{
GtkWidget *editwindow;
GtkWidget *vbox5;
GtkWidget *table3;
GtkWidget *label17;
GtkWidget *label16;
GtkWidget *label21;
GtkWidget *label22;
GtkWidget *label34;
GtkWidget *comboboxentry_charset;
GtkWidget *hbox1;
GtkWidget *scrolledwindow2;
GtkWidget *treeview_servers;
GtkWidget *vbuttonbox1;
GtkWidget *buttonadd;
GtkWidget *buttonremove;
GtkWidget *buttonedit;
GtkWidget *check;
GtkTreeModel *model;
GtkListStore *store;
GtkCellRenderer *renderer;
char buf[128];
char buf2[128 + 8];
char tbuf[256];
snprintf (tbuf, sizeof tbuf, _("conspire: Network Editor (%s)"), net->name);
editwindow = mg_create_generic_tab(_("Network Editor"), tbuf, FALSE, TRUE, servlist_closegui, NULL, 550, 200, &vbox5, NULL);
table3 = gtk_table_new (17, 3, FALSE);
gtk_widget_show (table3);
gtk_box_pack_start (GTK_BOX (vbox5), table3, TRUE, TRUE, 0);
gtk_table_set_row_spacings (GTK_TABLE (table3), 2);
gtk_table_set_col_spacings (GTK_TABLE (table3), 8);
snprintf (buf, sizeof (buf), _("Servers for %s"), net->name);
snprintf (buf2, sizeof (buf2), "<b>%s</b>", buf);
label16 = gtk_label_new (buf2);
gtk_widget_show (label16);
gtk_table_attach (GTK_TABLE (table3), label16, 0, 3, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 3);
gtk_label_set_use_markup (GTK_LABEL (label16), TRUE);
gtk_misc_set_alignment (GTK_MISC (label16), 0, 0.5);
check = servlist_create_check (0, !(net->flags & FLAG_CYCLE), table3,
2, 1, _("Connect to selected server only"));
add_tip (check, _("Don't cycle through all the servers when the connection fails."));
label17 = bold_label (_("Your Details"));
gtk_table_attach (GTK_TABLE (table3), label17, 0, 3, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 3);
servlist_create_check (1, net->flags & FLAG_USE_GLOBAL, table3,
4, 1, _("Use global user information"));
edit_entry_nick =
servlist_create_entry (table3, _("_Nick name:"), 5, net->nick,
&edit_label_nick, 0);
edit_entry_nick2 =
servlist_create_entry (table3, _("Second choice:"), 6, net->nick2,
&edit_label_nick2, 0);
edit_entry_user =
servlist_create_entry (table3, _("_User name:"), 7, net->user,
&edit_label_user, 0);
edit_entry_real =
servlist_create_entry (table3, _("Rea_l name:"), 8, net->real,
&edit_label_real, 0);
label21 = bold_label (_("Connecting"));
gtk_table_attach (GTK_TABLE (table3), label21, 0, 3, 9, 10,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 3);
servlist_create_check (3, net->flags & FLAG_AUTO_CONNECT, table3,
11, 1, _("Auto connect to this network at startup"));
servlist_create_check (4, net->flags & FLAG_USE_PROXY, table3,
12, 1, _("Use a proxy server"));
edit_entry_join =
servlist_create_entry (table3, _("C_hannels to join:"), 15,
net->autojoin, 0,
_("Channels to join, separated by commas, but not spaces!"));
edit_entry_nickserv =
servlist_create_entry (table3, _("Nickserv password:"******"If your nickname requires a password, enter it here. Not all IRC networks support this."));
gtk_entry_set_visibility (GTK_ENTRY (edit_entry_nickserv), FALSE);
edit_entry_pass =
servlist_create_entry (table3, _("Server password:"******"Password for the server, if in doubt, leave blank."));
gtk_entry_set_visibility (GTK_ENTRY (edit_entry_pass), FALSE);
edit_entry_sasl_user =
servlist_create_entry (table3, _("SASL username:"******"If your network uses SASL, put your username here."));
edit_entry_sasl_pass =
servlist_create_entry (table3, _("SASL password:"******"If your network uses SASL, put your password here."));
gtk_entry_set_visibility (GTK_ENTRY (edit_entry_sasl_pass), FALSE);
label34 = gtk_label_new (_("Character set:"));
gtk_widget_show (label34);
gtk_table_attach (GTK_TABLE (table3), label34, 1, 2, 21, 22,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label34), 0, 0.5);
comboboxentry_charset = servlist_create_charsetcombo ();
ignore_changed = TRUE;
gtk_entry_set_text (GTK_ENTRY (GTK_BIN (comboboxentry_charset)->child), net->encoding ? net->encoding : "System default");
ignore_changed = FALSE;
gtk_widget_show (comboboxentry_charset);
gtk_table_attach (GTK_TABLE (table3), comboboxentry_charset, 2, 3, 21, 22,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
label22 = bold_label (_("Perform"));
gtk_table_attach (GTK_TABLE (table3), label22, 0, 3, 22, 23,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 3);
edit_entry_cmd =
servlist_create_textview (table3, _("Connect commands:"), 24,
net->command, 0,
_("Extra commands to execute after connecting. Alternatively, to run a large series of commands on connect, use LOAD -e <filename>, where <filename> is a text-file full of commands to execute."));
/*********** FINITO *************/
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_table_attach (GTK_TABLE (table3), hbox1, 1, 3, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow2);
gtk_box_pack_start (GTK_BOX (hbox1), scrolledwindow2, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow2),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow2),
GTK_SHADOW_IN);
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
model = GTK_TREE_MODEL (store);
edit_tree = treeview_servers = gtk_tree_view_new_with_model (model);
g_object_unref (model);
gtk_widget_show (treeview_servers);
gtk_container_add (GTK_CONTAINER (scrolledwindow2), treeview_servers);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview_servers),
FALSE);
renderer = gtk_cell_renderer_text_new ();
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (servlist_editserver_cb), model);
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (treeview_servers), -1,
0, renderer,
"text", 0,
"editable", 1,
NULL);
vbuttonbox1 = gtk_vbutton_box_new ();
gtk_box_set_spacing (GTK_BOX (vbuttonbox1), 3);
gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonbox1), GTK_BUTTONBOX_START);
gtk_widget_show (vbuttonbox1);
gtk_box_pack_start (GTK_BOX (hbox1), vbuttonbox1, FALSE, FALSE, 3);
buttonadd = gtk_button_new_from_stock ("gtk-add");
g_signal_connect (G_OBJECT (buttonadd), "clicked",
G_CALLBACK (servlist_addserver_cb), edit_tree);
gtk_widget_show (buttonadd);
gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonadd);
GTK_WIDGET_SET_FLAGS (buttonadd, GTK_CAN_DEFAULT);
buttonremove = gtk_button_new_from_stock ("gtk-remove");
g_signal_connect (G_OBJECT (buttonremove), "clicked",
G_CALLBACK (servlist_deleteserver_cb), NULL);
gtk_widget_show (buttonremove);
gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonremove);
GTK_WIDGET_SET_FLAGS (buttonremove, GTK_CAN_DEFAULT);
buttonedit = gtk_button_new_with_mnemonic (_("_Edit"));
g_signal_connect (G_OBJECT (buttonedit), "clicked",
G_CALLBACK (servlist_editserverbutton_cb), NULL);
gtk_widget_show (buttonedit);
gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonedit);
GTK_WIDGET_SET_FLAGS (buttonedit, GTK_CAN_DEFAULT);
if (net->flags & FLAG_USE_GLOBAL)
{
gtk_widget_hide (edit_label_nick);
gtk_widget_hide (edit_entry_nick);
gtk_widget_hide (edit_label_nick2);
gtk_widget_hide (edit_entry_nick2);
gtk_widget_hide (edit_label_user);
gtk_widget_hide (edit_entry_user);
gtk_widget_hide (edit_label_real);
gtk_widget_hide (edit_entry_real);
}
return editwindow;
}
void l_usldoks(short ds,short ms,short gs, //Дата начала просмотра
GtkWidget *wpredok)
{
usldoks_data data;
char bros[512];
GdkColor color;
data.ds=data.dn=ds;
data.ms=data.mn=ms;
data.gs=data.gn=gs;
data.window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(data.window),TRUE);
//gtk_window_set_default_size (GTK_WINDOW (data.window),400,-1);
//gdk_color_parse("black",&color);
//gtk_widget_modify_bg(data.window,GTK_STATE_NORMAL,&color);
sprintf(bros,"%s %s",name_system,gettext("Список документов"));
gtk_window_set_title (GTK_WINDOW (data.window),bros);
gtk_container_set_border_width (GTK_CONTAINER (data.window), 5);
gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
if(wpredok != NULL)
{
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
//Удерживать окно над породившем его окном всегда
gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok));
//Закрыть окно если окно предок удалено
gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE);
}
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(usldoks_key_press),&data);
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_release_event",GTK_SIGNAL_FUNC(iceb_key_release),&data.kl_shift);
GtkWidget *hbox = gtk_hbox_new (FALSE, 1);
gtk_container_add (GTK_CONTAINER (data.window), hbox);
GtkWidget *vbox1 = gtk_vbox_new (FALSE, 1);
GtkWidget *vbox2 = gtk_vbox_new (FALSE, 1);
gtk_box_pack_start (GTK_BOX (hbox), vbox1, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
gtk_widget_show(hbox);
data.label_kolstr=gtk_label_new (gettext("Список документов"));
gtk_box_pack_start (GTK_BOX (vbox2),data.label_kolstr,FALSE, FALSE, 0);
gtk_widget_show(vbox1);
gtk_widget_show(vbox2);
data.label_poisk=gtk_label_new ("");
/************
PangoFontDescription *font_pango=pango_font_description_from_string(shrift_ravnohir.ravno());
gtk_widget_modify_font(GTK_WIDGET(data.label_ost),font_pango);
pango_font_description_free(font_pango);
***************/
gdk_color_parse("red",&color);
gtk_widget_modify_fg(data.label_poisk,GTK_STATE_NORMAL,&color);
gtk_box_pack_start (GTK_BOX (vbox2),data.label_poisk,FALSE, FALSE, 0);
data.sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_usize(GTK_WIDGET(data.sw),-1,200);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (data.sw),GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (data.sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
//gtk_box_pack_start (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0);
gtk_box_pack_end (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0);
//Кнопки
GtkTooltips *tooltips[KOL_F_KL];
sprintf(bros,"F2 ?");
data.knopka[FK2]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK2],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data);
tooltips[FK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Включение/выключение показа только не подтверждённых документов"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2);
gtk_widget_show(data.knopka[FK2]);
sprintf(bros,"SF2 %s",gettext("Метка"));
data.knopka[SFK2]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK2],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[SFK2]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data);
tooltips[SFK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[SFK2],data.knopka[SFK2],gettext("Снятие метки неподтверждённого документа"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK2]),(gpointer)SFK2);
gtk_widget_show(data.knopka[SFK2]);
sprintf(bros,"F3 *");
data.knopka[FK3]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK3],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK3]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data);
tooltips[FK3]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK3],data.knopka[FK3],gettext("Включение/выключение показа документов без проводок"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK3]),(gpointer)FK3);
gtk_widget_show(data.knopka[FK3]);
sprintf(bros,"SF3 %s",gettext("Метка"));
data.knopka[SFK3]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK3],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[SFK3]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data);
tooltips[SFK3]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[SFK3],data.knopka[SFK3],gettext("Снятие метки документа без проводок"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK3]),(gpointer)SFK3);
gtk_widget_show(data.knopka[SFK3]);
sprintf(bros,"F4 %s",gettext("Поиск"));
data.knopka[FK4]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK4],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data);
tooltips[FK4]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Поиск нужных записей"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4);
gtk_widget_show(data.knopka[FK4]);
sprintf(bros,"F5 %s",gettext("Просмотр"));
data.knopka[FK5]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK5],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK5]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data);
tooltips[FK5]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK5],data.knopka[FK5],gettext("Просмотр выбранного документа"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK5]),(gpointer)FK5);
gtk_widget_show(data.knopka[FK5]);
sprintf(bros,"F6 %s",gettext("Экспорт"));
data.knopka[FK6]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK6],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK6]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data);
tooltips[FK6]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK6],data.knopka[FK6],gettext("Экспорт кассовых ордеров в подсистему \"Учёт кассовых ордеров\""),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK6]),(gpointer)FK6);
gtk_widget_show(data.knopka[FK6]);
sprintf(bros,"F9 %s",gettext("Оплата"));
data.knopka[FK9]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK9],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK9]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data);
tooltips[FK9]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK9],data.knopka[FK9],gettext("Переключение режимов просмотра (только оплаченыые, только не оплаченные, все)"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK9]),(gpointer)FK9);
gtk_widget_show(data.knopka[FK9]);
sprintf(bros,"F10 %s",gettext("Выход"));
data.knopka[FK10]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1),data.knopka[FK10],TRUE,TRUE, 0);
tooltips[FK10]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]), "clicked",GTK_SIGNAL_FUNC(usldoks_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10);
gtk_widget_show(data.knopka[FK10]);
gtk_widget_realize(data.window);
gdk_window_set_cursor(data.window->window,gdk_cursor_new(ICEB_CURSOR));
gtk_widget_grab_focus(data.knopka[FK10]);
usldoks_create_list(&data);
gtk_widget_show(data.window);
//if(metka == 0)
gtk_window_maximize(GTK_WINDOW(data.window));
//gtk_window_fullscreen(GTK_WINDOW(data.window));
gtk_main();
if(wpredok != NULL)
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));
}
int main(int argc, char* argv[])
{
// VMime initialization
vmime::platform::setHandler<vmime::platforms::posix::posixHandler>();
// GTK+ initialization
gtk_init(&argc, &argv);
// Create a new window
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(window), 800, 550);
gtk_window_set_title(GTK_WINDOW(window), "VMime Viewer Example");
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(destroy), NULL);
GtkWidget* vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
// Menubar
GtkActionGroup* actionGroup = gtk_action_group_new ("Actions");
gtk_action_group_add_actions(actionGroup, uiActions, G_N_ELEMENTS(uiActions), NULL);
GtkUIManager* uiManager = gtk_ui_manager_new();
gtk_ui_manager_insert_action_group(uiManager, actionGroup, 1);
gtk_ui_manager_add_ui_from_string(uiManager, uiDefinition, -1, NULL);
GtkWidget* menuBar = gtk_ui_manager_get_widget(uiManager, "/MainMenuBar");
gtk_box_pack_start(GTK_BOX(vbox), menuBar, FALSE, FALSE, 0);
// Horizontal Pane
GtkWidget* hpane = gtk_hpaned_new();
gtk_box_pack_start(GTK_BOX(vbox), hpane, TRUE, TRUE, 0);
// Tree View
treeModel = gtk_tree_store_new(2, G_TYPE_STRING, G_TYPE_POINTER);
treeView = gtk_tree_view_new();
g_signal_connect(G_OBJECT(treeView), "cursor-changed", G_CALLBACK(treeViewSelChanged), NULL);
GtkWidget* scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(scroll), treeView);
gtk_paned_add1(GTK_PANED(hpane), scroll);
GtkTreeViewColumn* col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, "Component Name");
gtk_tree_view_append_column(GTK_TREE_VIEW(treeView), col);
GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", 0);
gtk_tree_view_set_model(GTK_TREE_VIEW(treeView), GTK_TREE_MODEL(treeModel));
g_object_unref(treeModel);
gtk_widget_set_size_request(treeView, 200, 100);
// Text Area
textArea = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(textArea), FALSE);
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(scroll), textArea);
gtk_paned_add2(GTK_PANED(hpane), scroll);
// Show main window
gtk_widget_show_all(window);
// GTK main loop
gtk_main();
return 0;
}
void
tasks_add_edit_dialog_show (gboolean tasks_edit_mode, GUI *appGUI) {
GtkWidget *vbox1;
GtkWidget *vbox2;
GtkWidget *label;
GtkWidget *select_date_button;
GtkWidget *scrolledwindow;
GtkWidget *hseparator;
GtkWidget *hbuttonbox;
GtkWidget *table;
GtkWidget *cancel_button;
gchar tmpbuf[BUFFER_SIZE];
appGUI->tsk->tasks_add_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width (GTK_CONTAINER (appGUI->tsk->tasks_add_window), 6);
if(tasks_edit_mode == TRUE) {
gtk_window_set_title (GTK_WINDOW (appGUI->tsk->tasks_add_window), _("Edit task"));
} else {
gtk_window_set_title (GTK_WINDOW (appGUI->tsk->tasks_add_window), _("Add task"));
}
gtk_window_move (GTK_WINDOW (appGUI->tsk->tasks_add_window),
config.tasks_addedit_win_x, config.tasks_addedit_win_y);
gtk_window_set_default_size (GTK_WINDOW(appGUI->tsk->tasks_add_window),
config.tasks_addedit_win_w, config.tasks_addedit_win_h);
gtk_window_set_transient_for(GTK_WINDOW(appGUI->tsk->tasks_add_window), GTK_WINDOW(appGUI->main_window));
gtk_window_set_modal(GTK_WINDOW(appGUI->tsk->tasks_add_window), TRUE);
g_signal_connect (G_OBJECT (appGUI->tsk->tasks_add_window), "key_press_event",
G_CALLBACK (tasks_add_edit_key_press_cb), appGUI);
g_signal_connect (G_OBJECT (appGUI->tsk->tasks_add_window), "delete_event",
G_CALLBACK(tasks_add_edit_window_close_cb), appGUI);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (appGUI->tsk->tasks_add_window), vbox1);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_box_pack_start (GTK_BOX (vbox1), vbox2, TRUE, TRUE, 0);
table = gtk_table_new (4, 4, FALSE);
gtk_widget_show (table);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_box_pack_start (GTK_BOX (vbox2), table, FALSE, FALSE, 4);
sprintf(tmpbuf, "<b>%s:</b>", _("Summary"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
sprintf(tmpbuf, "<b>%s:</b>", _("Due date"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
appGUI->tsk->summary_entry = gtk_entry_new ();
gtk_widget_show (appGUI->tsk->summary_entry);
gtk_table_attach (GTK_TABLE (table), appGUI->tsk->summary_entry, 1, 4, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
appGUI->tsk->due_date_entry = gtk_entry_new ();
gtk_widget_show (appGUI->tsk->due_date_entry);
GTK_WIDGET_UNSET_FLAGS(appGUI->tsk->due_date_entry, GTK_CAN_FOCUS);
gtk_editable_set_editable (GTK_EDITABLE (appGUI->tsk->due_date_entry), FALSE);
gtk_table_attach (GTK_TABLE (table), appGUI->tsk->due_date_entry, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
select_date_button = gtk_button_new_from_stock (OSMO_STOCK_BUTTON_SELECT_DATE);
gtk_widget_show (select_date_button);
GTK_WIDGET_UNSET_FLAGS(select_date_button, GTK_CAN_FOCUS);
g_signal_connect(select_date_button, "clicked",
G_CALLBACK(select_date_cb), appGUI);
gtk_table_attach (GTK_TABLE (table), select_date_button, 2, 4, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
sprintf(tmpbuf, "<b>%s:</b>", _("Category"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
appGUI->tsk->category_combobox = gtk_combo_box_new_text ();
gtk_widget_show (appGUI->tsk->category_combobox);
gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (appGUI->tsk->category_combobox), FALSE);
gtk_table_attach (GTK_TABLE (table), appGUI->tsk->category_combobox, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
create_category_combobox (GTK_COMBO_BOX (appGUI->tsk->category_combobox), appGUI->opt->tasks_category_store, TRUE);
gtk_combo_box_set_active(GTK_COMBO_BOX(appGUI->tsk->category_combobox),
gui_list_store_get_text_index (appGUI->opt->tasks_category_store, gtk_combo_box_get_active_text(GTK_COMBO_BOX(appGUI->tsk->cf_combobox))));
sprintf(tmpbuf, "<b>%s:</b>", _("Priority"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
appGUI->tsk->priority_combobox = gtk_combo_box_new_text ();
gtk_widget_show (appGUI->tsk->priority_combobox);
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->tsk->priority_combobox), _("Low"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->tsk->priority_combobox), _("Medium"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->tsk->priority_combobox), _("High"));
gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (appGUI->tsk->priority_combobox), FALSE);
gtk_table_attach (GTK_TABLE (table), appGUI->tsk->priority_combobox, 3, 4, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_combo_box_set_active (GTK_COMBO_BOX (appGUI->tsk->priority_combobox), 1);
sprintf(tmpbuf, "<b>%s:</b>", _("Description"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow);
gtk_box_pack_start (GTK_BOX (vbox2), scrolledwindow, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_SHADOW_IN);
appGUI->tsk->desc_textview = gtk_text_view_new ();
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (appGUI->tsk->desc_textview), GTK_WRAP_WORD);
gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(appGUI->tsk->desc_textview), 4);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(appGUI->tsk->desc_textview), 4);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(appGUI->tsk->desc_textview), 4);
gtk_widget_show (appGUI->tsk->desc_textview);
gtk_container_add (GTK_CONTAINER (scrolledwindow), appGUI->tsk->desc_textview);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 4);
hbuttonbox = gtk_hbutton_box_new ();
gtk_widget_show (hbuttonbox);
gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbuttonbox), 2);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing (GTK_BOX (hbuttonbox), 16);
if (config.default_stock_icons) {
cancel_button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
} else {
cancel_button = gtk_button_new_from_stock (OSMO_STOCK_BUTTON_CANCEL);
}
gtk_widget_show (cancel_button);
gtk_container_add (GTK_CONTAINER (hbuttonbox), cancel_button);
g_signal_connect(cancel_button, "clicked",
G_CALLBACK(button_tasks_add_edit_window_close_cb), appGUI);
if (config.default_stock_icons) {
appGUI->tsk->tasks_ok_button = gtk_button_new_from_stock (GTK_STOCK_OK);
} else {
appGUI->tsk->tasks_ok_button = gtk_button_new_from_stock (OSMO_STOCK_BUTTON_OK);
}
gtk_widget_show (appGUI->tsk->tasks_ok_button);
gtk_container_add (GTK_CONTAINER (hbuttonbox), appGUI->tsk->tasks_ok_button);
g_signal_connect(appGUI->tsk->tasks_ok_button, "clicked",
G_CALLBACK(tasks_item_entered_cb), appGUI);
appGUI->tsk->tasks_edit_state = tasks_edit_mode;
appGUI->tsk->tasks_accept_state = FALSE;
gtk_entry_set_text (GTK_ENTRY(appGUI->tsk->due_date_entry), _("No date"));
if (tasks_edit_mode == TRUE) {
appGUI->tsk->tasks_accept_state = TRUE;
fill_fields (appGUI->tsk->due_date_entry, appGUI->tsk->summary_entry, appGUI->tsk->desc_textview, appGUI);
}
gtk_widget_set_sensitive(appGUI->tsk->tasks_ok_button, appGUI->tsk->tasks_accept_state);
gtk_widget_show(appGUI->tsk->tasks_add_window);
}
/**
* entry_properties_new:
*
* Returns: a new #GtkWidget
*/
GtkWidget *
entry_properties_new (TConnection *tcnc)
{
EntryProperties *eprop;
g_return_val_if_fail (T_IS_CONNECTION (tcnc), NULL);
eprop = ENTRY_PROPERTIES (g_object_new (ENTRY_PROPERTIES_TYPE, NULL));
eprop->priv->tcnc = g_object_ref (tcnc);
GtkWidget *sw;
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_NONE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (eprop), sw, TRUE, TRUE, 0);
GtkWidget *textview;
textview = gtk_text_view_new ();
gtk_container_add (GTK_CONTAINER (sw), textview);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (textview), 5);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (textview), 5);
gtk_text_view_set_editable (GTK_TEXT_VIEW (textview), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (textview), FALSE);
eprop->priv->text = gtk_text_view_get_buffer (GTK_TEXT_VIEW (textview));
eprop->priv->view = GTK_TEXT_VIEW (textview);
gtk_widget_show_all (sw);
gtk_text_buffer_create_tag (eprop->priv->text, "section",
"weight", PANGO_WEIGHT_BOLD,
"foreground", "blue", NULL);
gtk_text_buffer_create_tag (eprop->priv->text, "error",
"foreground", "red", NULL);
gtk_text_buffer_create_tag (eprop->priv->text, "data",
"left-margin", 20, NULL);
gtk_text_buffer_create_tag (eprop->priv->text, "convdata",
"style", PANGO_STYLE_ITALIC,
"background", "lightgray",
"left-margin", 20, NULL);
gtk_text_buffer_create_tag (eprop->priv->text, "starter",
"indent", -10,
"left-margin", 20, NULL);
g_signal_connect (textview, "key-press-event",
G_CALLBACK (key_press_event), eprop);
g_signal_connect (textview, "event-after",
G_CALLBACK (event_after), eprop);
g_signal_connect (textview, "motion-notify-event",
G_CALLBACK (motion_notify_event), eprop);
g_signal_connect (textview, "visibility-notify-event",
G_CALLBACK (visibility_notify_event), eprop);
g_signal_connect (textview, "populate-popup",
G_CALLBACK (populate_popup_cb), eprop);
entry_properties_set_dn (eprop, NULL);
return (GtkWidget*) eprop;
}
GtkWidget *
userlist_create (GtkWidget *box)
{
GtkWidget *sw, *treeview;
static const GtkTargetEntry dnd_dest_targets[] =
{
{"text/uri-list", 0, 1},
{"XCHAT_CHANVIEW", GTK_TARGET_SAME_APP, 75 }
};
static const GtkTargetEntry dnd_src_target[] =
{
{"XCHAT_USERLIST", GTK_TARGET_SAME_APP, 75 }
};
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
prefs.pchat_gui_ulist_show_hosts ?
GTK_POLICY_AUTOMATIC :
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (box), sw, TRUE, TRUE, 0);
gtk_widget_show (sw);
treeview = gtk_tree_view_new ();
gtk_widget_set_name (treeview, "xchat-userlist");
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
gtk_tree_selection_set_mode (gtk_tree_view_get_selection
(GTK_TREE_VIEW (treeview)),
GTK_SELECTION_MULTIPLE);
/* set up drops */
gtk_drag_dest_set (treeview, GTK_DEST_DEFAULT_ALL, dnd_dest_targets, 2,
GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK);
gtk_drag_source_set (treeview, GDK_BUTTON1_MASK, dnd_src_target, 1, GDK_ACTION_MOVE);
/* file DND (for DCC) */
g_signal_connect (G_OBJECT (treeview), "drag_motion",
G_CALLBACK (userlist_dnd_motion), treeview);
g_signal_connect (G_OBJECT (treeview), "drag_leave",
G_CALLBACK (userlist_dnd_leave), 0);
g_signal_connect (G_OBJECT (treeview), "drag_data_received",
G_CALLBACK (userlist_dnd_drop), treeview);
g_signal_connect (G_OBJECT (treeview), "button_press_event",
G_CALLBACK (userlist_click_cb), 0);
g_signal_connect (G_OBJECT (treeview), "key_press_event",
G_CALLBACK (userlist_key_cb), 0);
/* tree/chanview DND */
#ifndef _WIN32 /* leaks GDI pool memory, don't enable */
g_signal_connect (G_OBJECT (treeview), "drag_begin",
G_CALLBACK (mg_drag_begin_cb), NULL);
g_signal_connect (G_OBJECT (treeview), "drag_drop",
G_CALLBACK (mg_drag_drop_cb), NULL);
g_signal_connect (G_OBJECT (treeview), "drag_motion",
G_CALLBACK (mg_drag_motion_cb), NULL);
g_signal_connect (G_OBJECT (treeview), "drag_end",
G_CALLBACK (mg_drag_end_cb), NULL);
#endif
userlist_add_columns (GTK_TREE_VIEW (treeview));
gtk_container_add (GTK_CONTAINER (sw), treeview);
gtk_widget_show (treeview);
return treeview;
}
void
gui_create_tasks(GUI *appGUI) {
GtkWidget *vbox1;
GtkWidget *vbox2;
GtkWidget *table;
GtkWidget *label;
GtkWidget *top_scrolledwindow;
GtkWidget *hseparator;
GtkWidget *close_button;
GtkCellRenderer *renderer;
GtkWidget *top_viewport;
GtkWidget *bottom_viewport;
GtkTextBuffer *text_buffer;
GError *error = NULL;
GtkActionGroup *action_group = NULL;
gchar tmpbuf[BUFFER_SIZE];
const gchar *ui_info =
" <toolbar name=\"toolbar\">\n"
" <toolitem name=\"add\" action=\"add\" />\n"
" <toolitem name=\"delete\" action=\"delete\" />\n"
" <separator name=\"sep1\" />\n"
" <toolitem name=\"edit\" action=\"edit\" />\n"
" </toolbar>\n";
GtkActionEntry entries[] = {
{ "add", OSMO_STOCK_TASKS_ADD, _("New task"), NULL, _("New task"), NULL },
{ "edit", OSMO_STOCK_TASKS_EDIT, _("Edit task"), NULL, _("Edit task"), NULL },
{ "delete", OSMO_STOCK_TASKS_REMOVE, _("Remove task"), NULL, _("Remove task"), NULL },
};
guint n_entries = G_N_ELEMENTS (entries);
appGUI->tsk->filter_index = 0;
vbox1 = gtk_vbox_new (FALSE, 1);
gtk_widget_show (vbox1);
gtk_container_set_border_width (GTK_CONTAINER (vbox1), 8);
sprintf(tmpbuf, "<b>%s</b>", _("Tasks"));
gui_add_to_notebook (vbox1, tmpbuf, appGUI);
appGUI->tsk->vbox = GTK_BOX(vbox1);
/*-------------------------------------------------------------------------------------*/
action_group = gtk_action_group_new ("_actions");
gtk_action_group_add_actions (action_group, entries, n_entries, NULL);
gtk_action_group_set_sensitive(action_group, TRUE);
appGUI->tsk->tasks_uim_widget = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group (appGUI->tsk->tasks_uim_widget, action_group, 0);
g_signal_connect (appGUI->tsk->tasks_uim_widget, "add_widget", G_CALLBACK (add_tasks_toolbar_widget), appGUI);
if (!gtk_ui_manager_add_ui_from_string (appGUI->tsk->tasks_uim_widget, ui_info, -1, &error)) {
g_message ("building toolbar failed: %s", error->message);
g_error_free (error);
}
gtk_ui_manager_ensure_update (appGUI->tsk->tasks_uim_widget);
gtk_toolbar_set_style (appGUI->tsk->tasks_toolbar, GTK_TOOLBAR_ICONS);
gtk_toolbar_set_tooltips (appGUI->tsk->tasks_toolbar, config.enable_tooltips);
/*-------------------------------------------------------------------------------------*/
/* assign callbacks */
g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/add")), "clicked",
G_CALLBACK(tasks_add_item_cb), appGUI);
g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit")), "clicked",
G_CALLBACK(tasks_edit_item_cb), appGUI);
g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete")), "clicked",
G_CALLBACK(tasks_remove_item_cb), appGUI);
/*-------------------------------------------------------------------------------------*/
gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit"), FALSE);
gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete"), FALSE);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6);
table = gtk_table_new (1, 4, FALSE);
gtk_widget_show (table);
gtk_box_pack_start (GTK_BOX (vbox1), table, FALSE, TRUE, 0);
gtk_table_set_col_spacings (GTK_TABLE (table), 8);
sprintf(tmpbuf, "<b>%s:</b>", _("Category filter"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
appGUI->tsk->cf_combobox = gtk_combo_box_new_text ();
gtk_widget_show (appGUI->tsk->cf_combobox);
gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (appGUI->tsk->cf_combobox), FALSE);
GTK_WIDGET_UNSET_FLAGS(appGUI->tsk->cf_combobox, GTK_CAN_FOCUS);
gtk_table_attach (GTK_TABLE (table), appGUI->tsk->cf_combobox, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
g_signal_connect(appGUI->tsk->cf_combobox, "changed",
G_CALLBACK(category_filter_cb), appGUI);
g_signal_connect(G_OBJECT(appGUI->tsk->cf_combobox), "focus",
G_CALLBACK(category_combo_box_focus_cb), NULL);
appGUI->tsk->n_items_label = gtk_label_new ("");
gtk_widget_show (appGUI->tsk->n_items_label);
gtk_widget_set_size_request (appGUI->tsk->n_items_label, 100, -1);
gtk_table_attach (GTK_TABLE (table), appGUI->tsk->n_items_label, 3, 4, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_use_markup (GTK_LABEL (appGUI->tsk->n_items_label), TRUE);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6);
/*-------------------------------------------------------------------------------------*/
appGUI->tsk->tasks_paned = gtk_vpaned_new();
gtk_widget_show (appGUI->tsk->tasks_paned);
gtk_paned_set_position(GTK_PANED(appGUI->tsk->tasks_paned), 99999);
gtk_box_pack_start(GTK_BOX(vbox1), appGUI->tsk->tasks_paned, TRUE, TRUE, 0);
top_viewport = gtk_viewport_new (NULL, NULL);
gtk_widget_show (top_viewport);
gtk_viewport_set_shadow_type (GTK_VIEWPORT (top_viewport), GTK_SHADOW_NONE);
gtk_paned_pack1 (GTK_PANED (appGUI->tsk->tasks_paned), top_viewport, FALSE, TRUE);
top_scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (top_scrolledwindow);
gtk_container_add (GTK_CONTAINER (top_viewport), top_scrolledwindow);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (top_scrolledwindow), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (top_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
appGUI->tsk->tasks_list_store = gtk_list_store_new(TASKS_NUM_COLUMNS,
G_TYPE_BOOLEAN,
G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
appGUI->tsk->tasks_filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(appGUI->tsk->tasks_list_store), NULL);
gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER(appGUI->tsk->tasks_filter),
(GtkTreeModelFilterVisibleFunc)tasks_list_filter_cb,
appGUI, NULL);
appGUI->tsk->tasks_sort = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(appGUI->tsk->tasks_filter));
appGUI->tsk->tasks_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(appGUI->tsk->tasks_sort));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(appGUI->tsk->tasks_list), config.tasks_rules_hint);
gtk_widget_show (appGUI->tsk->tasks_list);
GTK_WIDGET_SET_FLAGS (appGUI->tsk->tasks_list, GTK_CAN_DEFAULT);
gtk_widget_modify_fg(GTK_WIDGET(appGUI->tsk->tasks_list), GTK_STATE_SELECTED,
(& GTK_WIDGET(appGUI->tsk->tasks_list)->style->base[GTK_STATE_SELECTED]));
gtk_widget_modify_fg(GTK_WIDGET(appGUI->tsk->tasks_list), GTK_STATE_NORMAL,
(& GTK_WIDGET(appGUI->tsk->tasks_list)->style->bg[GTK_STATE_NORMAL]));
g_signal_connect(G_OBJECT(appGUI->tsk->tasks_list), "button_press_event",
G_CALLBACK(list_dbclick_cb), appGUI);
appGUI->tsk->tasks_list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (appGUI->tsk->tasks_list));
g_signal_connect(G_OBJECT(appGUI->tsk->tasks_list_selection), "changed",
G_CALLBACK(tasks_item_selected), appGUI);
/* create columns */
renderer = gtk_cell_renderer_toggle_new();
appGUI->tsk->tasks_columns[COLUMN_DONE] = gtk_tree_view_column_new_with_attributes (_("Done"),
renderer,
"active", COLUMN_DONE,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DONE]);
g_signal_connect (renderer, "toggled", G_CALLBACK (done_toggled), appGUI);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_DUE_DATE] = gtk_tree_view_column_new_with_attributes(_("Due date"),
renderer,
"text", COLUMN_DUE_DATE,
"strikethrough", COLUMN_DONE,
"foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DUE_DATE], config.visible_due_date_column);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DUE_DATE]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN] = gtk_tree_view_column_new_with_attributes(NULL,
renderer,
"text", COLUMN_DUE_DATE_JULIAN,
"strikethrough", COLUMN_DONE,
"foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN], FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN] = gtk_tree_view_column_new_with_attributes(NULL,
renderer,
"text", COLUMN_START_DATE_JULIAN,
"strikethrough", COLUMN_DONE,
"foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN], FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_PRIORITY] = gtk_tree_view_column_new_with_attributes(_("Priority"),
renderer,
"text", COLUMN_PRIORITY,
"strikethrough", COLUMN_DONE,
"foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_PRIORITY], config.visible_priority_column);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_PRIORITY]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_CATEGORY] = gtk_tree_view_column_new_with_attributes(_("Category"),
renderer,
"text", COLUMN_CATEGORY,
"strikethrough", COLUMN_DONE,
"foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_CATEGORY], config.visible_category_column);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_CATEGORY]);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_cell_renderer_set_fixed_size(renderer, 0, -1);
appGUI->tsk->tasks_columns[COLUMN_SUMMARY] = gtk_tree_view_column_new_with_attributes(_("Summary"),
renderer,
"text", COLUMN_SUMMARY,
"strikethrough", COLUMN_DONE,
"foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_SUMMARY]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION] = gtk_tree_view_column_new_with_attributes(_("Description"),
renderer,
"text", COLUMN_DESCRIPTION,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION], FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_COLOR] = gtk_tree_view_column_new_with_attributes(NULL,
renderer,
"text", COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_COLOR], FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_COLOR]);
/* configure list options */
gtk_container_add (GTK_CONTAINER (top_scrolledwindow), appGUI->tsk->tasks_list);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW(appGUI->tsk->tasks_list), FALSE);
/* configure sorting */
gtk_tree_sortable_set_sort_func((GtkTreeSortable *)appGUI->tsk->tasks_sort, 0,
(GtkTreeIterCompareFunc)custom_tasks_sort_function, NULL, NULL);
gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_DUE_DATE, config.tasks_sorting_order);
gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_PRIORITY, config.tasks_sorting_order);
gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_DONE, config.tasks_sorting_order);
/*----------------------------------------------------------------------------*/
bottom_viewport = gtk_viewport_new (NULL, NULL);
gtk_widget_show (bottom_viewport);
gtk_viewport_set_shadow_type (GTK_VIEWPORT (bottom_viewport), GTK_SHADOW_NONE);
gtk_paned_pack2 (GTK_PANED (appGUI->tsk->tasks_paned), bottom_viewport, TRUE, TRUE);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_container_set_border_width (GTK_CONTAINER (vbox2), 0);
gtk_container_add (GTK_CONTAINER (bottom_viewport), vbox2);
appGUI->tsk->panel_hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox2), appGUI->tsk->panel_hbox, FALSE, FALSE, 0);
gtk_widget_show(appGUI->tsk->panel_hbox);
sprintf(tmpbuf, "%s:", _("Task details"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (appGUI->tsk->panel_hbox), label, FALSE, FALSE, 0);
if (config.default_stock_icons) {
close_button = gui_stock_button(GTK_STOCK_CLOSE, FALSE);
} else {
close_button = gui_stock_button(OSMO_STOCK_BUTTON_CLOSE, FALSE);
}
GTK_WIDGET_UNSET_FLAGS(close_button, GTK_CAN_FOCUS);
gtk_button_set_relief (GTK_BUTTON(close_button), GTK_RELIEF_NONE);
gtk_tooltips_set_tip (appGUI->osmo_tooltips, close_button, _("Close description panel"), NULL);
gtk_box_pack_end (GTK_BOX (appGUI->tsk->panel_hbox), close_button, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (close_button), "clicked",
G_CALLBACK (panel_close_desc_cb), appGUI);
appGUI->tsk->panel_scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (appGUI->tsk->panel_scrolledwindow);
gtk_box_pack_start (GTK_BOX (vbox2), appGUI->tsk->panel_scrolledwindow, TRUE, TRUE, 0);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (appGUI->tsk->panel_scrolledwindow), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (appGUI->tsk->panel_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
appGUI->tsk->tasks_desc_textview = gtk_text_view_new ();
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (appGUI->tsk->tasks_desc_textview), GTK_WRAP_WORD);
gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), FALSE);
gtk_text_view_set_editable(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), FALSE);
gtk_widget_show (appGUI->tsk->tasks_desc_textview);
gtk_container_add (GTK_CONTAINER (appGUI->tsk->panel_scrolledwindow), appGUI->tsk->tasks_desc_textview);
text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview));
gtk_text_buffer_create_tag (text_buffer, "italic",
"style", PANGO_STYLE_ITALIC, NULL);
appGUI->tsk->font_tag_object = gtk_text_buffer_create_tag (text_buffer, "info_font",
"font", (gchar *) config.task_info_font, NULL);
}
static void
gb_book_links_construct (GbBookLinks *self)
{
GbBookLinksPrivate *priv;
GtkWidget *swindow;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
priv = self->priv;
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swindow),
GTK_SHADOW_IN);
/* Create tree view */
priv->tree_view = gtk_tree_view_new ();
gtk_tree_view_set_activate_on_single_click (GTK_TREE_VIEW (priv->tree_view), TRUE);
g_signal_connect_swapped (priv->tree_view, "row-activated",
G_CALLBACK (schedule_emit_link_activated), self);
gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (priv->tree_view), FALSE);
gtk_tree_view_set_level_indentation (GTK_TREE_VIEW (priv->tree_view), 20);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->tree_view));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->tree_view), FALSE);
gtk_container_add (GTK_CONTAINER (swindow), priv->tree_view);
gtk_box_pack_start (GTK_BOX (self), swindow, TRUE, TRUE, 0);
gtk_widget_show_all (GTK_WIDGET (self));
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (priv->tree_view), column);
renderer = (GtkCellRenderer *)
g_object_new (GTK_TYPE_CELL_RENDERER_TEXT,
"ellipsize", PANGO_ELLIPSIZE_END,
"weight", PANGO_WEIGHT_BOLD,
"xpad", 10,
NULL);
gtk_tree_view_column_pack_start (GTK_TREE_VIEW_COLUMN (column), renderer, TRUE);
gtk_tree_view_column_set_attributes (GTK_TREE_VIEW_COLUMN (column), renderer,
"markup", BOOK_LINKS_COLUMN_MARKUP,
NULL);
renderer = gd_styled_text_renderer_new ();
gd_styled_text_renderer_add_class (GD_STYLED_TEXT_RENDERER (renderer), "dim-label");
g_object_set (renderer,
"max-width-chars", 12,
"scale", PANGO_SCALE_SMALL,
"xalign", 1.0,
"xpad", 10,
NULL);
gtk_tree_view_column_pack_end (GTK_TREE_VIEW_COLUMN (column), renderer, FALSE);
/*
gtk_tree_view_column_set_attributes (GTK_TREE_VIEW_COLUMN (column), renderer,
"text", BOOK_LINKS_COLUMN_LABEL,
NULL);
*/
priv->model = (GtkTreeModel *)gtk_list_store_new (BOOK_LINKS_COLUMN_N,
G_TYPE_STRING,
G_TYPE_STRING);
}
static PanelAddtoDialog *
panel_addto_dialog_new (PanelWidget *panel_widget)
{
PanelAddtoDialog *dialog;
GtkWidget *dialog_vbox;
#if !GTK_CHECK_VERSION (3, 0, 0)
GtkWidget *vbox;
#endif
GtkWidget *inner_vbox;
GtkWidget *find_hbox;
GtkWidget *sw;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
dialog = g_new0 (PanelAddtoDialog, 1);
g_object_set_qdata_full (G_OBJECT (panel_widget->toplevel),
panel_addto_dialog_quark,
dialog,
(GDestroyNotify) panel_addto_dialog_free);
dialog->panel_widget = panel_widget;
g_signal_connect (dialog->panel_widget->toplevel->settings,
"changed::" PANEL_TOPLEVEL_NAME_KEY,
G_CALLBACK (panel_addto_name_notify),
dialog);
dialog->addto_dialog = gtk_dialog_new ();
gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog),
GTK_STOCK_HELP, GTK_RESPONSE_HELP);
dialog->back_button = gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog),
GTK_STOCK_GO_BACK,
PANEL_ADDTO_RESPONSE_BACK);
dialog->add_button = gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog),
GTK_STOCK_ADD,
PANEL_ADDTO_RESPONSE_ADD);
gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog),
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE);
gtk_widget_set_sensitive (GTK_WIDGET (dialog->add_button), FALSE);
gtk_dialog_set_default_response (GTK_DIALOG (dialog->addto_dialog),
PANEL_ADDTO_RESPONSE_ADD);
gtk_container_set_border_width (GTK_CONTAINER (dialog->addto_dialog), 5);
dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog->addto_dialog));
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_box_set_spacing (GTK_BOX (dialog_vbox), 12);
gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5);
#else
gtk_box_set_spacing (GTK_BOX (dialog_vbox), 2);
#endif
g_signal_connect (G_OBJECT (dialog->addto_dialog), "response",
G_CALLBACK (panel_addto_dialog_response), dialog);
g_signal_connect (dialog->addto_dialog, "destroy",
G_CALLBACK (panel_addto_dialog_destroy), dialog);
#if !GTK_CHECK_VERSION (3, 0, 0)
vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
gtk_container_add (GTK_CONTAINER (dialog_vbox), vbox);
#endif
inner_vbox = gtk_vbox_new (FALSE, 6);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_box_pack_start (GTK_BOX (dialog_vbox), inner_vbox, TRUE, TRUE, 0);
#else
gtk_box_pack_start (GTK_BOX (vbox), inner_vbox, TRUE, TRUE, 0);
#endif
find_hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (inner_vbox), find_hbox, FALSE, FALSE, 0);
dialog->label = gtk_label_new_with_mnemonic ("");
gtk_misc_set_alignment (GTK_MISC (dialog->label), 0.0, 0.5);
gtk_label_set_use_markup (GTK_LABEL (dialog->label), TRUE);
gtk_box_pack_start (GTK_BOX (find_hbox), dialog->label,
FALSE, FALSE, 0);
dialog->search_entry = gtk_entry_new ();
g_signal_connect (G_OBJECT (dialog->search_entry), "changed",
G_CALLBACK (panel_addto_search_entry_changed), dialog);
g_signal_connect (G_OBJECT (dialog->search_entry), "activate",
G_CALLBACK (panel_addto_search_entry_activated), dialog);
gtk_box_pack_end (GTK_BOX (find_hbox), dialog->search_entry,
TRUE, TRUE, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (dialog->label),
dialog->search_entry);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (inner_vbox), sw, TRUE, TRUE, 0);
dialog->tree_view = gtk_tree_view_new ();
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (dialog->tree_view),
FALSE);
gtk_tree_view_expand_all (GTK_TREE_VIEW (dialog->tree_view));
renderer = g_object_new (GTK_TYPE_CELL_RENDERER_PIXBUF,
"xpad", 4,
"ypad", 4,
NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (dialog->tree_view),
-1, NULL,
renderer,
"pixbuf", COLUMN_ICON,
NULL);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (dialog->tree_view),
-1, NULL,
renderer,
"markup", COLUMN_TEXT,
NULL);
//FIXME use the same search than the one for the search entry?
gtk_tree_view_set_search_column (GTK_TREE_VIEW (dialog->tree_view),
COLUMN_SEARCH);
gtk_tree_view_set_row_separator_func (GTK_TREE_VIEW (dialog->tree_view),
panel_addto_separator_func,
GINT_TO_POINTER (COLUMN_TEXT),
NULL);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tree_view));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (dialog->tree_view),
COLUMN_TEXT);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
g_signal_connect (selection, "changed",
G_CALLBACK (panel_addto_selection_changed),
dialog);
g_signal_connect (dialog->tree_view, "row-activated",
G_CALLBACK (panel_addto_selection_activated),
dialog);
gtk_container_add (GTK_CONTAINER (sw), dialog->tree_view);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_show_all (dialog_vbox);
#else
gtk_widget_show_all (vbox);
#endif
panel_toplevel_push_autohide_disabler (dialog->panel_widget->toplevel);
panel_widget_register_open_dialog (panel_widget,
dialog->addto_dialog);
panel_addto_name_change (dialog,
panel_toplevel_get_name (dialog->panel_widget->toplevel));
return dialog;
}
GtkWidget *
do_tree_store (GtkWidget *do_widget)
{
if (!window)
{
GtkWidget *vbox;
GtkWidget *sw;
GtkWidget *treeview;
GtkTreeModel *model;
/* create window, etc */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "Card planning sheet");
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
vbox = gtk_vbox_new (FALSE, 8);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_box_pack_start (GTK_BOX (vbox),
gtk_label_new ("Jonathan's Holiday Card Planning Sheet"),
FALSE, FALSE, 0);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
/* create model */
model = create_model ();
/* create tree view */
treeview = gtk_tree_view_new_with_model (model);
g_object_unref (model);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE);
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)),
GTK_SELECTION_MULTIPLE);
add_columns (GTK_TREE_VIEW (treeview));
gtk_container_add (GTK_CONTAINER (sw), treeview);
/* expand all rows after the treeview widget has been realized */
g_signal_connect (treeview, "realize",
G_CALLBACK (gtk_tree_view_expand_all), NULL);
gtk_window_set_default_size (GTK_WINDOW (window), 650, 400);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
/*主界面进入点*/
int main(int argc,char **argv)
{
GtkWidget *win;
GtkWidget *menu;
GtkWidget *menu_bar;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *text;
GtkWidget *scrolled;
GtkWidget *open;
GtkWidget *close;
GtkWidget *clean;
GtkTextBuffer *buffer;
GtkAccelGroup *accel_group;
PangoFontDescription *font_name;
DATA data;
CONFDATA conf;
ABOUT about_data;
//HELP help_data;
struct sigaction act,old;
setpgrp();
init_with_conf(&conf);
init_about_data(&about_data);
//init_help_data(&help_data);
data.buf=g_string_new(NULL);
data.python_path=conf.python_path;
data.proxy_py_path=conf.proxy_py_path;
setlocale(LC_ALL,"");
/*设置语言环境*/
if(conf.language_env == NULL)
{
setlocale(LC_CTYPE,"zh_CN.UTF-8");
setenv("LANG","zh_CN.UTF-8",1);
}
else
{
setlocale(LC_CTYPE,conf.language_env);
setenv("LANG",conf.language_env,1);
}
if(conf.gtk_goagent_path!=NULL)
chdir(conf.gtk_goagent_path);
/*是否自动更新
* 如果是则在后台运行版更新进程
*/
if(strcmp(conf.goagent_auto_upgrade,"true")==0)
auto_upgrade_goagent(GOAGENT_URL,&conf);
/*国际化*/
bindtextdomain("gtk_goagent","./locale/");
textdomain("gtk_goagent");
act.sa_flags=0;
act.sa_handler=clean_data;
/*设置自定义信号处理
* 用于在启动GoAgent失败时清理数据
*/
sigaction(SIGUSR1,&act,&old);
gtk_init(&argc,&argv);
win=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(win),GTK_WIN_POS_CENTER);
gtk_window_set_title(GTK_WINDOW(win),"Gtk GoAgent");
gtk_window_set_icon_from_file(GTK_WINDOW(win),"img/64x64/gtk_goagent.png",NULL);
create_tray(win);
//create_pre_ui(&pre,&conf);
vbox=gtk_vbox_new(FALSE,0);
accel_group=gtk_accel_group_new();
gtk_window_add_accel_group(GTK_WINDOW(win),accel_group);
gtk_container_add(GTK_CONTAINER(win),vbox);
text=gtk_text_view_new();
/*设置日志显示框字体*/
if(conf.font!=NULL)
{
font_name=pango_font_description_from_string(conf.font);
gtk_widget_modify_font(text,font_name);
}
buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
/*创建红色黑色和黄色标记
* 正常日志黑色输出
* 绿色用于警告
* 红色用于错误
* 黄色用于调试
*/
gtk_text_buffer_create_tag(buffer,"green_fg",
"foreground","green",NULL);
gtk_text_buffer_create_tag(buffer,"red_fg","foreground",
"red",NULL);
gtk_text_buffer_create_tag(buffer,"black_fg","foreground",
"black",NULL);
gtk_text_buffer_create_tag(buffer,"yellow_fg",
"foreground","yellow",NULL);
data.text=text;
data.off=0;
menu_bar=gtk_menu_bar_new();
gtk_box_pack_start(GTK_BOX(vbox),menu_bar,FALSE,FALSE,0);
/*创建菜单*/
menu=create_menu(menu_bar,_("_File"));
create_menu_with_image(menu,GTK_STOCK_OPEN,accel_group,connect_goagent,&data);
create_menu_with_image(menu,GTK_STOCK_CLOSE,accel_group,disconnect_goagent,&data);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),gtk_separator_menu_item_new());
create_menu_with_image(menu,GTK_STOCK_QUIT,accel_group,really_quit,&data);
menu=create_menu(menu_bar,_("_Edit"));
create_menu_with_image(menu,GTK_STOCK_PREFERENCES,accel_group,preferences,NULL);
create_menu_with_image(menu,_("Up_load"),accel_group,upload,&conf);
menu=create_menu(menu_bar,_("_Help"));
create_menu_with_image(menu,GTK_STOCK_HELP,accel_group,help,NULL);
create_menu_with_image(menu,GTK_STOCK_ABOUT,accel_group,about,&about_data);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),gtk_separator_menu_item_new());
create_menu_with_image(menu,_("Upgrade GoAg_ent"),accel_group,upgrade_goagent,conf.proxy_py_path);
//create_menu_with_image(menu,_("Upgrade _Gtk GoAGent"),accel_group,upgrade_gtk_goagent,NULL);
gtk_widget_set_size_request(text,0x300,0x180);
/*设置显示构件不可编辑和自动换行*/
gtk_text_view_set_editable(GTK_TEXT_VIEW(text),FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text),GTK_WRAP_CHAR);
/*创建滚动条并设置自动更新*/
scrolled=gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(scrolled),text);
gtk_box_pack_start(GTK_BOX(vbox),scrolled,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(vbox),gtk_separator_menu_item_new(),FALSE,FALSE,5);
show_time(vbox);
gtk_box_pack_start(GTK_BOX(vbox),gtk_separator_menu_item_new(),FALSE,FALSE,5);
hbox=gtk_hbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,5);
open=gtk_button_new_with_label(_("Connect"));
gtk_box_pack_start(GTK_BOX(hbox),open,FALSE,FALSE,30);
g_signal_connect(G_OBJECT(open),"clicked",G_CALLBACK(connect_goagent),&data);
clean=gtk_button_new_with_label(_("Clean"));
gtk_box_pack_start(GTK_BOX(hbox),clean,TRUE,TRUE,100);
g_signal_connect(G_OBJECT(clean),"clicked",G_CALLBACK(clean_buffer),&data);
close=gtk_button_new_with_label(_("Disconnect"));
gtk_box_pack_end(GTK_BOX(hbox),close,FALSE,FALSE,30);
g_signal_connect(G_OBJECT(close),"clicked",G_CALLBACK(disconnect_goagent),&data);
g_signal_connect(G_OBJECT(win),"delete_event",G_CALLBACK(really_quit),NULL);
gtk_widget_show_all(win);
gtk_main();
//setpgrp();
g_idle_remove_by_data(&data);
g_string_free(data.buf,TRUE);
kill(0,SIGKILL);
//killpg(getpgrp(),SIGKILL);
while(waitpid(-1,NULL,WNOHANG)!=-1);
//g_idle_remove_by_data(&data);
return 0;
}
GtkWidget *
create_disk_view(ProcData *procdata)
{
GtkWidget *disk_box;
GtkWidget *scrolled;
GtkWidget *disk_tree;
GtkListStore *model;
GtkTreeViewColumn *col;
GtkCellRenderer *cell;
guint i;
const gchar * const titles[] = {
N_("Device"),
N_("Directory"),
N_("Type"),
N_("Total"),
N_("Free"),
N_("Available"),
N_("Used")
};
disk_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6);
gtk_container_set_border_width(GTK_CONTAINER(disk_box), 12);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled),
GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(disk_box), scrolled, TRUE, TRUE, 0);
model = gtk_list_store_new(DISK_N_COLUMNS, /* n columns */
G_TYPE_STRING, /* DISK_DEVICE */
G_TYPE_STRING, /* DISK_DIR */
G_TYPE_STRING, /* DISK_TYPE */
G_TYPE_UINT64, /* DISK_TOTAL */
G_TYPE_UINT64, /* DISK_FREE */
G_TYPE_UINT64, /* DISK_AVAIL */
G_TYPE_UINT64, /* DISK_USED */
GDK_TYPE_PIXBUF, /* DISK_ICON */
G_TYPE_INT /* DISK_USED_PERCENTAGE */
);
disk_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
g_signal_connect(G_OBJECT(disk_tree), "row-activated", G_CALLBACK(open_dir), NULL);
procdata->disk_list = disk_tree;
gtk_container_add(GTK_CONTAINER(scrolled), disk_tree);
g_object_unref(G_OBJECT(model));
/* icon + device */
col = gtk_tree_view_column_new();
cell = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(col, cell, FALSE);
gtk_tree_view_column_set_attributes(col, cell, "pixbuf", DISK_ICON,
NULL);
cell = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, cell, FALSE);
gtk_tree_view_column_set_attributes(col, cell, "text", DISK_DEVICE,
NULL);
gtk_tree_view_column_set_title(col, _(titles[DISK_DEVICE]));
gtk_tree_view_column_set_sort_column_id(col, DISK_DEVICE);
gtk_tree_view_column_set_reorderable(col, TRUE);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_min_width (col, 30);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
g_signal_connect(G_OBJECT(col), "notify::fixed-width", G_CALLBACK(cb_disks_column_resized), procdata->settings);
gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col);
/* sizes - used */
for (i = DISK_DIR; i <= DISK_AVAIL; i++) {
cell = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(col, cell, TRUE);
gtk_tree_view_column_set_title(col, _(titles[i]));
gtk_tree_view_column_set_sort_column_id(col, i);
gtk_tree_view_column_set_reorderable(col, TRUE);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_min_width (col, 30);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
g_signal_connect(G_OBJECT(col), "notify::fixed-width", G_CALLBACK(cb_disks_column_resized), procdata->settings);
gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col);
switch (i) {
case DISK_TOTAL:
case DISK_FREE:
case DISK_AVAIL:
g_object_set(cell, "xalign", 1.0f, NULL);
gtk_tree_view_column_set_cell_data_func(col, cell,
&procman::size_cell_data_func,
GUINT_TO_POINTER(i),
NULL);
break;
default:
gtk_tree_view_column_set_attributes(col, cell,
"text", i,
NULL);
break;
}
}
/* used + percentage */
col = gtk_tree_view_column_new();
cell = gtk_cell_renderer_text_new();
g_object_set(cell, "xalign", 1.0f, NULL);
gtk_tree_view_column_pack_start(col, cell, FALSE);
gtk_tree_view_column_set_cell_data_func(col, cell,
&procman::size_cell_data_func,
GUINT_TO_POINTER(DISK_USED),
NULL);
cell = gtk_cell_renderer_progress_new();
gtk_tree_view_column_pack_start(col, cell, TRUE);
gtk_tree_view_column_set_attributes(col, cell, "value",
DISK_USED_PERCENTAGE, NULL);
gtk_tree_view_column_set_title(col, _(titles[DISK_USED]));
gtk_tree_view_column_set_sort_column_id(col, DISK_USED);
gtk_tree_view_column_set_reorderable(col, TRUE);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_min_width (col, 150);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
g_signal_connect(G_OBJECT(col), "notify::fixed-width", G_CALLBACK(cb_disks_column_resized), procdata->settings);
gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col);
/* numeric sort */
gtk_widget_show_all(disk_box);
procman_get_tree_state(procdata->settings, disk_tree,
"disktreenew");
g_signal_connect (G_OBJECT(disk_tree), "columns-changed",
G_CALLBACK(cb_disk_columns_changed), procdata);
return disk_box;
}
static void
gimp_palette_editor_init (GimpPaletteEditor *editor)
{
GimpDataEditor *data_editor = GIMP_DATA_EDITOR (editor);
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *spinbutton;
editor->zoom_factor = 1.0;
editor->col_width = 0;
editor->last_width = 0;
editor->columns = COLUMNS;
data_editor->view = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_size_request (data_editor->view, -1, PREVIEW_HEIGHT);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (data_editor->view),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (editor), data_editor->view, TRUE, TRUE, 0);
gtk_widget_show (data_editor->view);
editor->view = gimp_view_new_full_by_types (NULL,
GIMP_TYPE_PALETTE_VIEW,
GIMP_TYPE_PALETTE,
PREVIEW_WIDTH, PREVIEW_HEIGHT, 0,
FALSE, TRUE, FALSE);
gimp_view_renderer_palette_set_cell_size
(GIMP_VIEW_RENDERER_PALETTE (GIMP_VIEW (editor->view)->renderer), -1);
gimp_view_renderer_palette_set_draw_grid
(GIMP_VIEW_RENDERER_PALETTE (GIMP_VIEW (editor->view)->renderer), TRUE);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (data_editor->view),
editor->view);
gtk_widget_show (editor->view);
g_signal_connect (gtk_widget_get_parent (editor->view), "size-allocate",
G_CALLBACK (palette_editor_viewport_size_allocate),
editor);
g_signal_connect (editor->view, "entry-clicked",
G_CALLBACK (palette_editor_entry_clicked),
editor);
g_signal_connect (editor->view, "entry-selected",
G_CALLBACK (palette_editor_entry_selected),
editor);
g_signal_connect (editor->view, "entry-activated",
G_CALLBACK (palette_editor_entry_activated),
editor);
g_signal_connect (editor->view, "entry-context",
G_CALLBACK (palette_editor_entry_context),
editor);
g_signal_connect (editor->view, "color-dropped",
G_CALLBACK (palette_editor_color_dropped),
editor);
gimp_dnd_viewable_dest_add (editor->view,
GIMP_TYPE_PALETTE,
palette_editor_drop_palette,
editor);
gimp_dnd_viewable_dest_add (gtk_widget_get_parent (editor->view),
GIMP_TYPE_PALETTE,
palette_editor_drop_palette,
editor);
gimp_dnd_color_dest_add (gtk_widget_get_parent (editor->view),
palette_editor_drop_color,
editor);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_pack_start (GTK_BOX (editor), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
/* The color name entry */
editor->color_name = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (hbox), editor->color_name, TRUE, TRUE, 0);
gtk_entry_set_text (GTK_ENTRY (editor->color_name), _("Undefined"));
gtk_editable_set_editable (GTK_EDITABLE (editor->color_name), FALSE);
gtk_widget_show (editor->color_name);
g_signal_connect (editor->color_name, "changed",
G_CALLBACK (palette_editor_color_name_changed),
editor);
label = gtk_label_new (_("Columns:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
editor->columns_adj = (GtkAdjustment *)
gtk_adjustment_new (0, 0, 64, 1, 4, 0);
spinbutton = gtk_spin_button_new (editor->columns_adj, 1.0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0);
gtk_widget_show (spinbutton);
g_signal_connect (editor->columns_adj, "value-changed",
G_CALLBACK (palette_editor_columns_changed),
editor);
}
static GdkWindow *
draw_popup_image (GtkWidget *widget, GtkTreePath *path,
GtkTreeViewColumn *column, GdkRegion *tr)
{
g_assert (GTK_IS_TREE_VIEW (widget));
g_assert (!GTK_WIDGET_NO_WINDOW (widget));
/* Iterator for the data in the current row of the list. */
GtkTreeIter iter;
gtk_tree_model_get_iter (GTK_TREE_MODEL (list_store), &iter, path);
char *file, *ancillary_file, *polsarpro_aux_info, *uavsar_type;
gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
COL_INPUT_FILE, &file,
COL_ANCILLARY_FILE, &ancillary_file,
COL_UAVSAR_TYPE, &uavsar_type,
COL_POLSARPRO_INFO, &polsarpro_aux_info,
-1);
char *metadata_file = meta_file_name (file);
char *data_file = data_file_name (file, uavsar_type);
char *lut_basename = extract_lut_name(polsarpro_aux_info);
if (is_polsarpro(file)) {
if(strlen(metadata_file) > 0) {
g_free(data_file);
data_file = (gchar*)g_malloc(sizeof(gchar)*(strlen(metadata_file) + 1));
sprintf(data_file, "%s", metadata_file);
}
else {
g_free(metadata_file);
metadata_file = (gchar*)g_malloc(sizeof(gchar)*(strlen(data_file) + 5));
sprintf(metadata_file, "%s%s", data_file, ".hdr");
}
if (!fileExists(metadata_file)) strcpy(metadata_file, "");
}
GdkPixbuf *popup_image_pixbuf
= make_input_image_thumbnail_pixbuf (metadata_file, data_file, lut_basename,
uavsar_type, THUMB_SIZE_BIG);
if (!popup_image_pixbuf && strlen(ancillary_file) > 0)
{
popup_image_pixbuf = make_input_image_thumbnail_pixbuf (
ancillary_file, ancillary_file, lut_basename, uavsar_type, THUMB_SIZE_BIG);
}
g_free(file);
g_free(ancillary_file);
g_free(metadata_file);
g_free(data_file);
g_free(polsarpro_aux_info);
free(lut_basename);
if (popup_image_pixbuf)
{
/* We want to center the popup over the original thumbnail. Since
we know the original thumbnail is square, the clipbox corresponds
to the region, so we can just get the clipbox of the thumbnail
and take the center of that as the center of our popum image. */
GdkRectangle tn_rec;
gdk_region_get_clipbox (tr, &tn_rec);
gint tree_view_x, tree_view_y;
gdk_window_get_origin (widget->window, &tree_view_x, &tree_view_y);
GdkWindowAttr nwa;
nwa.event_mask = GDK_ALL_EVENTS_MASK;
// popup must take into account any horizontal scrolling
// that has taken place in the tree view
GtkScrolledWindow *s =
GTK_SCROLLED_WINDOW(get_widget_checked("scrolledwindow_in"));
GtkAdjustment *adj = gtk_scrolled_window_get_hadjustment(s);
gint h_adj = (gint)(.5 + gtk_adjustment_get_value(adj));
// FIXME: when the pointer is over the popup itself,
// maybe_clear_popup_image doesn't notice that we are still over the
// thumbnail below and so clears things! FIXME: I don't understand
// why this code puts the popup image top left corner only halfway
// down the thumbnail edge. It looks fine this way actually, but as
// I understand this code it should put popup top left at thumbnail
// bottom right.
nwa.x = tree_view_x + tn_rec.x + tn_rec.width - h_adj;
nwa.y = tree_view_y + tn_rec.y + tn_rec.height;
nwa.width = gdk_pixbuf_get_width(popup_image_pixbuf);
nwa.height = gdk_pixbuf_get_height(popup_image_pixbuf);
nwa.wclass = GDK_INPUT_OUTPUT;
nwa.window_type = GDK_WINDOW_CHILD;
nwa.override_redirect = TRUE;
GdkWindow *root_window
= gdk_screen_get_root_window (gdk_screen_get_default ());
GdkWindow *popup_image_window
= gdk_window_new (root_window, &nwa,
GDK_WA_X | GDK_WA_Y | GDK_WA_NOREDIR);
gdk_window_show (popup_image_window);
/* Magic number understood by gdk_draw_pixbuf to mean "use pixbuf
width". */
const gint use_pixbuf_width = -1;
gdk_draw_pixbuf (GDK_DRAWABLE (popup_image_window),
NULL,
popup_image_pixbuf,
0, 0, 0, 0,
use_pixbuf_width, use_pixbuf_width,
GDK_RGB_DITHER_NONE,
0, 0);
g_object_unref (popup_image_pixbuf);
return popup_image_window;
}
else
{
return NULL;
}
}
GtkWidget *Create_Log_Area (void)
{
GtkWidget *Frame;
GtkWidget *ScrollWindowLogList;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkWidget *PopupMenu;
Frame = gtk_frame_new(_("Log"));
gtk_container_set_border_width(GTK_CONTAINER(Frame), 2);
/*
* The ScrollWindow and the List
*/
ScrollWindowLogList = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ScrollWindowLogList),
GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(Frame),ScrollWindowLogList);
/* The file list */
logListModel = gtk_list_store_new(LOG_COLUMN_COUNT,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
GDK_TYPE_COLOR,
GDK_TYPE_COLOR);
LogList = gtk_tree_view_new_with_model(GTK_TREE_MODEL(logListModel));
g_object_unref (logListModel);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(LogList), FALSE);
gtk_container_add(GTK_CONTAINER(ScrollWindowLogList), LogList);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(LogList), FALSE);
gtk_widget_set_size_request(LogList, 0, 0);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(LogList), FALSE);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(LogList)),GTK_SELECTION_MULTIPLE);
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(GTK_TREE_VIEW(LogList), column);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"stock-id", LOG_PIXBUF,
NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"text", LOG_TIME_TEXT,
"background-gdk", LOG_ROW_BACKGROUND,
"foreground-gdk", LOG_ROW_FOREGROUND,
NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"text", LOG_TEXT,
"background-gdk", LOG_ROW_BACKGROUND,
"foreground-gdk", LOG_ROW_FOREGROUND,
NULL);
// Create Popup Menu on browser album list
PopupMenu = gtk_ui_manager_get_widget(UIManager, "/LogPopup");
gtk_menu_attach_to_widget (GTK_MENU (PopupMenu), LogList, NULL);
g_signal_connect (G_OBJECT (LogList), "button-press-event",
G_CALLBACK (Log_Popup_Menu_Handler), PopupMenu);
// Load pending messages in the Log list
Log_Print_Tmp_List();
if (SHOW_LOG_VIEW)
//gtk_widget_show_all(ScrollWindowLogList);
gtk_widget_show_all(Frame);
//return ScrollWindowLogList;
return Frame;
}
/*
Create a minimal web browser that has Emacsy integrated into it.
*/
int main(int argc, char* argv[])
{
int err;
// Initialize GNU Guile.
scm_init_guile();
// Initialize Emacsy.
err = emacsy_initialize();
if (err)
return err;
// Register the primitive procedures that control the browser.
init_primitives();
// You can evaluate S-expressions here.
scm_c_eval_string("(use-modules (system repl error-handling))"
"(define (safe-load filename) "
" (call-with-error-handling "
" (lambda () (load filename)))) ");
// But to make the application easy to mold, it's best to load the
// Scheme code from a file.
const char *startup_script = "emacsy-webkit-gtk-w-buffers.scm";
if (access(startup_script, R_OK) != -1) {
printf("Loading '%s'.\n", startup_script);
// We could load the file like this:
//scm_c_primitive_load(".emacy-webkit-gtk.scm");
// But this will drop us into a REPL if anything goes wrong.
scm_call_1(scm_c_private_ref("guile-user", "safe-load"),
scm_from_locale_string(startup_script));
} else {
printf("Did not find '%s'.\n", startup_script);
}
// Initialize GTK+.
gtk_init(&argc, &argv);
// Create an 800x600 window that will contain the browser instance.
GtkWidget *main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(main_window), 800, 600);
//gtk_window_set_size(GTK_WINDOW(main_window), 800, 600);
GdkGeometry geom_struct;
geom_struct.max_width = 800;
geom_struct.max_height = 600;
gtk_window_set_geometry_hints(GTK_WINDOW(main_window),
NULL,
&geom_struct,
GDK_HINT_MAX_SIZE);
/* you might need to use GTK_STATE_ACTIVE or GTK_STATE_PRELIGHT */
GdkColor black = {0, 0x0, 0x0, 0x0};
GdkColor white = {0, 0xFFFF, 0xFFFF, 0xFFFF};
gtk_widget_modify_bg(GTK_WINDOW(main_window), GTK_STATE_NORMAL, &black);
gtk_widget_modify_fg(GTK_WINDOW(main_window), GTK_STATE_NORMAL, &white);
// Create a browser instance
/* web_view = WEBKIT_WEB_VIEW(webkit_web_view_new()); */
/* webkit_web_view_set_highlight_text_matches(web_view, TRUE); */
web_view = NULL;
// Create a scrollable area, and put the browser instance into it
scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
scm_c_eval_string("(new-tab)");
//gtk_container_add(GTK_CONTAINER(scrolled_window), GTK_WIDGET(web_view));
// Set up callbacks so that if either the main window or the browser
// instance is closed, the program will exit.
g_signal_connect(main_window, "destroy", G_CALLBACK(destroy_window), NULL);
//g_signal_connect(web_view, "close-web-view", G_CALLBACK(close_window), main_window);
// This label will be where we display Emacsy's echo-area.
label = gtk_label_new("label");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.0f);
gtk_label_set_use_underline(GTK_LABEL(label), FALSE);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_label_set_single_line_mode(GTK_LABEL(label), TRUE);
gtk_label_set_max_width_chars(GTK_LABEL(label), 160);
modeline = gtk_label_new("modeline");
gtk_misc_set_alignment(GTK_MISC(modeline), 0.0f, 0.0f);
gtk_label_set_use_underline(GTK_LABEL(modeline), FALSE);
gtk_label_set_line_wrap(GTK_LABEL(modeline), TRUE);
gtk_label_set_single_line_mode(GTK_LABEL(modeline), TRUE);
gtk_label_set_max_width_chars(GTK_LABEL(modeline), 160);
// While idle, process events in Emacsy and upate the echo-area.
g_idle_add((GSourceFunc) process_and_update_emacsy, NULL);
// Handle key press and release events.
g_signal_connect(main_window, "key_press_event", G_CALLBACK(key_press), NULL);
g_signal_connect(main_window, "key_release_event", G_CALLBACK(key_press), NULL);
GtkWidget *vbox;
vbox = gtk_vbox_new(FALSE, 1);
gtk_container_add(GTK_CONTAINER(vbox), scrolled_window);
gtk_box_pack_start(GTK_BOX(vbox), modeline, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
// Put the scrollable area into the main window.
gtk_container_add(GTK_CONTAINER(main_window), vbox);
// Load a web page into the browser instance.
webkit_web_view_load_uri(web_view,
"http://shanecelis.github.io/2013/06/15/the-garden/");
// Make sure that when the browser area becomes visible, it will get mouse
// and keyboard events.
gtk_widget_grab_focus(GTK_WIDGET(web_view));
// Make sure the main window and all its contents are visible.
gtk_widget_show_all(main_window);
gtk_window_set_resizable(GTK_WINDOW(main_window), FALSE);
// Run the main GTK+ event loop.
gtk_main();
return 0;
}
static int show_console(void)
{
GtkWidget *hbox;
GtkWidget *wbox;
GtkWidget *notebook;
GtkWidget *sw;
GtkWidget *bbox, *hbbox, *add, *removew, *reloadw;
char *modtitles[3] = { "Module", "Description", "Use Count" };
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
statusbar = gtk_statusbar_new();
gtk_widget_show(statusbar);
gtk_signal_connect(GTK_OBJECT(window), "delete_event",
GTK_SIGNAL_FUNC (exit_nicely), window);
gtk_signal_connect(GTK_OBJECT(window), "destroy",
GTK_SIGNAL_FUNC (exit_now), window);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
quit = gtk_button_new_with_label("Quit Asterisk");
gtk_signal_connect(GTK_OBJECT(quit), "clicked",
GTK_SIGNAL_FUNC (exit_completely), window);
gtk_widget_show(quit);
closew = gtk_button_new_with_label("Close Window");
gtk_signal_connect(GTK_OBJECT(closew), "clicked",
GTK_SIGNAL_FUNC (exit_nicely), window);
gtk_widget_show(closew);
notebook = gtk_notebook_new();
verb = gtk_clist_new(1);
gtk_clist_columns_autosize(GTK_CLIST(verb));
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_container_add(GTK_CONTAINER(sw), verb);
gtk_widget_show(verb);
gtk_widget_show(sw);
gtk_widget_set_usize(verb, 640, 400);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), sw, gtk_label_new("Verbose Status"));
modules = gtk_clist_new_with_titles(3, modtitles);
gtk_clist_columns_autosize(GTK_CLIST(modules));
gtk_clist_set_column_auto_resize(GTK_CLIST(modules), 0, TRUE);
gtk_clist_set_column_auto_resize(GTK_CLIST(modules), 1, TRUE);
gtk_clist_set_column_auto_resize(GTK_CLIST(modules), 2, TRUE);
gtk_clist_set_sort_column(GTK_CLIST(modules), 0);
gtk_clist_set_auto_sort(GTK_CLIST(modules), TRUE);
gtk_clist_column_titles_passive(GTK_CLIST(modules));
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_container_add(GTK_CONTAINER(sw), modules);
gtk_clist_set_selection_mode(GTK_CLIST(modules), GTK_SELECTION_BROWSE);
gtk_widget_show(modules);
gtk_widget_show(sw);
add = gtk_button_new_with_label("Load...");
gtk_widget_show(add);
removew = gtk_button_new_with_label("Unload");
gtk_widget_show(removew);
reloadw = gtk_button_new_with_label("Reload");
gtk_widget_show(reloadw);
gtk_signal_connect(GTK_OBJECT(removew), "clicked",
GTK_SIGNAL_FUNC (remove_module), window);
gtk_signal_connect(GTK_OBJECT(add), "clicked",
GTK_SIGNAL_FUNC (add_module), window);
gtk_signal_connect(GTK_OBJECT(reloadw), "clicked",
GTK_SIGNAL_FUNC (reload_module), window);
bbox = gtk_vbox_new(FALSE, 5);
gtk_widget_show(bbox);
gtk_widget_set_usize(bbox, 100, -1);
gtk_box_pack_start(GTK_BOX(bbox), add, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(bbox), removew, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(bbox), reloadw, FALSE, FALSE, 5);
hbbox = gtk_hbox_new(FALSE, 5);
gtk_widget_show(hbbox);
gtk_box_pack_start(GTK_BOX(hbbox), sw, TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(hbbox), bbox, FALSE, FALSE, 5);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), hbbox, gtk_label_new("Module Information"));
gtk_widget_show(notebook);
wbox = gtk_hbox_new(FALSE, 5);
gtk_widget_show(wbox);
gtk_box_pack_end(GTK_BOX(wbox), quit, FALSE, FALSE, 5);
gtk_box_pack_end(GTK_BOX(wbox), closew, FALSE, FALSE, 5);
hbox = gtk_vbox_new(FALSE, 0);
gtk_widget_show(hbox);
/* Command line */
cli = gtk_entry_new();
gtk_widget_show(cli);
gtk_signal_connect(GTK_OBJECT(cli), "activate",
GTK_SIGNAL_FUNC (cli_activate), NULL);
gtk_box_pack_start(GTK_BOX(hbox), notebook, TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(hbox), wbox, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), cli, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), statusbar, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), hbox);
gtk_window_set_title(GTK_WINDOW(window), "Asterisk Console");
gtk_widget_grab_focus(cli);
ast_pthread_create(&console_thread, NULL, consolethread, NULL);
/* XXX Okay, seriously fix me! XXX */
usleep(100000);
ast_register_verbose(verboser);
gtk_clist_freeze(GTK_CLIST(verb));
ast_loader_register(mod_update);
gtk_clist_thaw(GTK_CLIST(verb));
gdk_input_add(clipipe[0], GDK_INPUT_READ, cliinput, NULL);
mod_update();
update_statusbar("Asterisk Console Ready");
return 0;
}
GtkWidget *
itip_formatter_page_factory (EPlugin *ep,
EConfigHookItemFactoryData *hook_data)
{
EShell *shell;
ESourceRegistry *registry;
GtkWidget *page;
GtkWidget *tab_label;
GtkWidget *frame;
GtkWidget *frame_label;
GtkWidget *padding_label;
GtkWidget *hbox;
GtkWidget *inner_vbox;
GtkWidget *check;
GtkWidget *label;
GtkWidget *ess;
GtkWidget *scrolledwin;
gchar *str;
GSettings *settings;
shell = e_shell_get_default ();
registry = e_shell_get_registry (shell);
/* Create a new notebook page */
page = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (page), 12);
tab_label = gtk_label_new (_("Meeting Invitations"));
gtk_notebook_append_page (GTK_NOTEBOOK (hook_data->parent), page, tab_label);
/* Frame */
frame = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0);
/* "General" */
frame_label = gtk_label_new ("");
str = g_strdup_printf ("<span weight=\"bold\">%s</span>", _("General"));
gtk_label_set_markup (GTK_LABEL (frame_label), str);
g_free (str);
gtk_misc_set_alignment (GTK_MISC (frame_label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (frame), frame_label, FALSE, FALSE, 0);
/* Indent/padding */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (frame), hbox, FALSE, TRUE, 0);
padding_label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), padding_label, FALSE, FALSE, 0);
inner_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (hbox), inner_vbox, FALSE, FALSE, 0);
/* Delete message after acting */
settings = e_util_ref_settings ("org.gnome.evolution.plugin.itip");
check = gtk_check_button_new_with_mnemonic (_("_Delete message after acting"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), g_settings_get_boolean (settings, CONF_KEY_DELETE));
g_signal_connect (
check, "toggled",
G_CALLBACK (delete_toggled_cb), NULL);
gtk_box_pack_start (GTK_BOX (inner_vbox), check, FALSE, FALSE, 0);
g_object_unref (settings);
/* "Conflict searching" */
frame = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (page), frame, TRUE, TRUE, 24);
frame_label = gtk_label_new ("");
str = g_strdup_printf ("<span weight=\"bold\">%s</span>", _("Conflict Search"));
gtk_label_set_markup (GTK_LABEL (frame_label), str);
g_free (str);
gtk_misc_set_alignment (GTK_MISC (frame_label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (frame), frame_label, FALSE, FALSE, 0);
/* Indent/padding */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (frame), hbox, TRUE, TRUE, 0);
padding_label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), padding_label, FALSE, FALSE, 0);
inner_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (hbox), inner_vbox, TRUE, TRUE, 0);
/* Source selector */
label = gtk_label_new (_("Select the calendars to search for meeting conflicts"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (inner_vbox), label, FALSE, FALSE, 0);
scrolledwin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (
GTK_SCROLLED_WINDOW (scrolledwin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (
GTK_SCROLLED_WINDOW (scrolledwin),
GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (inner_vbox), scrolledwin, TRUE, TRUE, 0);
ess = e_conflict_search_selector_new (registry);
atk_object_set_name (gtk_widget_get_accessible (ess), _("Conflict Search"));
gtk_container_add (GTK_CONTAINER (scrolledwin), ess);
gtk_widget_show_all (page);
return page;
}
static GtkWidget *
servlist_open_networks (void)
{
GtkWidget *servlist;
GtkWidget *vbox1;
GtkWidget *label2;
GtkWidget *table1;
GtkWidget *label3;
GtkWidget *label4;
GtkWidget *label5;
GtkWidget *label6;
GtkWidget *label7;
GtkWidget *entry1;
GtkWidget *entry2;
GtkWidget *entry3;
GtkWidget *entry4;
GtkWidget *entry5;
GtkWidget *vbox2;
GtkWidget *label1;
GtkWidget *table4;
GtkWidget *scrolledwindow3;
GtkWidget *treeview_networks;
GtkWidget *checkbutton_skip;
GtkWidget *vbuttonbox2;
GtkWidget *button_add;
GtkWidget *button_remove;
GtkWidget *button_edit;
GtkWidget *button_sort;
GtkWidget *button_connect;
GtkTreeModel *model;
GtkListStore *store;
GtkCellRenderer *renderer;
servlist =
mg_create_generic_tab(_("Network List"), _("conspire: Networks"),
FALSE, TRUE, servlist_close_cb, NULL, 640, 480, &vbox1, NULL);
label2 = bold_label (_("User Information"));
gtk_box_pack_start (GTK_BOX (vbox1), label2, FALSE, FALSE, 0);
table1 = gtk_table_new (5, 2, FALSE);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (vbox1), table1, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (table1), 8);
gtk_table_set_row_spacings (GTK_TABLE (table1), 2);
gtk_table_set_col_spacings (GTK_TABLE (table1), 4);
label3 = gtk_label_new_with_mnemonic (_("_Nick name:"));
gtk_widget_show (label3);
gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5);
label4 = gtk_label_new (_("Second choice:"));
gtk_widget_show (label4);
gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5);
label5 = gtk_label_new (_("Third choice:"));
gtk_widget_show (label5);
gtk_table_attach (GTK_TABLE (table1), label5, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5);
label6 = gtk_label_new_with_mnemonic (_("_User name:"));
gtk_widget_show (label6);
gtk_table_attach (GTK_TABLE (table1), label6, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5);
label7 = gtk_label_new_with_mnemonic (_("Rea_l name:"));
gtk_widget_show (label7);
gtk_table_attach (GTK_TABLE (table1), label7, 0, 1, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5);
entry_nick1 = entry1 = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry1), prefs.nick1);
gtk_widget_show (entry1);
gtk_table_attach (GTK_TABLE (table1), entry1, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
entry_nick2 = entry2 = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry2), prefs.nick2);
gtk_widget_show (entry2);
gtk_table_attach (GTK_TABLE (table1), entry2, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
entry_nick3 = entry3 = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry3), prefs.nick3);
gtk_widget_show (entry3);
gtk_table_attach (GTK_TABLE (table1), entry3, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
entry_guser = entry4 = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry4), prefs.username);
gtk_widget_show (entry4);
gtk_table_attach (GTK_TABLE (table1), entry4, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
entry_greal = entry5 = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry5), prefs.realname);
gtk_widget_show (entry5);
gtk_table_attach (GTK_TABLE (table1), entry5, 1, 2, 4, 5,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_box_pack_start (GTK_BOX (vbox1), vbox2, TRUE, TRUE, 0);
label1 = bold_label (_("Networks"));
gtk_box_pack_start (GTK_BOX (vbox2), label1, FALSE, FALSE, 0);
table4 = gtk_table_new (2, 2, FALSE);
gtk_widget_show (table4);
gtk_box_pack_start (GTK_BOX (vbox2), table4, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (table4), 8);
gtk_table_set_row_spacings (GTK_TABLE (table4), 2);
gtk_table_set_col_spacings (GTK_TABLE (table4), 3);
scrolledwindow3 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow3);
gtk_table_attach (GTK_TABLE (table4), scrolledwindow3, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow3),
GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow3),
GTK_SHADOW_IN);
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
model = GTK_TREE_MODEL (store);
networks_tree = treeview_networks = gtk_tree_view_new_with_model (model);
g_object_unref (model);
gtk_widget_show (treeview_networks);
gtk_container_add (GTK_CONTAINER (scrolledwindow3), treeview_networks);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview_networks),
FALSE);
renderer = gtk_cell_renderer_text_new ();
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (servlist_celledit_cb), model);
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (treeview_networks), -1,
0, renderer,
"text", 0,
"editable", 1,
NULL);
checkbutton_skip =
gtk_check_button_new_with_mnemonic (_("Skip network list on startup"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton_skip),
prefs.skip_serverlist);
g_signal_connect (G_OBJECT (checkbutton_skip), "toggled",
G_CALLBACK (no_servlist), 0);
gtk_widget_show (checkbutton_skip);
gtk_table_attach (GTK_TABLE (table4), checkbutton_skip, 0, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
vbuttonbox2 = gtk_vbutton_box_new ();
gtk_box_set_spacing (GTK_BOX (vbuttonbox2), 3);
gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonbox2), GTK_BUTTONBOX_START);
gtk_widget_show (vbuttonbox2);
gtk_table_attach (GTK_TABLE (table4), vbuttonbox2, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
button_add = gtk_button_new_from_stock ("gtk-add");
g_signal_connect (G_OBJECT (button_add), "clicked",
G_CALLBACK (servlist_addnet_cb), networks_tree);
gtk_widget_show (button_add);
gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_add);
GTK_WIDGET_SET_FLAGS (button_add, GTK_CAN_DEFAULT);
button_remove = gtk_button_new_from_stock ("gtk-remove");
g_signal_connect (G_OBJECT (button_remove), "clicked",
G_CALLBACK (servlist_deletenet_cb), 0);
gtk_widget_show (button_remove);
gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_remove);
GTK_WIDGET_SET_FLAGS (button_remove, GTK_CAN_DEFAULT);
button_edit = gtk_button_new_with_mnemonic (_("_Edit..."));
g_signal_connect (G_OBJECT (button_edit), "clicked",
G_CALLBACK (servlist_edit_cb), 0);
gtk_widget_show (button_edit);
gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_edit);
GTK_WIDGET_SET_FLAGS (button_edit, GTK_CAN_DEFAULT);
button_sort = gtk_button_new_with_mnemonic (_("_Sort"));
add_tip (button_sort, _("Sorts the network list in alphabetical order. "
"Use SHIFT-UP and SHIFT-DOWN keys to move a row."));
g_signal_connect (G_OBJECT (button_sort), "clicked",
G_CALLBACK (servlist_sort), 0);
gtk_widget_show (button_sort);
gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_sort);
GTK_WIDGET_SET_FLAGS (button_sort, GTK_CAN_DEFAULT);
button_connect = gtkutil_button (vbuttonbox2, GTK_STOCK_CONNECT, NULL,
servlist_connect_cb, NULL, _("C_onnect"));
GTK_WIDGET_SET_FLAGS (button_connect, GTK_CAN_DEFAULT);
gtk_label_set_mnemonic_widget (GTK_LABEL (label3), entry1);
gtk_label_set_mnemonic_widget (GTK_LABEL (label6), entry4);
gtk_label_set_mnemonic_widget (GTK_LABEL (label7), entry5);
gtk_widget_grab_focus (networks_tree);
return servlist;
}
void
gftpui_ask_transfer (gftp_transfer * tdata)
{
char *dltitles[4], *add_data[4] = { NULL, NULL, NULL, NULL },
tempstr[50], temp1str[50], *pos;
GtkWidget * dialog, * tempwid, * scroll, * hbox;
gftp_file * tempfle;
GList * templist;
size_t len;
int i;
dltitles[0] = _("Filename");
dltitles[1] = tdata->fromreq->hostname;
dltitles[2] = tdata->toreq->hostname;
dltitles[3] = _("Action");
#if GTK_MAJOR_VERSION == 1
dialog = gtk_dialog_new ();
gtk_grab_add (dialog);
gtk_window_set_title (GTK_WINDOW (dialog), _("Transfer Files"));
gtk_container_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->action_area), 5);
gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->action_area), 35);
gtk_box_set_homogeneous (GTK_BOX (GTK_DIALOG (dialog)->action_area), TRUE);
gtk_signal_connect_object (GTK_OBJECT (dialog), "delete_event",
GTK_SIGNAL_FUNC (gtk_widget_destroy),
GTK_OBJECT (dialog));
#else
dialog = gtk_dialog_new_with_buttons (_("Transfer Files"), NULL, 0,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_OK,
NULL);
#endif
gtk_window_set_wmclass (GTK_WINDOW(dialog), "transfer", "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);
tempwid = gtk_label_new (_("The following file(s) exist on both the local and remote computer\nPlease select what you would like to do"));
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), tempwid, FALSE,
FALSE, 0);
gtk_widget_show (tempwid);
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_size_request (scroll, 450, 200);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
tdata->clist = gtk_clist_new_with_titles (4, dltitles);
gtk_container_add (GTK_CONTAINER (scroll), tdata->clist);
#if GTK_MAJOR_VERSION == 1
gtk_clist_set_selection_mode (GTK_CLIST (tdata->clist),
GTK_SELECTION_EXTENDED);
#else
gtk_clist_set_selection_mode (GTK_CLIST (tdata->clist),
GTK_SELECTION_MULTIPLE);
#endif
gtk_clist_set_column_width (GTK_CLIST (tdata->clist), 0, 100);
gtk_clist_set_column_justification (GTK_CLIST (tdata->clist), 1,
GTK_JUSTIFY_RIGHT);
gtk_clist_set_column_width (GTK_CLIST (tdata->clist), 1, 85);
gtk_clist_set_column_justification (GTK_CLIST (tdata->clist), 2,
GTK_JUSTIFY_RIGHT);
gtk_clist_set_column_width (GTK_CLIST (tdata->clist), 2, 85);
gtk_clist_set_column_width (GTK_CLIST (tdata->clist), 3, 85);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), scroll, TRUE, TRUE,
0);
gtk_widget_show (tdata->clist);
gtk_widget_show (scroll);
for (templist = tdata->files; templist != NULL;
templist = templist->next)
{
tempfle = templist->data;
if (tempfle->startsize == 0 || S_ISDIR (tempfle->st_mode))
{
tempfle->shown = 0;
continue;
}
tempfle->shown = 1;
len = strlen (tdata->toreq->directory);
pos = tempfle->destfile;
if (len == 1 && (*tdata->toreq->directory) == '/')
pos++;
if (strncmp (pos, tdata->toreq->directory, len) == 0)
pos += len + 1;
add_data[0] = pos;
gftp_get_transfer_action (tdata->fromreq, tempfle);
switch (tempfle->transfer_action)
{
case GFTP_TRANS_ACTION_OVERWRITE:
add_data[3] = _("Overwrite");
break;
case GFTP_TRANS_ACTION_SKIP:
add_data[3] = _("Skip");
break;
case GFTP_TRANS_ACTION_RESUME:
add_data[3] = _("Resume");
break;
default:
add_data[3] = _("Error");
break;
}
add_data[1] = insert_commas (tempfle->size, tempstr, sizeof (tempstr));
add_data[2] = insert_commas (tempfle->startsize, temp1str,
sizeof (temp1str));
i = gtk_clist_append (GTK_CLIST (tdata->clist), add_data);
gtk_clist_set_row_data (GTK_CLIST (tdata->clist), i, tempfle);
}
gtk_clist_select_all (GTK_CLIST (tdata->clist));
hbox = gtk_hbox_new (TRUE, 20);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
tempwid = gtk_button_new_with_label (_("Overwrite"));
gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (tempwid), "clicked",
GTK_SIGNAL_FUNC (gftpui_gtk_overwrite), (gpointer) tdata);
gtk_widget_show (tempwid);
tempwid = gtk_button_new_with_label (_("Resume"));
gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (tempwid), "clicked",
GTK_SIGNAL_FUNC (gftpui_gtk_resume), (gpointer) tdata);
gtk_widget_show (tempwid);
tempwid = gtk_button_new_with_label (_("Skip File"));
gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (tempwid), "clicked",
GTK_SIGNAL_FUNC (gftpui_gtk_skip), (gpointer) tdata);
gtk_widget_show (tempwid);
hbox = gtk_hbox_new (TRUE, 20);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
tempwid = gtk_button_new_with_label (_("Select All"));
gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (tempwid), "clicked",
GTK_SIGNAL_FUNC (gftpui_gtk_trans_selectall), (gpointer) tdata);
gtk_widget_show (tempwid);
tempwid = gtk_button_new_with_label (_("Deselect All"));
gtk_box_pack_start (GTK_BOX (hbox), tempwid, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (tempwid), "clicked",
GTK_SIGNAL_FUNC (gftpui_gtk_trans_unselectall), (gpointer) tdata);
gtk_widget_show (tempwid);
#if GTK_MAJOR_VERSION == 1
tempwid = gtk_button_new_with_label (_("OK"));
GTK_WIDGET_SET_FLAGS (tempwid, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area), tempwid,
TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (tempwid), "clicked",
GTK_SIGNAL_FUNC (gftpui_gtk_ok), (gpointer) tdata);
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);
tempwid = gtk_button_new_with_label (_(" Cancel "));
GTK_WIDGET_SET_FLAGS (tempwid, GTK_CAN_DEFAULT);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area), tempwid,
TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (tempwid), "clicked",
GTK_SIGNAL_FUNC (gftpui_gtk_cancel), (gpointer) tdata);
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 (GTK_OBJECT (dialog), "response",
G_CALLBACK (gftpui_gtk_transfer_action),(gpointer) tdata);
#endif
gtk_widget_show (dialog);
dialog = NULL;
}
static void create_bus_layout_dialog (bus_layout_D *dialog)
{
GtkWidget *tblMain = NULL, *frm = NULL, *img = NULL, *tbl = NULL, *align = NULL ;
dialog->dialog = gtk_dialog_new () ;
gtk_window_set_title (GTK_WINDOW (dialog->dialog), _("Bus Layout")) ;
gtk_window_set_resizable (GTK_WINDOW (dialog->dialog), TRUE) ;
gtk_window_set_default_size (GTK_WINDOW (dialog->dialog), 300, 200) ;
tblMain = gtk_table_new (1, 2, FALSE) ;
gtk_widget_show (tblMain) ;
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog->dialog)->vbox), tblMain, TRUE, TRUE, 0) ;
gtk_container_set_border_width (GTK_CONTAINER (tblMain), 2) ;
frm = gtk_frame_new (_("Cells And Buses")) ;
gtk_widget_show (frm) ;
gtk_table_attach (GTK_TABLE (tblMain), frm, 0, 1, 0, 1,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 2, 2) ;
gtk_container_set_border_width (GTK_CONTAINER (frm), 2) ;
dialog->sw = gtk_scrolled_window_new (NULL, NULL) ;
gtk_widget_show (dialog->sw) ;
gtk_container_add (GTK_CONTAINER (frm), dialog->sw) ;
gtk_container_set_border_width (GTK_CONTAINER (dialog->sw), 2) ;
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (dialog->sw), GTK_SHADOW_IN) ;
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (dialog->sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC) ;
dialog->tview = create_bus_layout_tree_view (FALSE, NULL, GTK_SELECTION_MULTIPLE) ;
gtk_widget_show (dialog->tview) ;
gtk_container_add (GTK_CONTAINER (dialog->sw), dialog->tview) ;
gtk_tree_selection_set_select_function (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tview)),
(GtkTreeSelectionFunc)select_cell_row_p, NULL, NULL) ;
align = gtk_alignment_new (0.0, 0.0, 1.0, 1.0) ;
gtk_widget_show (align) ;
gtk_table_attach (GTK_TABLE (tblMain), align, 1, 2, 0, 1,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(GTK_FILL), 2, 2) ;
gtk_container_set_border_width (GTK_CONTAINER (align), 2) ;
tbl = gtk_table_new (3, 1, FALSE) ;
gtk_widget_show (tbl) ;
gtk_container_add (GTK_CONTAINER (align), tbl) ;
gtk_container_set_border_width (GTK_CONTAINER (tbl), 2) ;
dialog->bbox = gtk_vbutton_box_new () ;
gtk_widget_show (dialog->bbox) ;
gtk_table_attach (GTK_TABLE (tbl), dialog->bbox, 0, 1, 0, 1,
(GtkAttachOptions)(0),
(GtkAttachOptions)(0), 2, 2) ;
gtk_container_set_border_width (GTK_CONTAINER (dialog->bbox), 2) ;
gtk_button_box_set_spacing (GTK_BUTTON_BOX (dialog->bbox), gtk_vbutton_box_get_spacing_default ()) ;
dialog->btnCreateBus = create_pixmap_button (img = gtk_image_new_from_stock (GTK_STOCK_ADD, GTK_ICON_SIZE_BUTTON), _("Create Bus"), FALSE) ;
gtk_widget_show (dialog->btnCreateBus) ;
gtk_widget_show (img) ;
gtk_box_pack_start (GTK_BOX (dialog->bbox), dialog->btnCreateBus, FALSE, TRUE, 0) ;
dialog->btnDeleteBus = create_pixmap_button (img = gtk_image_new_from_stock (GTK_STOCK_REMOVE, GTK_ICON_SIZE_BUTTON), _("Delete Bus"), FALSE) ;
gtk_widget_show (dialog->btnDeleteBus) ;
gtk_widget_show (img) ;
gtk_box_pack_start (GTK_BOX (dialog->bbox), dialog->btnDeleteBus, FALSE, TRUE, 0) ;
dialog->btnMoveBusUp = create_pixmap_button (img = gtk_image_new_from_stock (GTK_STOCK_GO_UP, GTK_ICON_SIZE_BUTTON), _("Move Bus Up"), FALSE) ;
gtk_widget_show (dialog->btnMoveBusUp) ;
gtk_widget_show (img) ;
gtk_box_pack_start (GTK_BOX (dialog->bbox), dialog->btnMoveBusUp, FALSE, TRUE, 0) ;
dialog->btnMoveBusDown = create_pixmap_button (img = gtk_image_new_from_stock (GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_BUTTON), _("Move Bus Down"), FALSE) ;
gtk_widget_show (dialog->btnMoveBusDown) ;
gtk_widget_show (img) ;
gtk_box_pack_start (GTK_BOX (dialog->bbox), dialog->btnMoveBusDown, FALSE, TRUE, 0) ;
dialog->btnMoveCellsUp = create_pixmap_button (img = gtk_image_new_from_stock (GTK_STOCK_GO_UP, GTK_ICON_SIZE_BUTTON), _("Make Cell(s) More Significant"), FALSE) ;
gtk_widget_show (dialog->btnMoveCellsUp) ;
gtk_widget_show (img) ;
gtk_box_pack_start (GTK_BOX (dialog->bbox), dialog->btnMoveCellsUp, FALSE, TRUE, 0) ;
dialog->btnMoveCellsDown = create_pixmap_button (img = gtk_image_new_from_stock (GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_BUTTON), _("Make Cell(s) Less Significant"), FALSE) ;
gtk_widget_show (dialog->btnMoveCellsDown) ;
gtk_widget_show (img) ;
gtk_box_pack_start (GTK_BOX (dialog->bbox), dialog->btnMoveCellsDown, FALSE, TRUE, 0) ;
dialog->lblBusName = gtk_label_new (_("Bus Name:")) ;
gtk_widget_show (dialog->lblBusName) ;
gtk_table_attach (GTK_TABLE (tbl), dialog->lblBusName, 0, 1, 1, 2,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 2, 2) ;
gtk_label_set_justify (GTK_LABEL (dialog->lblBusName), GTK_JUSTIFY_LEFT) ;
gtk_misc_set_alignment (GTK_MISC (dialog->lblBusName), 0.0, 1.0) ;
dialog->txtBusName = gtk_entry_new () ;
gtk_widget_show (dialog->txtBusName) ;
gtk_table_attach (GTK_TABLE (tbl), dialog->txtBusName, 0, 1, 2, 3,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 2, 2) ;
dialog->lblWarning = gtk_label_new (NULL) ;
gtk_table_attach (GTK_TABLE (tbl), dialog->lblWarning, 0, 1, 3, 4,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 2, 2) ;
gtk_label_set_markup (GTK_LABEL (dialog->lblWarning), _("<span foreground=\"red\">Warning:</span> The bus must have a name.")) ;
gtk_label_set_justify (GTK_LABEL (dialog->lblWarning), GTK_JUSTIFY_LEFT) ;
gtk_misc_set_alignment (GTK_MISC (dialog->lblWarning), 0.0, 0.0) ;
gtk_label_set_line_wrap (GTK_LABEL (dialog->lblWarning), TRUE) ;
gtk_dialog_add_button (GTK_DIALOG (dialog->dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL) ;
dialog->btnOK = gtk_dialog_add_button (GTK_DIALOG (dialog->dialog), GTK_STOCK_OK, GTK_RESPONSE_OK) ;
gtk_dialog_set_default_response (GTK_DIALOG (dialog->dialog), GTK_RESPONSE_OK) ;
g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tview))), "changed", (GCallback)tree_view_selection_changed, dialog) ;
g_signal_connect (G_OBJECT (dialog->btnCreateBus), "clicked", (GCallback)create_bus_button_clicked, dialog) ;
g_signal_connect (G_OBJECT (dialog->btnDeleteBus), "clicked", (GCallback)delete_bus_button_clicked, dialog) ;
g_signal_connect (G_OBJECT (dialog->btnMoveCellsUp), "clicked", (GCallback)raise_bus_cell_position, dialog) ;
g_signal_connect (G_OBJECT (dialog->btnMoveCellsDown), "clicked", (GCallback)lower_bus_cell_position, dialog) ;
g_signal_connect (G_OBJECT (dialog->btnMoveBusUp), "clicked", (GCallback)raise_bus_position, dialog) ;
g_signal_connect (G_OBJECT (dialog->btnMoveBusDown), "clicked", (GCallback)lower_bus_position, dialog) ;
g_signal_connect (G_OBJECT (dialog->txtBusName), "changed", (GCallback)bus_name_changed, dialog) ;
}
void SetupHashWindow()
{
/* Setup window */
gui.windows.hash = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(gui.windows.hash), "Hashes");
gtk_window_set_default_size(GTK_WINDOW(gui.windows.hash), 580, 340);
gtk_window_set_deletable(GTK_WINDOW(gui.windows.hash), false);
gui.fixed.hash = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(gui.windows.hash), gui.fixed.hash);
/* Load hashes */
gui.entries.hash = gtk_entry_new();
gtk_widget_set_size_request(gui.entries.hash, 380, 32);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.entries.hash, 8, 8);
gui.cbox.hash = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "Hashlist");
gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "Hash");
gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "pwdump");
gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "Cain");
gtk_widget_set_size_request(gui.cbox.hash, 90, 32);
gtk_combo_box_set_active(GTK_COMBO_BOX(gui.cbox.hash), 0);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.cbox.hash, 390, 8);
gui.buttons.hash_load = gtk_button_new_with_label("Load");
gtk_widget_set_size_request(gui.buttons.hash_load, 80, 32);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_load, 485, 8);
/* TreeView */
gui.hash.scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(gui.hash.scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gui.hash.tree = gtk_tree_view_new();
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(gui.hash.tree), true);
gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(gui.hash.tree), true);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(gui.hash.tree), true);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(gui.hash.tree), true);
gui.hash.store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING);
gtk_tree_view_set_model(GTK_TREE_VIEW(gui.hash.tree), GTK_TREE_MODEL(gui.hash.store));
gui.hash.render = gtk_cell_renderer_text_new();
GtkTreeViewColumn *col = gtk_tree_view_column_new_with_attributes("Algorithm", gui.hash.render, "text", 0, NULL);
gtk_tree_view_column_set_sort_column_id(col, 0);
gtk_tree_view_append_column(GTK_TREE_VIEW(gui.hash.tree), col);
col = gtk_tree_view_column_new_with_attributes("Length", gui.hash.render, "text", 1, NULL);
gtk_tree_view_column_set_sort_column_id(col, 1);
gtk_tree_view_append_column(GTK_TREE_VIEW(gui.hash.tree), col);
col = gtk_tree_view_column_new_with_attributes("Hash", gui.hash.render, "text", 2, NULL);
gtk_tree_view_column_set_sort_column_id(col, 2);
gtk_tree_view_append_column(GTK_TREE_VIEW(gui.hash.tree), col);
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(gui.hash.tree));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
gtk_container_add(GTK_CONTAINER(gui.hash.scroll), gui.hash.tree);
gtk_widget_set_size_request(gui.hash.tree, 560, 240);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.hash.scroll, 8, 48);
/* Buttons */
gui.buttons.hash_delete = gtk_button_new_with_label("Remove");
gtk_widget_set_size_request(gui.buttons.hash_delete, 80, 32);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_delete, 8, 300);
gui.buttons.hash_clear = gtk_button_new_with_label("Clear");
gtk_widget_set_size_request(gui.buttons.hash_clear, 80, 32);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_clear, 100, 300);
gui.buttons.hash_ok = gtk_button_new_with_label("OK");
gtk_widget_set_size_request(gui.buttons.hash_ok, 80, 32);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_ok, 480, 300);
g_signal_connect(gui.buttons.hash_load, "clicked", G_CALLBACK(LoadHashes), NULL);
g_signal_connect(gui.buttons.hash_ok, "clicked", G_CALLBACK(HideHashWindow), NULL);
g_signal_connect(gui.buttons.hash_delete, "clicked", G_CALLBACK(DeleteHashes), NULL);
g_signal_connect(gui.buttons.hash_clear, "clicked", G_CALLBACK(ClearHashes), NULL);
return;
}
int main(int argc, char **argv) {
printf("%d command line arguments \n", argc);
for (int i = 0; i < argc; i++)
printf("%d: %s \n", i, argv[i]);
if (argc == 1) {
printf("usage: scrscr filename.png\n");
return 0;
}
fn = argv[1];
gtk_init( &argc, &argv );
GError* error = NULL;
pixbuf = gdk_pixbuf_new_from_file(fn, &error);
if (pixbuf == NULL) {
printf("cant open file\n");
exit(1);
}
window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
//gtk_window_move(window, 10, 300);
gtk_window_set_resizable(GTK_WINDOW(window), TRUE);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(cb_save_and_quit), NULL);
g_signal_connect(window, "key-press-event", G_CALLBACK(keypress), NULL);
vbox = gtk_vbox_new( FALSE, 6 );
gtk_container_add( GTK_CONTAINER( window ), vbox );
swindow = gtk_scrolled_window_new( NULL, NULL );
gtk_box_pack_start( GTK_BOX( vbox ), swindow, TRUE, TRUE, 0 );
hbox = gtk_hbox_new( TRUE, 6 );
vbox2 = gtk_vbox_new( TRUE, 6 );
//pixbuf = gdk_pixbuf_new( GDK_COLORSPACE_RGB, FALSE, 8, 200, 200 );
//gdk_pixbuf_fill( pixbuf, 0xffff00ff );
image = gtk_image_new_from_pixbuf( pixbuf );
//g_object_unref( G_OBJECT( pixbuf ) );
prepare_blits();
gtk_window_set_default_size(GTK_WINDOW(window), width+100, height+150);
gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW( swindow ), hbox );
image_evbox = gtk_event_box_new();
gtk_container_add(image_evbox, image);
//gtk_box_pack_start( GTK_BOX( hbox ), image, FALSE, FALSE, 0 );
gtk_box_pack_start(hbox, vbox2, FALSE, FALSE, 0);
gtk_box_pack_start(vbox2, image_evbox, FALSE, FALSE, 0);
g_signal_connect(image_evbox, "button-press-event", G_CALLBACK(i_mousedown), NULL);
g_signal_connect(image_evbox, "button-release-event", G_CALLBACK(i_mouseup), NULL);
g_signal_connect(image_evbox, "motion-notify-event", G_CALLBACK(i_mousemove), NULL);
hbox = gtk_hbox_new( FALSE, 6 );
gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
GtkWidget* button = gtk_button_new_with_label( "undo" );
g_signal_connect( G_OBJECT( button ), "clicked", G_CALLBACK(cb_undo), NULL );
gtk_box_pack_start( GTK_BOX( hbox ), button, FALSE, FALSE, 0 );
GtkWidget* button_blue = gtk_button_new_with_label( "blue" );
GtkWidget* button_red = gtk_button_new_with_label( "red" );
GtkWidget* button_green = gtk_button_new_with_label( "green" );
//GtkWidget* button_fill = gtk_button_new_with_label( "fill" );
GtkWidget* button_fill = gtk_toggle_button_new_with_label( "fill" );
gtk_toggle_button_set_active(button_fill, fill);
g_signal_connect( G_OBJECT( button_blue ), "clicked", G_CALLBACK(cb_blue), NULL );
g_signal_connect( G_OBJECT( button_red ), "clicked", G_CALLBACK(cb_red), NULL );
g_signal_connect( G_OBJECT( button_green ), "clicked", G_CALLBACK(cb_green), NULL );
g_signal_connect( G_OBJECT( button_fill ), "clicked", G_CALLBACK(cb_fill_stroke), NULL );
gtk_box_pack_start( GTK_BOX( hbox ), button_blue, FALSE, FALSE, 0 );
gtk_box_pack_start( GTK_BOX( hbox ), button_red, FALSE, FALSE, 0 );
gtk_box_pack_start( GTK_BOX( hbox ), button_green, FALSE, FALSE, 0 );
gtk_box_pack_start( GTK_BOX( hbox ), button_fill, FALSE, FALSE, 0 );
button = gtk_button_new_with_label( "done" );
g_signal_connect( G_OBJECT( button ), "clicked", G_CALLBACK(cb_save_and_quit), NULL );
gtk_box_pack_end( GTK_BOX( hbox ), button, FALSE, FALSE, 0 );
gtk_widget_show_all( window );
gtk_main();
return 0;
}
int main(int argc, char ** argv)
{
GtkWidget * vbox;
GtkWidget * hpaned;
GtkWidget * sc_win, * sc_buffer;
GtkWidget * menu_bar;
GtkWidget * file_menu, * file_item;
GtkWidget * generate_menu, * generate_item;
GtkWidget * settings_menu, * settings_item;
GtkWidget * zoom_box, * zoom_button;
int i;
//init general
colors = (color_t *)malloc(NUM_COLORS * sizeof(color_t));
oldcolors = (color_t *)malloc(OLD_NUM_COLORS * sizeof(color_t));
memset(mdata, 0, BUFFER_COUNT * sizeof(unsigned char *));
memset(icons, 0, BUFFER_COUNT * sizeof(GtkWidget *));
memset(icon_event_boxes, 0, BUFFER_COUNT * sizeof(GtkWidget *));
mdata[current_buffer] = (unsigned char *)malloc(128 * 128);
load_colors_plain(colors, "colors");
load_colors_plain(oldcolors, "oldcolors");
newcolors = colors;
//save_colors(colors, "colors.bin");
//load_colors(colors, "colors.bin");
srand(time(NULL));
config = config_new();
//init gtk
gtk_init(&argc, &argv);
//window
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "ImageToMap X v" VERSION_NUMBER);
g_signal_connect(window, "delete_event", G_CALLBACK(kill_window), NULL);
//vbox
#ifdef GTK2
vbox = gtk_vbox_new(FALSE, 0);
#else
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#endif
gtk_frame_set_shadow_type(GTK_FRAME(vbox), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER (window), vbox);
gtk_widget_show(vbox);
//////menu_bar
menu_bar = gtk_menu_bar_new();
gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, TRUE, 0);
gtk_widget_show(menu_bar);
////////file_menu
file_menu = gtk_menu_new();
//////////file_menu items
construct_tool_bar_add(file_menu, "Open", ITEM_SIGNAL_OPEN);
construct_tool_bar_add(file_menu, "Open Grid Image", ITEM_SIGNAL_OPEN_GRID_IMAGE);
construct_tool_bar_add(file_menu, "Save", ITEM_SIGNAL_SAVE);
construct_tool_bar_add(file_menu, "Save Increment", ITEM_SIGNAL_SAVE_INCREMENT);
construct_tool_bar_add(file_menu, "Save All", ITEM_SIGNAL_SAVE_ALL);
construct_tool_bar_add(file_menu, "Save Raw Map", ITEM_SIGNAL_SAVE_RM);
construct_tool_bar_add(file_menu, "Export Image", ITEM_SIGNAL_EXPORT_IMAGE);
/* construct_tool_bar_add_deactivate(file_menu, "Render World", ITEM_SIGNAL_WORLD_RENDER_ITEM); */
construct_tool_bar_add(file_menu, "Render World", ITEM_SIGNAL_WORLD_RENDER_ITEM);
construct_tool_bar_add(file_menu, "Clean Buffer List", ITEM_SIGNAL_CLEAN);
construct_tool_bar_add(file_menu, "Quit", ITEM_SIGNAL_QUIT);
/////////file_item
file_item = gtk_menu_item_new_with_label("File");
gtk_widget_show(file_item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file_item), file_menu);
gtk_menu_shell_append((GtkMenuShell *)menu_bar, file_item);
////////generate_menu
generate_menu = gtk_menu_new();
//////////generate_menu items
construct_tool_bar_add(generate_menu, "Mandelbrot", ITEM_SIGNAL_GENERATE_MANDELBROT);
construct_tool_bar_add(generate_menu, "Julia", ITEM_SIGNAL_GENERATE_JULIA);
construct_tool_bar_add(generate_menu, "Palette", ITEM_SIGNAL_GENERATE_PALETTE);
construct_tool_bar_add(generate_menu, "Random Noise", ITEM_SIGNAL_GENERATE_RANDOM_NOISE);
construct_tool_bar_add(generate_menu, "From Clipboard", ITEM_SIGNAL_GENERATE_FROM_CLIPBOARD);
/////////generate_item
generate_item = gtk_menu_item_new_with_label("Generate");
gtk_widget_show(generate_item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(generate_item), generate_menu);
gtk_menu_shell_append((GtkMenuShell *)menu_bar, generate_item);
////////settings_menu
settings_menu = gtk_menu_new();
////////settings_item
settings_item = gtk_menu_item_new_with_label("Settings");
gtk_widget_show(settings_item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(settings_item), settings_menu);
gtk_menu_shell_append((GtkMenuShell *)menu_bar, settings_item);
//////////FSD_checkbox
FSD_checkbox = gtk_check_menu_item_new_with_label("Floyd–Steinberg dithering");
gtk_menu_shell_append(GTK_MENU_SHELL(settings_menu), FSD_checkbox);
gtk_widget_show(FSD_checkbox);
//////////YUV_checkbox
YUV_checkbox = gtk_check_menu_item_new_with_label("YUV color conversion");
gtk_menu_shell_append(GTK_MENU_SHELL(settings_menu), YUV_checkbox);
gtk_widget_show(YUV_checkbox);
//////////old_colors_checkbox
old_colors_checkbox = gtk_check_menu_item_new_with_label("Old Colors");
gtk_menu_shell_append(GTK_MENU_SHELL(settings_menu), old_colors_checkbox);
gtk_widget_show(old_colors_checkbox);
g_signal_connect_swapped(old_colors_checkbox, "toggled",
G_CALLBACK(old_colors_checkbox_toggle), 0);
//drop_down_menu
init_drop_down_menu();
//hpaned
#ifdef GTK2
hpaned = gtk_hpaned_new();
#else
hpaned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
#endif
gtk_widget_set_size_request (hpaned, 220, -1);
gtk_box_pack_start(GTK_BOX(vbox), hpaned, TRUE, TRUE, 0);
gtk_widget_show(hpaned);
////sc_buffer
sc_buffer = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sc_buffer), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
#ifdef GTK2
gtk_widget_set_size_request(sc_buffer, 128 + 32, 512);
#else
gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(sc_buffer), 128 + 32);
gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sc_buffer), 512);
#endif
gtk_paned_pack2(GTK_PANED(hpaned), sc_buffer, FALSE, FALSE);
gtk_widget_show(sc_buffer);
//////list_vbox
#ifdef GTK2
list_vbox = gtk_vbox_new(FALSE, 0);
#else
list_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#endif
#ifdef GTK2
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sc_buffer), list_vbox);
#else
gtk_container_add(GTK_CONTAINER(sc_buffer), list_vbox);
#endif
gtk_widget_show(list_vbox);
////sc_win
sc_win = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sc_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
#ifdef GTK2
gtk_widget_set_size_request(sc_win, 128 * 4, 128 * 4);
gtk_window_resize(GTK_WINDOW(window), 128 * 4 + 200, 128 * 4 + 70);
#else
gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(sc_win), 128 * 4);
gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sc_win), 128 * 4);
#endif
gtk_paned_pack1(GTK_PANED(hpaned), sc_win, TRUE, FALSE);
gtk_widget_show(sc_win);
//////image
dimage = gdk_pixbuf_new_from_file("start.png", NULL);
image = gtk_image_new();
gtk_image_set_from_pixbuf(GTK_IMAGE(image), dimage);
#ifdef GTK2
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sc_win), image);
#else
gtk_container_add(GTK_CONTAINER(sc_win), image);
#endif
gtk_widget_show(image);
////zoom_box
#ifdef GTK2
zoom_box = gtk_hbox_new(FALSE, 0);
#else
zoom_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#endif
gtk_box_pack_start(GTK_BOX(vbox), zoom_box, FALSE, FALSE, 0);
gtk_widget_show(zoom_box);
//////zoom_button (+)
zoom_button = gtk_button_new_with_label("+");
gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2);
g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoomp");
gtk_widget_show(zoom_button);
//////zoom_button (|)
zoom_button = gtk_button_new_with_label("|");
gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2);
g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoome");
gtk_widget_show(zoom_button);
//////zoom_button (-)
zoom_button = gtk_button_new_with_label("-");
gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2);
g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoomm");
gtk_widget_show(zoom_button);
//icon
gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("imagetomap.ico"));
//Drag and drop
gtk_drag_dest_set(window, GTK_DEST_DEFAULT_ALL, targets, sizeof(targets)/sizeof(*targets), GDK_ACTION_COPY);
gtk_drag_dest_add_uri_targets(window);
g_signal_connect(window, "drag-drop", G_CALLBACK(drag_drop), NULL);
g_signal_connect(window, "drag-motion", G_CALLBACK(drag_motion), NULL);
g_signal_connect(window, "drag-data-received", G_CALLBACK(drag_received), NULL);
g_signal_connect(window, "drag-leave", G_CALLBACK(drag_leave), NULL);
//display window
gtk_widget_show (window);
gtk_main();
//clean up
free(colors);
for(i = 0; i < BUFFER_COUNT; i++)
free(mdata[i]);
config_free(config);
return 0;
}
GtkWidget *create_notebook_page_dialog(int page, dialog_buttons btn[MAX_KEYS], dialog_checkbox checkbox[CHECK_NBR])
{
GtkWidget *main_box;
GtkWidget *joy_choose_frame, *joy_choose_box;
GtkWidget *keys_frame, *keys_box;
GtkWidget *keys_tree_box, *keys_tree_scroll;
GtkWidget *keys_tree_clear_btn, *keys_tree_remove_btn, *keys_tree_modify_btn, *keys_tree_show_key_btn, *keys_tree_show_joy_btn;
GtkWidget *keys_btn_box, *keys_filter_box;
GtkWidget *keys_static_frame, *keys_static_box;
GtkWidget *keys_static_area;
joy_choose_cbox = GTK_COMBO_BOX(gtk_combo_box_new_text());
populate_new_joysticks(joy_choose_cbox);
set_current_joy();
g_signal_connect(GTK_OBJECT (joy_choose_cbox), "changed", G_CALLBACK(joy_changed), NULL);
keys_tree_scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(keys_tree_scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER(keys_tree_scroll), key_tree_manager->view_widget(page));
gtk_widget_set_size_request(keys_tree_scroll, 300, 500);
keys_tree_clear_btn = gtk_button_new_with_label("Clear All");
g_signal_connect(GTK_OBJECT (keys_tree_clear_btn), "clicked", G_CALLBACK(on_clear_clicked), NULL);
gtk_widget_set_size_request(keys_tree_clear_btn, 70, 24);
keys_tree_remove_btn = gtk_button_new_with_label("Remove");
g_signal_connect(GTK_OBJECT (keys_tree_remove_btn), "clicked", G_CALLBACK(on_remove_clicked), NULL);
gtk_widget_set_size_request(keys_tree_remove_btn, 70, 24);
keys_tree_modify_btn = gtk_button_new_with_label("Modify");
g_signal_connect(GTK_OBJECT (keys_tree_modify_btn), "clicked", G_CALLBACK(on_modify_clicked), NULL);
gtk_widget_set_size_request(keys_tree_modify_btn, 70, 24);
keys_tree_show_joy_btn = gtk_check_button_new_with_label("Show joy");
g_signal_connect(GTK_OBJECT (keys_tree_show_joy_btn), "toggled", G_CALLBACK(on_view_joy_clicked), NULL);
gtk_widget_set_size_request(keys_tree_show_joy_btn, 100, 24);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(keys_tree_show_joy_btn), true);
keys_tree_show_key_btn = gtk_check_button_new_with_label("Show key");
g_signal_connect(GTK_OBJECT (keys_tree_show_key_btn), "toggled", G_CALLBACK(on_view_key_clicked), NULL);
gtk_widget_set_size_request(keys_tree_show_key_btn, 100, 24);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(keys_tree_show_key_btn), true);
joy_choose_box = gtk_hbox_new(false, 5);
joy_choose_frame = gtk_frame_new ("Joystick to use for this pad");
gtk_container_add (GTK_CONTAINER(joy_choose_frame), joy_choose_box);
keys_btn_box = gtk_hbox_new(false, 5);
keys_filter_box = gtk_hbox_new(false, 5);
keys_tree_box = gtk_vbox_new(false, 5);
keys_static_box = gtk_hbox_new(false, 5);
keys_static_frame = gtk_frame_new ("");
gtk_container_add (GTK_CONTAINER(keys_static_frame), keys_static_box);
keys_static_area = gtk_fixed_new();
for(int i = 0; i < MAX_KEYS; i++)
{
btn[i].put(b_pos[i].label, i, GTK_FIXED(keys_static_area), b_pos[i].x, b_pos[i].y);
}
u32 mask = 1 << (16*page);
for(int i = 0; i < CHECK_NBR; i++) {
checkbox[i].create(keys_static_area, check_pos[i].label, check_pos[i].x, check_pos[i].y, mask);
mask = mask << 1;
}
keys_box = gtk_hbox_new(false, 5);
keys_frame = gtk_frame_new ("Key Settings");
gtk_container_add (GTK_CONTAINER(keys_frame), keys_box);
gtk_box_pack_start (GTK_BOX (keys_tree_box), keys_tree_scroll, true, true, 0);
gtk_box_pack_start (GTK_BOX (keys_tree_box), keys_btn_box, false, false, 0);
gtk_box_pack_start (GTK_BOX (keys_tree_box), keys_filter_box, false, false, 0);
gtk_box_pack_start (GTK_BOX (keys_filter_box), keys_tree_show_joy_btn, false, false, 0);
gtk_box_pack_start (GTK_BOX (keys_filter_box), keys_tree_show_key_btn, false, false, 0);
gtk_box_pack_start (GTK_BOX (keys_btn_box), keys_tree_clear_btn, false, false, 0);
gtk_box_pack_start (GTK_BOX (keys_btn_box), keys_tree_remove_btn, false, false, 0);
gtk_box_pack_start (GTK_BOX (keys_btn_box), keys_tree_modify_btn, false, false, 0);
gtk_container_add(GTK_CONTAINER(joy_choose_box), GTK_WIDGET(joy_choose_cbox));
gtk_box_pack_start(GTK_BOX (keys_box), keys_tree_box, false, false, 0);
gtk_container_add(GTK_CONTAINER(keys_box), keys_static_area);
main_box = gtk_vbox_new(false, 5);
gtk_container_add(GTK_CONTAINER(main_box), joy_choose_frame);
gtk_container_add(GTK_CONTAINER(main_box), keys_frame);
return main_box;
}
int main (int argc,
char *argv[])
{
GtkWidget *window, *swin, *viewport, *table1, *table2, *vbox;
GtkAdjustment *horizontal, *vertical;
GtkWidget *buttons1[10][10], *buttons2[10][10];
unsigned int i, j;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Scrolled Windows & Viewports");
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
gtk_widget_set_size_request (window, 500, 400);
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (gtk_main_quit), NULL);
table1 = gtk_table_new (10, 10, TRUE);
table2 = gtk_table_new (10, 10, TRUE);
gtk_table_set_row_spacings (GTK_TABLE (table1), 5);
gtk_table_set_row_spacings (GTK_TABLE (table2), 5);
gtk_table_set_col_spacings (GTK_TABLE (table1), 5);
gtk_table_set_col_spacings (GTK_TABLE (table2), 5);
/* Pack each table with 100 buttons. */
for (i = 0; i < 10; i++)
{
for (j = 0; j < 10; j++)
{
buttons1[i][j] = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
buttons2[i][j] = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
gtk_button_set_relief (GTK_BUTTON (buttons1[i][j]), GTK_RELIEF_NONE);
gtk_button_set_relief (GTK_BUTTON (buttons2[i][j]), GTK_RELIEF_NONE);
gtk_table_attach_defaults (GTK_TABLE (table1), buttons1[i][j],
i, i + 1, j, j + 1);
gtk_table_attach_defaults (GTK_TABLE (table2), buttons2[i][j],
i, i + 1, j, j + 1);
}
}
/* Create a scrolled window and a viewport, each with one table. Use the
* adjustments in the scrolled window to synchronize both containers. */
swin = gtk_scrolled_window_new (NULL, NULL);
horizontal = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (swin));
vertical = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (swin));
viewport = gtk_viewport_new (horizontal, vertical);
gtk_container_set_border_width (GTK_CONTAINER (swin), 5);
gtk_container_set_border_width (GTK_CONTAINER (viewport), 5);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (swin), table1);
gtk_container_add (GTK_CONTAINER (viewport), table2);
/* Pack the widgets into a GtkVBox and then into the window. */
vbox = gtk_vbox_new (TRUE, 5);
gtk_box_pack_start_defaults (GTK_BOX (vbox), viewport);
gtk_box_pack_start_defaults (GTK_BOX (vbox), swin);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show_all (window);
gtk_main();
return 0;
}