static VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE arg, buffer;
GtkToolItem *item = NULL;
rb_scan_args(argc, argv, "01", &arg);
if (NIL_P(arg)) {
item = gtk_toggle_tool_button_new();
} else if (TYPE(arg) == T_HASH) {
VALUE stock_id;
rbg_scan_options(arg,
"stock_id", &stock_id,
NULL);
if (!NIL_P(stock_id))
item = gtk_toggle_tool_button_new_from_stock(RVAL2GLIBID(stock_id, buffer));
} else {
item = gtk_toggle_tool_button_new_from_stock(RVAL2GLIBID(arg, buffer));
}
if (!item)
rb_raise(rb_eArgError, "Invalid arguments.");
RBGTK_INITIALIZE(self, item);
return Qnil;
}
void sc_gui_update_toolbar(void)
{
/* toolbar item is not requested, so remove the item if it exists */
if (! sc_info->show_toolbar_item)
{
if (sc_info->toolbar_button != NULL)
{
gtk_widget_hide(GTK_WIDGET(sc_info->toolbar_button));
}
}
else
{
if (sc_info->toolbar_button == NULL)
{
sc_info->toolbar_button = gtk_toggle_tool_button_new_from_stock(GTK_STOCK_SPELL_CHECK);
plugin_add_toolbar_item(geany_plugin, sc_info->toolbar_button);
ui_add_document_sensitive(GTK_WIDGET(sc_info->toolbar_button));
g_signal_connect(sc_info->toolbar_button, "toggled",
G_CALLBACK(toolbar_item_toggled_cb), NULL);
}
gtk_widget_show(GTK_WIDGET(sc_info->toolbar_button));
sc_ignore_callback = TRUE;
gtk_toggle_tool_button_set_active(
GTK_TOGGLE_TOOL_BUTTON(sc_info->toolbar_button), sc_info->check_while_typing);
sc_ignore_callback = FALSE;
}
}
/*#
@method new_from_stock GtkToggleToolButton
@brief Creates a new GtkToggleToolButton containing the image and text from a stock item.
@param stock_id the name of the stock item
@return A new GtkToggleToolButton
Some stock ids have preprocessor macros like GTK_STOCK_OK and GTK_STOCK_APPLY.
It is an error if stock_id is not a name of a stock item.
*/
FALCON_FUNC ToggleToolButton::new_from_stock( VMARG )
{
Gtk::ArgCheck1 args( vm, "S" );
const gchar* stock = args.getCString( 0 );
GtkToggleToolButton* btn = (GtkToggleToolButton*) gtk_toggle_tool_button_new_from_stock( stock );
vm->retval( new Gtk::ToggleToolButton( vm->findWKI( "GtkToggleToolButton" )->asClass(), btn ) );
}
JNIEXPORT jlong JNICALL
Java_org_gnome_gtk_GtkToggleToolButton_gtk_1toggle_1tool_1button_1new_1from_1stock
(
JNIEnv* env,
jclass cls,
jstring _stockId
)
{
GtkToolItem* result;
jlong _result;
const gchar* stockId;
// convert parameter stockId
stockId = (const gchar*) bindings_java_getString(env, _stockId);
if (stockId == NULL) {
return 0L; // Java Exception already thrown
}
// call function
result = gtk_toggle_tool_button_new_from_stock(stockId);
// cleanup parameter stockId
bindings_java_releaseString(stockId);
// translate return value to JNI type
_result = (jlong) result;
// cleanup return value
if (result != NULL) {
bindings_java_memory_cleanup((GObject*)result, TRUE);
}
// and finally
return _result;
}
void make_toolbar(Viewer *viewer, GtkWidget *parent)
{
GtkWidget *toolbar = gtk_toolbar_new();
gtk_box_pack_start(GTK_BOX(parent), toolbar, FALSE, FALSE, 0);
// add a recording button to the toolbar
viewer->record_button = GTK_WIDGET(
gtk_toggle_tool_button_new_from_stock (GTK_STOCK_MEDIA_RECORD));
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (viewer->record_button),
TRUE);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (viewer->record_button),
viewer->tips,
"Record an AVI of the viewport, saved in the current directory",
NULL);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar),
GTK_TOOL_ITEM (viewer->record_button), 0);
gtk_widget_show (viewer->record_button);
g_signal_connect (G_OBJECT (viewer->record_button), "toggled",
G_CALLBACK (on_record_toggled), viewer);
// screenshot button
GtkToolItem *ssbt = gtk_tool_button_new_from_stock (GTK_STOCK_FLOPPY);
gtk_tool_button_set_label (GTK_TOOL_BUTTON (ssbt), "Screenshot");
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (ssbt), TRUE);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (ssbt), viewer->tips,
"Save a PPM screenshot of the viewport to the current directory",
NULL);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), ssbt, 1);
gtk_widget_show (GTK_WIDGET (ssbt));
g_signal_connect (G_OBJECT (ssbt), "clicked",
G_CALLBACK (on_screenshot_clicked), viewer);
// quit button
GtkToolItem *quitbt = gtk_tool_button_new_from_stock (GTK_STOCK_QUIT);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (quitbt), viewer->tips,
"Quit", NULL);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), quitbt, 2);
gtk_widget_show (GTK_WIDGET (quitbt));
g_signal_connect (G_OBJECT (quitbt), "clicked", gtk_main_quit, NULL);
GtkToolItem * sep = gtk_separator_tool_item_new ();
gtk_widget_show (GTK_WIDGET (sep));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), sep, 3);
GtkWidget * hbox = gtk_hbox_new (FALSE, 5);
GtkWidget * label = gtk_label_new ("Record FPS");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
viewer->fps_spin = gtk_spin_button_new_with_range (0.1, 120.0, 1.0);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (viewer->fps_spin), 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (viewer->fps_spin), 30);
gtk_box_pack_start (GTK_BOX (hbox), viewer->fps_spin, FALSE, FALSE, 0);
GtkToolItem * toolitem = gtk_tool_item_new ();
gtk_container_add (GTK_CONTAINER (toolitem), hbox);
gtk_widget_show_all (GTK_WIDGET (toolitem));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, 4);
viewer->toolbar = GTK_TOOLBAR (toolbar);
}
static VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE stock_id;
GtkToolItem* item;
rb_scan_args(argc, argv, "01", &stock_id);
if (NIL_P(stock_id)){
item = gtk_toggle_tool_button_new();
} else {
if (TYPE(stock_id) == T_SYMBOL){
item = gtk_toggle_tool_button_new_from_stock(rb_id2name(SYM2ID(stock_id)));
} else {
item = gtk_toggle_tool_button_new_from_stock(RVAL2CSTR(stock_id));
}
}
RBGTK_INITIALIZE(self, item);
return Qnil;
}
void show_menu (gboolean show)
{
aud_set_bool ("gtkui", "menu_visible", show);
if (show)
{
/* remove menu button from toolbar and show menu bar */
if (menu_main)
gtk_widget_destroy (menu_main);
if (menu_button)
gtk_widget_destroy ((GtkWidget *) menu_button);
if (! menu)
{
menu = make_menu_bar (accel);
g_signal_connect (menu, "destroy", (GCallback) gtk_widget_destroyed,
& menu);
gtk_widget_show (menu);
gtk_box_pack_start ((GtkBox *) menu_box, menu, TRUE, TRUE, 0);
}
}
else
{
/* hide menu bar and add menu item to toolbar */
if (menu)
gtk_widget_destroy (menu);
if (! menu_main)
{
menu_main = make_menu_main (accel);
g_signal_connect (menu_main, "destroy", (GCallback)
gtk_widget_destroyed, & menu_main);
g_signal_connect (menu_main, "hide", (GCallback) menu_hide_cb, NULL);
}
if (! menu_button)
{
menu_button = gtk_toggle_tool_button_new_from_stock (AUD_STOCK_AUDACIOUS);
g_signal_connect (menu_button, "destroy", (GCallback)
gtk_widget_destroyed, & menu_button);
gtk_widget_show ((GtkWidget *) menu_button);
gtk_toolbar_insert ((GtkToolbar *) toolbar, menu_button, 0);
g_signal_connect (menu_button, "toggled", (GCallback) menu_button_cb, NULL);
}
}
}
static void initGUI(int numframes, gchar *notefile)
{
int i = 0, transIndex = 0;
GtkWidget *timeBox = NULL,
*notePadBox = NULL,
*notePadScroll = NULL,
*table = NULL;
GtkWidget *image = NULL,
*frame = NULL,
*evbox = NULL,
*outerevbox = NULL,
*timeFrame = NULL;
GtkWidget *mainVBox = NULL;
GdkColor black;
GtkWidget *toolbar = NULL, *timeToolbar = NULL;
GtkToolItem *openButton = NULL,
*saveAsButton = NULL,
*fontSelectButton = NULL,
*timeFontSelectButton = NULL;
PangoFontDescription *font_desc = NULL;
struct viewport *thisport = NULL;
/* init colors */
if (gdk_color_parse("#000000", &black) != TRUE)
fprintf(stderr, "Could not resolve color \"black\".\n");
if (gdk_color_parse("#BBFFBB", &col_current) != TRUE)
fprintf(stderr, "Could not resolve color \"col_current\".\n");
if (gdk_color_parse("#FFBBBB", &col_marked) != TRUE)
fprintf(stderr, "Could not resolve color \"col_marked\".\n");
if (gdk_color_parse("#BBBBBB", &col_dim) != TRUE)
fprintf(stderr, "Could not resolve color \"col_dim\".\n");
/* init our two windows */
win_preview = gtk_window_new(GTK_WINDOW_TOPLEVEL);
win_beamer = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(win_preview), "pdfpres - Preview");
gtk_window_set_title(GTK_WINDOW(win_beamer), "pdfpres - Beamer");
g_signal_connect(G_OBJECT(win_preview), "delete_event",
G_CALLBACK(onQuit), NULL);
g_signal_connect(G_OBJECT(win_preview), "destroy",
G_CALLBACK(onQuit), NULL);
g_signal_connect(G_OBJECT(win_beamer), "delete_event",
G_CALLBACK(onQuit), NULL);
g_signal_connect(G_OBJECT(win_beamer), "destroy",
G_CALLBACK(onQuit), NULL);
g_signal_connect(G_OBJECT(win_preview), "key_press_event",
G_CALLBACK(onKeyPressed), NULL);
g_signal_connect(G_OBJECT(win_beamer), "key_press_event",
G_CALLBACK(onKeyPressed), NULL);
gtk_widget_add_events(win_beamer, GDK_BUTTON_RELEASE_MASK
| GDK_SCROLL_MASK);
g_signal_connect(G_OBJECT(win_beamer), "button_release_event",
G_CALLBACK(onMouseReleased), NULL);
g_signal_connect(G_OBJECT(win_beamer), "scroll_event",
G_CALLBACK(onScroll), NULL);
gtk_widget_add_events(win_preview, GDK_BUTTON_RELEASE_MASK
| GDK_SCROLL_MASK);
g_signal_connect(G_OBJECT(win_preview), "button_release_event",
G_CALLBACK(onMouseReleased), NULL);
g_signal_connect(G_OBJECT(win_preview), "scroll_event",
G_CALLBACK(onScroll), NULL);
gtk_container_set_border_width(GTK_CONTAINER(win_preview), 0);
gtk_container_set_border_width(GTK_CONTAINER(win_beamer), 0);
gtk_widget_modify_bg(win_beamer, GTK_STATE_NORMAL, &black);
/* create buttons */
timeToolbar = gtk_toolbar_new();
gtk_toolbar_set_style(GTK_TOOLBAR(timeToolbar), GTK_TOOLBAR_ICONS);
gtk_container_set_border_width(GTK_CONTAINER(timeToolbar), 5);
if (!prefs.timer_is_clock)
{
startButton = gtk_tool_button_new_from_stock(
GTK_STOCK_MEDIA_PLAY);
g_signal_connect(G_OBJECT(startButton), "clicked",
G_CALLBACK(toggleTimer), NULL);
gtk_toolbar_insert(GTK_TOOLBAR(timeToolbar), startButton, -1);
resetButton = gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_REWIND);
g_signal_connect(G_OBJECT(resetButton), "clicked",
G_CALLBACK(resetTimer), NULL);
gtk_toolbar_insert(GTK_TOOLBAR(timeToolbar), resetButton, -1);
gtk_toolbar_insert(GTK_TOOLBAR(timeToolbar),
gtk_separator_tool_item_new(), -1);
}
timeFontSelectButton =
gtk_tool_button_new_from_stock(GTK_STOCK_SELECT_FONT);
gtk_toolbar_insert(GTK_TOOLBAR(timeToolbar),
timeFontSelectButton, -1);
g_signal_connect(G_OBJECT(timeFontSelectButton), "clicked",
G_CALLBACK(onTimerFontSelectClick), NULL);
/* setting text size for time label */
timeElapsedLabel = gtk_label_new(NULL);
font_desc = pango_font_description_from_string(prefs.font_timer);
gtk_widget_modify_font(GTK_WIDGET(timeElapsedLabel), font_desc);
pango_font_description_free(font_desc);
if (prefs.timer_is_clock)
{
printCurrentTime(timeElapsedLabel);
}
else
{
gtk_label_set_text(GTK_LABEL(timeElapsedLabel), "00:00");
}
/* Add timer label to another event box so we can set a nice border.
*/
evbox = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(evbox), timeElapsedLabel);
gtk_container_set_border_width(GTK_CONTAINER(evbox), 10);
/* create timer */
timeBox = gtk_vbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(timeBox), evbox,
TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(timeBox), timeToolbar,
FALSE, FALSE, 5);
if (prefs.timer_is_clock)
{
timeFrame = gtk_frame_new("Clock");
}
else
{
timeFrame = gtk_frame_new("Timer");
}
gtk_container_add(GTK_CONTAINER(timeFrame), timeBox);
/* create note pad inside a scrolled window */
notePadBox = gtk_vbox_new(FALSE, 2);
notePadScroll = gtk_scrolled_window_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(notePadScroll), 5);
notePadFrame = gtk_frame_new("Notes for current slide");
notePad = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(notePad), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(notePad), FALSE);
g_signal_connect(G_OBJECT(notePad), "key_press_event",
G_CALLBACK(onPadKeyPressed), NULL);
/* Remarks:
*
* - The note pad uses word wrapping. If that's not enough, it also
* uses wrapping on a per character basis.
* - The note pad is placed into a GtkScrolledWindow. This window
* allows vertical scrolling but no horizontal scrolling.
*/
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(notePad),
GTK_WRAP_WORD_CHAR);
gtk_container_add(GTK_CONTAINER(notePadScroll), notePad);
gtk_scrolled_window_set_shadow_type(
GTK_SCROLLED_WINDOW(notePadScroll), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(notePadScroll),
GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_box_pack_start(GTK_BOX(notePadBox), notePadScroll, TRUE,
TRUE, 2);
/* set note pad font and margin */
font_desc = pango_font_description_from_string(prefs.font_notes);
gtk_widget_modify_font(notePad, font_desc);
pango_font_description_free(font_desc);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(notePad), 5);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(notePad), 5);
noteBuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(notePad));
/* We detect changes of the notes by catching the "changed" signal.
* As this signal is also emitted when we change the buffer
* programmatically, we first have a look if there was a
* "begin_user_action" signal. If so, the user has changed the
* buffer.
*/
g_signal_connect(G_OBJECT(noteBuffer), "changed",
G_CALLBACK(onEditing), NULL);
g_signal_connect(G_OBJECT(noteBuffer), "begin_user_action",
G_CALLBACK(onBeginUserAction), NULL);
g_signal_connect(G_OBJECT(noteBuffer), "end_user_action",
G_CALLBACK(onEndUserAction), NULL);
/* create toolbar */
toolbar = gtk_toolbar_new();
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
gtk_container_set_border_width(GTK_CONTAINER(toolbar), 5);
openButton = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), openButton, -1);
g_signal_connect(G_OBJECT(openButton), "clicked",
G_CALLBACK(onOpenClicked), NULL);
/* TODO: Tooltips?! */
saveButton = gtk_tool_button_new_from_stock(GTK_STOCK_SAVE);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), saveButton, -1);
gtk_widget_set_sensitive(GTK_WIDGET(saveButton), FALSE);
g_signal_connect(G_OBJECT(saveButton), "clicked",
G_CALLBACK(onSaveClicked), NULL);
saveAsButton = gtk_tool_button_new_from_stock(GTK_STOCK_SAVE_AS);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), saveAsButton, -1);
g_signal_connect(G_OBJECT(saveAsButton), "clicked",
G_CALLBACK(onSaveAsClicked), NULL);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar),
gtk_separator_tool_item_new(), -1);
editButton = gtk_toggle_tool_button_new_from_stock(GTK_STOCK_EDIT);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), editButton, -1);
g_signal_connect(G_OBJECT(editButton), "toggled",
G_CALLBACK(onEditToggled), NULL);
fontSelectButton =
gtk_tool_button_new_from_stock(GTK_STOCK_SELECT_FONT);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), fontSelectButton, -1);
g_signal_connect(G_OBJECT(fontSelectButton), "clicked",
G_CALLBACK(onFontSelectClick), NULL);
gtk_box_pack_start(GTK_BOX(notePadBox), toolbar, FALSE, FALSE, 2);
gtk_container_add(GTK_CONTAINER(notePadFrame), notePadBox);
/* init containers for "preview" */
table = gtk_table_new(numframes, numframes + 1, TRUE);
gtk_table_set_col_spacings(GTK_TABLE(table), 5);
gtk_container_set_border_width(GTK_CONTAINER(table), 10);
/* dynamically create all the frames */
for (i = 0; i < numframes; i++)
{
/* calc the offset for this frame */
transIndex = i - (int)((double)numframes / 2.0);
/* create the widget - note that it is important not to
* set the title to NULL. this would cause a lot more
* redraws on startup because the frame will get re-
* allocated when the title changes. */
frame = gtk_frame_new("");
/* create a new drawing area - the pdf will be rendered in
* there */
image = gtk_image_new();
/* add widgets to their parents. the image is placed in an
* eventbox, the box's size_allocate signal will be handled. so,
* we know the exact width/height we can render into. (placing
* the image into the frame would create the need of knowing the
* frame's border size...)
*/
evbox = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(evbox), image);
gtk_container_add(GTK_CONTAINER(frame), evbox);
/* every frame will be placed in another eventbox so we can set a
* background color */
outerevbox = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(outerevbox), frame);
if (i == 0)
{
gtk_table_attach_defaults(GTK_TABLE(table), notePadFrame,
0, 1, 0, numframes - 1);
gtk_table_attach_defaults(GTK_TABLE(table), outerevbox,
0, 1, numframes - 1, numframes);
}
else
{
if (i == numframes - 1)
{
gtk_table_attach_defaults(GTK_TABLE(table), outerevbox,
numframes, numframes + 1,
0, 1);
gtk_table_attach_defaults(GTK_TABLE(table), timeFrame,
numframes, numframes + 1,
numframes - 1, numframes);
}
else
{
if (i == (int)(numframes / 2))
{
gtk_table_attach_defaults(GTK_TABLE(table),
outerevbox, i, i + 2, 0, numframes);
}
else
{
if (i < (int)(numframes / 2))
{
gtk_table_attach_defaults(GTK_TABLE(table),
outerevbox, i, i + 1,
numframes - i - 1, numframes - i);
}
else
{
gtk_table_attach_defaults(GTK_TABLE(table),
outerevbox, i + 1, i + 2,
numframes - i - 1, numframes - i);
}
}
}
}
/* make the eventbox "transparent" */
gtk_event_box_set_visible_window(GTK_EVENT_BOX(evbox), FALSE);
/* save info of this rendering port */
thisport = (struct viewport *)malloc(sizeof(struct viewport));
g_assert(thisport);
thisport->offset = transIndex;
thisport->image = image;
thisport->frame = frame;
thisport->pixbuf = NULL;
thisport->width = -1;
thisport->height = -1;
thisport->isBeamer = FALSE;
ports = g_list_append(ports, thisport);
/* resize callback */
g_signal_connect(G_OBJECT(evbox), "size_allocate",
G_CALLBACK(onResize), thisport);
g_signal_connect(G_OBJECT(evbox), "expose_event",
G_CALLBACK(onExpose), thisport);
}
/* Add main content and a status bar to preview window.
*
* Note: It's important to use gtk_box_pack_* to add the statusbar
* because gtk_container_add will pick unappropriate defaults. */
mainVBox = gtk_vbox_new(FALSE, 5);
gtk_container_add(GTK_CONTAINER(mainVBox), table);
mainStatusbar = gtk_statusbar_new();
gtk_box_pack_end(GTK_BOX(mainVBox), mainStatusbar,
FALSE, FALSE, 0);
setStatusText_strdup("Ready.");
gtk_container_add(GTK_CONTAINER(win_preview), mainVBox);
/* in order to set the initially highlighted frame */
refreshFrames();
/* add a rendering area to the beamer window */
image = gtk_image_new();
gtk_container_add(GTK_CONTAINER(win_beamer), image);
/* save info of this rendering port */
thisport = (struct viewport *)malloc(sizeof(struct viewport));
g_assert(thisport);
thisport->offset = 0;
thisport->image = image;
thisport->frame = NULL;
thisport->pixbuf = NULL;
thisport->width = -1;
thisport->height = -1;
thisport->isBeamer = TRUE;
ports = g_list_append(ports, thisport);
/* connect the on-resize-callback directly to the window */
g_signal_connect(G_OBJECT(win_beamer), "size_allocate",
G_CALLBACK(onResize), thisport);
g_signal_connect(G_OBJECT(win_beamer), "expose_event",
G_CALLBACK(onExpose), thisport);
/* load notes if requested */
if (notefile)
{
showNotesFromFile(notefile);
}
/* Set default sizes for both windows. (Note: If the widgets don't
* fit into that space, the windows will be larger. Also, they are
* allowed to get shrinked by the user.) */
gtk_window_set_default_size(GTK_WINDOW(win_preview), 640, 480);
gtk_window_set_default_size(GTK_WINDOW(win_beamer), 320, 240);
/* show the windows */
gtk_widget_show_all(win_preview);
gtk_widget_show_all(win_beamer);
/* now, as the real gdk window exists, hide mouse cursor in the
* beamer window */
gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(win_beamer)),
gdk_cursor_new(GDK_BLANK_CURSOR));
/* Show a clock or a timer? */
if (prefs.timer_is_clock)
{
g_timeout_add(500, (GSourceFunc)printCurrentTime,
(gpointer)timeElapsedLabel);
}
else
{
g_timeout_add(500, (GSourceFunc)printTimeElapsed,
(gpointer)timeElapsedLabel);
}
}
/* engineering_init */
static Engineering * _engineering_init(PhonePluginHelper * helper)
{
Engineering * engineering;
GtkWidget * vbox;
GtkWidget * toolbar;
GtkWidget * paned;
GtkWidget * frame;
GtkWidget * scrolled;
size_t i;
GtkCellRenderer * renderer;
GtkTreeViewColumn * column;
if((engineering = object_new(sizeof(*engineering))) == NULL)
return NULL;
engineering->helper = helper;
engineering->source = 0;
engineering->enci = 0;
engineering->enci_cnt = 0;
/* widgets */
/* window */
engineering->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(engineering->window), 200, 300);
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_window_set_icon_name(GTK_WINDOW(engineering->window),
"stock_compile");
#endif
gtk_window_set_title(GTK_WINDOW(engineering->window),
"Engineering mode");
g_signal_connect_swapped(engineering->window, "delete-event",
G_CALLBACK(_on_engineering_closex), engineering);
#if GTK_CHECK_VERSION(3, 0, 0)
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#else
vbox = gtk_vbox_new(FALSE, 0);
#endif
/* toolbar */
toolbar = gtk_toolbar_new();
engineering->tb_play = gtk_toggle_tool_button_new_from_stock(
GTK_STOCK_MEDIA_PLAY);
g_signal_connect_swapped(G_OBJECT(engineering->tb_play), "toggled",
G_CALLBACK(_on_engineering_play_toggled), engineering);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), engineering->tb_play, -1);
engineering->tb_fullscreen = gtk_toggle_tool_button_new_from_stock(
GTK_STOCK_FULLSCREEN);
g_signal_connect_swapped(engineering->tb_fullscreen, "toggled",
G_CALLBACK(_on_engineering_fullscreen_toggled),
engineering);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), engineering->tb_fullscreen,
-1);
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, TRUE, 0);
/* serving cell view */
#if GTK_CHECK_VERSION(3, 0, 0)
paned = gtk_paned_new(GTK_ORIENTATION_VERTICAL);
#else
paned = gtk_vpaned_new();
#endif
frame = gtk_frame_new("Serving cell");
engineering->sc_store = gtk_list_store_new(SC_COL_COUNT,
G_TYPE_STRING, /* SC_COL_FREQUENCY */
G_TYPE_STRING, /* SC_COL_C1 */
G_TYPE_STRING, /* SC_COL_C2 */
G_TYPE_STRING, /* SC_COL_RX_LEVEL */
G_TYPE_STRING, /* SC_COL_STATION_ID */
G_TYPE_STRING, /* SC_COL_CELL_ID */
G_TYPE_STRING, /* SC_COL_TX_LEVEL */
G_TYPE_STRING, /* SC_COL_TIMESLOT_NUMBER */
G_TYPE_STRING, /* SC_COL_LAC */
G_TYPE_STRING); /* SC_COL_TMSI */
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
engineering->sc_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(
engineering->sc_store));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(engineering->sc_view), TRUE);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(
engineering->sc_view)),
GTK_SELECTION_NONE);
/* columns */
for(i = 0; _engineering_sc_columns[i].title != NULL; i++)
{
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_engineering_sc_columns[i].title, renderer,
"text", _engineering_sc_columns[i].col, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(engineering->sc_view),
column);
}
gtk_container_add(GTK_CONTAINER(scrolled), engineering->sc_view);
gtk_container_add(GTK_CONTAINER(frame), scrolled);
gtk_container_set_border_width(GTK_CONTAINER(frame), 4);
gtk_paned_add1(GTK_PANED(paned), frame);
/* neighbor cells view */
frame = gtk_frame_new("Neighbor cells");
engineering->nc_store = gtk_list_store_new(NC_COL_COUNT,
G_TYPE_STRING, /* NC_COL_FREQUENCY */
G_TYPE_STRING, /* NC_COL_C1 */
G_TYPE_STRING, /* NC_COL_C2 */
G_TYPE_STRING, /* NC_COL_RXLEV */
G_TYPE_STRING, /* NC_COL_BSIC */
G_TYPE_STRING, /* NC_COL_CELL_ID */
G_TYPE_STRING, /* NC_COL_LAC */
G_TYPE_STRING, /* NC_COL_FRAME_OFFSET */
G_TYPE_STRING, /* NC_COL_CBA */
G_TYPE_STRING, /* NC_COL_CBQ */
G_TYPE_STRING, /* NC_COL_CELL_TYPE_IND */
G_TYPE_STRING); /* NC_COL_RAC */
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
engineering->nc_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(
engineering->nc_store));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(engineering->nc_view), TRUE);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(
engineering->nc_view)),
GTK_SELECTION_NONE);
/* columns */
for(i = 0; _engineering_nc_columns[i].title != NULL; i++)
{
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_engineering_nc_columns[i].title, renderer,
"text", _engineering_nc_columns[i].col, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(engineering->nc_view),
column);
}
gtk_container_add(GTK_CONTAINER(scrolled), engineering->nc_view);
gtk_container_add(GTK_CONTAINER(frame), scrolled);
gtk_container_set_border_width(GTK_CONTAINER(frame), 4);
gtk_container_add(GTK_CONTAINER(engineering->window), vbox);
gtk_paned_add2(GTK_PANED(paned), frame);
gtk_box_pack_start(GTK_BOX(vbox), paned, TRUE, TRUE, 0);
gtk_widget_show_all(engineering->window);
/* trigger */
#if 0 /* FIXME reimplement using an extension to the Hayes modem plug-in */
helper->register_trigger(helper->phone, plugin, "%EM",
_on_engineering_trigger_em);
#endif
return engineering;
}
void
launch_class_window (struct utt *utt)
{
GtkWidget *window, *vbox;
GtkWidget *toolbar, *notebook, *label;
GtkToolItem *item;
GtkWidget *temp_label;
struct utt_module_tree_node *node;
struct utt_module *module;
gchar *name;
gtk_widget_hide_all (utt->ui.home_window);
utt->ui.class_window = window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "delete-event", gtk_main_quit, NULL);
gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
gtk_widget_set_size_request (window, 640, 480);
module = utt->im_node->module;
name = g_strdup_printf ("%s(%s)", _("Universal Typing Training"), module->locale_name ());
gtk_window_set_title (GTK_WINDOW (utt->ui.class_window), name);
g_free (name);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
toolbar = gtk_toolbar_new ();
gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0);
item = gtk_tool_button_new_from_stock (GTK_STOCK_INDEX);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (item), -1);
item = gtk_toggle_tool_button_new_from_stock (GTK_STOCK_MEDIA_PAUSE);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (item), -1);
gtk_widget_set_sensitive (GTK_WIDGET (item), FALSE);
item = gtk_tool_button_new_from_stock (GTK_STOCK_PREFERENCES);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (item), -1);
item = gtk_tool_button_new_from_stock (GTK_STOCK_HOME);
g_signal_connect (item, "clicked", G_CALLBACK (on_home_click), utt);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (item), -1);
item = gtk_tool_button_new_from_stock (GTK_STOCK_HELP);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (item), -1);
notebook = gtk_notebook_new ();
gtk_box_pack_start (GTK_BOX (vbox), notebook, TRUE, TRUE, 0);
node = utt->im_node->children;
/* g_print ("%s %p %p\n", utt->im_node->node_name, */
/* utt->im_node->children, utt->im_node->sibling); */
/* utt_modules_foreach_module (utt->modules, (GFunc)print_module_name, NULL); */
/* g_print ("%p\n", node); */
while (node) {
module = node->module;
if (!module || module->module_type != UTT_MODULE_CLASS_TYPE) {
continue;
}
label = gtk_label_new (module->locale_name ());
temp_label = gtk_label_new ("class page");
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
temp_label/* module->create_main_page () */,
label);
node = node->sibling;
}
gtk_widget_show_all (utt->ui.class_window);
}
GtkWidget* ptk_toolbar_add_items_from_data( GtkWidget* toolbar,
PtkToolItemEntry* entries,
gpointer cb_data,
GtkTooltips* tooltips )
{
GtkWidget* btn;
PtkToolItemEntry* ent;
GtkWidget* image;
GtkWidget* menu;
GtkIconSize icon_size = gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar));
GSList* radio_group = NULL;
for( ent = entries; ; ++ent )
{
/* Normal tool item */
if( G_LIKELY( ent->stock_icon || ent->tooltip || ent->label ) )
{
/* Stock item */
if( G_LIKELY(ent->stock_icon) )
image = gtk_image_new_from_stock( ent->stock_icon, icon_size );
else
image = NULL;
if( G_LIKELY( ! ent->menu ) ) { /* Normal button */
if( G_UNLIKELY( PTK_IS_STOCK_ITEM(ent) ) )
btn = GTK_WIDGET(gtk_tool_button_new_from_stock ( ent->label ));
else
btn = GTK_WIDGET(gtk_tool_button_new ( image, _(ent->label) ));
}
else if( G_UNLIKELY( PTK_IS_CHECK_TOOL_ITEM(ent) ) ) {
if( G_UNLIKELY( PTK_IS_STOCK_ITEM(ent) ) )
btn = GTK_WIDGET(gtk_toggle_tool_button_new_from_stock(ent->label));
else {
btn = GTK_WIDGET(gtk_toggle_tool_button_new ());
gtk_tool_button_set_icon_widget( GTK_TOOL_BUTTON(btn), image );
gtk_tool_button_set_label(GTK_TOOL_BUTTON(btn), _(ent->label));
}
}
else if( G_UNLIKELY( PTK_IS_RADIO_TOOL_ITEM(ent) ) ) {
if( G_UNLIKELY( PTK_IS_STOCK_ITEM(ent) ) )
btn = GTK_WIDGET(gtk_radio_tool_button_new_from_stock( radio_group, ent->label ));
else {
btn = GTK_WIDGET(gtk_radio_tool_button_new( radio_group ));
if( G_LIKELY( PTK_IS_RADIO_TOOL_ITEM( (ent + 1) ) ) )
radio_group = gtk_radio_tool_button_get_group( GTK_RADIO_TOOL_BUTTON(btn) );
else
radio_group = NULL;
gtk_tool_button_set_icon_widget( GTK_TOOL_BUTTON(btn), image );
gtk_tool_button_set_label(GTK_TOOL_BUTTON(btn), _(ent->label));
}
}
else if( ent->menu ) {
if( G_UNLIKELY( PTK_IS_STOCK_ITEM(ent) ) )
btn = GTK_WIDGET(gtk_menu_tool_button_new_from_stock ( ent->label ));
else {
btn = GTK_WIDGET(gtk_menu_tool_button_new ( image, _(ent->label) ));
if( G_LIKELY( 3 < (int)ent->menu ) ) { /* Sub menu */
menu = ptk_menu_new_from_data( ent->menu, cb_data, NULL );
gtk_menu_tool_button_set_menu( GTK_MENU_TOOL_BUTTON(btn), menu );
}
}
}
if( G_LIKELY(ent->callback) ) { /* Callback */
if( G_LIKELY( ent->menu == NULL || ent->menu == PTK_EMPTY_MENU) )
g_signal_connect( btn, "clicked", ent->callback, cb_data);
else
g_signal_connect( btn, "toggled", ent->callback, cb_data);
}
if( G_LIKELY(ent->tooltip) )
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (btn), tooltips, _(ent->tooltip), NULL);
}
else
{
if( ! PTK_IS_SEPARATOR_TOOL_ITEM(ent) ) /* End of menu */
break;
btn = (GtkWidget*)gtk_separator_tool_item_new ();
}
gtk_toolbar_insert ( GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(btn), -1 );
if( G_UNLIKELY(ent->ret) ) {/* Return */
*ent->ret = btn;
ent->ret = NULL;
}
}
return NULL;
}
gint
main (gint argc, gchar **argv)
{
GtkWidget *window, *toolbar, *table, *treeview, *scrolled_window;
GtkWidget *hbox, *hbox1, *hbox2, *checkbox, *option_menu, *menu;
gint i;
static const gchar *toolbar_styles[] = { "icons", "text", "both (vertical)",
"both (horizontal)" };
GtkToolItem *item;
GtkListStore *store;
GtkWidget *image;
GtkWidget *menuitem;
GtkWidget *button;
GtkWidget *label;
GIcon *gicon;
GSList *group;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
table = gtk_table_new (4, 2, FALSE);
gtk_container_add (GTK_CONTAINER (window), table);
toolbar = gtk_toolbar_new ();
gtk_table_attach (GTK_TABLE (table), toolbar,
0,2, 0,1, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
hbox1 = gtk_hbox_new (FALSE, 3);
gtk_container_set_border_width (GTK_CONTAINER (hbox1), 5);
gtk_table_attach (GTK_TABLE (table), hbox1,
1,2, 1,2, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
hbox2 = gtk_hbox_new (FALSE, 2);
gtk_container_set_border_width (GTK_CONTAINER (hbox2), 5);
gtk_table_attach (GTK_TABLE (table), hbox2,
1,2, 2,3, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
checkbox = gtk_check_button_new_with_mnemonic("_Vertical");
gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
g_signal_connect (checkbox, "toggled",
G_CALLBACK (change_orientation), toolbar);
checkbox = gtk_check_button_new_with_mnemonic("_Show Arrow");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE);
gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
g_signal_connect (checkbox, "toggled",
G_CALLBACK (change_show_arrow), toolbar);
checkbox = gtk_check_button_new_with_mnemonic("_Set Toolbar Style:");
g_signal_connect (checkbox, "toggled", G_CALLBACK (set_toolbar_style_toggled), toolbar);
gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
option_menu = gtk_option_menu_new();
gtk_widget_set_sensitive (option_menu, FALSE);
g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu);
menu = gtk_menu_new();
for (i = 0; i < G_N_ELEMENTS (toolbar_styles); i++)
{
GtkWidget *menuitem;
menuitem = gtk_menu_item_new_with_label (toolbar_styles[i]);
gtk_container_add (GTK_CONTAINER (menu), menuitem);
gtk_widget_show (menuitem);
}
gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu), menu);
gtk_option_menu_set_history (GTK_OPTION_MENU (option_menu),
GTK_TOOLBAR (toolbar)->style);
gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0);
g_signal_connect (option_menu, "changed",
G_CALLBACK (change_toolbar_style), toolbar);
checkbox = gtk_check_button_new_with_mnemonic("_Set Icon Size:");
g_signal_connect (checkbox, "toggled", G_CALLBACK (set_icon_size_toggled), toolbar);
gtk_box_pack_start (GTK_BOX (hbox2), checkbox, FALSE, FALSE, 0);
option_menu = gtk_option_menu_new();
g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu);
gtk_widget_set_sensitive (option_menu, FALSE);
menu = gtk_menu_new();
menuitem = gtk_menu_item_new_with_label ("small toolbar");
g_object_set_data (G_OBJECT (menuitem), "value-id", GINT_TO_POINTER (GTK_ICON_SIZE_SMALL_TOOLBAR));
gtk_container_add (GTK_CONTAINER (menu), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("large toolbar");
g_object_set_data (G_OBJECT (menuitem), "value-id", GINT_TO_POINTER (GTK_ICON_SIZE_LARGE_TOOLBAR));
gtk_container_add (GTK_CONTAINER (menu), menuitem);
gtk_widget_show (menuitem);
gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu), menu);
gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0);
g_signal_connect (option_menu, "changed",
G_CALLBACK (icon_size_history_changed), toolbar);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_table_attach (GTK_TABLE (table), scrolled_window,
1,2, 3,4, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
store = create_items_list (&treeview);
gtk_container_add (GTK_CONTAINER (scrolled_window), treeview);
item = gtk_tool_button_new_from_stock (GTK_STOCK_NEW);
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Custom label");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), NULL);
add_item_to_list (store, item, "New");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb, item);
gtk_tool_item_set_expand (item, TRUE);
menu = gtk_menu_new ();
for (i = 0; i < 20; i++)
{
char *text;
text = g_strdup_printf ("Menuitem %d", i);
menuitem = gtk_menu_item_new_with_label (text);
g_free (text);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
}
item = gtk_menu_tool_button_new_from_stock (GTK_STOCK_OPEN);
gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu);
add_item_to_list (store, item, "Open");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb1, item);
menu = gtk_menu_new ();
for (i = 0; i < 20; i++)
{
char *text;
text = g_strdup_printf ("A%d", i);
menuitem = gtk_menu_item_new_with_label (text);
g_free (text);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
}
item = gtk_menu_tool_button_new_from_stock (GTK_STOCK_GO_BACK);
gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu);
add_item_to_list (store, item, "BackWithHistory");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_separator_tool_item_new ();
add_item_to_list (store, item, "-----");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new_from_stock (GTK_STOCK_REFRESH);
add_item_to_list (store, item, "Refresh");
g_signal_connect (item, "clicked", G_CALLBACK (reload_clicked), NULL);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG);
item = gtk_tool_item_new ();
gtk_widget_show (image);
gtk_container_add (GTK_CONTAINER (item), image);
add_item_to_list (store, item, "(Custom Item)");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new_from_stock (GTK_STOCK_GO_BACK);
add_item_to_list (store, item, "Back");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_separator_tool_item_new ();
add_item_to_list (store, item, "-----");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new_from_stock (GTK_STOCK_GO_FORWARD);
add_item_to_list (store, item, "Forward");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_toggle_tool_button_new_from_stock (GTK_STOCK_BOLD);
g_signal_connect (item, "toggled", G_CALLBACK (bold_toggled), NULL);
add_item_to_list (store, item, "Bold");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gtk_widget_set_sensitive (GTK_WIDGET (item), FALSE);
item = gtk_separator_tool_item_new ();
add_item_to_list (store, item, "-----");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gtk_tool_item_set_expand (item, TRUE);
gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE);
g_assert (gtk_toolbar_get_nth_item (GTK_TOOLBAR (toolbar), 0) != 0);
item = gtk_radio_tool_button_new_from_stock (NULL, GTK_STOCK_JUSTIFY_LEFT);
group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item));
add_item_to_list (store, item, "Left");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_radio_tool_button_new_from_stock (group, GTK_STOCK_JUSTIFY_CENTER);
make_prop_editor (G_OBJECT (item));
group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item));
add_item_to_list (store, item, "Center");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_radio_tool_button_new_from_stock (group, GTK_STOCK_JUSTIFY_RIGHT);
add_item_to_list (store, item, "Right");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new (gtk_image_new_from_file ("apple-red.png"), "_Apple");
add_item_to_list (store, item, "Apple");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gtk_tool_button_set_use_underline (GTK_TOOL_BUTTON (item), TRUE);
gicon = g_content_type_get_icon ("video/ogg");
image = gtk_image_new_from_gicon (gicon, GTK_ICON_SIZE_LARGE_TOOLBAR);
g_object_unref (gicon);
item = gtk_tool_button_new (image, "Video");
add_item_to_list (store, item, "Video");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
image = gtk_image_new_from_icon_name ("utility-terminal", GTK_ICON_SIZE_LARGE_TOOLBAR);
item = gtk_tool_button_new (image, "Terminal");
add_item_to_list (store, item, "Terminal");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
hbox = gtk_hbox_new (FALSE, 5);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_table_attach (GTK_TABLE (table), hbox,
1,2, 4,5, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
button = gtk_button_new_with_label ("Drag me to the toolbar");
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
label = gtk_label_new ("Drop index:");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
checkbox = gtk_check_button_new_with_mnemonic("_Right to left");
if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE);
else
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), FALSE);
g_signal_connect (checkbox, "toggled", G_CALLBACK (rtl_toggled), NULL);
gtk_box_pack_end (GTK_BOX (hbox), checkbox, FALSE, FALSE, 0);
gtk_drag_source_set (button, GDK_BUTTON1_MASK,
target_table, G_N_ELEMENTS (target_table),
GDK_ACTION_MOVE);
gtk_drag_dest_set (toolbar, GTK_DEST_DEFAULT_DROP,
target_table, G_N_ELEMENTS (target_table),
GDK_ACTION_MOVE);
g_signal_connect (toolbar, "drag_motion",
G_CALLBACK (toolbar_drag_motion), NULL);
g_signal_connect (toolbar, "drag_leave",
G_CALLBACK (toolbar_drag_leave), NULL);
g_signal_connect (toolbar, "drag_drop",
G_CALLBACK (toolbar_drag_drop), label);
gtk_widget_show_all (window);
make_prop_editor (G_OBJECT (toolbar));
g_signal_connect (window, "delete_event", G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect (toolbar, "popup_context_menu", G_CALLBACK (popup_context_menu), NULL);
gtk_main ();
return 0;
}
