void ZLGtkApplicationWindow::addToolbarItem(ZLToolbar::ItemPtr item) {
GtkToolItem *gtkItem = 0;
switch (item->type()) {
case ZLToolbar::Item::TEXT_FIELD:
case ZLToolbar::Item::COMBO_BOX:
{
const ZLToolbar::ParameterItem ¶meterItem = (const ZLToolbar::ParameterItem&)*item;
GtkEntryParameter *parameter =
new GtkEntryParameter(*this, parameterItem);
addVisualParameter(parameterItem.parameterId(), parameter);
gtkItem = parameter->createToolItem();
gtk_tool_item_set_tooltip(gtkItem, myToolbar->tooltips, parameterItem.tooltip().c_str(), 0);
}
break;
case ZLToolbar::Item::PLAIN_BUTTON:
case ZLToolbar::Item::TOGGLE_BUTTON:
case ZLToolbar::Item::MENU_BUTTON:
gtkItem = createGtkToolButton((ZLToolbar::AbstractButtonItem&)*item);
break;
case ZLToolbar::Item::SEPARATOR:
gtkItem = gtk_separator_tool_item_new();
gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(gtkItem), false);
break;
}
if (gtkItem != 0) {
gtk_toolbar_insert(myToolbar, gtkItem, -1);
myAbstractToGtk[&*item] = gtkItem;
myGtkToAbstract[gtkItem] = item;
gtk_widget_show_all(GTK_WIDGET(gtkItem));
}
}
/* Create a toolbar with cut, copy, paste and select all */
static void create_toolbar( GtkWidget *toolbar, GtkWidget *entry ) {
GtkToolItem *cut = gtk_tool_button_new_from_stock( GTK_STOCK_CUT );
GtkToolItem *copy = gtk_tool_button_new_from_stock( GTK_STOCK_COPY );
GtkToolItem *paste = gtk_tool_button_new_from_stock( GTK_STOCK_PASTE );
GtkToolItem *selectall = gtk_tool_button_new_from_stock(
GTK_STOCK_SELECT_ALL );
GtkToolItem *separator = gtk_separator_tool_item_new();
gtk_toolbar_set_show_arrow( GTK_TOOLBAR( toolbar ), TRUE );
gtk_toolbar_set_style( GTK_TOOLBAR( toolbar ), GTK_TOOLBAR_BOTH );
gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), cut, 0 );
gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), copy, 1 );
gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), paste, 2 );
gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), separator, 3 );
gtk_toolbar_insert( GTK_TOOLBAR( toolbar ), selectall, 4 );
g_signal_connect_swapped( G_OBJECT( cut ), "clicked",
G_CALLBACK( gtk_editable_cut_clipboard ), entry );
g_signal_connect_swapped( G_OBJECT( copy ), "clicked",
G_CALLBACK( gtk_editable_copy_clipboard ), entry );
g_signal_connect_swapped( G_OBJECT( paste ), "clicked",
G_CALLBACK( gtk_editable_paste_clipboard ), entry );
g_signal_connect_swapped( G_OBJECT( selectall ), "clicked",
G_CALLBACK( select_all ), entry );
}
void ui_common_toolbar_append_separator(GtkWidget * toolbar) {
GtkToolItem * toolbar_item;
toolbar_item = gtk_separator_tool_item_new();
gtk_tool_item_set_homogeneous(toolbar_item, FALSE);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolbar_item, -1);
return;
}
static GtkToolItem*
separator_new()
{
GtkToolItem *separator = gtk_separator_tool_item_new();
gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(separator), FALSE);
return separator;
}
static GtkWidget *
mug_toolbar (MugData * mugdata)
{
GtkWidget *toolbar;
int i;
struct {
const char *stock_id;
ToolAction action;
} tools[] = {
{"go-up", ACTION_PREV_MSG},
{"go-down", ACTION_NEXT_MSG},
{NULL, ACTION_SEPARATOR},
{"view-refresh", ACTION_REINDEX},
{NULL, ACTION_SEPARATOR},
{"help-about", ACTION_ABOUT},
{NULL, ACTION_SEPARATOR},
{"application-exit", ACTION_DO_QUIT}};
toolbar = gtk_toolbar_new ();
for (i = 0; i != G_N_ELEMENTS (tools); ++i) {
if (tools[i].action == ACTION_SEPARATOR) { /* separator? */
gtk_toolbar_insert (GTK_TOOLBAR (toolbar),
gtk_separator_tool_item_new (), i);
continue;
} else /* nope: a real item */
gtk_toolbar_insert (GTK_TOOLBAR (toolbar),
get_connected_tool_button
(tools[i].stock_id, tools[i].action,
mugdata), i);
}
return toolbar;
}
static void
tm_populate(GtkWidget * toolbar, BalsaToolbarModel * model)
{
gboolean style_is_both;
gboolean make_two_line;
GArray *current;
guint j;
GActionMap *action_map =
g_object_get_data(G_OBJECT(toolbar), BALSA_TOOLBAR_ACTION_MAP);
style_is_both = (model->style == GTK_TOOLBAR_BOTH
|| (model->style == (GtkToolbarStyle) - 1
&& tm_default_style() == GTK_TOOLBAR_BOTH));
make_two_line = style_is_both && tm_has_second_line(model);
current = balsa_toolbar_model_get_current(model);
for (j = 0; j < current->len; j++) {
BalsaToolbarEntry *entry;
GtkToolItem *item;
entry = &g_array_index(current, BalsaToolbarEntry, j);
if (!*entry->action) {
item = gtk_separator_tool_item_new();
} else {
GtkWidget *icon;
GAction *action;
const GVariantType *type;
gchar *prefixed_action;
icon = gtk_image_new_from_icon_name
(balsa_icon_id(entry->icon), GTK_ICON_SIZE_SMALL_TOOLBAR);
action = g_action_map_lookup_action(action_map, entry->action);
if (action &&
(type = g_action_get_state_type(action)) &&
g_variant_type_equal(type, G_VARIANT_TYPE_BOOLEAN)) {
item = gtk_toggle_tool_button_new();
g_object_set(G_OBJECT(item), "icon-widget", icon,
"label", entry->action, NULL);
} else {
item = gtk_tool_button_new(icon, entry->action);
}
tm_set_tool_item_label(GTK_TOOL_ITEM(item), entry->icon,
make_two_line);
prefixed_action =
g_strconcat(action ? "win." : "app.", entry->action, NULL);
gtk_actionable_set_action_name(GTK_ACTIONABLE(item),
prefixed_action);
g_free(prefixed_action);
}
gtk_toolbar_insert((GtkToolbar *) toolbar, item, -1);
}
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar),
model->style != (GtkToolbarStyle) (-1) ?
model->style : tm_default_style());
gtk_widget_show_all(toolbar);
}
static void remmina_main_create_quick_search(RemminaMain *remminamain)
{
GtkWidget *widget;
GValue val =
{ 0 };
remminamain->priv->quick_search_separator = gtk_separator_tool_item_new();
gtk_toolbar_insert(GTK_TOOLBAR(remminamain->priv->toolbar), remminamain->priv->quick_search_separator, -1);
remminamain->priv->quick_search_item = gtk_tool_item_new();
gtk_toolbar_insert(GTK_TOOLBAR(remminamain->priv->toolbar), remminamain->priv->quick_search_item, -1);
widget = gtk_entry_new();
gtk_widget_show(widget);
gtk_entry_set_icon_from_stock(GTK_ENTRY(widget), GTK_ENTRY_ICON_PRIMARY, GTK_STOCK_FIND);
gtk_entry_set_icon_from_stock(GTK_ENTRY(widget), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR);
gtk_entry_set_width_chars(GTK_ENTRY(widget), 25);
gtk_container_add(GTK_CONTAINER(remminamain->priv->quick_search_item), widget);
g_value_init(&val, G_TYPE_BOOLEAN);
g_value_set_boolean(&val, FALSE);
g_object_set_property(G_OBJECT(widget), "primary-icon-activatable", &val);
g_value_unset(&val);
g_signal_connect(G_OBJECT(widget), "icon-press", G_CALLBACK(remmina_main_quick_search_on_icon_press), remminamain);
g_signal_connect(G_OBJECT(widget), "changed", G_CALLBACK(remmina_main_quick_search_on_changed), remminamain);
remminamain->priv->quick_search_entry = widget;
}
static void
add_section_toolbar (CEPageIP6 *page, GtkWidget *section, GCallback add_cb)
{
GtkWidget *toolbar;
GtkToolItem *item;
GtkStyleContext *context;
GtkWidget *box;
GtkWidget *button;
GtkWidget *image;
toolbar = gtk_toolbar_new ();
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_MENU);
context = gtk_widget_get_style_context (toolbar);
gtk_style_context_set_junction_sides (context, GTK_JUNCTION_TOP);
gtk_style_context_add_class (context, GTK_STYLE_CLASS_INLINE_TOOLBAR);
gtk_container_add (GTK_CONTAINER (section), toolbar);
item = gtk_separator_tool_item_new ();
gtk_tool_item_set_expand (item, TRUE);
gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (item), 0);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
item = gtk_tool_item_new ();
gtk_container_add (GTK_CONTAINER (item), box);
button = gtk_button_new ();
g_signal_connect_swapped (button, "clicked", G_CALLBACK (add_cb), page);
image = gtk_image_new_from_icon_name ("list-add-symbolic", GTK_ICON_SIZE_MENU);
atk_object_set_name (gtk_widget_get_accessible (button), _("Add"));
gtk_button_set_image (GTK_BUTTON (button), image);
gtk_container_add (GTK_CONTAINER (box), button);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (item), 1);
}
static GtkWidget *
mug_toolbar (MugData * mugdata)
{
GtkWidget *toolbar;
int i;
struct {
const char *stock_id;
ToolAction action;
} tools[] = {
{GTK_STOCK_GO_UP, ACTION_PREV_MSG},
{GTK_STOCK_GO_DOWN, ACTION_NEXT_MSG},
{NULL, ACTION_SEPARATOR},
{GTK_STOCK_REFRESH, ACTION_REINDEX},
{NULL, ACTION_SEPARATOR},
{GTK_STOCK_ABOUT, ACTION_ABOUT},
{NULL, ACTION_SEPARATOR},
{GTK_STOCK_QUIT, ACTION_DO_QUIT}};
toolbar = gtk_toolbar_new ();
for (i = 0; i != G_N_ELEMENTS (tools); ++i) {
if (tools[i].action == ACTION_SEPARATOR) { /* separator? */
gtk_toolbar_insert (GTK_TOOLBAR (toolbar),
gtk_separator_tool_item_new (), i);
continue;
} else /* nope: a real item */
gtk_toolbar_insert (GTK_TOOLBAR (toolbar),
get_connected_tool_button
(tools[i].stock_id, tools[i].action,
mugdata), i);
}
return toolbar;
}
/** Inserts a toolbar item before the Quit button, or after the previous plugin toolbar item.
* A separator is added on the first call to this function, and will be shown when @a item is
* shown; hidden when @a item is hidden.
* @note You should still destroy @a item yourself, usually in @ref plugin_cleanup().
* @param plugin Must be @ref geany_plugin.
* @param item The item to add. */
GEANY_API_SYMBOL
void plugin_add_toolbar_item(GeanyPlugin *plugin, GtkToolItem *item)
{
GtkToolbar *toolbar = GTK_TOOLBAR(main_widgets.toolbar);
gint pos;
GeanyAutoSeparator *autosep;
g_return_if_fail(plugin);
autosep = &plugin->priv->toolbar_separator;
if (!autosep->widget)
{
GtkToolItem *sep;
pos = toolbar_get_insert_position();
sep = gtk_separator_tool_item_new();
gtk_toolbar_insert(toolbar, sep, pos);
autosep->widget = GTK_WIDGET(sep);
toolbar_item_ref(sep);
}
else
{
pos = gtk_toolbar_get_item_index(toolbar, GTK_TOOL_ITEM(autosep->widget));
g_return_if_fail(pos >= 0);
}
gtk_toolbar_insert(toolbar, item, pos + autosep->item_count + 1);
toolbar_item_ref(item);
/* hide the separator widget if there are no toolbar items showing for the plugin */
ui_auto_separator_add_ref(autosep, GTK_WIDGET(item));
}
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 GtkToolItem*
expander_new()
{
GtkToolItem *expander = gtk_separator_tool_item_new();
gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(expander), FALSE);
gtk_tool_item_set_expand(GTK_TOOL_ITEM(expander), TRUE);
return expander;
}
ToolBar * x_toolbar_new(void) {
ToolBar * toolbar = (ToolBar *) g_malloc(sizeof(ToolBar));
x_toolbar_init(toolbar);
toolbar->tBar = gtk_toolbar_new ();
toolbar->SaveItem = gtk_tool_button_new_from_stock (GTK_STOCK_SAVE);
toolbar->OpenItem = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN);
gtk_widget_set_tooltip_text (GTK_WIDGET(toolbar->SaveItem), "Save buffer");
gtk_widget_set_tooltip_text (GTK_WIDGET(toolbar->OpenItem), "load some file contents");
toolbar->FirstSeparatorItem = gtk_separator_tool_item_new ();
toolbar->CutItem = gtk_tool_button_new_from_stock (GTK_STOCK_CUT);
toolbar->CopyItem = gtk_tool_button_new_from_stock (GTK_STOCK_COPY);
toolbar->PasteItem = gtk_tool_button_new_from_stock (GTK_STOCK_PASTE);
toolbar->SelectAllItem = gtk_tool_button_new_from_stock (GTK_STOCK_SELECT_ALL);
gtk_widget_set_tooltip_text (GTK_WIDGET(toolbar->CutItem), "Cut selected bounds to clipboard");
gtk_widget_set_tooltip_text (GTK_WIDGET(toolbar->CopyItem), "Copy selected bounds to clipboard");
gtk_widget_set_tooltip_text (GTK_WIDGET(toolbar->PasteItem), "Paste from clipboard");
gtk_widget_set_tooltip_text (GTK_WIDGET(toolbar->SelectAllItem), "Select all (From start to end)");
toolbar->SecondSeparatorItem = gtk_separator_tool_item_new ();
toolbar->UndoItem = gtk_tool_button_new_from_stock (GTK_STOCK_UNDO);
toolbar->RedoItem = gtk_tool_button_new_from_stock (GTK_STOCK_REDO);
gtk_widget_set_tooltip_text (GTK_WIDGET(toolbar->UndoItem), "Undo");
gtk_widget_set_tooltip_text (GTK_WIDGET(toolbar->RedoItem), "Redo");
toolbar->ThirdSeparatorItem = gtk_separator_tool_item_new ();
toolbar->FontSelectItem = gtk_tool_button_new_from_stock (GTK_STOCK_SELECT_FONT);
toolbar->SearchItem = gtk_tool_button_new_from_stock (GTK_STOCK_FIND_AND_REPLACE);
gtk_widget_set_tooltip_text (GTK_WIDGET(toolbar->FontSelectItem), "Font selector dialog");
gtk_widget_set_tooltip_text (GTK_WIDGET(toolbar->SearchItem), "Search something into buffer");
x_toolbar_boxing (toolbar);
x_toolbar_init(toolbar);
return toolbar;
}
static void activate(GtkApplication *app, gpointer user_data) {
GtkWidget *window;
GtkWidget *grid;
GtkWidget *toolbar;
GtkToolItem *tool_item;
GtkWidget *notes;
int position = 0; // toolbar position
// Create a window with a title, default size, and set border width
window = gtk_application_window_new (app);
gtk_window_set_title (GTK_WINDOW(window), "GUI: notebook");
gtk_window_set_default_size(GTK_WINDOW(window), 400, 300);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_container_set_border_width (GTK_CONTAINER(window), 10);
// ------------- TOOLBAR ----------------
// Create a basic toolbar
toolbar = gtk_toolbar_new();
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
tool_item = gtk_tool_button_new_from_stock (GTK_STOCK_REFRESH);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_item, position ++);
tool_item = gtk_separator_tool_item_new();
gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(tool_item), FALSE);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_item, position ++);
tool_item = gtk_tool_button_new_from_stock (GTK_STOCK_CLOSE);
// connect application quit callback here
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_item, position ++);
// ------------- NOTEPAD -----------------
notes = gtk_notebook_new();
gtk_notebook_append_page(GTK_NOTEBOOK(notes),
create_notepage_fileselect(),
gtk_label_new("Config"));
// Create a full-window grid to contain toolbar and the notebook
grid = gtk_grid_new();
gtk_grid_attach (GTK_GRID(grid), toolbar, 0, 0, 1, 1);
gtk_grid_attach (GTK_GRID(grid), notes, 0, 1, 1, 1);
gtk_container_add (GTK_CONTAINER(window), GTK_WIDGET(grid));
gtk_widget_show_all (window);
}
/* Checks the passed xmlNode for a recognized item (ToolButton, ToggleToolButton, Separator)
* Returns the widget or NULL if nothing useful is found
*/
GtkWidget* ToolbarCreator::createToolItem(xml::Node& node, GtkToolbar* toolbar) {
const std::string nodeName = node.getName();
GtkWidget* toolItem;
if (nodeName == "separator") {
toolItem = GTK_WIDGET(gtk_separator_tool_item_new());
}
else if (nodeName == "toolbutton" || nodeName == "toggletoolbutton") {
// Found a button, load the values that are shared by both types
const std::string name = node.getAttributeValue("name");
const std::string icon = node.getAttributeValue("icon");
const std::string tooltip = _(node.getAttributeValue("tooltip").c_str());
const std::string action = node.getAttributeValue("action");
if (nodeName == "toolbutton") {
// Create a new GtkToolButton and assign the right callback
toolItem = GTK_WIDGET(gtk_tool_button_new(NULL, name.c_str()));
}
else {
// Create a new GtkToggleToolButton and assign the right callback
toolItem = GTK_WIDGET(gtk_toggle_tool_button_new());
}
IEvent* event = GlobalEventManager().findEvent(action);
if (event != NULL) {
event->connectWidget(GTK_WIDGET(toolItem));
// Tell the event to update the state of this button
event->updateWidgets();
} else {
globalErrorStream() << "ToolbarCreator: Failed to lookup command " << action << "\n";
}
// Set the tooltip, if not empty
if (!tooltip.empty()) {
gtk_tooltips_set_tip(_tooltips, GTK_WIDGET(toolItem), tooltip.c_str(), "");
//gtk_tool_item_set_tooltip(GTK_TOOL_ITEM(toolItem), _tooltips, tooltip.c_str(), "");
}
// Load and assign the icon, if specified
if (icon != "") {
GtkWidget* image = gtk_image_new_from_pixbuf(gtkutil::getLocalPixbufWithMask(icon));
gtk_widget_show(image);
gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(toolItem), image);
}
}
else {
return NULL;
}
gtk_widget_show(toolItem);
return toolItem;
}
GtkWidget *gui_toolbar_new(toolbar_item_t *tbitems)
{
GtkWidget *icon;
GtkWidget *toolbar;
GtkToolItem *item;
int i;
toolbar = gtk_toolbar_new();
gtk_orientable_set_orientation (GTK_ORIENTABLE (toolbar), GTK_ORIENTATION_HORIZONTAL );
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH);
for (i=0; tbitems[i].icon!=NULL; i++)
{
if (strcmp(tbitems[i].icon,TOOLBAR_ITEM_SEPARATOR)==0)
{
item = gtk_separator_tool_item_new();
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(item),-1);
}
else if (strcmp(tbitems[i].icon,TOOLBAR_ITEM_EXPANDER)==0)
{
item = gtk_separator_tool_item_new();
gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM(item),FALSE);
gtk_tool_item_set_expand(GTK_TOOL_ITEM(item),TRUE);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(item),-1);
}
else
{
icon = gtk_image_new_from_icon_name(tbitems[i].icon, GTK_ICON_SIZE_LARGE_TOOLBAR);
item = gtk_tool_button_new(icon, tbitems[i].text);
if (tbitems[i].callback)
g_signal_connect(G_OBJECT(item),"clicked",G_CALLBACK(tbitems[i].callback),(gpointer)tbitems[i].callback_data);
if (tbitems[i].tooltip)
gtk_widget_set_tooltip_text(GTK_WIDGET(item),tbitems[i].tooltip);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(item),-1);
}
}
return toolbar;
}
int main(int argc,char *argv[])
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *toolbar;
GtkWidget *undo;
GtkWidget *redo;
GtkWidget *sep;
GtkWidget *exit;
gtk_init(&argc,&argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(window),250,200);
gtk_window_set_title(GTK_WINDOW(window),"undoredo");
vbox = gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(window),vbox);
toolbar = gtk_toolbar_new();
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar),GTK_TOOLBAR_ICONS);
gtk_container_set_border_width(GTK_CONTAINER(toolbar),2);
undo = gtk_tool_button_new_from_stock(GTK_STOCK_UNDO);
gtk_widget_set_name(GTK_WIDGET(undo),"undo");
gtk_toolbar_insert(GTK_TOOLBAR(toolbar),undo,-1);
redo = gtk_tool_button_new_from_stock(GTK_STOCK_REDO);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar),redo,-1);
sep = gtk_separator_tool_item_new();
gtk_toolbar_insert(GTK_TOOLBAR(toolbar),sep,-1);
exit = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar),exit,-1);
gtk_box_pack_start(GTK_BOX(vbox),toolbar,FALSE,FALSE,5);
g_signal_connect(G_OBJECT(undo),"clicked",G_CALLBACK(undo_redo),redo);
g_signal_connect(G_OBJECT(redo),"clicked",G_CALLBACK(undo_redo),undo);
g_signal_connect(G_OBJECT(exit),"clicked",G_CALLBACK(gtk_main_quit),NULL);
g_signal_connect_swapped(G_OBJECT(window),"destroy",G_CALLBACK(gtk_main_quit),NULL);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
/* desktop_toolbar_create */
GtkWidget * desktop_toolbar_create(DesktopToolbar * toolbar,
gpointer data, GtkAccelGroup * accel)
{
GtkWidget * ret;
size_t i;
DesktopToolbar * p;
GtkWidget * widget;
ret = gtk_toolbar_new();
for(i = 0; toolbar[i].name != NULL; i++)
{
p = &toolbar[i];
if(p->name[0] == '\0')
{
p->widget = gtk_separator_tool_item_new();
gtk_toolbar_insert(GTK_TOOLBAR(ret), p->widget, -1);
continue;
}
#if !GTK_CHECK_VERSION(3, 10, 0)
else if(strncmp(p->stock, "gtk-", 4) == 0) /* stock icon */
p->widget = gtk_tool_button_new_from_stock(p->stock);
#endif
else if(p->stock != NULL) /* icon name */
{
widget = gtk_image_new_from_icon_name(p->stock,
GTK_ICON_SIZE_LARGE_TOOLBAR);
p->widget = gtk_tool_button_new(widget, p->name);
}
else
p->widget = gtk_tool_button_new(NULL, _(p->name));
if(p->callback != NULL)
g_signal_connect_swapped(G_OBJECT(p->widget), "clicked",
G_CALLBACK(p->callback), data);
else
gtk_widget_set_sensitive(GTK_WIDGET(p->widget), FALSE);
if(accel != NULL && p->accel != 0)
gtk_widget_add_accelerator(GTK_WIDGET(p->widget),
"clicked", accel, p->accel, p->modifier,
GTK_ACCEL_VISIBLE);
#if 0 /* GTK_CHECK_VERSION(2, 12, 0) */
/* XXX the default is returned instead of the configuration */
if(gtk_toolbar_get_style(GTK_TOOLBAR(ret)) == GTK_TOOLBAR_ICONS)
gtk_tool_item_set_tooltip_text(p->widget, p->name);
#endif
gtk_toolbar_insert(GTK_TOOLBAR(ret), p->widget, -1);
}
return ret;
}
static void
page_holder_app_add_browser_cb (MidoriApp* app,
MidoriBrowser* browser,
MidoriExtension* extension)
{
GtkWidget* panel;
GtkWidget* notebook;
GtkWidget* toolbar;
GtkToolItem* toolitem;
panel = katze_object_get_object (browser, "panel");
notebook = gtk_notebook_new ();
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_RIGHT);
gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);
gtk_widget_show (notebook);
toolbar = gtk_toolbar_new ();
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH_HORIZ);
gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_BUTTON);
gtk_widget_show (toolbar);
toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_JUMP_TO);
gtk_tool_item_set_is_important (toolitem, TRUE);
g_signal_connect (toolitem, "clicked",
G_CALLBACK (page_holder_button_jump_to_clicked_cb), notebook);
gtk_widget_show (GTK_WIDGET (toolitem));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
toolitem = gtk_separator_tool_item_new ();
gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (toolitem), FALSE);
gtk_tool_item_set_expand (toolitem, TRUE);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
gtk_widget_show (GTK_WIDGET (toolitem));
toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_ADD);
gtk_tool_item_set_is_important (toolitem, TRUE);
g_signal_connect (toolitem, "clicked",
G_CALLBACK (page_holder_button_add_clicked_cb), notebook);
gtk_widget_show (GTK_WIDGET (toolitem));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
midori_panel_append_widget (MIDORI_PANEL (panel), notebook,
/* i18n: A panel showing a user specified web page */
STOCK_PAGE_HOLDER, _("Pageholder"), toolbar);
g_signal_connect (extension, "deactivate",
G_CALLBACK (page_holder_deactivate_cb), notebook);
g_object_unref (panel);
}
static void cm_create_toolbar(CookieManagerPage *cmp)
{
CookieManagerPagePrivate *priv = cmp->priv;
GtkWidget *toolbar;
GtkToolItem *toolitem;
priv->toolbar = toolbar = gtk_toolbar_new();
toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_DELETE);
gtk_tool_item_set_is_important(toolitem, TRUE);
g_signal_connect(toolitem, "clicked", G_CALLBACK(cm_button_delete_clicked_cb), cmp);
gtk_widget_show(GTK_WIDGET(toolitem));
gtk_widget_set_sensitive(GTK_WIDGET(toolitem), FALSE);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
priv->delete_button = GTK_WIDGET(toolitem);
toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_DELETE);
gtk_tool_button_set_label(GTK_TOOL_BUTTON(toolitem), _("Delete All"));
gtk_tool_item_set_tooltip_text(toolitem,
_("Deletes all shown cookies. "
"If a filter is set, only those cookies are deleted which match the filter."));
gtk_tool_item_set_is_important(toolitem, TRUE);
g_signal_connect(toolitem, "clicked", G_CALLBACK(cm_button_delete_all_clicked_cb), cmp);
gtk_widget_show(GTK_WIDGET(toolitem));
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
priv->delete_all_button = GTK_WIDGET(toolitem);
toolitem = gtk_separator_tool_item_new();
gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(toolitem), FALSE);
gtk_tool_item_set_expand(toolitem, TRUE);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
gtk_widget_show(GTK_WIDGET(toolitem));
toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_ADD);
gtk_tool_item_set_tooltip_text(toolitem, _("Expand All"));
g_signal_connect(toolitem, "clicked", G_CALLBACK(cm_tree_popup_expand_activate_cb), cmp);
gtk_widget_show(GTK_WIDGET(toolitem));
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
priv->expand_buttons[0] = GTK_WIDGET(toolitem);
toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_REMOVE);
gtk_tool_item_set_tooltip_text(toolitem, _("Collapse All"));
g_signal_connect(toolitem, "clicked", G_CALLBACK(cm_tree_popup_collapse_activate_cb), cmp);
gtk_widget_show(GTK_WIDGET(toolitem));
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
priv->expand_buttons[1] = GTK_WIDGET(toolitem);
}
GtkWidget *getToolbar(){
GtkToolItem *tool_item; //tool item widget
GtkTooltips *tooltip; //tooltip widget
//Create the toolbar
toolbar = gtk_toolbar_new();
//Set the style of toolbar
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
//Set the border width of toolbar
gtk_container_set_border_width(GTK_CONTAINER(toolbar), BORDER_WIDTH_SIZE);
//Create the tooltip
tooltip = gtk_tooltips_new();
//Create the setup tool item
tool_item = gtk_tool_button_new_from_stock(GTK_STOCK_NETWORK);
//Set the tooltip on the tool item
gtk_tooltips_set_tip(tooltip, GTK_WIDGET(tool_item), "Setup", NULL);
//Insert the tool item into toolbar
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_item, -1);
//Create the play tool item
tool_item = gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_PLAY);
//Set the tooltip on the tool item
gtk_tooltips_set_tip(tooltip, GTK_WIDGET(tool_item), "Play", NULL);
//Insert the tool item into toolbar
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_item, -1);
//Create the teardown tool item
tool_item = gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_STOP);
//Set the tooltip on the tool item
gtk_tooltips_set_tip(tooltip, GTK_WIDGET(tool_item), "Teardown", NULL);
//Insert the tool item into toolbar
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_item, -1);
//Create the separator tool item
tool_item = gtk_separator_tool_item_new();
//Insert the tool item into toolbar
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_item, -1);
//Create the quit tool item
tool_item = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT);
//Set the tooltip on the tool item
gtk_tooltips_set_tip(tooltip, GTK_WIDGET(tool_item), "Quit", NULL);
//Insert the tool item into toolbar
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_item, -1);
return toolbar;
}
static GtkWidget*
create_toolbar (GtkWidget *window)
{
/* Create toolbar */
GtkToolbar *toolbar = GTK_TOOLBAR (gtk_toolbar_new ());
gtk_toolbar_set_icon_size (toolbar, GTK_ICON_SIZE_LARGE_TOOLBAR);
GtkToolItem *quit;
toolbar_add_button (toolbar,
gtk_menu_tool_button_new_from_stock (GTK_STOCK_GOTO_FIRST),
FOLDING_TAB_PANE_GET_FROM_WINDOW (window, FOLDING_TAB_PANE_LEFT));
toolbar_add_button (toolbar,
gtk_menu_tool_button_new_from_stock (GTK_STOCK_GOTO_LAST),
FOLDING_TAB_PANE_GET_FROM_WINDOW (window, FOLDING_TAB_PANE_RIGHT));
toolbar_add_button (toolbar,
gtk_menu_tool_button_new_from_stock (GTK_STOCK_GOTO_TOP),
FOLDING_TAB_PANE_GET_FROM_WINDOW (window, FOLDING_TAB_PANE_TOP));
toolbar_add_button (toolbar,
gtk_menu_tool_button_new_from_stock (GTK_STOCK_GOTO_BOTTOM),
FOLDING_TAB_PANE_GET_FROM_WINDOW (window, FOLDING_TAB_PANE_BOTTOM));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), gtk_separator_tool_item_new(),
gtk_toolbar_get_n_items (toolbar));
quit = gtk_tool_button_new_from_stock (GTK_STOCK_QUIT);
gtk_toolbar_insert (toolbar, quit,
gtk_toolbar_get_n_items (toolbar));
g_signal_connect (G_OBJECT (quit), "clicked",
G_CALLBACK (application_shutdown), toolbar);
return GTK_WIDGET (toolbar);
}
static void gigolo_bookmark_panel_init(GigoloBookmarkPanel *self)
{
GtkWidget *swin, *toolbar;
GtkToolItem *toolitem;
GigoloBookmarkPanelPrivate *priv = gigolo_bookmark_panel_get_instance_private(self);
gtk_orientable_set_orientation (GTK_ORIENTABLE (self), GTK_ORIENTATION_VERTICAL);
toolbar = gtk_toolbar_new();
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_BOTH_HORIZ);
gtk_toolbar_set_icon_size(GTK_TOOLBAR(toolbar), GTK_ICON_SIZE_BUTTON);
toolitem = gtk_tool_button_new(gtk_image_new_from_icon_name ("gtk-connect",
gtk_toolbar_get_icon_size(GTK_TOOLBAR(toolbar))), NULL);
gtk_widget_set_tooltip_text(GTK_WIDGET(toolitem), _("Connect to the selected bookmark"));
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
g_signal_connect(toolitem, "clicked", G_CALLBACK(button_connect_click_cb), self);
priv->button_connect = GTK_WIDGET(toolitem);
toolitem = gtk_separator_tool_item_new();
gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(toolitem), FALSE);
gtk_tool_item_set_expand(toolitem, TRUE);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
toolitem = gtk_tool_button_new(gtk_image_new_from_icon_name ("gtk-close",
gtk_toolbar_get_icon_size(GTK_TOOLBAR(toolbar))), NULL);
gtk_widget_set_tooltip_text(GTK_WIDGET(toolitem), _("Close panel"));
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
g_signal_connect(toolitem, "clicked", G_CALLBACK(button_close_click_cb), self);
tree_prepare(self);
swin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(swin), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(swin), priv->tree);
gtk_box_pack_start(GTK_BOX(self), toolbar, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self), swin, TRUE, TRUE, 0);
gtk_widget_show_all(toolbar);
gtk_widget_show_all(swin);
}
static void
toolbar_add_button (GtkToolbar *toolbar,
GtkToolItem *button,
FoldingTabPane *pane_to_handle)
{
gtk_toolbar_insert (toolbar, gtk_separator_tool_item_new(),
gtk_toolbar_get_n_items (toolbar));
gtk_toolbar_insert (toolbar, button,
gtk_toolbar_get_n_items (toolbar));
gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (button),
create_toolbar_button_menu ());
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (toolbar_button_clicked), pane_to_handle);
}
/*
*===========================================================================
* T O O L B A R
*===========================================================================
*/
GtkWidget*
createToolbar()
{
GtkWidget* toolbar;
GtkToolItem* toolitem;
toolbar = gtk_toolbar_new();
toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_ADD);
gtk_toolbar_insert((GtkToolbar *)toolbar, toolitem, -1);
toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_APPLY);
gtk_toolbar_insert((GtkToolbar *)toolbar, toolitem, -1);
toolitem = gtk_separator_tool_item_new();
gtk_toolbar_insert((GtkToolbar *)toolbar, toolitem, -1);
toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_ABOUT);
gtk_toolbar_insert((GtkToolbar *)toolbar, toolitem, -1);
return toolbar;
}
Gtk::Widget * Ganash::ApplicationWindow::setupTool()
{
GtkWidget *toolbar;
GtkToolItem *item_new;
GtkToolItem *item_open;
GtkToolItem *item_save;
GtkToolItem *item_sep;
GtkToolItem *item_exit;
toolbar = gtk_toolbar_new();
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
//gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_SMALL_TOOLBAR);
GtkStyleContext *context;
context = gtk_widget_get_style_context(toolbar);
gtk_style_context_add_class(context, "primary-toolbar");
gtk_container_set_border_width(GTK_CONTAINER(toolbar), 0);
item_new = gtk_tool_button_new_from_stock(GTK_STOCK_NEW);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item_new, -1);
item_open = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item_open, -1);
item_save = gtk_tool_button_new_from_stock(GTK_STOCK_SAVE);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item_save, -1);
item_sep = gtk_separator_tool_item_new();
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item_sep, -1);
item_exit = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item_exit, -1);
return Glib::wrap(toolbar);
}
static GtkToolItem *
create_item_from_action (EggEditableToolbar *etoolbar,
const char *name)
{
GtkToolItem *item;
g_return_val_if_fail (name != NULL, NULL);
if (strcmp (name, "_separator") == 0)
{
item = gtk_separator_tool_item_new ();
}
else
{
GtkAction *action = find_action (etoolbar, name);
if (action == NULL) return NULL;
item = GTK_TOOL_ITEM (gtk_action_create_tool_item (action));
/* Normally done on-demand by the GtkUIManager, but no
* such demand may have been made yet, so do it ourselves.
*/
gtk_action_set_accel_group
(action, gtk_ui_manager_get_accel_group(etoolbar->priv->manager));
g_signal_connect_object (action, "notify::sensitive",
G_CALLBACK (action_sensitive_cb), item, 0);
}
gtk_widget_show (GTK_WIDGET (item));
g_object_set_data_full (G_OBJECT (item), EGG_ITEM_NAME,
g_strdup (name), g_free);
return item;
}
bool wxToolBar::DoInsertTool(size_t pos, wxToolBarToolBase *toolBase)
{
wxToolBarTool* tool = static_cast<wxToolBarTool*>(toolBase);
GSList* radioGroup;
switch ( tool->GetStyle() )
{
case wxTOOL_STYLE_BUTTON:
switch (tool->GetKind())
{
case wxITEM_CHECK:
tool->m_item = gtk_toggle_tool_button_new();
g_signal_connect(tool->m_item, "toggled",
G_CALLBACK(item_toggled), tool);
break;
case wxITEM_RADIO:
radioGroup = GetRadioGroup(pos);
if (radioGroup)
{
// this is the first button in the radio button group,
// it will be toggled automatically by GTK so bring the
// internal flag in sync
tool->Toggle(true);
}
tool->m_item = gtk_radio_tool_button_new(radioGroup);
g_signal_connect(tool->m_item, "toggled",
G_CALLBACK(item_toggled), tool);
break;
default:
wxFAIL_MSG("unknown toolbar child type");
// fall through
case wxITEM_DROPDOWN:
case wxITEM_NORMAL:
tool->m_item = gtk_tool_button_new(NULL, "");
g_signal_connect(tool->m_item, "clicked",
G_CALLBACK(item_clicked), tool);
break;
}
if (!HasFlag(wxTB_NOICONS))
{
GtkWidget* image = gtk_image_new();
gtk_tool_button_set_icon_widget(
GTK_TOOL_BUTTON(tool->m_item), image);
tool->SetImage();
gtk_widget_show(image);
g_signal_connect(image, "expose_event",
G_CALLBACK(image_expose_event), tool);
}
if (!tool->GetLabel().empty())
{
gtk_tool_button_set_label(
GTK_TOOL_BUTTON(tool->m_item), wxGTK_CONV(tool->GetLabel()));
// needed for labels in horizontal toolbar with wxTB_HORZ_LAYOUT
gtk_tool_item_set_is_important(tool->m_item, true);
}
if (!HasFlag(wxTB_NO_TOOLTIPS) && !tool->GetShortHelp().empty())
{
gtk_tool_item_set_tooltip(tool->m_item,
m_tooltips, wxGTK_CONV(tool->GetShortHelp()), "");
}
g_signal_connect(GTK_BIN(tool->m_item)->child, "button_press_event",
G_CALLBACK(button_press_event), tool);
g_signal_connect(tool->m_item, "enter_notify_event",
G_CALLBACK(enter_notify_event), tool);
g_signal_connect(tool->m_item, "leave_notify_event",
G_CALLBACK(enter_notify_event), tool);
if (tool->GetKind() == wxITEM_DROPDOWN)
tool->CreateDropDown();
gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos));
break;
case wxTOOL_STYLE_SEPARATOR:
tool->m_item = gtk_separator_tool_item_new();
gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos));
break;
case wxTOOL_STYLE_CONTROL:
wxWindow* control = tool->GetControl();
if (control->m_widget->parent == NULL)
AddChildGTK(control);
tool->m_item = GTK_TOOL_ITEM(control->m_widget->parent->parent);
if (gtk_toolbar_get_item_index(m_toolbar, tool->m_item) != int(pos))
{
g_object_ref(tool->m_item);
gtk_container_remove(
GTK_CONTAINER(m_toolbar), GTK_WIDGET(tool->m_item));
gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos));
g_object_unref(tool->m_item);
}
// Inserted items "slide" into place using an animated effect that
// causes multiple size events on the item. Must set size request
// to keep item size from getting permanently set too small by the
// first of these size events.
const wxSize size = control->GetSize();
gtk_widget_set_size_request(control->m_widget, size.x, size.y);
break;
}
gtk_widget_show(GTK_WIDGET(tool->m_item));
InvalidateBestSize();
return true;
}
EvAlaGtk::EvAlaGtk( void *ev_parent_ctx,
GtkWidget *ev_parent_wid,
char *ala_name,
pwr_tObjid ev_user,
int ev_eventname_seg,
int ev_width,
int ev_height,
int ev_x,
int ev_y,
pwr_tObjid ev_view,
unsigned int ev_options,
void *widget,
pwr_tStatus *status) :
EvAla( ev_parent_ctx, ala_name, ev_user, ev_eventname_seg,
ev_width, ev_height, ev_x, ev_y, ev_view, ev_options, status),
parent_wid(ev_parent_wid), toplevel(0)
{
pwr_tStatus sts;
pwr_sClass_OpPlace *opp;
pwr_tFileName fname;
int ala_width = 700;
int ala_height = 300;
*status = 1;
if ( ev_width != 0 && ev_height != 0) {
ala_width = ev_width;
ala_height = ev_height;
}
// Check user object
if ( cdh_ObjidIsNull( user)) {
*status = XNAV__NOUSER;
return;
}
sts = gdh_ObjidToPointer( user, (pwr_tAddress *) &opp);
if ( EVEN(sts)) {
*status = XNAV__NOUSER;
return;
}
ala_size = opp->MaxNoOfAlarms;
// create_aliaslist( opp);
// Ala Window
if ( !(options & ev_mAlaOptions_Embedded)) {
toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", ala_height,
"default-width", ala_width,
"title", CoWowGtk::translate_utf8(ala_name),
NULL);
parent_wid_ala = toplevel;
g_signal_connect( parent_wid_ala, "delete_event", G_CALLBACK(ala_delete_event), this);
g_signal_connect( parent_wid_ala, "destroy", G_CALLBACK(ala_destroy_event), this);
g_signal_connect( parent_wid_ala, "focus-in-event", G_CALLBACK(ala_action_inputfocus), this);
CoWowGtk::SetWindowIcon( parent_wid_ala);
}
else
parent_wid_ala = (GtkWidget *)widget;
ala_vbox = gtk_vbox_new( FALSE, 0);
// Menu
// Accelerators
GtkAccelGroup *accel_g = (GtkAccelGroup *) g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
gtk_window_add_accel_group(GTK_WINDOW(parent_wid_ala), accel_g);
GtkMenuBar *menu_bar = (GtkMenuBar *) g_object_new(GTK_TYPE_MENU_BAR, NULL);
// File entry
GtkWidget *file_print = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Print"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(file_print),
gtk_image_new_from_stock( "gtk-print", GTK_ICON_SIZE_MENU));
g_signal_connect(file_print, "activate", G_CALLBACK(ala_activate_print), this);
GtkWidget *file_close = gtk_image_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Close"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(file_close),
gtk_image_new_from_stock( "gtk-close", GTK_ICON_SIZE_MENU));
g_signal_connect(file_close, "activate", G_CALLBACK(ala_activate_exit), this);
gtk_widget_add_accelerator( file_close, "activate", accel_g,
'w', GdkModifierType(GDK_CONTROL_MASK), GTK_ACCEL_VISIBLE);
GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_print);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);
GtkWidget *file = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_File"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));
// Functions entry
GtkWidget *functions_ack_last = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Acknowledge"));
g_signal_connect( functions_ack_last, "activate",
G_CALLBACK(ala_activate_ack_last), this);
gtk_widget_add_accelerator( functions_ack_last, "activate", accel_g,
'k', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_ack_all = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("A_cknowledge All"));
g_signal_connect( functions_ack_all, "activate",
G_CALLBACK(ala_activate_ack_all), this);
GtkWidget *functions_open_plc = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("Open _Program"));
g_signal_connect( functions_open_plc, "activate",
G_CALLBACK(ala_activate_open_plc), this);
gtk_widget_add_accelerator( functions_open_plc, "activate", accel_g,
'l', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_display_object = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Display object in Navigator"));
g_signal_connect( functions_display_object, "activate",
G_CALLBACK(ala_activate_display_in_xnav), this);
gtk_widget_add_accelerator( functions_display_object, "activate", accel_g,
'd', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkMenu *func_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), functions_ack_last);
gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), functions_ack_all);
gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), functions_open_plc);
gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), functions_display_object);
GtkWidget *functions = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Functions"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), functions);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(functions), GTK_WIDGET(func_menu));
// View entry
GtkWidget *view_shift_view = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("S_hift View"));
g_signal_connect( view_shift_view, "activate",
G_CALLBACK(ala_activate_shift_view), this);
gtk_widget_add_accelerator( view_shift_view, "activate", accel_g,
'n', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_in = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Zoom _In"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(view_zoom_in),
gtk_image_new_from_stock( "gtk-zoom-in", GTK_ICON_SIZE_MENU));
g_signal_connect( view_zoom_in, "activate",
G_CALLBACK(ala_activate_zoom_in), this);
gtk_widget_add_accelerator( view_zoom_in, "activate", accel_g,
'i', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_out = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Zoom _Out"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(view_zoom_out),
gtk_image_new_from_stock( "gtk-zoom-out", GTK_ICON_SIZE_MENU));
g_signal_connect( view_zoom_out, "activate",
G_CALLBACK(ala_activate_zoom_out), this);
gtk_widget_add_accelerator( view_zoom_out, "activate", accel_g,
'o', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_reset = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Zoom _Reset"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(view_zoom_reset),
gtk_image_new_from_stock( "gtk-zoom-100", GTK_ICON_SIZE_MENU));
g_signal_connect( view_zoom_reset, "activate",
G_CALLBACK(ala_activate_zoom_reset), this);
gtk_widget_add_accelerator( view_zoom_reset, "activate", accel_g,
'b', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *view_disp_hundredth = gtk_check_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Display hundredth"));
g_signal_connect( view_disp_hundredth, "activate",
G_CALLBACK(ala_activate_disp_hundredth), this);
GtkWidget *view_hide_object = gtk_check_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Hide Event Name"));
g_signal_connect( view_hide_object, "activate",
G_CALLBACK(ala_activate_hide_object), this);
GtkWidget *view_hide_text = gtk_check_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("Hide _Event Text"));
g_signal_connect( view_hide_text, "activate",
G_CALLBACK(ala_activate_hide_text), this);
// Submenu Select View
GtkWidget *view_select_flat = gtk_menu_item_new_with_mnemonic( "_Flat");
g_signal_connect( view_select_flat, "activate",
G_CALLBACK(ala_activate_select_flat), this);
GtkWidget *view_select = gtk_menu_item_new_with_mnemonic( "_Select View");
GtkMenu *view_select_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_select_menu), view_select_flat);
for ( unsigned int i = 0; i < sizeof(opp->AlarmViews)/sizeof(opp->AlarmViews[0]); i++) {
pwr_sClass_AlarmView *viewp;
if ( cdh_ObjidIsNull( opp->AlarmViews[i]))
break;
sts = gdh_ObjidToPointer( opp->AlarmViews[i], (void **)&viewp);
if ( ODD(sts)) {
alarm_views[i] = opp->AlarmViews[i];
GtkWidget *view_select_view = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8(viewp->Name));
switch ( i) {
case 0: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view1), this); break;
case 1: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view2), this); break;
case 2: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view3), this); break;
case 3: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view4), this); break;
case 4: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view5), this); break;
case 5: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view6), this); break;
case 6: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view7), this); break;
case 7: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view8), this); break;
case 8: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view9), this); break;
case 9: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view10), this); break;
case 10: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view11), this); break;
case 11: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view12), this); break;
case 12: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view13), this); break;
case 13: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view14), this); break;
case 14: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view15), this); break;
case 15: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view16), this); break;
case 16: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view17), this); break;
case 17: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view18), this); break;
case 18: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view19), this); break;
case 19: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view20), this); break;
case 20: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view21), this); break;
case 21: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view22), this); break;
case 22: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view23), this); break;
case 23: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view24), this); break;
case 24: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view25), this); break;
}
gtk_menu_shell_append(GTK_MENU_SHELL(view_select_menu), view_select_view);
}
}
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view_select),
GTK_WIDGET(view_select_menu));
GtkMenu *view_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_shift_view);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_select);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_in);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_out);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_reset);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_disp_hundredth);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_hide_object);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_hide_text);
GtkWidget *view = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_View"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), view);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), GTK_WIDGET(view_menu));
// Help entry
GtkWidget *help_help = gtk_image_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Help"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(help_help),
gtk_image_new_from_stock( "gtk-help", GTK_ICON_SIZE_MENU));
g_signal_connect(help_help, "activate", G_CALLBACK(ala_activate_help), this);
gtk_widget_add_accelerator( help_help, "activate", accel_g,
'h', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *help_helpevent = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("Help Selected Event"));
g_signal_connect( help_helpevent, "activate",
G_CALLBACK(ala_activate_helpevent), this);
GtkMenu *help_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_helpevent);
GtkWidget *help = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Help"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu));
// Create ala evlist
ala = new EvListGtk( this, ala_vbox, ev_eType_AlarmList, ala_size, eventname_seg,
&ala_widget, ala_init_cb);
ala->start_trace_cb = &ala_start_trace_cb;
ala->display_in_xnav_cb =&ala_display_in_xnav_cb;
ala->name_to_alias_cb = &ala_name_to_alias_cb;
ala->popup_menu_cb = &ala_popup_menu_cb;
ala->sound_cb = &ala_sound_cb;
ala->help_event_cb = &help_event_cb;
ala->selection_changed_cb = &ala_selection_changed_cb;
// Toolbar
GtkToolbar *tools = (GtkToolbar *) g_object_new(GTK_TYPE_TOOLBAR, NULL);
GtkWidget *tools_ack = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_acknowledge.png");
gtk_container_add( GTK_CONTAINER( tools_ack), gtk_image_new_from_file( fname));
g_signal_connect(tools_ack, "clicked", G_CALLBACK(ala_activate_ack_last), this);
g_object_set( tools_ack, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_ack, CoWowGtk::translate_utf8("Acknowledge"), "");
GtkWidget *tools_zoom_in = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_in.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_in),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_in, "clicked", G_CALLBACK(ala_activate_zoom_in), this);
g_object_set( tools_zoom_in, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_in,CoWowGtk::translate_utf8("Zoom in"), "");
GtkWidget *tools_zoom_out = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_out.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_out),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_out, "clicked", G_CALLBACK(ala_activate_zoom_out), this);
g_object_set( tools_zoom_out, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_out,CoWowGtk::translate_utf8("Zoom out"), "");
GtkWidget *tools_zoom_reset = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_reset.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_reset),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_reset, "clicked", G_CALLBACK(ala_activate_zoom_reset), this);
g_object_set( tools_zoom_reset, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_reset,CoWowGtk::translate_utf8("Zoom reset"), "");
ala_methodtoolbar = new XttMethodToolbarGtk(0, 0, ~0, "");
GtkToolbar *tools_meth = (GtkToolbar *) ((XttMethodToolbarGtk *)ala_methodtoolbar)->build();
ala_methodtoolbar->m_xnav = (XNav *)((Ev *)parent_ctx)->parent_ctx;
ala_methodtoolbar->m_parent_ctx = ala;
ala_methodtoolbar->get_select_cb = ala->get_select;
ala_sup_methodtoolbar = new XttMethodToolbarGtk(0, 0, mt_mMethod_OpenPlc | mt_mMethod_RtNavigator,
" for supervisory object");
GtkToolbar *tools_sup = (GtkToolbar *) ((XttMethodToolbarGtk *)ala_sup_methodtoolbar)->build();
ala_sup_methodtoolbar->m_xnav = (XNav *)((Ev *)parent_ctx)->parent_ctx;
ala_sup_methodtoolbar->m_parent_ctx = ala;
ala_sup_methodtoolbar->get_select_cb = ala->get_select_supobject;
GtkWidget *ala_toolsbox = gtk_hbox_new( FALSE, 0);
gtk_box_pack_start( GTK_BOX(ala_toolsbox), GTK_WIDGET(tools), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(ala_toolsbox), GTK_WIDGET(gtk_separator_tool_item_new()), FALSE, FALSE, 4);
gtk_box_pack_start( GTK_BOX(ala_toolsbox), GTK_WIDGET(tools_sup), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(ala_toolsbox), GTK_WIDGET(gtk_separator_tool_item_new()), FALSE, FALSE, 4);
gtk_box_pack_start( GTK_BOX(ala_toolsbox), GTK_WIDGET(tools_meth), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(ala_vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(ala_vbox), GTK_WIDGET(ala_toolsbox), FALSE, FALSE, 0);
gtk_box_pack_end( GTK_BOX(ala_vbox), GTK_WIDGET(ala_widget), TRUE, TRUE, 0);
if ( !(options & ev_mAlaOptions_Embedded)) {
gtk_container_add( GTK_CONTAINER(parent_wid_ala), ala_vbox);
}
// gtk_widget_show_all( parent_wid_ala);
ala_methodtoolbar->set_sensitive();
ala_sup_methodtoolbar->set_sensitive();
// }
if ( !(options & ev_mAlaOptions_Embedded)) {
gtk_widget_show_all( parent_wid_ala);
if ( !(x == 0 && y == 0)) {
// Set position
gtk_window_move( GTK_WINDOW(parent_wid_ala), x, y);
}
}
else
gtk_widget_set_size_request( ala_vbox, ala_width, ala_height);
ala_displayed = 1;
wow = new CoWowGtk( parent_wid_ala);
*status = 1;
}
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);
}
}
