static void create_toolbar_menu()
{
GtkWidget *iconw;
GtkWidget *close_button;
bdk_window.toolbar = gtk_toolbar_new ();
gtk_toolbar_set_orientation (GTK_TOOLBAR (bdk_window.toolbar), GTK_ORIENTATION_HORIZONTAL);
gtk_toolbar_set_style (GTK_TOOLBAR (bdk_window.toolbar), GTK_TOOLBAR_BOTH);
/* our first item is <close> button */
iconw = gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_SMALL_TOOLBAR) ; // ("gtk.xpm"); /* icon widget */
close_button =
gtk_toolbar_append_item (GTK_TOOLBAR (bdk_window.toolbar), /* our toolbar */
"Open", /* button label */
"Open a file", /* this button's tooltip */
"Private", /* tooltip private info */
iconw, /* icon widget */
GTK_SIGNAL_FUNC (open_event), /* a signal */
NULL);
gtk_toolbar_append_space (GTK_TOOLBAR (bdk_window.toolbar)); /* space after item */
/* our first item is <close> button */
iconw = gtk_image_new_from_stock (GTK_STOCK_QUIT, GTK_ICON_SIZE_SMALL_TOOLBAR) ; // ("gtk.xpm"); /* icon widget */
close_button =
gtk_toolbar_append_item( GTK_TOOLBAR (bdk_window.toolbar), /* our toolbar */
"Close", /* button label */
"Closes this app", /* this button's tooltip */
"Private", /* tooltip private info */
iconw, /* icon widget */
GTK_SIGNAL_FUNC (gtk_main_quit), /* a signal */
NULL);
gtk_box_pack_start (GTK_BOX (bdk_window.main_vbox), bdk_window.toolbar, FALSE, TRUE, 0);
}
static GtkWidget *
alleyoop_toolbar_new (Alleyoop *grind)
{
GtkWidget *toolbar, *image;
GtkToolbarChild *child;
toolbar = gtk_toolbar_new ();
image = gtk_image_new_from_stock (GTK_STOCK_EXECUTE, GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_widget_show (image);
gtk_toolbar_append_item ((GtkToolbar *) toolbar, _("Run"), _("Run Program"), NULL,
image, G_CALLBACK (file_run_cb), grind);
image = gtk_image_new_from_stock (GTK_STOCK_CANCEL, GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_widget_show (image);
gtk_toolbar_append_item ((GtkToolbar *) toolbar, _("Kill"), _("Kill Program"), NULL,
image, G_CALLBACK (file_kill_cb), grind);
gtk_toolbar_insert_stock ((GtkToolbar *) toolbar, GTK_STOCK_OPEN, _("Open Log File"),
NULL, G_CALLBACK (file_open_cb), grind, 2);
gtk_toolbar_insert_stock ((GtkToolbar *) toolbar, GTK_STOCK_SAVE, _("Save Log File"),
NULL, G_CALLBACK (file_save_cb), grind, 3);
gtk_widget_show (toolbar);
child = ((GtkToolbar *) toolbar)->children->data;
grind->toolbar_run = child->widget;
child = ((GtkToolbar *) toolbar)->children->next->data;
grind->toolbar_kill = child->widget;
return toolbar;
}
void GTKMusicBrowser::CreateToolbar(GtkWidget *vbox)
{
toolbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL,
GTK_TOOLBAR_BOTH);
gtk_toolbar_set_button_relief(GTK_TOOLBAR(toolbar), GTK_RELIEF_NONE);
gtk_toolbar_set_space_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_SPACE_LINE);
gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "New Playlist",
"Start Editing a new Playlist",
"Toolbar/New", NewPixmap(new_pic),
GTK_SIGNAL_FUNC(new_plist_tool), this);
gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Save Playlist",
"Save the Current Playlist to Disk",
"Toolbar/Save", NewPixmap(save_pic),
GTK_SIGNAL_FUNC(save_list_tool), this);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Import Items",
"Import a Playlist or Track into My Music",
"Toolbar/Import", NewPixmap(import_pic),
GTK_SIGNAL_FUNC(import_tool), this);
toolRemove = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Remove Track",
"Remove a Track from the Playlist",
"Toolbar/Remove", NewPixmap(trash_pic),
GTK_SIGNAL_FUNC(remove_tool), this);
gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Edit",
"Edit a Track or Playlist",
"Toolbar/Edit", NewPixmap(edit_pic),
GTK_SIGNAL_FUNC(edit_tool), this);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
addTrack = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Add Items",
"Add Music from My Music to the Playlist",
"Toolbar/AddItem", NewPixmap(add_track_pic),
GTK_SIGNAL_FUNC(add_track_tool), this);
addFile = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Add File",
"Add a File to the Playlist",
"Toolbar/Add", NewPixmap(add_file),
GTK_SIGNAL_FUNC(add_tool), this);
toolUp = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Move Up",
"Move The Currently Selected Track in the Playlist Up",
"Toolbar/Up", NewPixmap(up_pic),
GTK_SIGNAL_FUNC(move_up_tool), this);
toolDown = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Move Down",
"Move the Currently Selected Track in the Playlist Down",
"Toolbar/Down", NewPixmap(down_pic),
GTK_SIGNAL_FUNC(move_down_tool), this);
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, TRUE, 0);
SetToolbarType();
gtk_widget_show(toolbar);
}
void roadmap_main_add_tool (const char *label,
const char *icon,
const char *tip,
RoadMapCallback callback) {
if (RoadMapMainToolbar == NULL) {
RoadMapMainToolbar = gtk_toolbar_new ();
gtk_box_pack_start (GTK_BOX(RoadMapMainBox),
RoadMapMainToolbar, FALSE, FALSE, 0);
}
gtk_toolbar_append_item (GTK_TOOLBAR(RoadMapMainToolbar),
label, tip, NULL,
roadmap_main_toolbar_icon (icon),
(GtkSignalFunc) roadmap_main_activate, callback);
if (gdk_screen_height() < 550)
{
/* When using a small screen, we want either the labels or the icons,
* but not both (small screens are typical with PDAs).
*/
gtk_toolbar_set_style
(GTK_TOOLBAR(RoadMapMainToolbar),
GtkIconsInitialized?GTK_TOOLBAR_ICONS:GTK_TOOLBAR_TEXT);
}
}
GtkWidget *
gtk_utils_append_toolbar_button (GtkToolbar *toolbar,
GtkUtilsToolbarEntry *entry,
GtkUtilsToolbarButtonFlags flags,
gpointer user_data)
{
#if GTK_2_4_OR_LATER
GtkToolItem *button;
g_return_val_if_fail (entry, NULL);
button = gtk_tool_button_new ((gtk_image_new_from_stock
(entry->icon_stock_id,
gtk_toolbar_get_icon_size (toolbar))),
(entry->label_text
? _(entry->label_text) : NULL));
if (entry->tooltip_text) {
gtk_tool_item_set_tooltip (button, toolbar->tooltips,
_(entry->tooltip_text), NULL);
}
gtk_tool_item_set_homogeneous (button, ((flags & GTK_UTILS_HOMOGENEOUS)
? TRUE : FALSE));
gtk_tool_item_set_is_important (button, ((flags & GTK_UTILS_IS_IMPORTANT)
? TRUE : FALSE));
g_signal_connect (button, "clicked",
G_CALLBACK (invoke_toolbar_button_callback), user_data);
gtk_toolbar_insert (toolbar, button, -1);
#else
GtkWidget *button;
g_return_val_if_fail (entry, NULL);
UNUSED (flags);
button = (gtk_toolbar_append_item
(toolbar, (entry->label_text ? _(entry->label_text) : NULL),
_(entry->tooltip_text), NULL,
gtk_image_new_from_stock (entry->icon_stock_id,
gtk_toolbar_get_icon_size (toolbar)),
(GtkSignalFunc) invoke_toolbar_button_callback, user_data));
#endif
if (!toolbar_button_entry_quark) {
toolbar_button_entry_quark
= g_quark_from_static_string ("quarry-toolbar-button-entry");
}
g_object_set_qdata (G_OBJECT (button), toolbar_button_entry_quark, entry);
/* For GTK+ 2.4 and up. It is certainly a widget. */
return (GtkWidget *) button;
}
void
add_tool_button (GtkWidget * toolbar, gchar * name, gchar * description,
GtkWidget * icon, GtkSignalFunc button_clicked)
{
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), name, description, "",
icon, GTK_SIGNAL_FUNC (button_clicked),
GTK_OBJECT (toolbar));
}
static VALUE
rg_append(int argc, VALUE *argv, VALUE self)
{
GtkWidget* ret = NULL;
VALUE type = Qnil;
VALUE widget, stock_id, element_type, text, ttext, ptext, icon, func;
if (argc > 0) type = argv[0];
if (NIL_P(type) || TYPE(type) == T_STRING){
rb_scan_args(argc, argv, "05", &text, &ttext, &ptext, &icon, &func);
if (NIL_P(func)) func = rb_block_proc();
G_RELATIVE(self, func);
ret = gtk_toolbar_append_item(_SELF(self), N_RVAL2CSTR(text),
N_RVAL2CSTR(ttext), N_RVAL2CSTR(ptext),
N_RVAL2WIDGET(icon),
GTK_SIGNAL_FUNC(exec_callback),
(gpointer)func);
} else if (TYPE(type) == T_FIXNUM) {
rb_scan_args(argc, argv, "07", &element_type, &widget, &text, &ttext, &ptext, &icon, &func);
if (NIL_P(func)) func = rb_block_proc();
G_RELATIVE(self, func);
ret = gtk_toolbar_append_element(_SELF(self),
RVAL2GENUM(element_type, GTK_TYPE_TOOLBAR_CHILD_TYPE),
N_RVAL2WIDGET(widget), N_RVAL2CSTR(text),
N_RVAL2CSTR(ttext), N_RVAL2CSTR(ptext),
N_RVAL2WIDGET(icon),
GTK_SIGNAL_FUNC(exec_callback),
(gpointer)func);
if (RVAL2GENUM(element_type, GTK_TYPE_TOOLBAR_CHILD_TYPE) == GTK_TOOLBAR_CHILD_SPACE)
ret = NULL;
} else if (TYPE(type) == T_SYMBOL) {
rb_scan_args(argc, argv, "13", &stock_id, &ttext, &ptext, &func);
if (NIL_P(func)) func = rb_block_proc();
G_RELATIVE(self, func);
ret = gtk_toolbar_insert_stock(_SELF(self), rb_id2name(SYM2ID(stock_id)),
N_RVAL2CSTR(ttext), N_RVAL2CSTR(ptext),
GTK_SIGNAL_FUNC(exec_callback),
(gpointer)func, -1);
} else {
rb_scan_args(argc, argv, "12", &widget, &ttext, &ptext);
gtk_toolbar_append_widget(_SELF(self), GTK_WIDGET(RVAL2GOBJ(widget)),
N_RVAL2CSTR(ttext), N_RVAL2CSTR(ptext));
return widget;
}
return ret ? GOBJ2RVAL(ret) : Qnil;
}
/*! \todo Finish function documentation!!!
* \brief
* \par Function Description
*
*/
void x_window_create_main(GschemToplevel *w_current)
{
TOPLEVEL *toplevel = gschem_toplevel_get_toplevel (w_current);
GtkPolicyType policy;
GtkWidget *main_box=NULL;
GtkWidget *menubar=NULL;
GtkWidget *toolbar=NULL;
GtkWidget *handlebox=NULL;
GtkWidget *hscrollbar;
GtkWidget *vscrollbar;
GtkAdjustment *hadjustment;
GtkAdjustment *vadjustment;
char *right_button_text;
/* used to signify that the window isn't mapped yet */
w_current->window = NULL;
w_current->main_window = GTK_WIDGET (gschem_main_window_new ());
gtk_widget_set_name (w_current->main_window, "gschem");
gtk_window_set_policy (GTK_WINDOW (w_current->main_window), TRUE, TRUE, TRUE);
/* We want the widgets to flow around the drawing area, so we don't
* set a size of the main window. The drawing area's size is fixed,
* see below
*/
/*
* normally we let the window manager handle locating and sizing
* the window. However, for some batch processing of schematics
* (generating a pdf of all schematics for example) we want to
* override this. Hence "auto_place_mode".
*/
if( auto_place_mode )
gtk_widget_set_uposition (w_current->main_window, 10, 10);
/* this should work fine */
g_signal_connect (G_OBJECT (w_current->main_window), "delete_event",
G_CALLBACK (i_callback_close_wm),
w_current);
/* Containers first */
main_box = gtk_vbox_new(FALSE, 1);
gtk_container_border_width(GTK_CONTAINER(main_box), 0);
gtk_container_add(GTK_CONTAINER(w_current->main_window), main_box);
menubar = get_main_menu (w_current);
if (w_current->handleboxes) {
handlebox = gtk_handle_box_new ();
gtk_box_pack_start(GTK_BOX(main_box), handlebox, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (handlebox), menubar);
} else {
gtk_box_pack_start(GTK_BOX(main_box), menubar, FALSE, FALSE, 0);
}
w_current->menubar = menubar;
gtk_widget_realize (w_current->main_window);
if (w_current->handleboxes && w_current->toolbars) {
handlebox = gtk_handle_box_new ();
gtk_box_pack_start (GTK_BOX (main_box), handlebox, FALSE, FALSE, 0);
}
if (w_current->toolbars) {
toolbar = gtk_toolbar_new();
gtk_toolbar_set_orientation (GTK_TOOLBAR(toolbar),
GTK_ORIENTATION_HORIZONTAL);
gtk_toolbar_set_style (GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
if (w_current->handleboxes) {
gtk_container_add (GTK_CONTAINER (handlebox), toolbar);
} else {
gtk_box_pack_start(GTK_BOX(main_box), toolbar, FALSE, FALSE, 0);
}
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
_("New"),
_("New file"),
"toolbar/new",
x_window_stock_pixmap("new", w_current),
(GtkSignalFunc) i_callback_toolbar_file_new,
w_current);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
_("Open"),
_("Open file..."),
"toolbar/open",
x_window_stock_pixmap("open", w_current),
(GtkSignalFunc) i_callback_toolbar_file_open,
w_current);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
_("Save"),
_("Save file"),
"toolbar/save",
x_window_stock_pixmap("save", w_current),
(GtkSignalFunc) i_callback_toolbar_file_save,
w_current);
gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
_("Undo"),
_("Undo last operation"),
"toolbar/undo",
x_window_stock_pixmap("undo", w_current),
(GtkSignalFunc) i_callback_toolbar_edit_undo,
w_current);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
_("Redo"),
_("Redo last undo"),
"toolbar/redo",
x_window_stock_pixmap("redo", w_current),
(GtkSignalFunc) i_callback_toolbar_edit_redo,
w_current);
gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
/* not part of any radio button group */
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
_("Component"),
_("Add component...\nSelect library and component from list, move the mouse into main window, click to place\nRight mouse button to cancel"),
"toolbar/component",
x_window_stock_pixmap("insert-symbol", w_current),
(GtkSignalFunc) i_callback_toolbar_add_component,
w_current);
w_current->toolbar_net =
gtk_toolbar_append_element(GTK_TOOLBAR(toolbar),
GTK_TOOLBAR_CHILD_RADIOBUTTON,
NULL,
_("Nets"),
_("Add nets mode\nRight mouse button to cancel"),
"toolbar/nets",
x_window_stock_pixmap("insert-net", w_current),
(GtkSignalFunc) i_callback_toolbar_add_net,
w_current);
w_current->toolbar_bus =
gtk_toolbar_append_element(GTK_TOOLBAR(toolbar),
GTK_TOOLBAR_CHILD_RADIOBUTTON,
w_current->toolbar_net,
_("Bus"),
_("Add buses mode\nRight mouse button to cancel"),
"toolbar/bus",
x_window_stock_pixmap("insert-bus", w_current),
(GtkSignalFunc) i_callback_toolbar_add_bus,
w_current);
/* not part of any radio button group */
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
_("Text"),
_("Add Text..."),
"toolbar/text",
x_window_stock_pixmap("insert-text", w_current),
(GtkSignalFunc) i_callback_toolbar_add_text,
w_current);
gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
w_current->toolbar_select =
gtk_toolbar_append_element(GTK_TOOLBAR(toolbar),
GTK_TOOLBAR_CHILD_RADIOBUTTON,
w_current->toolbar_bus,
_("Select"),
_("Select mode"),
"toolbar/select",
x_window_stock_pixmap("select", w_current),
(GtkSignalFunc) i_callback_toolbar_edit_select,
w_current);
gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w_current->toolbar_select),
TRUE);
}
/* Try to create popup menu (appears in right mouse button */
w_current->popup_menu = (GtkWidget *) get_main_popup(w_current);
/* Setup a GtkScrolledWindow for the drawing area */
hadjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0.0,
0.0,
toplevel->init_right,
100.0,
100.0,
10.0));
vadjustment = GTK_ADJUSTMENT (gtk_adjustment_new (toplevel->init_bottom,
0.0,
toplevel->init_bottom,
100.0,
100.0,
10.0));
w_current->scrolled = gtk_scrolled_window_new (hadjustment, vadjustment);
gtk_container_add(GTK_CONTAINER(main_box), w_current->scrolled);
x_window_create_drawing(w_current->scrolled, w_current);
x_window_setup_draw_events(w_current);
policy = (w_current->scrollbars_flag) ? GTK_POLICY_ALWAYS : GTK_POLICY_NEVER;
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (w_current->scrolled), policy, policy);
hscrollbar = gtk_scrolled_window_get_hscrollbar (GTK_SCROLLED_WINDOW (w_current->scrolled));
gtk_range_set_update_policy (GTK_RANGE (hscrollbar), GTK_UPDATE_CONTINUOUS);
vscrollbar = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (w_current->scrolled));
gtk_range_set_update_policy (GTK_RANGE (vscrollbar), GTK_UPDATE_CONTINUOUS);
/* macro box */
w_current->macro_widget = GTK_WIDGET (g_object_new (GSCHEM_TYPE_MACRO_WIDGET, NULL));
gtk_box_pack_start (GTK_BOX (main_box),
w_current->macro_widget,
FALSE,
FALSE,
0);
g_signal_connect (w_current->macro_widget,
"response",
G_CALLBACK (&x_window_invoke_macro),
w_current);
/* bottom box */
if (default_third_button == POPUP_ENABLED) {
right_button_text = _("Menu/Cancel");
} else {
right_button_text = _("Pan/Cancel");
}
w_current->bottom_widget = GTK_WIDGET (g_object_new (GSCHEM_TYPE_BOTTOM_WIDGET,
"grid-mode", gschem_options_get_grid_mode (w_current->options),
"grid-size", gschem_options_get_snap_size (w_current->options), /* x_grid_query_drawn_spacing (w_current), -- occurs before the page is set */
"left-button-text", _("Pick"),
"middle-button-text", _("none"),
"right-button-text", right_button_text,
"snap-mode", gschem_options_get_snap_mode (w_current->options),
"snap-size", gschem_options_get_snap_size (w_current->options),
"status-text", _("Select Mode"),
NULL));
i_update_middle_button (w_current, NULL, NULL);
gtk_box_pack_start (GTK_BOX (main_box), w_current->bottom_widget, FALSE, FALSE, 0);
gtk_widget_show_all (w_current->main_window);
w_current->window = w_current->drawing_area->window;
w_current->drawable = w_current->window;
x_window_setup_gc(w_current);
}
GtkWidget*
get_viewer_toolbar(GtkWidget *parent)
{
GtkWidget *toolbar, *pixmap_wid, *button;
GdkPixmap *pixmap;
GdkBitmap *mask;
GtkStyle *style;
gboolean fit_screen;
style = gtk_widget_get_style(parent);
toolbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_ICONS);
gtk_tooltips_set_colors(
GTK_TOOLBAR(toolbar)->tooltips,
get_viewer_tooltips_bgcolor(parent->window, gdk_window_get_colormap(parent->window)),
&style->fg[GTK_STATE_NORMAL]);
gtk_tooltips_set_delay(GTK_TOOLBAR(toolbar)->tooltips, 100);
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)browse_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL, _("Browse"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_browse),
NULL);
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)fullscreen_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL, _("Full screen"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_full_screen),
NULL);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)save_image_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
saveimage_button = gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL, _("Save Image"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_save_image),
NULL);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)prev_image_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
prev_button = gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL, _("Previous Image"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_prev_image),
NULL);
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)next_image_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
next_button = gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL, _("Next Image"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_next_image),
NULL);
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)slideshow_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
slideshow_button = gtk_toolbar_append_element(
GTK_TOOLBAR(toolbar),
GTK_TOOLBAR_CHILD_TOGGLEBUTTON,
NULL,
NULL,
_("Stop/Resume Slideshow"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_slideshow_toggled),
NULL);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)refresh_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL, _("Refresh"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_refresh),
NULL);
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)screen_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
button = gtk_toolbar_append_element(
GTK_TOOLBAR(toolbar),
GTK_TOOLBAR_CHILD_TOGGLEBUTTON,
NULL,
NULL,
_("Fit Screen"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_fitscreen_toggled),
NULL);
fit_screen = rc_get_boolean("fit_screen");
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(button), fit_screen);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)rotate_left_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL,
_("Rotate -90"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_rotate),
(gint *) LEFT);
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)rotate_right_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL,
_("Rotate +90"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_rotate),
(gint *) RIGHT);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)right_left_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL,
_("Reflect Right/Left"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_reflect),
(gint *) RIGHTLEFT);
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)up_down_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL,
_("Reflect Up/Down"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(viewer_toolbar_reflect),
(gint *) UPDOWN);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
pixmap = gdk_pixmap_create_from_xpm_d(
parent->window,
&mask, &style->bg[GTK_STATE_NORMAL],
(gchar **)exit_xpm);
pixmap_wid = gtk_pixmap_new(pixmap, mask);
gtk_widget_show(pixmap_wid);
gtk_toolbar_append_item(
GTK_TOOLBAR(toolbar),
NULL,
_("Exit"), NULL,
pixmap_wid,
GTK_SIGNAL_FUNC(close_gtksee),
NULL);
return toolbar;
}
static GtkWidget *
gtk2perl_toolbar_insert_internal (GtkToolbar * toolbar,
SV * type,
SV * widget,
SV * text,
SV * tooltip_text,
SV * tooltip_private_text,
SV * icon,
SV * callback,
SV * user_data,
SV * position,
WhichInsert which,
WhichOp op)
{
GtkWidget * w = NULL;
const char * real_tooltip_text = NULL;
const char * real_tooltip_private_text = NULL;
/* _ornull is not always right for text, but is for the others. */
real_tooltip_text = SvGChar_ornull (tooltip_text);
real_tooltip_private_text = SvGChar_ornull (tooltip_private_text);
switch (which) {
case STOCK:
/* stock with NULL text (the stock id) makes no sense,
* so let's make sure perl will issue an uninitialized
* value warning for undef passed here for text. */
w = gtk_toolbar_insert_stock (toolbar, SvGChar (text),
real_tooltip_text,
real_tooltip_private_text,
NULL, NULL,
SvIV (position));
break;
case ITEM:
{
const gchar * real_text = SvGChar_ornull (text);
GtkWidget * real_icon = SvGtkWidget_ornull (icon);
switch (op) {
case PREPEND:
w = gtk_toolbar_prepend_item (toolbar, real_text,
real_tooltip_text,
real_tooltip_private_text,
real_icon, NULL, NULL);
break;
case APPEND:
w = gtk_toolbar_append_item (toolbar, real_text,
real_tooltip_text,
real_tooltip_private_text,
real_icon, NULL, NULL);
break;
case INSERT:
w = gtk_toolbar_insert_item (toolbar, real_text,
real_tooltip_text,
real_tooltip_private_text,
real_icon, NULL, NULL,
SvIV (position));
break;
default:
g_assert_not_reached ();
}
}
break;
case ELEMENT:
{
GtkToolbarChildType real_type = SvGtkToolbarChildType(type);
const gchar * real_text = SvGChar_ornull (text);
GtkWidget * real_widget = SvGtkWidget_ornull (widget);
GtkWidget * real_icon = SvGtkWidget_ornull (icon);
switch (op) {
case PREPEND:
w = gtk_toolbar_prepend_element (toolbar, real_type,
real_widget,
real_text,
real_tooltip_text,
real_tooltip_private_text,
real_icon,
NULL, NULL);
break;
case APPEND:
w = gtk_toolbar_append_element (toolbar, real_type,
real_widget,
real_text,
real_tooltip_text,
real_tooltip_private_text,
real_icon,
NULL, NULL);
break;
case INSERT:
w = gtk_toolbar_insert_element (toolbar, real_type,
real_widget,
real_text,
real_tooltip_text,
real_tooltip_private_text,
real_icon,
NULL, NULL,
SvIV (position));
break;
default:
g_assert_not_reached ();
}
}
break;
case WIDGET:
{
w = SvGtkWidget (widget);
switch (op) {
case PREPEND:
gtk_toolbar_prepend_widget (toolbar, w,
real_tooltip_text,
real_tooltip_private_text);
break;
case APPEND:
gtk_toolbar_append_widget (toolbar, w,
real_tooltip_text,
real_tooltip_private_text);
break;
case INSERT:
gtk_toolbar_insert_widget (toolbar, w,
real_tooltip_text,
real_tooltip_private_text,
SvIV (position));
break;
default:
g_assert_not_reached ();
}
}
break;
default:
g_assert_not_reached ();
}
if (gperl_sv_is_defined (callback))
gperl_signal_connect (newSVGtkWidget (w), "clicked",
callback, user_data, 0);
return w;
}
void
browser_create (void)
{
GtkWidget *vbox;
GdkPixmap *icon_pix;
GdkBitmap *icon_mask;
GtkAccelGroup *accel;
GtkWidget *menu;
GtkWidget *toolbar;
GtkWidget *hpaned;
GtkWidget *vpaned;
GtkWidget *iconw;
GtkWidget *hbox;
GtkWidget *label;
browser = g_new (Browser, 1);
browser->current_path = g_string_new (conf.startup_dir);
browser->last_path = g_string_new ("");
browser->filelist = (FileList *) file_list_init ();
browser->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (browser->window), "PornView");
gtk_widget_realize (browser->window);
icon_pix =
gdk_pixmap_create_from_xpm_d (G_WINDOW (browser->window), &icon_mask,
NULL, pornview_xpm);
gdk_window_set_icon (G_WINDOW (browser->window), NULL, icon_pix,
icon_mask);
gtk_signal_connect (GTK_OBJECT (browser->window), "delete_event",
GTK_SIGNAL_FUNC (browser_destroy), NULL);
gtk_window_set_default_size (GTK_WINDOW (browser->window),
conf.window_width, conf.window_height);
vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox);
gtk_container_add (GTK_CONTAINER (browser->window), vbox);
/*
* main menu
*/
accel = gtk_accel_group_new ();
browser->menu =
gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<browser_menu>", accel);
#ifdef ENABLE_NLS
gtk_item_factory_set_translate_func (browser->menu,
(GtkTranslateFunc) menu_translate,
NULL, NULL);
#endif
gtk_item_factory_create_items (browser->menu, browser_menu_factory_count,
browser_menu_factory, NULL);
menu = gtk_item_factory_get_widget (browser->menu, "<browser_menu>");
gtk_box_pack_start (GTK_BOX (vbox), menu, FALSE, FALSE, 0);
gtk_widget_show (menu);
#ifndef USE_GTK2
gtk_accel_group_attach (accel, GTK_OBJECT (browser->window));
#endif
/*
* toolbar
*/
#ifdef USE_GTK2
toolbar = gtk_toolbar_new ();
#else
toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_ICONS);
#endif
gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, TRUE, 0);
gtk_widget_show (toolbar);
iconw = pixbuf_create_pixmap_from_xpm_data (exit_xpm);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), NULL, _("Exit"), NULL,
iconw, (GtkSignalFunc) browser_destroy, NULL);
#ifndef USE_GTK2
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
#endif
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
iconw = pixbuf_create_pixmap_from_xpm_data (options_xpm);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), NULL, _("Preference"),
NULL, iconw, (GtkSignalFunc) browser_prefs,
NULL);
hpaned = gedo_hpaned_new ();
gtk_container_add (GTK_CONTAINER (vbox), hpaned);
gtk_widget_show (hpaned);
vpaned = gedo_vpaned_new ();
gtk_widget_show (vpaned);
gedo_paned_add1 (GEDO_PANED (hpaned), vpaned);
/*
* dirtree
*/
dirview_create (conf.startup_dir, browser->window);
gedo_paned_add1 (GEDO_PANED (vpaned), DIRVIEW_CONTAINER);
commentview = comment_view_create ();
browser->notebook = commentview->notebook;
/*
* videoplay
*/
#ifdef ENABLE_MOVIE
videoplay_create ();
label = gtk_label_new (_(" Preview "));
gtk_notebook_prepend_page (GTK_NOTEBOOK (browser->notebook),
VIDEOPLAY_CONTAINER, label);
gtk_notebook_set_page (GTK_NOTEBOOK (browser->notebook), 0);
#endif
/*
* imageview
*/
imageview_create ();
label = gtk_label_new (_(" Preview "));
gtk_notebook_prepend_page (GTK_NOTEBOOK (browser->notebook),
IMAGEVIEW_CONTAINER, label);
#ifndef ENABLE_MOVIE
gtk_notebook_set_page (GTK_NOTEBOOK (browser->notebook), 0);
#endif
gedo_paned_add2 (GEDO_PANED (hpaned), commentview->main_vbox);
/*
* thumbview
*/
thumbview_create (browser->window);
gedo_paned_add2 (GEDO_PANED (vpaned), THUMBVIEW_CONTAINER);
/*
* statusbar
*/
hbox = gtk_hbox_new (FALSE, 0);
gtk_widget_set_name (hbox, "StatusBarContainer");
gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
browser->status_dir = gtk_statusbar_new ();
gtk_widget_set_name (browser->status_dir, "StatusBar1");
gtk_container_border_width (GTK_CONTAINER (browser->status_dir), 1);
gtk_widget_set_usize (browser->status_dir, 80, 15);
gtk_box_pack_start (GTK_BOX (hbox), browser->status_dir, FALSE, FALSE, 0);
gtk_widget_show (browser->status_dir);
browser->status_name = gtk_statusbar_new ();
gtk_widget_set_name (browser->status_name, "StatusBar2");
gtk_container_border_width (GTK_CONTAINER (browser->status_name), 1);
gtk_widget_set_usize (browser->status_name, 150, -1);
gtk_box_pack_start (GTK_BOX (hbox), browser->status_name, TRUE, TRUE, 0);
gtk_widget_show (browser->status_name);
browser->status_image = gtk_statusbar_new ();
gtk_widget_set_name (browser->status_image, "StatusBar3");
gtk_container_border_width (GTK_CONTAINER (browser->status_image), 1);
gtk_widget_set_usize (browser->status_image, 150, -1);
gtk_box_pack_start (GTK_BOX (hbox), browser->status_image, TRUE, TRUE, 0);
gtk_widget_show (browser->status_image);
browser->progress = gtk_progress_bar_new ();
gtk_widget_set_name (browser->progress, "ProgressBar");
gtk_box_pack_end (GTK_BOX (hbox), browser->progress, FALSE, FALSE, 0);
gtk_widget_show (browser->progress);
gtk_widget_show (browser->window);
#ifdef ENABLE_MOVIE
gtk_widget_hide (gtk_notebook_get_nth_page
(GTK_NOTEBOOK (browser->notebook), 1));
gtk_notebook_set_page (GTK_NOTEBOOK (browser->notebook), 0);
#endif
dirview_scroll_center ();
timer_id = gtk_timeout_add (100, cb_browser_select_dir, conf.startup_dir);
}
static GtkWidget *
thumbview_create_toolbar (ThumbView * tv)
{
GtkWidget *toolbar;
GtkWidget *iconw;
g_return_val_if_fail (tv, NULL);
#ifdef USE_GTK2
toolbar = gtk_toolbar_new ();
#else
toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_ICONS);
gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NONE);
gtk_toolbar_set_space_style (GTK_TOOLBAR (toolbar),
GTK_TOOLBAR_SPACE_LINE);
gtk_toolbar_set_space_size (GTK_TOOLBAR (toolbar), 16);
#endif
/*
* refresh
*/
iconw = pixbuf_create_pixmap_from_xpm_data (refresh_xpm);
tv->toolbar_refresh_btn =
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), NULL,
_("Refresh"), NULL, iconw,
GTK_SIGNAL_FUNC (cb_thumbview_refresh), tv);
/*
* previous
*/
iconw = pixbuf_create_pixmap_from_xpm_data (left_xpm);
tv->toolbar_previous_btn =
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), NULL,
_("Previous Image/Movie"), NULL, iconw,
GTK_SIGNAL_FUNC (cb_thumbview_previous), tv);
/*
* next
*/
iconw = pixbuf_create_pixmap_from_xpm_data (right_xpm);
tv->toolbar_next_btn = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
NULL,
_("Next Image/Movie"),
NULL,
iconw,
GTK_SIGNAL_FUNC
(cb_thumbview_next), tv);
/*
* first
*/
iconw = pixbuf_create_pixmap_from_xpm_data (first_xpm);
tv->toolbar_first_btn =
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), NULL,
_("First Image/Movie"), NULL, iconw,
GTK_SIGNAL_FUNC (cb_thumbview_first), tv);
/*
* last
*/
iconw = pixbuf_create_pixmap_from_xpm_data (last_xpm);
tv->toolbar_last_btn = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
NULL,
_("Last Image/Movie"),
NULL,
iconw,
GTK_SIGNAL_FUNC
(cb_thumbview_last), tv);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
/*
* info
*/
iconw = pixbuf_create_pixmap_from_xpm_data (info_xpm);
tv->toolbar_info_btn = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
NULL,
_("Properties"),
NULL,
iconw,
GTK_SIGNAL_FUNC
(cb_thumbview_info), tv);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
/*
* view thumbs
*/
iconw = pixbuf_create_pixmap_from_xpm_data (view_thumbs_xpm);
tv->toolbar_thumbs_btn =
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), NULL,
_("View Thumbs"), NULL, iconw,
GTK_SIGNAL_FUNC
(cb_thumbview_toggle_mode), tv);
/*
* view list
*/
iconw = pixbuf_create_pixmap_from_xpm_data (view_list_xpm);
tv->toolbar_list_btn = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
NULL, _("View List"),
NULL, iconw,
GTK_SIGNAL_FUNC
(cb_thumbview_toggle_mode),
tv);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
/*
* view fullscreen
*/
iconw = pixbuf_create_pixmap_from_xpm_data (fullscreen_xpm);
tv->toolbar_view_btn = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
NULL,
_("Fullscreen"),
NULL, iconw,
GTK_SIGNAL_FUNC
(cb_thumbview_fullscreen_view),
tv);
/*
* slideshow
*/
iconw = pixbuf_create_pixmap_from_xpm_data (slideshow_xpm);
tv->toolbar_slideshow_btn =
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), NULL,
_("Slideshow"), NULL, iconw,
GTK_SIGNAL_FUNC
(cb_thumbview_slideshow_view), tv);
gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
/*
* no zoom
*/
iconw = pixbuf_create_pixmap_from_xpm_data (no_zoom_xpm);
tv->toolbar_no_zoom_btn =
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), NULL,
_("No Zoom"), NULL, iconw,
GTK_SIGNAL_FUNC (cb_thumbview_no_zoom), tv);
/*
* auto zoom
*/
iconw = pixbuf_create_pixmap_from_xpm_data (zoom_fit_xpm);
tv->toolbar_zoom_auto_btn =
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), NULL,
_("Auto Zoom"), NULL, iconw,
GTK_SIGNAL_FUNC (cb_thumbview_zoom_auto),
tv);
/*
* zoom in
*/
iconw = pixbuf_create_pixmap_from_xpm_data (zoom_in_xpm);
tv->toolbar_zoom_in_btn =
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), NULL,
_("Zoom In"), NULL, iconw,
GTK_SIGNAL_FUNC (cb_thumbview_zoom_in), tv);
/*
* zoom out
*/
iconw = pixbuf_create_pixmap_from_xpm_data (zoom_out_xpm);
tv->toolbar_zoom_out_btn =
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), NULL,
_("Zoom Out"), NULL, iconw,
GTK_SIGNAL_FUNC (cb_thumbview_zoom_out), tv);
gtk_widget_show_all (toolbar);
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
return toolbar;
}
int WebBrowserObject::BrowserOpen(void)
{
Lock();
if (!area.w) {
area.w = systemObject->configGetInt("video_width", systemObject->GetScreenWidth());
}
if (!area.h) {
area.h = systemObject->configGetInt("video_height", systemObject->GetScreenHeight());
}
if (!toplevel) {
toplevel = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_realize(toplevel);
gdk_window_set_decorations(toplevel->window, (GdkWMDecoration)0);
toplevelVBox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(toplevel), toplevelVBox);
mozilla = gtk_moz_embed_new();
gtk_moz_embed_set_chrome_mask(GTK_MOZ_EMBED(mozilla), GTK_MOZ_EMBED_FLAG_ALLCHROME);
toolbarHBox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(toplevelVBox), toolbarHBox, FALSE, FALSE, 0);
toolbar = gtk_toolbar_new();
g_object_ref(toolbar);
gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar), GTK_ORIENTATION_HORIZONTAL);
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_BOTH);
if (toolbar_flag) {
gtk_box_pack_start(GTK_BOX(toolbarHBox), toolbar, FALSE, FALSE, 0);
}
backButton = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Back", "Go Back", "Go Back", 0, GTK_SIGNAL_FUNC(back_clicked_cb), this);
stopButton = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Stop", "Stop", "Stop", 0, GTK_SIGNAL_FUNC(stop_clicked_cb), this);
forwardButton = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Forward", "Forward", "Forward", 0, GTK_SIGNAL_FUNC(forward_clicked_cb), this);
reloadButton = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Reload", "Reload", "Reload", 0, GTK_SIGNAL_FUNC(reload_clicked_cb), this);
closeButton = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Close", "Close window", "Close window", 0, GTK_SIGNAL_FUNC(close_clicked_cb), this);
urlEntry = gtk_entry_new();
g_object_ref(urlEntry);
if (toolbar_flag) {
gtk_box_pack_start(GTK_BOX(toolbarHBox), urlEntry, TRUE, TRUE, 0);
}
gtk_box_pack_start(GTK_BOX(toplevelVBox), mozilla, TRUE, TRUE, 0);
progressAreaHBox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(toplevelVBox), progressAreaHBox, FALSE, FALSE, 0);
progressBar = gtk_progress_bar_new();
gtk_box_pack_start(GTK_BOX(progressAreaHBox), progressBar, FALSE, FALSE, 0);
statusAlign = gtk_alignment_new(0, 0, 1, 1);
gtk_widget_set_usize(statusAlign, 1, -1);
statusBar = gtk_statusbar_new();
gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(statusBar), 0);
gtk_container_add(GTK_CONTAINER(statusAlign), statusBar);
gtk_box_pack_start(GTK_BOX(progressAreaHBox), statusAlign, TRUE, TRUE, 0);
gtk_widget_set_sensitive(closeButton, TRUE);
gtk_widget_set_sensitive(backButton, FALSE);
gtk_widget_set_sensitive(stopButton, FALSE);
gtk_widget_set_sensitive(forwardButton, FALSE);
gtk_widget_set_sensitive(reloadButton, FALSE);
gtk_signal_connect(GTK_OBJECT(urlEntry), "activate", GTK_SIGNAL_FUNC(url_activate_cb), this);
gtk_signal_connect(GTK_OBJECT(toplevel), "delete_event", GTK_SIGNAL_FUNC(delete_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "destroy", GTK_SIGNAL_FUNC(destroy_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "destroy_browser", GTK_SIGNAL_FUNC(destroy_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "title", GTK_SIGNAL_FUNC(title_changed_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "new_window", GTK_SIGNAL_FUNC(new_window_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "visibility", GTK_SIGNAL_FUNC(visibility_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "size_to", GTK_SIGNAL_FUNC(size_to_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "location", GTK_SIGNAL_FUNC(location_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "net_start", GTK_SIGNAL_FUNC(net_start_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "net_stop", GTK_SIGNAL_FUNC(net_stop_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "net_state", GTK_SIGNAL_FUNC(net_state_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "progress", GTK_SIGNAL_FUNC(progress_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "link_message", GTK_SIGNAL_FUNC(link_message_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "js_status", GTK_SIGNAL_FUNC(js_status_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "open_uri", GTK_SIGNAL_FUNC(open_uri_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "dom_key_down", GTK_SIGNAL_FUNC(dom_key_down_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "dom_key_up", GTK_SIGNAL_FUNC(dom_key_up_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "dom_mouse_down", GTK_SIGNAL_FUNC(dom_mouse_down_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "dom_mouse_up", GTK_SIGNAL_FUNC(dom_mouse_up_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "dom_key_press", GTK_SIGNAL_FUNC(dom_key_press_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "dom_mouse_click", GTK_SIGNAL_FUNC(dom_mouse_click_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "dom_mouse_dbl_click", GTK_SIGNAL_FUNC(dom_mouse_dbl_click_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "dom_mouse_over", GTK_SIGNAL_FUNC(dom_mouse_over_cb), this);
gtk_signal_connect(GTK_OBJECT(mozilla), "dom_mouse_out", GTK_SIGNAL_FUNC(dom_mouse_out_cb), this);
}
Unlock();
SetPosition(area.x, area.y, area.w, area.h);
SetVisible(1);
if (location) {
gtk_moz_embed_load_url(GTK_MOZ_EMBED(mozilla), location);
}
systemObject->RegisterExternalEventHandler(this);
return 0;
}
/*! \todo Finish function documentation!!!
* \brief
* \par Function Description
*
*/
void x_window_create_main(GSCHEM_TOPLEVEL *w_current)
{
TOPLEVEL *toplevel = w_current->toplevel;
GtkWidget *label=NULL;
GtkWidget *main_box=NULL;
GtkWidget *menubar=NULL;
GtkWidget *drawbox=NULL;
GtkWidget *bottom_box=NULL;
GtkWidget *toolbar=NULL;
GtkWidget *handlebox=NULL;
/* used to signify that the window isn't mapped yet */
w_current->window = NULL;
w_current->main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_name (w_current->main_window, "gschem");
gtk_window_set_policy (GTK_WINDOW (w_current->main_window), TRUE, TRUE, TRUE);
/* We want the widgets to flow around the drawing area, so we don't
* set a size of the main window. The drawing area's size is fixed,
* see below
*/
/*
* normally we let the window manager handle locating and sizing
* the window. However, for some batch processing of schematics
* (generating a pdf of all schematics for example) we want to
* override this. Hence "auto_place_mode".
*/
if( auto_place_mode )
gtk_widget_set_uposition (w_current->main_window, 10, 10);
/* this should work fine */
g_signal_connect (G_OBJECT (w_current->main_window), "delete_event",
G_CALLBACK (i_callback_close_wm),
w_current);
/* Containers first */
main_box = gtk_vbox_new(FALSE, 1);
gtk_container_border_width(GTK_CONTAINER(main_box), 0);
gtk_container_add(GTK_CONTAINER(w_current->main_window), main_box);
menubar = get_main_menu (w_current);
if (w_current->handleboxes) {
handlebox = gtk_handle_box_new ();
gtk_box_pack_start(GTK_BOX(main_box), handlebox, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (handlebox), menubar);
} else {
gtk_box_pack_start(GTK_BOX(main_box), menubar, FALSE, FALSE, 0);
}
w_current->menubar = menubar;
gtk_widget_realize (w_current->main_window);
if (w_current->handleboxes && w_current->toolbars) {
handlebox = gtk_handle_box_new ();
gtk_box_pack_start (GTK_BOX (main_box), handlebox, FALSE, FALSE, 0);
}
if (w_current->toolbars) {
toolbar = gtk_toolbar_new();
gtk_toolbar_set_orientation (GTK_TOOLBAR(toolbar),
GTK_ORIENTATION_HORIZONTAL);
gtk_toolbar_set_style (GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
if (w_current->handleboxes) {
gtk_container_add (GTK_CONTAINER (handlebox), toolbar);
} else {
gtk_box_pack_start(GTK_BOX(main_box), toolbar, FALSE, FALSE, 0);
}
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
_("New"),
_("New file"),
"toolbar/new",
x_window_stock_pixmap("new", w_current),
(GtkSignalFunc) i_callback_toolbar_file_new,
w_current);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
_("Open"),
_("Open file..."),
"toolbar/open",
x_window_stock_pixmap("open", w_current),
(GtkSignalFunc) i_callback_toolbar_file_open,
w_current);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
_("Save"),
_("Save file"),
"toolbar/save",
x_window_stock_pixmap("save", w_current),
(GtkSignalFunc) i_callback_toolbar_file_save,
w_current);
gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
_("Undo"),
_("Undo last operation"),
"toolbar/undo",
x_window_stock_pixmap("undo", w_current),
(GtkSignalFunc) i_callback_toolbar_edit_undo,
w_current);
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
_("Redo"),
_("Redo last undo"),
"toolbar/redo",
x_window_stock_pixmap("redo", w_current),
(GtkSignalFunc) i_callback_toolbar_edit_redo,
w_current);
gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
/* not part of any radio button group */
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
_("Component"),
_("Add component...\nSelect library and component from list, move the mouse into main window, click to place\nRight mouse button to cancel"),
"toolbar/component",
x_window_stock_pixmap("comp", w_current),
(GtkSignalFunc) i_callback_toolbar_add_component,
w_current);
w_current->toolbar_net =
gtk_toolbar_append_element(GTK_TOOLBAR(toolbar),
GTK_TOOLBAR_CHILD_RADIOBUTTON,
NULL,
_("Nets"),
_("Add nets mode\nRight mouse button to cancel"),
"toolbar/nets",
x_window_stock_pixmap("net", w_current),
(GtkSignalFunc) i_callback_toolbar_add_net,
w_current);
w_current->toolbar_bus =
gtk_toolbar_append_element(GTK_TOOLBAR(toolbar),
GTK_TOOLBAR_CHILD_RADIOBUTTON,
w_current->toolbar_net,
_("Bus"),
_("Add buses mode\nRight mouse button to cancel"),
"toolbar/bus",
x_window_stock_pixmap("bus", w_current),
(GtkSignalFunc) i_callback_toolbar_add_bus,
w_current);
/* not part of any radio button group */
gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
_("Text"),
_("Add Text..."),
"toolbar/text",
x_window_stock_pixmap("text", w_current),
(GtkSignalFunc) i_callback_toolbar_add_text,
w_current);
gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
w_current->toolbar_select =
gtk_toolbar_append_element(GTK_TOOLBAR(toolbar),
GTK_TOOLBAR_CHILD_RADIOBUTTON,
w_current->toolbar_bus,
_("Select"),
_("Select mode"),
"toolbar/select",
x_window_stock_pixmap("select", w_current),
(GtkSignalFunc) i_callback_toolbar_edit_select,
w_current);
gtk_toolbar_append_space (GTK_TOOLBAR(toolbar));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w_current->toolbar_select),
TRUE);
}
/* Try to create popup menu (appears in right mouse button */
w_current->popup_menu = (GtkWidget *) get_main_popup(w_current);
drawbox = gtk_hbox_new(FALSE, 0);
gtk_container_border_width(GTK_CONTAINER(drawbox), 0);
gtk_container_add(GTK_CONTAINER(main_box), drawbox);
x_window_create_drawing(drawbox, w_current);
x_window_setup_draw_events(w_current);
if (w_current->scrollbars_flag == TRUE) {
/* setup scroll bars */
w_current->v_adjustment = GTK_ADJUSTMENT (
gtk_adjustment_new (toplevel->init_bottom, 0.0, toplevel->init_bottom,
100.0, 100.0, 10.0));
w_current->v_scrollbar = gtk_vscrollbar_new (w_current->v_adjustment);
gtk_range_set_update_policy (GTK_RANGE (w_current->v_scrollbar),
GTK_UPDATE_CONTINUOUS);
gtk_box_pack_start (GTK_BOX (drawbox), w_current->v_scrollbar,
FALSE, FALSE, 0);
g_signal_connect (w_current->v_adjustment,
"value_changed",
G_CALLBACK (x_event_vschanged),
w_current);
w_current->h_adjustment = GTK_ADJUSTMENT (
gtk_adjustment_new (0.0, 0.0, toplevel->init_right, 100.0, 100.0, 10.0));
w_current->h_scrollbar = gtk_hscrollbar_new (w_current->h_adjustment);
gtk_range_set_update_policy (GTK_RANGE (w_current->h_scrollbar),
GTK_UPDATE_CONTINUOUS);
gtk_box_pack_start (GTK_BOX (main_box), w_current->h_scrollbar,
FALSE, FALSE, 0);
g_signal_connect (w_current->h_adjustment,
"value_changed",
G_CALLBACK (x_event_hschanged),
w_current);
}
/* macro box */
w_current->macro_entry = gtk_entry_new();
g_signal_connect(w_current->macro_entry, "activate",
G_CALLBACK(&x_window_invoke_macro), w_current);
w_current->macro_box = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(w_current->macro_box), w_current->macro_entry,
TRUE, TRUE, 2);
gtk_container_border_width(GTK_CONTAINER(w_current->macro_box), 1);
gtk_box_pack_start (GTK_BOX (main_box), w_current->macro_box,
FALSE, FALSE, 0);
/* bottom box */
bottom_box = gtk_hbox_new(FALSE, 0);
gtk_container_border_width(GTK_CONTAINER(bottom_box), 1);
gtk_box_pack_start (GTK_BOX (main_box), bottom_box, FALSE, FALSE, 0);
/* label = gtk_label_new ("Mouse buttons:");
gtk_box_pack_start (GTK_BOX (bottom_box), label, FALSE, FALSE, 10);
*/
label = gtk_label_new (" ");
gtk_box_pack_start (GTK_BOX (bottom_box), label, FALSE, FALSE, 2);
w_current->left_label = gtk_label_new (_("Pick"));
gtk_box_pack_start (GTK_BOX (bottom_box), w_current->left_label,
FALSE, FALSE, 0);
label = gtk_label_new ("|");
gtk_box_pack_start (GTK_BOX (bottom_box), label, FALSE, FALSE, 5);
if (w_current->middle_button == STROKE) {
#ifdef HAVE_LIBSTROKE
w_current->middle_label = gtk_label_new (_("Stroke"));
#else
w_current->middle_label = gtk_label_new (_("none"));
#endif
} else if (w_current->middle_button == ACTION) {
w_current->middle_label = gtk_label_new (_("Action"));
} else {
w_current->middle_label = gtk_label_new (_("Repeat/none"));
}
gtk_box_pack_start (GTK_BOX (bottom_box), w_current->middle_label,
FALSE, FALSE, 0);
label = gtk_label_new ("|");
gtk_box_pack_start (GTK_BOX (bottom_box), label, FALSE, FALSE, 5);
if (default_third_button == POPUP_ENABLED) {
w_current->right_label = gtk_label_new (_("Menu/Cancel"));
} else {
w_current->right_label = gtk_label_new (_("Pan/Cancel"));
}
gtk_box_pack_start (GTK_BOX (bottom_box), w_current->right_label,
FALSE, FALSE, 0);
label = gtk_label_new (" ");
gtk_box_pack_start (GTK_BOX (bottom_box), label, FALSE, FALSE, 5);
w_current->grid_label = gtk_label_new (" ");
gtk_box_pack_start (GTK_BOX (bottom_box), w_current->grid_label,
FALSE, FALSE, 10);
w_current->status_label = gtk_label_new (_("Select Mode"));
gtk_box_pack_end (GTK_BOX (bottom_box), w_current->status_label, FALSE,
FALSE, 10);
gtk_widget_show_all (w_current->main_window);
gtk_widget_hide(w_current->macro_box);
w_current->window = w_current->drawing_area->window;
w_current->drawable = w_current->window;
x_window_setup_gc(w_current);
}
static void
init_chat_window_body(GtkWidget *vbox, HybridChatWindow *chat)
{
GtkWidget *scroll;
GtkWidget *button;
GtkWidget *image_icon;
GtkWidget *limit_label;
GtkTextBuffer *send_buffer;
gchar *word_limit_string;
gint word_limit;
HybridAccount *account;
HybridModule *module;
HybridIMOps *ops;
g_return_if_fail(vbox != NULL);
g_return_if_fail(chat != NULL);
/* create buddy tips panel */
create_buddy_tips_panel(vbox, chat);
/* create textview */
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(vbox), scroll, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll),
GTK_SHADOW_ETCHED_IN);
chat->textview = text_ops->create();
g_signal_connect(chat->textview, "focus-in-event",
GTK_SIGNAL_FUNC(focus_in_cb), chat);
gtk_container_add(GTK_CONTAINER(scroll), chat->textview);
/* create toolbar */
chat->toolbar = gtk_toolbar_new();
gtk_toolbar_set_style(GTK_TOOLBAR(chat->toolbar), GTK_TOOLBAR_ICONS);
gtk_box_pack_start(GTK_BOX(vbox), chat->toolbar, FALSE, FALSE, 0);
image_icon = gtk_image_new_from_file(PIXMAPS_DIR"menus/logs.png");
button = gtk_toolbar_append_item(GTK_TOOLBAR(chat->toolbar),
_("Chat logs"), _("View chat logs"), NULL, image_icon,
NULL, NULL);
if (IS_SYSTEM_CHAT(chat)) {
gtk_toolbar_append_space(GTK_TOOLBAR(chat->toolbar));
image_icon = gtk_image_new_from_file(PIXMAPS_DIR"menus/nudge.png");
button = gtk_toolbar_append_item(GTK_TOOLBAR(chat->toolbar),
_("Screen jitter"), _("Send a screen jitter"), NULL,
image_icon, NULL, NULL);
gtk_toolbar_append_space(GTK_TOOLBAR(chat->toolbar));
account = chat->account;
module = account->proto;
ops = module->info->im_ops;
if (ops->chat_word_limit &&
(word_limit = ops->chat_word_limit(account)) > 0) {
word_limit_string =
g_strdup_printf(_("Total %d character, left "), word_limit);
limit_label = gtk_label_new(word_limit_string);
g_free(word_limit_string);
word_limit_string =
g_strdup_printf(_("[<span color='#0099ff'>%d</span>] characters"),
word_limit);
chat->words_left_label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(chat->words_left_label), word_limit_string);
g_free(word_limit_string);
gtk_container_add(GTK_CONTAINER(chat->toolbar), limit_label);
gtk_container_add(GTK_CONTAINER(chat->toolbar), chat->words_left_label);
}
}
gtk_widget_show_all(chat->toolbar);
/* create textview */
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(vbox), scroll, FALSE, FALSE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll),
GTK_SHADOW_ETCHED_IN);
chat->sendtext = gtk_text_view_new();
gtk_widget_set_size_request(chat->sendtext, 0, 80);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(chat->sendtext),
GTK_WRAP_WORD_CHAR);
gtk_container_add(GTK_CONTAINER(scroll), chat->sendtext);
g_signal_connect(chat->sendtext, "key_press_event",
G_CALLBACK(key_pressed_cb), chat->parent);
g_signal_connect(chat->sendtext, "focus-in-event",
GTK_SIGNAL_FUNC(focus_in_cb), chat);
send_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(chat->sendtext));
g_signal_connect(send_buffer, "changed",
G_CALLBACK(sendtext_buffer_changed), chat);
gtk_window_present(GTK_WINDOW(chat->parent->window));
/* focus the send textview */
GTK_WIDGET_SET_FLAGS(chat->sendtext, GTK_CAN_FOCUS);
gtk_widget_grab_focus(chat->sendtext);
gtk_widget_show_all(scroll);
gtk_widget_show_all(vbox);
}
static TestGtkBrowser *
new_gtk_browser(guint32 chromeMask)
{
guint32 actualChromeMask = chromeMask;
TestGtkBrowser *browser = 0;
num_browsers++;
browser = g_new0(TestGtkBrowser, 1);
browser_list = g_list_prepend(browser_list, browser);
browser->menuBarOn = FALSE;
browser->toolBarOn = FALSE;
browser->locationBarOn = FALSE;
browser->statusBarOn = FALSE;
g_print("new_gtk_browser\n");
if (chromeMask == GTK_MOZ_EMBED_FLAG_DEFAULTCHROME)
actualChromeMask = GTK_MOZ_EMBED_FLAG_ALLCHROME;
if (actualChromeMask & GTK_MOZ_EMBED_FLAG_MENUBARON)
{
browser->menuBarOn = TRUE;
g_print("\tmenu bar\n");
}
if (actualChromeMask & GTK_MOZ_EMBED_FLAG_TOOLBARON)
{
browser->toolBarOn = TRUE;
g_print("\ttool bar\n");
}
if (actualChromeMask & GTK_MOZ_EMBED_FLAG_LOCATIONBARON)
{
browser->locationBarOn = TRUE;
g_print("\tlocation bar\n");
}
if (actualChromeMask & GTK_MOZ_EMBED_FLAG_STATUSBARON)
{
browser->statusBarOn = TRUE;
g_print("\tstatus bar\n");
}
// create our new toplevel window
browser->topLevelWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
// new vbox
browser->topLevelVBox = gtk_vbox_new(FALSE, 0);
// add it to the toplevel window
gtk_container_add(GTK_CONTAINER(browser->topLevelWindow),
browser->topLevelVBox);
// create our menu bar
browser->menuBar = gtk_menu_bar_new();
// create the file menu
browser->fileMenuItem = gtk_menu_item_new_with_label("File");
browser->fileMenu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM(browser->fileMenuItem),
browser->fileMenu);
browser->fileOpenNewBrowser =
gtk_menu_item_new_with_label("Open New Browser");
gtk_menu_append(GTK_MENU(browser->fileMenu),
browser->fileOpenNewBrowser);
browser->fileStream =
gtk_menu_item_new_with_label("Test Stream");
gtk_menu_append(GTK_MENU(browser->fileMenu),
browser->fileStream);
browser->fileClose =
gtk_menu_item_new_with_label("Close");
gtk_menu_append(GTK_MENU(browser->fileMenu),
browser->fileClose);
browser->fileQuit =
gtk_menu_item_new_with_label("Quit");
gtk_menu_append(GTK_MENU(browser->fileMenu),
browser->fileQuit);
// append it
gtk_menu_bar_append(GTK_MENU_BAR(browser->menuBar), browser->fileMenuItem);
// add it to the vbox
gtk_box_pack_start(GTK_BOX(browser->topLevelVBox),
browser->menuBar,
FALSE, // expand
FALSE, // fill
0); // padding
// create the hbox that will contain the toolbar and the url text entry bar
browser->toolbarHBox = gtk_hbox_new(FALSE, 0);
// add that hbox to the vbox
gtk_box_pack_start(GTK_BOX(browser->topLevelVBox),
browser->toolbarHBox,
FALSE, // expand
FALSE, // fill
0); // padding
// new horiz toolbar with buttons + icons
#ifdef MOZ_WIDGET_GTK
browser->toolbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL,
GTK_TOOLBAR_BOTH);
#endif /* MOZ_WIDGET_GTK */
#ifdef MOZ_WIDGET_GTK2
browser->toolbar = gtk_toolbar_new();
gtk_toolbar_set_orientation(GTK_TOOLBAR(browser->toolbar),
GTK_ORIENTATION_HORIZONTAL);
gtk_toolbar_set_style(GTK_TOOLBAR(browser->toolbar),
GTK_TOOLBAR_BOTH);
#endif /* MOZ_WIDGET_GTK2 */
// add it to the hbox
gtk_box_pack_start(GTK_BOX(browser->toolbarHBox), browser->toolbar,
FALSE, // expand
FALSE, // fill
0); // padding
// new back button
browser->backButton =
gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
"Back",
"Go Back",
"Go Back",
0, // XXX replace with icon
GTK_SIGNAL_FUNC(back_clicked_cb),
browser);
// new stop button
browser->stopButton =
gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
"Stop",
"Stop",
"Stop",
0, // XXX replace with icon
GTK_SIGNAL_FUNC(stop_clicked_cb),
browser);
// new forward button
browser->forwardButton =
gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
"Forward",
"Forward",
"Forward",
0, // XXX replace with icon
GTK_SIGNAL_FUNC(forward_clicked_cb),
browser);
// new reload button
browser->reloadButton =
gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
"Reload",
"Reload",
"Reload",
0, // XXX replace with icon
GTK_SIGNAL_FUNC(reload_clicked_cb),
browser);
// create the url text entry
browser->urlEntry = gtk_entry_new();
// add it to the hbox
gtk_box_pack_start(GTK_BOX(browser->toolbarHBox), browser->urlEntry,
TRUE, // expand
TRUE, // fill
0); // padding
// create our new gtk moz embed widget
browser->mozEmbed = gtk_moz_embed_new();
// add it to the toplevel vbox
gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), browser->mozEmbed,
TRUE, // expand
TRUE, // fill
0); // padding
// create the new hbox for the progress area
browser->progressAreaHBox = gtk_hbox_new(FALSE, 0);
// add it to the vbox
gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), browser->progressAreaHBox,
FALSE, // expand
FALSE, // fill
0); // padding
// create our new progress bar
browser->progressBar = gtk_progress_bar_new();
// add it to the hbox
gtk_box_pack_start(GTK_BOX(browser->progressAreaHBox), browser->progressBar,
FALSE, // expand
FALSE, // fill
0); // padding
// create our status area and the alignment object that will keep it
// from expanding
browser->statusAlign = gtk_alignment_new(0, 0, 1, 1);
gtk_widget_set_usize(browser->statusAlign, 1, -1);
// create the status bar
browser->statusBar = gtk_statusbar_new();
gtk_container_add(GTK_CONTAINER(browser->statusAlign), browser->statusBar);
// add it to the hbox
gtk_box_pack_start(GTK_BOX(browser->progressAreaHBox), browser->statusAlign,
TRUE, // expand
TRUE, // fill
0); // padding
// by default none of the buttons are marked as sensitive.
gtk_widget_set_sensitive(browser->backButton, FALSE);
gtk_widget_set_sensitive(browser->stopButton, FALSE);
gtk_widget_set_sensitive(browser->forwardButton, FALSE);
gtk_widget_set_sensitive(browser->reloadButton, FALSE);
// catch the destruction of the toplevel window
gtk_signal_connect(GTK_OBJECT(browser->topLevelWindow), "delete_event",
GTK_SIGNAL_FUNC(delete_cb), browser);
// hook up the activate signal to the right callback
gtk_signal_connect(GTK_OBJECT(browser->urlEntry), "activate",
GTK_SIGNAL_FUNC(url_activate_cb), browser);
// hook up to the open new browser activation
gtk_signal_connect(GTK_OBJECT(browser->fileOpenNewBrowser), "activate",
GTK_SIGNAL_FUNC(menu_open_new_cb), browser);
// hook up to the stream test
gtk_signal_connect(GTK_OBJECT(browser->fileStream), "activate",
GTK_SIGNAL_FUNC(menu_stream_cb), browser);
// close this window
gtk_signal_connect(GTK_OBJECT(browser->fileClose), "activate",
GTK_SIGNAL_FUNC(menu_close_cb), browser);
// quit the application
gtk_signal_connect(GTK_OBJECT(browser->fileQuit), "activate",
GTK_SIGNAL_FUNC(menu_quit_cb), browser);
// hook up the location change to update the urlEntry
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "location",
GTK_SIGNAL_FUNC(location_changed_cb), browser);
// hook up the title change to update the window title
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "title",
GTK_SIGNAL_FUNC(title_changed_cb), browser);
// hook up the start and stop signals
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_start",
GTK_SIGNAL_FUNC(load_started_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_stop",
GTK_SIGNAL_FUNC(load_finished_cb), browser);
// hook up to the change in network status
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_state",
GTK_SIGNAL_FUNC(net_state_change_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_state_all",
GTK_SIGNAL_FUNC(net_state_change_all_cb), browser);
// hookup to changes in progress
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "progress",
GTK_SIGNAL_FUNC(progress_change_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "progress_all",
GTK_SIGNAL_FUNC(progress_change_all_cb), browser);
// hookup to changes in over-link message
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "link_message",
GTK_SIGNAL_FUNC(link_message_cb), browser);
// hookup to changes in js status message
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "js_status",
GTK_SIGNAL_FUNC(js_status_cb), browser);
// hookup to see whenever a new window is requested
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "new_window",
GTK_SIGNAL_FUNC(new_window_cb), browser);
// hookup to any requested visibility changes
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "visibility",
GTK_SIGNAL_FUNC(visibility_cb), browser);
// hookup to the signal that says that the browser requested to be
// destroyed
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "destroy_browser",
GTK_SIGNAL_FUNC(destroy_brsr_cb), browser);
// hookup to the signal that is called when someone clicks on a link
// to load a new uri
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "open_uri",
GTK_SIGNAL_FUNC(open_uri_cb), browser);
// this signal is emitted when there's a request to change the
// containing browser window to a certain height, like with width
// and height args for a window.open in javascript
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "size_to",
GTK_SIGNAL_FUNC(size_to_cb), browser);
// key event signals
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_key_down",
GTK_SIGNAL_FUNC(dom_key_down_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_key_press",
GTK_SIGNAL_FUNC(dom_key_press_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_key_up",
GTK_SIGNAL_FUNC(dom_key_up_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_down",
GTK_SIGNAL_FUNC(dom_mouse_down_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_up",
GTK_SIGNAL_FUNC(dom_mouse_up_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_click",
GTK_SIGNAL_FUNC(dom_mouse_click_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_dbl_click",
GTK_SIGNAL_FUNC(dom_mouse_dbl_click_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_over",
GTK_SIGNAL_FUNC(dom_mouse_over_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_out",
GTK_SIGNAL_FUNC(dom_mouse_out_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_activate",
GTK_SIGNAL_FUNC(dom_activate_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_focus_in",
GTK_SIGNAL_FUNC(dom_focus_in_cb), browser);
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_focus_out",
GTK_SIGNAL_FUNC(dom_focus_out_cb), browser);
// hookup to when the window is destroyed
gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "destroy",
GTK_SIGNAL_FUNC(destroy_cb), browser);
// set the chrome type so it's stored in the object
gtk_moz_embed_set_chrome_mask(GTK_MOZ_EMBED(browser->mozEmbed),
actualChromeMask);
return browser;
}
GtkBrowser *
new_gtk_browser(guint32 chromeMask)
{
guint32 actualChromeMask = chromeMask;
GtkBrowser *browser = 0;
browser = g_new0(GtkBrowser, 1);
browser->menuBarOn = FALSE;
browser->toolBarOn = FALSE;
browser->locationBarOn = FALSE;
browser->statusBarOn = FALSE;
g_print("new_gtk_browser\n");
if (chromeMask == GTK_MOZ_EMBED_FLAG_DEFAULTCHROME)
actualChromeMask = GTK_MOZ_EMBED_FLAG_ALLCHROME;
if (actualChromeMask & GTK_MOZ_EMBED_FLAG_MENUBARON)
{
browser->menuBarOn = TRUE;
g_print("\tmenu bar\n");
}
if (actualChromeMask & GTK_MOZ_EMBED_FLAG_TOOLBARON)
{
browser->toolBarOn = TRUE;
g_print("\ttool bar\n");
}
if (actualChromeMask & GTK_MOZ_EMBED_FLAG_LOCATIONBARON)
{
browser->locationBarOn = TRUE;
g_print("\tlocation bar\n");
}
if (actualChromeMask & GTK_MOZ_EMBED_FLAG_STATUSBARON)
{
browser->statusBarOn = TRUE;
g_print("\tstatus bar\n");
}
// create our new toplevel window
browser->topLevelWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
// new vbox
browser->topLevelVBox = gtk_vbox_new(FALSE, 0);
// add it to the toplevel window
gtk_container_add(GTK_CONTAINER(browser->topLevelWindow),
browser->topLevelVBox);
// create our menu bar
browser->menuBar = gtk_menu_bar_new();
// create the file menu
browser->fileMenuItem = gtk_menu_item_new_with_label("File");
browser->fileMenu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM(browser->fileMenuItem),
browser->fileMenu);
browser->fileClose =
gtk_menu_item_new_with_label("Close");
gtk_menu_append(GTK_MENU(browser->fileMenu),
browser->fileClose);
// append it
gtk_menu_bar_append(GTK_MENU_BAR(browser->menuBar), browser->fileMenuItem);
// add it to the vbox
gtk_box_pack_start(GTK_BOX(browser->topLevelVBox),
browser->menuBar,
FALSE, // expand
FALSE, // fill
0); // padding
// create the hbox that will contain the toolbar and the url text entry bar
browser->toolbarHBox = gtk_hbox_new(FALSE, 0);
// add that hbox to the vbox
gtk_box_pack_start(GTK_BOX(browser->topLevelVBox),
browser->toolbarHBox,
FALSE, // expand
FALSE, // fill
0); // padding
// new horiz toolbar with buttons + icons
#ifdef MOZ_WIDGET_GTK
browser->toolbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL,
GTK_TOOLBAR_BOTH);
#endif /* MOZ_WIDGET_GTK */
#ifdef MOZ_WIDGET_GTK2
browser->toolbar = gtk_toolbar_new();
gtk_toolbar_set_orientation(GTK_TOOLBAR(browser->toolbar),
GTK_ORIENTATION_HORIZONTAL);
gtk_toolbar_set_style(GTK_TOOLBAR(browser->toolbar),
GTK_TOOLBAR_BOTH);
#endif /* MOZ_WIDGET_GTK2 */
// add it to the hbox
gtk_box_pack_start(GTK_BOX(browser->toolbarHBox), browser->toolbar,
FALSE, // expand
FALSE, // fill
0); // padding
// new back button
browser->backButton =
gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
"Back",
"Go Back",
"Go Back",
0, // XXX replace with icon
GTK_SIGNAL_FUNC(back_clicked_cb),
browser);
// new stop button
browser->stopButton =
gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
"Stop",
"Stop",
"Stop",
0, // XXX replace with icon
GTK_SIGNAL_FUNC(stop_clicked_cb),
browser);
// new forward button
browser->forwardButton =
gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
"Forward",
"Forward",
"Forward",
0, // XXX replace with icon
GTK_SIGNAL_FUNC(forward_clicked_cb),
browser);
// new reload button
browser->reloadButton =
gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
"Reload",
"Reload",
"Reload",
0, // XXX replace with icon
GTK_SIGNAL_FUNC(reload_clicked_cb),
browser);
// create the url text entry
browser->urlEntry = gtk_entry_new();
// add it to the hbox
gtk_box_pack_start(GTK_BOX(browser->toolbarHBox), browser->urlEntry,
TRUE, // expand
TRUE, // fill
0); // padding
// create our new gtk moz embed widget
browser->mozEmbed = gtk_moz_embed_new();
// add it to the toplevel vbox
gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), browser->mozEmbed,
TRUE, // expand
TRUE, // fill
0); // padding
// create the new hbox for the progress area
browser->progressAreaHBox = gtk_hbox_new(FALSE, 0);
// add it to the vbox
gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), browser->progressAreaHBox,
FALSE, // expand
FALSE, // fill
0); // padding
// create our new progress bar
browser->progressBar = gtk_progress_bar_new();
// add it to the hbox
gtk_box_pack_start(GTK_BOX(browser->progressAreaHBox), browser->progressBar,
FALSE, // expand
FALSE, // fill
0); // padding
// create our status area and the alignment object that will keep it
// from expanding
browser->statusAlign = gtk_alignment_new(0, 0, 1, 1);
gtk_widget_set_usize(browser->statusAlign, 1, -1);
// create the status bar
browser->statusBar = gtk_statusbar_new();
gtk_container_add(GTK_CONTAINER(browser->statusAlign), browser->statusBar);
// add it to the hbox
gtk_box_pack_start(GTK_BOX(browser->progressAreaHBox), browser->statusAlign,
TRUE, // expand
TRUE, // fill
0); // padding
// by default none of the buttons are marked as sensitive.
gtk_widget_set_sensitive(browser->backButton, FALSE);
gtk_widget_set_sensitive(browser->stopButton, FALSE);
gtk_widget_set_sensitive(browser->forwardButton, FALSE);
gtk_widget_set_sensitive(browser->reloadButton, FALSE);
// catch the destruction of the toplevel window
gtk_signal_connect(GTK_OBJECT(browser->topLevelWindow), "delete_event",
GTK_SIGNAL_FUNC(delete_cb), browser);
// hook up the activate signal to the right callback
gtk_signal_connect(GTK_OBJECT(browser->urlEntry), "activate",
GTK_SIGNAL_FUNC(url_activate_cb), browser);
// close this window
gtk_signal_connect(GTK_OBJECT(browser->fileClose), "activate",
GTK_SIGNAL_FUNC(menu_close_cb), browser);
install_mozembed_cb(browser);
// set the chrome type so it's stored in the object
gtk_moz_embed_set_chrome_mask(GTK_MOZ_EMBED(browser->mozEmbed),
actualChromeMask);
return browser;
}
void GUI_CreateSpeedDialWindow(void)
{
int nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
GtkItemFactory *item_factory;
GtkAccelGroup *accel_group;
SortColumn *sColumn;
GtkWidget *menubar;
GtkWidget *main_vbox;
GtkWidget *toolbar;
GtkWidget *clistScrolledWindow;
register gint i;
gchar *titles[3] = { _("Key"), _("Name"), _("Number") };
InitMainMenu();
GUI_SpeedDialWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_wmclass(GTK_WINDOW(GUI_SpeedDialWindow), "SpeedDialWindow", "Xgnokii");
gtk_window_set_title(GTK_WINDOW(GUI_SpeedDialWindow), _("Speed Dial"));
gtk_widget_set_usize(GTK_WIDGET(GUI_SpeedDialWindow), 350, 220);
//gtk_container_set_border_width (GTK_CONTAINER (GUI_SpeedDialWindow), 10);
gtk_signal_connect(GTK_OBJECT(GUI_SpeedDialWindow), "delete_event",
GTK_SIGNAL_FUNC(DeleteEvent), NULL);
gtk_widget_realize(GUI_SpeedDialWindow);
accel_group = gtk_accel_group_new();
item_factory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>", accel_group);
gtk_item_factory_create_items(item_factory, nmenu_items, menu_items, NULL);
gtk_window_add_accel_group(GTK_WINDOW(GUI_SpeedDialWindow), accel_group);
/* Finally, return the actual menu bar created by the item factory. */
menubar = gtk_item_factory_get_widget(item_factory, "<main>");
main_vbox = gtk_vbox_new(FALSE, 1);
gtk_container_border_width(GTK_CONTAINER(main_vbox), 1);
gtk_container_add(GTK_CONTAINER(GUI_SpeedDialWindow), main_vbox);
gtk_widget_show(main_vbox);
gtk_box_pack_start(GTK_BOX(main_vbox), menubar, FALSE, FALSE, 0);
gtk_widget_show(menubar);
/* Create the toolbar */
toolbar = gtk_toolbar_new();
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar), GTK_ORIENTATION_HORIZONTAL);
gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Read from phone"), NULL,
NewPixmap(Read_xpm, GUI_SpeedDialWindow->window,
&GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]),
(GtkSignalFunc) ReadSpeedDial, NULL);
gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Save to phone"), NULL,
NewPixmap(Send_xpm, GUI_SpeedDialWindow->window,
&GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]),
(GtkSignalFunc) SaveSpeedDial, NULL);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Import from file"), NULL,
NewPixmap(Open_xpm, GUI_SpeedDialWindow->window,
&GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]),
(GtkSignalFunc) ImportSpeedDial, NULL);
gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Export to file"), NULL,
NewPixmap(Save_xpm, GUI_SpeedDialWindow->window,
&GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]),
(GtkSignalFunc) ExportSpeedDial, NULL);
gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Edit entry"), NULL,
NewPixmap(Edit_xpm, GUI_SpeedDialWindow->window,
&GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]),
(GtkSignalFunc) EditKey, NULL);
gtk_box_pack_start(GTK_BOX(main_vbox), toolbar, FALSE, FALSE, 0);
gtk_widget_show(toolbar);
clist = gtk_clist_new_with_titles(3, titles);
gtk_clist_set_shadow_type(GTK_CLIST(clist), GTK_SHADOW_OUT);
// gtk_clist_set_compare_func (GTK_CLIST (clist), CListCompareFunc);
gtk_clist_set_sort_column(GTK_CLIST(clist), 0);
gtk_clist_set_sort_type(GTK_CLIST(clist), GTK_SORT_ASCENDING);
gtk_clist_set_auto_sort(GTK_CLIST(clist), FALSE);
//gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_EXTENDED);
gtk_clist_set_column_width(GTK_CLIST(clist), 1, 150);
gtk_clist_set_column_width(GTK_CLIST(clist), 2, 115);
gtk_clist_set_column_justification(GTK_CLIST(clist), 0, GTK_JUSTIFY_CENTER);
// gtk_clist_set_column_visibility (GTK_CLIST (clist), 3, xgnokiiConfig.callerGroupsSupported);
for (i = 0; i < 3; i++) {
if ((sColumn = g_malloc(sizeof(SortColumn))) == NULL) {
g_print(_("Error: %s: line %d: Can't allocate memory!\n"), __FILE__, __LINE__);
gtk_main_quit();
}
sColumn->clist = clist;
sColumn->column = i;
gtk_signal_connect(GTK_OBJECT(GTK_CLIST(clist)->column[i].button), "clicked",
GTK_SIGNAL_FUNC(SetSortColumn), (gpointer) sColumn);
}
gtk_signal_connect(GTK_OBJECT(clist), "select_row", GTK_SIGNAL_FUNC(ClickEntry), NULL);
clistScrolledWindow = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(clistScrolledWindow), clist);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(clistScrolledWindow),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(main_vbox), clistScrolledWindow, TRUE, TRUE, 0);
gtk_widget_show(clist);
gtk_widget_show(clistScrolledWindow);
questMark.pixmap = gdk_pixmap_create_from_xpm_d(GUI_SpeedDialWindow->window,
&questMark.mask,
&GUI_SpeedDialWindow->style->
bg[GTK_STATE_NORMAL], quest_xpm);
CreateErrorDialog(&errorDialog, GUI_SpeedDialWindow);
CreateInfoDialog(&infoDialog, GUI_SpeedDialWindow);
speedDialInitialized = FALSE;
}
/******************************************************************
Opens a read window
*******************************************************************/
int read_window_open(char *folder, struct mail *mail, int window)
{
int num;
struct Read_Data *data;
for (num=0; num < MAX_READ_OPEN; num++)
if (!read_open[num]) break;
if (num == MAX_READ_OPEN) return -1;
if ((data = (struct Read_Data*)malloc(sizeof(struct Read_Data))))
{
GtkWidget *vbox;
memset(data,0,sizeof(struct Read_Data));
data->folder_path = mystrdup(folder);
data->num = num;
read_open[num] = data;
data->wnd = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(data->wnd), "SimpleMail - Read mail");
gtk_window_set_default_size(GTK_WINDOW(data->wnd),640,400);
gtk_window_set_position(GTK_WINDOW(data->wnd),GTK_WIN_POS_CENTER);
gtk_signal_connect(GTK_OBJECT(data->wnd), "destroy",GTK_SIGNAL_FUNC (read_window_dispose), data);
vbox = gtk_vbox_new(0,4);
gtk_container_add(GTK_CONTAINER(data->wnd), vbox);
data->toolbar = gtk_toolbar_new();
gtk_box_pack_start(GTK_BOX(vbox), data->toolbar, FALSE, FALSE, 0 /* Padding */); /* only use minimal height */
gtk_toolbar_append_item(GTK_TOOLBAR(data->toolbar), "Prev", "", NULL /* private TT */, create_pixmap(data->wnd,"MailPrev.xpm"), NULL /* CALLBACK */, NULL /* UDATA */);
gtk_toolbar_append_item(GTK_TOOLBAR(data->toolbar), "Next", "", NULL /* private TT */, create_pixmap(data->wnd,"MailNext.xpm"), NULL/* CALLBACK */, NULL /* UDATA */);
gtk_toolbar_append_space(GTK_TOOLBAR(data->toolbar));
gtk_toolbar_append_item(GTK_TOOLBAR(data->toolbar), "Save", "", NULL /* private TT */, create_pixmap(data->wnd,"MailSave.xpm"), NULL /* CALLBACK */, NULL /* UDATA */);
gtk_toolbar_append_item(GTK_TOOLBAR(data->toolbar), "Print", "", NULL /* private TT */, create_pixmap(data->wnd,"Print.xpm"), NULL /* CALLBACK */, NULL /* UDATA */);
gtk_toolbar_append_space(GTK_TOOLBAR(data->toolbar));
gtk_toolbar_append_item(GTK_TOOLBAR(data->toolbar), "Delete", "", NULL /* private TT */, create_pixmap(data->wnd,"MailDelete.xpm"), NULL /* CALLBACK */, NULL /* UDATA */);
gtk_toolbar_append_item(GTK_TOOLBAR(data->toolbar), "Reply", "", NULL /* private TT */, create_pixmap(data->wnd,"MailReply.xpm"), NULL /* CALLBACK */, NULL /* UDATA */);
gtk_toolbar_append_item(GTK_TOOLBAR(data->toolbar), "Forward", "", NULL /* private TT */, create_pixmap(data->wnd,"MailForward.xpm"), NULL /* CALLBACK */, NULL /* UDATA */);
data->text_scrolled_window = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(data->text_scrolled_window),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
/* create the html document */
data->html_document = html_document_new();
data->html_view = html_view_new();
gtk_container_add (GTK_CONTAINER (data->text_scrolled_window), data->html_view);
gtk_box_pack_start(GTK_BOX(vbox), data->text_scrolled_window, TRUE, TRUE, 0 /* Padding */); /* only use minimal height */
/* FIXME: ugly ugly! sba: ??? */
html_view_set_document (HTML_VIEW (data->html_view), data->html_document);
#if 0
data->text_view = gtk_text_view_new();
g_object_set(data->text_view, "editable", FALSE, NULL);
gtk_container_add(GTK_CONTAINER(data->text_scrolled_window), data->text_view);
gtk_box_pack_start(GTK_BOX(vbox), data->text_scrolled_window, TRUE, TRUE, 0 /* Padding */); /* only use minimal height */
#endif
read_window_display_mail(data,mail);
gtk_widget_show_all(data->wnd);
}
return num;
}
