static void
message_list_view_delete_clicked(struct MessageListViewData *data,
Evas_Object * obj, void *event_info)
{
g_debug("message_list_view_delete_clicked()");
evas_object_hide(data->hv);
data->selected_row = etk_tree_selected_row_get(data->tree);
if (data->selected_row != NULL) {
GValueArray *message =
etk_tree_row_data_get(data->selected_row);
GHashTable *options = g_hash_table_new(g_str_hash, g_str_equal);
g_hash_table_insert(options, "id",
GINT_TO_POINTER(g_value_get_int
(g_value_array_get_nth
(message, 0))));
g_hash_table_insert(options, "delete_callback",
message_list_view_message_deleted);
g_hash_table_insert(options, "delete_callback_data", data);
struct Window *win = window_new(D_("Delete Message"));
window_init(win);
window_view_show(win, options, message_delete_view_show,
message_delete_view_hide);
}
}
/* Create a dialog box window that belongs to Wireshark's main window. */
GtkWidget *
dlg_window_new(const gchar *title)
{
GtkWidget *win;
win = window_new(GTK_WINDOW_TOPLEVEL, title);
/*
* On Windows, making the dialogs transient to top_level behaves strangely.
* It is not possible any more to bring the top level window to front easily.
* So we don't do this on Windows.
*
* XXX: Note well: This means that *on Windows* any code which creates a
* window using dlg_window_new() and then calls
* gtk_widget_destroy_with_parent() will *not* get the desired effect
* since the dialog window actually has has no parent.
*/
#ifndef _WIN32
if (top_level) {
gtk_window_set_transient_for(GTK_WINDOW(win), GTK_WINDOW(top_level));
}
#endif /*_WIN32*/
return win;
}
static void
_show(const int id, const int status, const char *number, int type)
{
struct Window *win = window_new(D_("Call"));
instance_manager_add(id, win);
GHashTable *options = g_hash_table_new(g_str_hash, g_str_equal);
g_hash_table_insert(options, "id", GINT_TO_POINTER(id));
g_hash_table_insert(options, "status", GINT_TO_POINTER(status));
g_hash_table_insert(options, "number", g_strdup(number));
g_hash_table_insert(options, "number_state",
GINT_TO_POINTER(CALL_NUMBER_NUMBER));
window_init(win);
window_delete_callback_set(win, _delete);
if (type == CALL_INCOMING) {
window_view_show(win, options, (void * (*)(struct Window *, void *)) call_incoming_view_show,
(void (*)(void *)) call_incoming_view_hide, NULL);
}
else if (type == CALL_ACTIVE) {
window_view_show(win, options,(void * (*)(struct Window *, void *)) call_active_view_show,
(void (*)(void *)) call_active_view_hide, NULL);
}
else {
g_critical("Unknown call type: %d", type);
g_hash_table_destroy(options);
}
}
static void menu_newwindow_tab(GtkWidget *wid, gpointer none) {
int old = new_window_in_tab_config;
new_window_in_tab_config = 1;
window_new(NULL, window_current->session, 0);
new_window_in_tab_config = old;
}
void
phonegui_backend_dialer_show()
{
g_debug("phonegui_backend_dialer_show()");
if (win == NULL) {
win = window_new(D_("Dialer"));
async_trigger(_show, win);
}
}
extern gboolean window_clone(GtkWidget *widget, gpointer data)
{
struct view_s* v = data;
struct view_s* v2 = window_new(v->name, v->pos, v->dims, v->data);
window_connect_sync(v, v2);
return FALSE;
}
static void
message_list_view_new_clicked(struct MessageListViewData *data,
Evas_Object * obj, void *event_info)
{
g_debug("message_list_view_new_clicked()");
struct Window *win = window_new(D_("Compose SMS"));
window_init(win);
window_view_show(win, NULL, message_new_view_show,
message_new_view_hide);
}
static void
message_show_view_answer_clicked(struct MessageShowViewData *data,
Evas_Object * obj, void *event_info)
{
GHashTable *options = g_hash_table_new(g_str_hash, g_str_equal);
g_hash_table_insert(options, "recipient", data->number);
struct Window *win = window_new(D_("Compose SMS"));
window_init(win);
window_view_show(win, options, message_new_view_show,
message_new_view_hide);
}
void gui_init_playback(void) {
playback_window = window_new();
playback_window->update = gui_update_playback;
playback_window->yoffset = 1;
if (conf->playback_window.height == 0) {
conf->playback_window.height = LINES - conf->playback_window.y;
}
if (conf->playback_window.width < 4) {
conf->playback_window.width = COLS - conf->playback_window.x;
}
window_init(playback_window, WINDOW_NAME_PLAYBACK, &conf->playback_window);
}
void gui_init_info(void) {
info_window = window_new();
info_window->update = gui_update_info;
info_window->yoffset = 0;
if (conf->info_window.height == 0) {
conf->info_window.height = LINES - conf->info_window.y;
}
if (conf->info_window.width < 4) {
conf->info_window.width = COLS - conf->info_window.x;
}
window_init(info_window, WINDOW_NAME_INFO, &conf->info_window);
}
/* Create a new window for a splash screen; it's a main window, without decoration,
positioned in the center of the screen. */
GtkWidget *
splash_window_new(void)
{
GtkWidget *win;
win = window_new(GTK_WINDOW_TOPLEVEL, "Wireshark");
gtk_window_set_decorated(GTK_WINDOW(win), FALSE);
/* set the initial position (must be done, before show is called!) */
gtk_window_set_position(GTK_WINDOW(win), GTK_WIN_POS_CENTER);
return win;
}
t_app *app_new(int argc,char **argv)
{
t_app *app = (t_app *)mem_malloc(sizeof(t_app));
app->argc=argc;
app->argv=argv;
set_name(app->name,"minuit");
app->main_func = app_default_func;
app->x_func = NULL;
app->off_screen=0;
app->frame=0;
app->timer=0;
app->timer_add = 1;
app->timer_add_low = .1;
app->timer_count=0;
app->loop=APP_LOOP;
app->buffer=APP_BUFFER;
app->with_glut=APP_WITH_GLUT;
app->debug_keyboard=0;
app->load_file = 0;
app->loaded_file = 0;
app->client = 0;
app->slave = 0;
app->osc_server = 0;
app->osc_client = 0;
app->osc_port = 0;
bzero( app->path_home, _PATH_);
bzero( app->path_current, _PATH_);
bzero( app->filename, _NAME_LONG_);
bzero( app->path_file, _PATH_);
app->mouse=mouse_new();
app->window=window_new(app->with_glut);
app->keyboard=keyboard_new();
app->clock=clock_new( "clock");
app->video_frames = lst_new("video");
app->video_frames_swap = lst_new("video swap");
app->video_offset = 0;
app->video_build = 1;
app->video_limit = APP_VIDEO_LIMIT;
clock_init(app->clock);
app->quit = 0;
return app;
}
void ncurses_contacts_changed(const char *name) {
window_t *w = NULL;
if (in_autoexec)
return;
if (!xstrcasecmp(name, "ncurses:contacts_size"))
config_contacts = 1;
if (config_contacts_size < 0)
config_contacts_size = 0;
if (config_contacts_size == 0)
config_contacts = 0;
if (config_contacts_size > 1000)
config_contacts_size = 1000;
if (config_contacts_margin > 10)
config_contacts_margin = 10;
if (config_contacts_edge > 3)
config_contacts_edge = 2;
contacts_edge = (1 << config_contacts_edge);
contacts_frame = (!config_contacts_frame ? 0
: contacts_edge & (WF_LEFT|WF_RIGHT) ? contacts_edge ^ (WF_LEFT|WF_RIGHT)
: contacts_edge ^ (WF_TOP|WF_BOTTOM));
if (config_contacts_order) {
strlcpy(contacts_order, config_contacts_order, sizeof(contacts_order));
corderlen = xstrlen(contacts_order);
} else {
xstrcpy(contacts_order, CONTACTS_ORDER_DEFAULT);
corderlen = CONTACTS_ORDER_DEFAULT_LEN; /* xstrlen(CONTACTS_ORDER_DEFAULT) eq CONTACTS_ORDER_DEFAULT_LEN */
}
/* XXX destroy window only if (!config_contacts) ? XXX */
if ((w = window_find_sa(NULL, "__contacts", 1))) {
window_kill(w);
w = NULL;
}
if (config_contacts /* && !w */) {
w = window_new("__contacts", NULL, 1000);
ncurses_contacts_update(w, 0);
}
ncurses_resize();
ncurses_commit();
}
static void
message_show_view_delete_clicked(struct MessageShowViewData *data,
Evas_Object * obj, void *event_info)
{
GHashTable *options = g_hash_table_new(g_str_hash, g_str_equal);
g_hash_table_insert(options, "id", GINT_TO_POINTER(data->id));
g_hash_table_insert(options, "delete_callback",
message_show_view_delete_callback);
g_hash_table_insert(options, "delete_callback_data", data);
struct Window *win = window_new(D_("Delete Message"));
window_init(win);
window_view_show(win, options, message_delete_view_show,
message_delete_view_hide);
}
void gui_init_playlist(void) {
playlist_window = window_new();
playlist_window->list = playlist;
playlist_window->type = WINDOW_TYPE_LIST;
playlist_window->update = gui_update_playlist;
playlist_window->activate = gui_activate_playlist;
playlist_window->deactivate = gui_deactivate_playlist;
playlist_window->input = gui_input_playlist;
if (conf->play_window.height == 0) {
conf->play_window.height = LINES - conf->play_window.y;
}
if (conf->play_window.width < 4) {
conf->play_window.width = COLS - conf->play_window.x;
}
window_init(playlist_window, WINDOW_NAME_PLAYLIST, &conf->play_window);
}
static void
equalizerwin_create_window(void)
{
equalizerwin = window_new (& config.equalizer_x, & config.equalizer_y, 275,
config.equalizer_shaded ? 14 : 116, FALSE, config.equalizer_shaded,
eq_win_draw);
gtk_window_set_title(GTK_WINDOW(equalizerwin), _("Audacious Equalizer"));
/* this will hide only mainwin. it's annoying! yaz */
gtk_window_set_transient_for(GTK_WINDOW(equalizerwin),
GTK_WINDOW(mainwin));
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(equalizerwin), TRUE);
gtk_widget_set_app_paintable(equalizerwin, TRUE);
g_signal_connect (equalizerwin, "delete-event", (GCallback) handle_window_close, NULL);
g_signal_connect (equalizerwin, "button-press-event", (GCallback) equalizerwin_press, NULL);
g_signal_connect (equalizerwin, "key-press-event", (GCallback) mainwin_keypress, NULL);
}
void gui_init_filelist(void) {
filelist_window = window_new();
filelist_window->list = mp3list;
filelist_window->type = WINDOW_TYPE_LIST;
filelist_window->update = gui_update_filelist;
filelist_window->activate = gui_activate_filelist;
filelist_window->deactivate = gui_deactivate_filelist;
filelist_window->input = gui_input_filelist;
if (conf->files_window.height == 0) {
conf->files_window.height = LINES - conf->files_window.y;
}
if (conf->files_window.width < 4) {
conf->files_window.width = COLS - conf->files_window.x;
}
window_init(filelist_window, WINDOW_NAME_FILELIST, &conf->files_window);
previous_selected = strdup("");
time(&typed_letters_last_activity);
}
static void
message_list_view_answer_clicked(struct MessageListViewData *data,
Evas_Object * obj, void *event_info)
{
evas_object_hide(data->hv);
data->selected_row = etk_tree_selected_row_get(data->tree);
if (data->selected_row != NULL) {
GValueArray *message =
etk_tree_row_data_get(data->selected_row);
GHashTable *options = g_hash_table_new(g_str_hash, g_str_equal);
g_hash_table_insert(options, "recipient", (gpointer) g_value_get_string(g_value_array_get_nth(message, 2))); /* lose the const */
struct Window *win = window_new(D_("SMS Answer"));
window_init(win);
window_view_show(win, options, message_new_view_show,
message_new_view_hide);
}
}
PyObject *ekg_cmd_window_new(PyObject * self, PyObject * pyargs)
{
char * name = NULL;
window_t *w;
if (!PyArg_ParseTuple(pyargs, "s", &name))
return NULL;
debug("[python] checking for window '%s'\n", name);
w = window_find(name);
if (w) {
PyErr_SetString(PyExc_RuntimeError, _("Window with this name already exists"));
return NULL;
}
debug("[python] Building object for window '%s'\n", name);
w = window_new(name, window_current->session, 0);
return (PyObject *)python_build_window_w(w);
}
/* Same as window_new(), but will keep it's geometry values (size, position, ...).
* Be sure to use window_present() and window_destroy() appropriately! */
GtkWidget *
window_new_with_geom(GtkWindowType type, const gchar *title, const gchar *geom_name)
{
window_geometry_t geom;
GtkWidget *win = window_new(type, title);
g_object_set_data(G_OBJECT(win), WINDOW_GEOM_KEY, (gpointer)g_strdup(geom_name));
/* do we have a previously saved size and position of this window? */
if(geom_name) {
/* It's a good idea to set the position and size of the window already here,
* as it's still invisible and won't "flicker the screen" while initially resizing. */
if(window_geom_load(geom_name, &geom)) {
/* XXX - use prefs to select which values to set? */
geom.set_pos = TRUE;
geom.set_size = TRUE;
geom.set_maximized = FALSE; /* don't maximize until window is shown */
window_set_geometry(win, &geom);
}
}
return win;
}
void
test(void) {
Window* window = window_new("omikuji", 400, 300);
Ticket* ticket = ticket_new_file("../res/omikuji.txt");
while (window_is_open(window)) {
WindowEvent event = window_poll_events(window);
switch (event.type) {
case WE_CLOSE: goto end; break;
case WE_KEYBOARD:
if (event.value == WE_KEY_A) {
}
break;
}
window_clear(window);
window_render_ticket(window, ticket);
window_display(window);
}
end:
ticket_delete(ticket);
window_delete(window);
}
GtkWidget *help_window_new(const gchar *title,
const gchar *subclass,
const gchar *path, const gchar *key)
{
GtkWidget *window;
GtkWidget *text;
GtkTextBuffer *buffer;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *button;
GtkWidget *scrolled;
/* window */
window = window_new(GTK_WINDOW_TOPLEVEL, subclass, NULL, NULL, title);
gtk_window_set_resizable(GTK_WINDOW(window), TRUE);
#if 0
gtk_container_set_border_width(GTK_CONTAINER(window), PREF_PAD_BORDER);
#endif
gtk_window_set_default_size(GTK_WINDOW(window), HELP_WINDOW_WIDTH, HELP_WINDOW_HEIGHT);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(help_window_delete_cb), NULL);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_widget_show(vbox);
g_object_set_data(G_OBJECT(window), "text_vbox", vbox);
/* text window */
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show(hbox);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0);
gtk_widget_show(scrolled);
text = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(text), FALSE);
gtk_container_add(GTK_CONTAINER(scrolled), text);
gtk_widget_show(text);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
gtk_text_buffer_create_tag(buffer, "monospace",
"family", "monospace", NULL);
hbox = gtk_hbutton_box_new();
gtk_container_set_border_width(GTK_CONTAINER(hbox), PREF_PAD_BORDER);
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
button = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(help_window_close), window);
gtk_container_add(GTK_CONTAINER(hbox), button);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_grab_default(button);
gtk_widget_show(button);
g_object_set_data(G_OBJECT(window), "text_widget", text);
help_window_load_text(text, path);
gtk_widget_show(window);
help_window_scroll(text, key);
return window;
}
static void editor_list_window_create(void)
{
GtkWidget *win_vbox;
GtkWidget *hbox;
GtkWidget *button;
GtkWidget *scrolled;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkTreeModel *store;
GtkTreeSortable *sortable;
EditorListWindow *ewl;
editor_list_window = ewl = g_new0(EditorListWindow, 1);
ewl->window = window_new(GTK_WINDOW_TOPLEVEL, "editors", PIXBUF_INLINE_ICON_CONFIG, NULL, _("Editors"));
gtk_window_set_type_hint(GTK_WINDOW(ewl->window), GDK_WINDOW_TYPE_HINT_DIALOG);
g_signal_connect(G_OBJECT(ewl->window), "delete_event",
G_CALLBACK(editor_list_window_delete), NULL);
gtk_window_set_default_size(GTK_WINDOW(ewl->window), CONFIG_WINDOW_DEF_WIDTH, CONFIG_WINDOW_DEF_HEIGHT);
gtk_window_set_resizable(GTK_WINDOW(ewl->window), TRUE);
gtk_container_set_border_width(GTK_CONTAINER(ewl->window), PREF_PAD_BORDER);
win_vbox = gtk_vbox_new(FALSE, PREF_PAD_SPACE);
gtk_container_add(GTK_CONTAINER(ewl->window), win_vbox);
gtk_widget_show(win_vbox);
hbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(hbox), PREF_PAD_BUTTON_GAP);
gtk_box_pack_end(GTK_BOX(win_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
button = pref_button_new(NULL, GTK_STOCK_NEW, NULL, FALSE,
G_CALLBACK(editor_list_window_new_cb), ewl);
gtk_container_add(GTK_CONTAINER(hbox), button);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_show(button);
button = pref_button_new(NULL, GTK_STOCK_EDIT, NULL, FALSE,
G_CALLBACK(editor_list_window_edit_cb), ewl);
gtk_container_add(GTK_CONTAINER(hbox), button);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_set_sensitive(button, FALSE);
gtk_widget_show(button);
ewl->edit_button = button;
button = pref_button_new(NULL, GTK_STOCK_DELETE, NULL, FALSE,
G_CALLBACK(editor_list_window_delete_cb), ewl);
gtk_container_add(GTK_CONTAINER(hbox), button);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_set_sensitive(button, FALSE);
gtk_widget_show(button);
ewl->delete_button = button;
button = pref_button_new(NULL, GTK_STOCK_CLOSE, NULL, FALSE,
G_CALLBACK(editor_list_window_close_cb), ewl);
gtk_container_add(GTK_CONTAINER(hbox), button);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_show(button);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(win_vbox), scrolled, TRUE, TRUE, 5);
gtk_widget_show(scrolled);
ewl->view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(desktop_file_list));
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ewl->view));
gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_SINGLE);
g_signal_connect(selection, "changed", G_CALLBACK(editor_list_window_selection_changed_cb), ewl);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(ewl->view), FALSE);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Name"));
gtk_tree_view_column_set_resizable(column, TRUE);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_NAME);
gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column);
gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_NAME);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Hidden"));
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_HIDDEN);
gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column);
gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_HIDDEN);
gtk_tree_view_column_set_alignment(column, 0.5);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Desktop file"));
gtk_tree_view_column_set_resizable(column, TRUE);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_KEY);
gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column);
gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_KEY);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Path"));
gtk_tree_view_column_set_resizable(column, TRUE);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_PATH);
gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column);
gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_PATH);
/* set up sorting */
store = gtk_tree_view_get_model(GTK_TREE_VIEW(ewl->view));
sortable = GTK_TREE_SORTABLE(store);
gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_KEY, editor_list_window_sort_cb,
GINT_TO_POINTER(DESKTOP_FILE_COLUMN_KEY), NULL);
gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_HIDDEN, editor_list_window_sort_cb,
GINT_TO_POINTER(DESKTOP_FILE_COLUMN_HIDDEN), NULL);
gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_NAME, editor_list_window_sort_cb,
GINT_TO_POINTER(DESKTOP_FILE_COLUMN_NAME), NULL);
gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_PATH, editor_list_window_sort_cb,
GINT_TO_POINTER(DESKTOP_FILE_COLUMN_PATH), NULL);
/* set initial sort order */
//gtk_tree_sortable_set_sort_column_id(sortable, DESKTOP_FILE_COLUMN_KEY, GTK_SORT_ASCENDING);
gtk_container_add(GTK_CONTAINER(scrolled), ewl->view);
gtk_widget_show(ewl->view);
gtk_widget_show(ewl->window);
}
static void editor_window_new(const gchar *src_path, const gchar *desktop_name)
{
EditorWindow *ew;
GtkWidget *win_vbox;
GtkWidget *hbox;
GtkWidget *button;
GtkWidget *ct_button;
GtkWidget *button_hbox;
GtkWidget *scrolled;
GtkWidget *text_view;
gchar *text;
gsize size;
ew = g_new0(EditorWindow, 1);
ew->window = window_new(GTK_WINDOW_TOPLEVEL, "Desktop", PIXBUF_INLINE_ICON_CONFIG, NULL, _("Desktop file"));
gtk_window_set_type_hint(GTK_WINDOW(ew->window), GDK_WINDOW_TYPE_HINT_DIALOG);
g_signal_connect(G_OBJECT(ew->window), "delete_event",
G_CALLBACK(editor_window_delete_cb), ew);
gtk_window_set_default_size(GTK_WINDOW(ew->window), CONFIG_WINDOW_DEF_WIDTH, CONFIG_WINDOW_DEF_HEIGHT);
gtk_window_set_resizable(GTK_WINDOW(ew->window), TRUE);
gtk_container_set_border_width(GTK_CONTAINER(ew->window), PREF_PAD_BORDER);
win_vbox = gtk_vbox_new(FALSE, PREF_PAD_SPACE);
gtk_container_add(GTK_CONTAINER(ew->window), win_vbox);
gtk_widget_show(win_vbox);
hbox = gtk_hbox_new(FALSE, PREF_PAD_SPACE);
gtk_box_pack_end(GTK_BOX(win_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
ew->entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(hbox), ew->entry, TRUE, TRUE, 0);
ew->desktop_name = NULL;
if (desktop_name)
{
gtk_entry_set_text(GTK_ENTRY(ew->entry), desktop_name);
ew->desktop_name = g_strdup(desktop_name);
}
gtk_widget_show(ew->entry);
g_signal_connect(G_OBJECT(ew->entry), "changed", G_CALLBACK(editor_window_entry_changed_cb), ew);
button_hbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(button_hbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(button_hbox), PREF_PAD_BUTTON_GAP);
gtk_box_pack_end(GTK_BOX(hbox), button_hbox, FALSE, FALSE, 0);
gtk_widget_show(button_hbox);
ew->save_button = pref_button_new(NULL, GTK_STOCK_SAVE, NULL, FALSE,
G_CALLBACK(editor_window_save_cb), ew);
gtk_container_add(GTK_CONTAINER(button_hbox), ew->save_button);
GTK_WIDGET_SET_FLAGS(ew->save_button, GTK_CAN_DEFAULT);
gtk_widget_set_sensitive(ew->save_button, FALSE);
gtk_widget_show(ew->save_button);
ct_button = ew->save_button;
button = pref_button_new(NULL, GTK_STOCK_CLOSE, NULL, FALSE,
G_CALLBACK(editor_window_close_cb), ew);
gtk_container_add(GTK_CONTAINER(button_hbox), button);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_widget_show(button);
if (!generic_dialog_get_alternative_button_order(ew->window))
{
gtk_box_reorder_child(GTK_BOX(button_hbox), ct_button, -1);
}
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(win_vbox), scrolled, TRUE, TRUE, 5);
gtk_widget_show(scrolled);
text_view = gtk_text_view_new();
gtk_container_add(GTK_CONTAINER(scrolled), text_view);
gtk_widget_show(text_view);
ew->buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view));
if (g_file_get_contents(src_path, &text, &size, NULL))
{
gtk_text_buffer_set_text(ew->buffer, text, size);
}
gtk_text_buffer_set_modified(ew->buffer, FALSE);
g_signal_connect(G_OBJECT(ew->buffer), "modified-changed",
G_CALLBACK(editor_window_text_modified_cb), ew);
gtk_widget_show(ew->window);
}
gchar *str_work;
time_t ti_time;
struct tm *ti_tm;
unsigned int elapsed_time;
/* initial computations */
summary_fill_in(&cfile, &summary);
#ifdef HAVE_LIBPCAP
summary_fill_in_capture(&global_capture_opts, &summary);
#endif
seconds = summary.stop_time - summary.start_time;
disp_seconds = summary.filtered_stop - summary.filtered_start;
marked_seconds = summary.marked_stop - summary.marked_start;
sum_open_w = window_new(GTK_WINDOW_TOPLEVEL, "Wireshark: Summary");
/* Container for each row of widgets */
main_vb = gtk_vbox_new(FALSE, 12);
gtk_container_set_border_width(GTK_CONTAINER(main_vb), 12);
gtk_container_add(GTK_CONTAINER(sum_open_w), main_vb);
/* table */
table = gtk_table_new(1, 2, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_table_set_row_spacings(GTK_TABLE(table), 3);
gtk_container_add(GTK_CONTAINER(main_vb), table);
row = 0;
/* File */
static void generic_dialog_setup(GenericDialog *gd,
const gchar *title,
const gchar *role,
GtkWidget *parent, gboolean auto_close,
void (*cancel_cb)(GenericDialog *, gpointer), gpointer data)
{
GtkWidget *vbox;
gd->auto_close = auto_close;
gd->data = data;
gd->cancel_cb = cancel_cb;
gd->dialog = window_new(GTK_WINDOW_TOPLEVEL, role, NULL, NULL, title);
gtk_window_set_type_hint(GTK_WINDOW(gd->dialog), GDK_WINDOW_TYPE_HINT_DIALOG);
if (parent)
{
GtkWindow *window = NULL;
if (GTK_IS_WINDOW(parent))
{
window = GTK_WINDOW(parent);
}
else
{
GtkWidget *top;
top = gtk_widget_get_toplevel(parent);
if (GTK_IS_WINDOW(top) && gtk_widget_is_toplevel(top)) window = GTK_WINDOW(top);
}
if (window) gtk_window_set_transient_for(GTK_WINDOW(gd->dialog), window);
}
g_signal_connect(G_OBJECT(gd->dialog), "delete_event",
G_CALLBACK(generic_dialog_delete_cb), gd);
g_signal_connect(G_OBJECT(gd->dialog), "key_press_event",
G_CALLBACK(generic_dialog_key_press_cb), gd);
gtk_window_set_resizable(GTK_WINDOW(gd->dialog), TRUE);
gtk_container_set_border_width(GTK_CONTAINER(gd->dialog), PREF_PAD_BORDER);
vbox = gtk_vbox_new(FALSE, PREF_PAD_BUTTON_SPACE);
gtk_container_add(GTK_CONTAINER(gd->dialog), vbox);
gtk_widget_show(vbox);
gd->vbox = gtk_vbox_new(FALSE, PREF_PAD_GAP);
gtk_box_pack_start(GTK_BOX(vbox), gd->vbox, TRUE, TRUE, 0);
gtk_widget_show(gd->vbox);
gd->hbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(gd->hbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(gd->hbox), PREF_PAD_BUTTON_GAP);
gtk_box_pack_start(GTK_BOX(vbox), gd->hbox, FALSE, FALSE, 0);
gtk_widget_show(gd->hbox);
if (gd->cancel_cb)
{
gd->cancel_button = generic_dialog_add_button(gd, GTK_STOCK_CANCEL, NULL, gd->cancel_cb, TRUE);
}
else
{
gd->cancel_button = NULL;
}
if (generic_dialog_get_alternative_button_order(gd->hbox))
{
g_signal_connect(G_OBJECT(gd->dialog), "show",
G_CALLBACK(generic_dialog_show_cb), gd);
}
gd->default_cb = NULL;
}
static ViewWindow *real_view_window_new(FileData *fd, GList *list, CollectionData *cd, CollectInfo *info)
{
ViewWindow *vw;
GtkAllocation req_size;
GdkGeometry geometry;
gint w, h;
if (!fd && !list && (!cd || !info)) return NULL;
vw = g_new0(ViewWindow, 1);
vw->window = window_new(GTK_WINDOW_TOPLEVEL, "view", PIXBUF_INLINE_ICON_VIEW, NULL, NULL);
geometry.min_width = DEFAULT_MINIMAL_WINDOW_SIZE;
geometry.min_height = DEFAULT_MINIMAL_WINDOW_SIZE;
gtk_window_set_geometry_hints(GTK_WINDOW(vw->window), NULL, &geometry, GDK_HINT_MIN_SIZE);
gtk_window_set_resizable(GTK_WINDOW(vw->window), TRUE);
gtk_container_set_border_width(GTK_CONTAINER(vw->window), 0);
vw->imd = image_new(FALSE);
image_color_profile_set(vw->imd,
options->color_profile.input_type,
options->color_profile.use_image);
image_color_profile_set_use(vw->imd, options->color_profile.enabled);
image_background_set_color_from_options(vw->imd, FALSE);
image_attach_window(vw->imd, vw->window, NULL, GQ_APPNAME, TRUE);
image_auto_refresh_enable(vw->imd, TRUE);
image_top_window_set_sync(vw->imd, TRUE);
gtk_container_add(GTK_CONTAINER(vw->window), vw->imd->widget);
gtk_widget_show(vw->imd->widget);
view_window_dnd_init(vw);
view_image_set_buttons(vw, vw->imd);
g_signal_connect(G_OBJECT(vw->window), "destroy",
G_CALLBACK(view_window_destroy_cb), vw);
g_signal_connect(G_OBJECT(vw->window), "delete_event",
G_CALLBACK(view_window_delete_cb), vw);
g_signal_connect(G_OBJECT(vw->window), "key_press_event",
G_CALLBACK(view_window_key_press_cb), vw);
if (cd && info)
{
image_change_from_collection(vw->imd, cd, info, image_zoom_get_default(NULL));
if (options->image.enable_read_ahead)
{
CollectInfo * r_info = collection_next_by_info(cd, info);
if (!r_info) r_info = collection_prev_by_info(cd, info);
if (r_info) image_prebuffer_set(vw->imd, r_info->fd);
}
}
else if (list)
{
view_window_set_list(vw, list);
vw->list_pointer = vw->list;
image_change_fd(vw->imd, (FileData *)vw->list->data, image_zoom_get_default(NULL));
if (options->image.enable_read_ahead)
{
GList *work = vw->list->next;
if (work) image_prebuffer_set(vw->imd, (FileData *)work->data);
}
}
else
{
image_change_fd(vw->imd, fd, image_zoom_get_default(NULL));
}
/* Wait until image is loaded otherwise size is not defined */
int count;
for (count = 10; count && !w && !h; count++)
{
image_get_image_size(vw->imd, &w, &h);
usleep(100000);
}
if (image_zoom_get(vw->imd) == 0.0)
{
image_get_image_size(vw->imd, &w, &h);
}
else
{
pixbuf_renderer_get_scaled_size(PIXBUF_RENDERER(vw->imd->pr), &w, &h);
}
if (options->image.limit_window_size)
{
gint mw = gdk_screen_width() * options->image.max_window_size / 100;
gint mh = gdk_screen_height() * options->image.max_window_size / 100;
if (w > mw) w = mw;
if (h > mh) h = mh;
}
gtk_window_set_default_size(GTK_WINDOW(vw->window), w, h);
req_size.x = req_size.y = 0;
req_size.width = w;
req_size.height = h;
gtk_widget_size_allocate(GTK_WIDGET(vw->window), &req_size);
gtk_widget_set_size_request(vw->imd->pr, w, h);
gtk_widget_show(vw->window);
view_window_list = g_list_append(view_window_list, vw);
file_data_register_notify_func(view_window_notify_cb, vw, NOTIFY_PRIORITY_LOW);
return vw;
}
CollectWindow *collection_window_new(const gchar *path)
{
CollectWindow *cw;
GtkWidget *vbox;
GtkWidget *frame;
GtkWidget *status_label;
GtkWidget *extra_label;
GdkGeometry geometry;
cw = g_new0(CollectWindow, 1);
collection_window_list = g_list_append(collection_window_list, cw);
cw->cd = collection_new(path);
cw->window = window_new(GTK_WINDOW_TOPLEVEL, "collection", PIXBUF_INLINE_ICON_BOOK, NULL, NULL);
geometry.min_width = DEFAULT_MINIMAL_WINDOW_SIZE;
geometry.min_height = DEFAULT_MINIMAL_WINDOW_SIZE;
geometry.base_width = COLLECT_DEF_WIDTH;
geometry.base_height = COLLECT_DEF_HEIGHT;
gtk_window_set_geometry_hints(GTK_WINDOW(cw->window), NULL, &geometry,
GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE);
if (options->save_window_positions && path && collection_load_only_geometry(cw->cd, path))
{
/* FIXME: x, y is not implemented */
gtk_window_set_default_size(GTK_WINDOW(cw->window), cw->cd->window_w, cw->cd->window_h);
}
else
{
gtk_window_set_default_size(GTK_WINDOW(cw->window), COLLECT_DEF_WIDTH, COLLECT_DEF_HEIGHT);
}
gtk_window_set_resizable(GTK_WINDOW(cw->window), TRUE);
collection_window_update_title(cw);
gtk_container_set_border_width(GTK_CONTAINER(cw->window), 0);
g_signal_connect(G_OBJECT(cw->window), "delete_event",
G_CALLBACK(collection_window_delete), cw);
g_signal_connect(G_OBJECT(cw->window), "key_press_event",
G_CALLBACK(collection_window_keypress), cw);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(cw->window), vbox);
gtk_widget_show(vbox);
cw->table = collection_table_new(cw->cd);
gtk_box_pack_start(GTK_BOX(vbox), cw->table->scrolled, TRUE, TRUE, 0);
gtk_widget_show(cw->table->scrolled);
cw->status_box = gtk_hbox_new(TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), cw->status_box, FALSE, FALSE, 0);
gtk_widget_show(cw->status_box);
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(cw->status_box), frame, TRUE, TRUE, 0);
gtk_widget_show(frame);
status_label = gtk_label_new("");
gtk_container_add(GTK_CONTAINER(frame), status_label);
gtk_widget_show(status_label);
extra_label = gtk_progress_bar_new();
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(extra_label), 0.0);
gtk_box_pack_start(GTK_BOX(cw->status_box), extra_label, TRUE, TRUE, 0);
gtk_widget_show(extra_label);
collection_table_set_labels(cw->table, status_label, extra_label);
gtk_widget_show(cw->window);
gtk_widget_grab_focus(cw->table->listview);
collection_set_update_info_func(cw->cd, collection_window_update_info, cw);
if (path && *path == G_DIR_SEPARATOR) collection_load_begin(cw->cd, NULL, COLLECTION_LOAD_NONE);
return cw;
}
