void set_toolbar_appearance (GtkToolbar *toolbar, int style, int tips) {
switch (style) {
case 0: gtk_toolbar_set_style (toolbar, GTK_TOOLBAR_ICONS); break;
case 1: gtk_toolbar_set_style (toolbar, GTK_TOOLBAR_TEXT); break;
case 2: gtk_toolbar_set_style (toolbar, GTK_TOOLBAR_BOTH); break;
default: break;
}
gtk_toolbar_set_tooltips (toolbar, tips);
}
void GTKMusicBrowser::SetToolbarType(void)
{
bool useText, useImages;
m_context->prefs->GetPrefBoolean(kShowToolbarTextLabelsPref, &useText);
m_context->prefs->GetPrefBoolean(kShowToolbarImagesPref, &useImages);
if (useText && useImages)
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_BOTH);
else if (useText)
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_TEXT);
else if (useImages)
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
}
void
liferea_shell_set_toolbar_style (const gchar *toolbar_style)
{
if (!toolbar_style) /* default to icons */
gtk_toolbar_set_style (GTK_TOOLBAR (shell->priv->toolbar), GTK_TOOLBAR_ICONS);
else if (g_str_equal (toolbar_style, "text"))
gtk_toolbar_set_style (GTK_TOOLBAR (shell->priv->toolbar), GTK_TOOLBAR_TEXT);
else if (g_str_equal (toolbar_style, "both"))
gtk_toolbar_set_style (GTK_TOOLBAR (shell->priv->toolbar), GTK_TOOLBAR_BOTH);
else if (g_str_equal (toolbar_style, "both_horiz") || g_str_equal (toolbar_style, "both-horiz") )
gtk_toolbar_set_style (GTK_TOOLBAR (shell->priv->toolbar), GTK_TOOLBAR_BOTH_HORIZ);
else /* default to icons */
gtk_toolbar_set_style (GTK_TOOLBAR (shell->priv->toolbar), GTK_TOOLBAR_ICONS);
}
void widgets_get_bottom_toolbar(GtkWidget **toolbar){
GtkToolItem *new_tool_item;
GtkWidget *new_tool_item_icon;
*toolbar = gtk_toolbar_new();
gtk_toolbar_set_style(GTK_TOOLBAR(*toolbar), GTK_TOOLBAR_ICONS);
int i;
int nicons = sizeof toolbar_item_icons / sizeof (*toolbar_item_icons);
for (i = 0; i < nicons; i++){
new_tool_item_icon = gtk_image_new_from_file(toolbar_item_icons[i].path_to_image);
new_tool_item = gtk_tool_button_new(new_tool_item_icon,toolbar_item_icons[i].name);
FormShifterToolItemType tool_type = toolbar_item_icons[i].type;
switch(tool_type){
/*case XPainter_UNDO_TOOL:
g_signal_connect(new_tool_item, "clicked", G_CALLBACK(undo), NULL);
break;
case XPainter_REDO_TOOL:
g_signal_connect(new_tool_item, "clicked", G_CALLBACK(redo), NULL);
break;*/
default:
g_signal_connect(new_tool_item, "clicked", G_CALLBACK(assign_current_tool), (gpointer) tool_type);
break;
}
gtk_toolbar_insert(GTK_TOOLBAR(*toolbar), new_tool_item, -1);
gtk_widget_set_can_focus ((GtkWidget*) new_tool_item, TRUE);
}
}
GtkWidget *hwidget_get_toolbar(HviewWidgetsT *w)
{
GtkWidget *tbar;
GtkToolItem *but;
tbar = gtk_toolbar_new();
gtk_toolbar_set_style(GTK_TOOLBAR(tbar), GTK_TOOLBAR_BOTH);
but = hwidget_get_tool_button("close.png", "Close", "Close session",
hview_session_close_call, w,
HWIDGET_TOOL_BUTTON);
gtk_toolbar_insert(GTK_TOOLBAR(tbar), but, -1);
but = hwidget_get_tool_button("discover.png", "Discover",
"Discover domain", hview_discover_call,
w, HWIDGET_TOOL_BUTTON);
gtk_toolbar_insert(GTK_TOOLBAR(tbar), but, -1);
but = hwidget_get_tool_button("sub_events.png", "Subscribe",
"Subscribe events",
hview_subscribe_events_call,
w,
HWIDGET_TOOL_BUTTON);
gtk_toolbar_insert(GTK_TOOLBAR(tbar), but, -1);
w->subev_item = but;
but = hwidget_get_tool_button("get_events.png", "Get event",
"Get event", hview_get_events_call,
w, HWIDGET_TOOL_BUTTON);
gtk_toolbar_insert(GTK_TOOLBAR(tbar), but, -1);
return tbar;
}
void
downloadmanager_setup(void)
{
dm.win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_type_hint(GTK_WINDOW(dm.win), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_default_size(GTK_WINDOW(dm.win), 500, 250);
gtk_window_set_title(GTK_WINDOW(dm.win), __NAME__" - Download Manager");
g_signal_connect(G_OBJECT(dm.win), "delete-event",
G_CALLBACK(gtk_widget_hide_on_delete), NULL);
g_signal_connect(G_OBJECT(dm.win), "key-press-event",
G_CALLBACK(key_downloadmanager), NULL);
dm.toolbar = gtk_toolbar_new();
gtk_orientable_set_orientation(GTK_ORIENTABLE(dm.toolbar),
GTK_ORIENTATION_VERTICAL);
gtk_toolbar_set_style(GTK_TOOLBAR(dm.toolbar), GTK_TOOLBAR_BOTH_HORIZ);
gtk_toolbar_set_show_arrow(GTK_TOOLBAR(dm.toolbar), FALSE);
dm.scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(dm.scroll),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(dm.scroll), dm.toolbar);
gtk_container_add(GTK_CONTAINER(dm.win), dm.scroll);
}
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);
}
void roadmap_main_add_tool (const char *label,
const char *icon,
const char *tip,
RoadMapCallback callback) {
if (RoadMapMainToolbar == NULL) {
RoadMapMainToolbar = gtk_toolbar_new ();
gtk_box_pack_start (GTK_BOX(RoadMapMainBox),
RoadMapMainToolbar, FALSE, FALSE, 0);
}
gtk_toolbar_append_item (GTK_TOOLBAR(RoadMapMainToolbar),
label, tip, NULL,
roadmap_main_toolbar_icon (icon),
(GtkSignalFunc) roadmap_main_activate, callback);
if (gdk_screen_height() < 550)
{
/* When using a small screen, we want either the labels or the icons,
* but not both (small screens are typical with PDAs).
*/
gtk_toolbar_set_style
(GTK_TOOLBAR(RoadMapMainToolbar),
GtkIconsInitialized?GTK_TOOLBAR_ICONS:GTK_TOOLBAR_TEXT);
}
}
static void create_toolbar_menu()
{
GtkWidget *iconw;
GtkWidget *close_button;
bdk_window.toolbar = gtk_toolbar_new ();
gtk_toolbar_set_orientation (GTK_TOOLBAR (bdk_window.toolbar), GTK_ORIENTATION_HORIZONTAL);
gtk_toolbar_set_style (GTK_TOOLBAR (bdk_window.toolbar), GTK_TOOLBAR_BOTH);
/* our first item is <close> button */
iconw = gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_SMALL_TOOLBAR) ; // ("gtk.xpm"); /* icon widget */
close_button =
gtk_toolbar_append_item (GTK_TOOLBAR (bdk_window.toolbar), /* our toolbar */
"Open", /* button label */
"Open a file", /* this button's tooltip */
"Private", /* tooltip private info */
iconw, /* icon widget */
GTK_SIGNAL_FUNC (open_event), /* a signal */
NULL);
gtk_toolbar_append_space (GTK_TOOLBAR (bdk_window.toolbar)); /* space after item */
/* our first item is <close> button */
iconw = gtk_image_new_from_stock (GTK_STOCK_QUIT, GTK_ICON_SIZE_SMALL_TOOLBAR) ; // ("gtk.xpm"); /* icon widget */
close_button =
gtk_toolbar_append_item( GTK_TOOLBAR (bdk_window.toolbar), /* our toolbar */
"Close", /* button label */
"Closes this app", /* this button's tooltip */
"Private", /* tooltip private info */
iconw, /* icon widget */
GTK_SIGNAL_FUNC (gtk_main_quit), /* a signal */
NULL);
gtk_box_pack_start (GTK_BOX (bdk_window.main_vbox), bdk_window.toolbar, FALSE, TRUE, 0);
}
static void
on_toolbar_style_changed (GSettings* settings,
const gchar* key,
gpointer user_data)
{
AnjutaWindow* win = ANJUTA_WINDOW (user_data);
gchar* tb_style = g_settings_get_string (settings, key);
if (strcasecmp (tb_style, "Default") == 0)
style = -1;
else if (strcasecmp (tb_style, "Both") == 0)
style = GTK_TOOLBAR_BOTH;
else if (strcasecmp (tb_style, "Horiz") == 0)
style = GTK_TOOLBAR_BOTH_HORIZ;
else if (strcasecmp (tb_style, "Icons") == 0)
style = GTK_TOOLBAR_ICONS;
else if (strcasecmp (tb_style, "Text") == 0)
style = GTK_TOOLBAR_TEXT;
if (style != -1)
{
gtk_toolbar_set_style (GTK_TOOLBAR (win->toolbar), style);
}
else
{
gtk_toolbar_unset_style (GTK_TOOLBAR (win->toolbar));
}
g_free (tb_style);
}
static void create_toolbar() {
browser->toolbar = gtk_toolbar_new();
#ifndef GTK_ORIENTABLE
gtk_toolbar_set_orientation(GTK_TOOLBAR (browser->toolbar), GTK_ORIENTATION_HORIZONTAL);
#else
gtk_orientable_set_orientation(GTK_ORIENTABLE (browser->toolbar), GTK_ORIENTATION_HORIZONTAL);
#endif
gtk_toolbar_set_style(GTK_TOOLBAR (browser->toolbar), GTK_TOOLBAR_BOTH_HORIZ);
GtkToolItem* item;
/* the back button */
item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_BACK);
g_signal_connect (G_OBJECT (item), "clicked", G_CALLBACK (go_back_cb), (gpointer) browser);
gtk_toolbar_insert(GTK_TOOLBAR (browser->toolbar), item, -1);
/* The forward button */
item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_FORWARD);
g_signal_connect (G_OBJECT (item), "clicked", G_CALLBACK (go_forward_cb), (gpointer) browser);
gtk_toolbar_insert(GTK_TOOLBAR (browser->toolbar), item, -1);
/* The URL entry */
item = gtk_tool_item_new();
gtk_tool_item_set_expand(item, TRUE);
browser->uri_entry = gtk_entry_new();
gtk_container_add(GTK_CONTAINER (item), browser->uri_entry);
g_signal_connect (G_OBJECT (browser->uri_entry), "activate", G_CALLBACK (activate_uri_entry_cb), (gpointer)browser);
gtk_toolbar_insert(GTK_TOOLBAR (browser->toolbar), item, -1);
/* The go button */
item = gtk_tool_button_new_from_stock(GTK_STOCK_OK);
g_signal_connect_swapped (G_OBJECT (item), "clicked", G_CALLBACK (activate_uri_entry_cb), (gpointer)browser->uri_entry);
gtk_toolbar_insert(GTK_TOOLBAR (browser->toolbar), item, -1);
}
static GtkWidget* create_toolbar()
{
GtkWidget* toolbar=gtk_toolbar_new();
gtk_toolbar_set_orientation(GTK_TOOLBAR (toolbar), GTK_ORIENTATION_HORIZONTAL);
gtk_toolbar_set_style(GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH_HORIZ);
GtkToolItem* item;
// botao para voltar
item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_BACK);
g_signal_connect(G_OBJECT (item), "clicked", G_CALLBACK (go_back_box), NULL);
gtk_toolbar_insert(GTK_TOOLBAR (toolbar), item, -1);
// botao para ir para url que esta antes
item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_FORWARD);
g_signal_connect(G_OBJECT (item), "clicked", G_CALLBACK (go_forward_box), NULL);
gtk_toolbar_insert(GTK_TOOLBAR (toolbar), item, -1);
// form de entrada de url
item = gtk_tool_item_new();
gtk_tool_item_set_expand(item, TRUE);
uri_entry = gtk_entry_new();
gtk_container_add(GTK_CONTAINER (item), uri_entry);
g_signal_connect(G_OBJECT (uri_entry), "activate", G_CALLBACK (activate_uri_entry_box), NULL);
gtk_toolbar_insert(GTK_TOOLBAR (toolbar), item, -1);
// botao bara ir e abrir
item = gtk_tool_button_new_from_stock(GTK_STOCK_OK);
g_signal_connect_swapped(G_OBJECT (item), "clicked", G_CALLBACK (activate_uri_entry_box), (gpointer)uri_entry);
gtk_toolbar_insert(GTK_TOOLBAR (toolbar), item, -1);
return toolbar;
}
static void
tm_set_style(GtkWidget * toolbar, BalsaToolbarModel * model)
{
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar),
model->style != (GtkToolbarStyle) (-1) ?
model->style : tm_default_style());
}
static void
on_toolbar_style_changed (AnjutaPreferences* prefs,
const gchar* key,
const gchar* tb_style,
gpointer user_data)
{
AnjutaApp* app = ANJUTA_APP (user_data);
if (tb_style)
{
if (strcasecmp (tb_style, "Default") == 0)
style = -1;
else if (strcasecmp (tb_style, "Both") == 0)
style = GTK_TOOLBAR_BOTH;
else if (strcasecmp (tb_style, "Horiz") == 0)
style = GTK_TOOLBAR_BOTH_HORIZ;
else if (strcasecmp (tb_style, "Icons") == 0)
style = GTK_TOOLBAR_ICONS;
else if (strcasecmp (tb_style, "Text") == 0)
style = GTK_TOOLBAR_TEXT;
DEBUG_PRINT ("Toolbar style: %s", tb_style);
}
if (style != -1)
{
gtk_toolbar_set_style (GTK_TOOLBAR (app->toolbar), style);
}
else
{
gtk_toolbar_unset_style (GTK_TOOLBAR (app->toolbar));
}
}
/**
* physically add widgets to store window
*/
bool nsgtk_toolbar_add_store_widget(GtkWidget *widget)
{
if (window->numberh >= NSGTK_STORE_WIDTH) {
window->currentbar = gtk_toolbar_new();
if (window->currentbar == NULL) {
warn_user("NoMemory", 0);
return false;
}
gtk_toolbar_set_style(GTK_TOOLBAR(window->currentbar),
GTK_TOOLBAR_BOTH);
gtk_toolbar_set_icon_size(GTK_TOOLBAR(window->currentbar),
GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_box_pack_start(GTK_BOX(window->widgetvbox),
window->currentbar, FALSE, FALSE, 0);
window->numberh = 0;
}
gtk_widget_set_size_request(widget, NSGTK_BUTTON_WIDTH,
NSGTK_BUTTON_HEIGHT);
gtk_toolbar_insert(GTK_TOOLBAR(window->currentbar), GTK_TOOL_ITEM(
widget), window->numberh++);
gtk_tool_item_set_use_drag_window(GTK_TOOL_ITEM(widget), TRUE);
gtk_drag_source_set(widget, GDK_BUTTON1_MASK, &entry, 1,
GDK_ACTION_COPY);
gtk_widget_show_all(window->window);
return true;
}
/*---------------------------------------------------------------------------*/
static void
set_app_drawing_toolbar_style (GtkUIManager *ui)
{
GtkWidget *toolbar;
gl_debug (DEBUG_UI, "START");
g_return_if_fail (ui && GTK_IS_UI_MANAGER (ui));
/* Updated view menu */
gl_ui_util_set_verb_state (ui, "/ui/MenuBar/ViewMenu/ViewDrawingToolBar",
gl_prefs_model_get_drawing_toolbar_visible (gl_prefs));
toolbar = gtk_ui_manager_get_widget (ui, "/DrawingToolBar");
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
if (gl_prefs_model_get_drawing_toolbar_visible (gl_prefs)) {
gtk_widget_show_all (toolbar);
} else {
gtk_widget_hide (toolbar);
}
gl_debug (DEBUG_UI, "END");
}
static void
set_fixed_style (EggEditableToolbar *t, GtkToolbarStyle style)
{
g_return_if_fail (GTK_IS_TOOLBAR (t->priv->fixed_toolbar));
gtk_toolbar_set_style (GTK_TOOLBAR (t->priv->fixed_toolbar),
style == GTK_TOOLBAR_ICONS ? GTK_TOOLBAR_BOTH_HORIZ : style);
}
int
main (int argc, char *argv[])
{
GtkWidget *window;
GtkToolbar *toolbar;
GtkToolItem *item;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "delete-event", G_CALLBACK (on_window_delete), NULL);
toolbar = GTK_TOOLBAR (gtk_toolbar_new ());
gtk_toolbar_set_style (toolbar, GTK_TOOLBAR_TEXT);
item = gtk_tool_button_new (NULL, "Prompt");
g_signal_connect (item, "clicked", G_CALLBACK (on_prompt_clicked), window);
gtk_toolbar_insert (toolbar, item, 0);
gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (toolbar));
gtk_window_set_default_size (GTK_WINDOW (window), 400, 80);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
ZLGtkApplicationWindow::ZLGtkApplicationWindow(ZLApplication *application) :
ZLApplicationWindow(application),
KeyActionOnReleaseNotOnPressOption(ZLCategoryKey::CONFIG, "KeyAction", "OnRelease", false),
myFullScreen(false) {
myProgram = HILDON_PROGRAM(hildon_program_get_instance());
g_set_application_name("");
myWindow = HILDON_WINDOW(hildon_window_new());
((ZLMaemoCommunicationManager&)ZLCommunicationManager::Instance()).init();
myToolbar = GTK_TOOLBAR(gtk_toolbar_new());
gtk_toolbar_set_show_arrow(myToolbar, false);
gtk_toolbar_set_orientation(myToolbar, GTK_ORIENTATION_HORIZONTAL);
gtk_toolbar_set_style(myToolbar, GTK_TOOLBAR_ICONS);
myMenu = GTK_MENU(gtk_menu_new());
hildon_window_set_menu(myWindow, myMenu);
gtk_widget_show_all(GTK_WIDGET(myMenu));
hildon_window_add_toolbar(myWindow, myToolbar);
hildon_program_add_window(myProgram, myWindow);
gtk_widget_show_all(GTK_WIDGET(myWindow));
myViewWidget = 0;
ZLGtkSignalUtil::connectSignal(GTK_OBJECT(myWindow), "delete_event", GTK_SIGNAL_FUNC(applicationQuit), this);
ZLGtkSignalUtil::connectSignal(GTK_OBJECT(myWindow), "key_press_event", GTK_SIGNAL_FUNC(handleKeyPress), this);
ZLGtkSignalUtil::connectSignal(GTK_OBJECT(myWindow), "key_release_event", GTK_SIGNAL_FUNC(handleKeyRelease), this);
}
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);
}
/* 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 );
}
static GtkWidget *create_toolbar(void)
{
GtkWidget *toolbar, *item;
GtkToolItem *tool_item;
toolbar = gtk_toolbar_new();
gtk_toolbar_set_icon_size(GTK_TOOLBAR(toolbar), GTK_ICON_SIZE_MENU);
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
tool_item = gtk_menu_tool_button_new(NULL, NULL);
gtk_tool_button_set_stock_id(GTK_TOOL_BUTTON(tool_item), GTK_STOCK_JUMP_TO);
item = (GtkWidget*)tool_item;
gtk_widget_set_tooltip_text(item, _("Show the current document"));
gtk_container_add(GTK_CONTAINER(toolbar), item);
g_signal_connect(item, "clicked", G_CALLBACK(on_refresh), NULL);
item = gtk_menu_new();
gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(tool_item), item);
g_signal_connect(item, "show", G_CALLBACK(on_doc_menu_show), NULL);
tool_item = gtk_tool_item_new();
gtk_tool_item_set_expand(tool_item, TRUE);
gtk_container_add(GTK_CONTAINER(toolbar), GTK_WIDGET(tool_item));
item = gtk_label_new(NULL);
gtk_label_set_ellipsize(GTK_LABEL(item), PANGO_ELLIPSIZE_START);
gtk_container_add(GTK_CONTAINER(tool_item), item);
edit_window.name_label = item;
item = ui_tool_button_new(GTK_STOCK_CLOSE, _("_Unsplit"), NULL);
gtk_container_add(GTK_CONTAINER(toolbar), item);
g_signal_connect(item, "clicked", G_CALLBACK(on_unsplit), NULL);
return toolbar;
}
/* Creates a toolbar based on the data found in the passed xmlNode
* Returns the fully populated GtkToolbar
*/
GtkToolbar* ToolbarManager::createToolbar(xml::Node& node) {
// Get all action children elements
xml::NodeList toolItemList = node.getChildren();
GtkWidget* toolbar;
if (!toolItemList.empty()) {
// Create a new toolbar
toolbar = gtk_toolbar_new();
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
// Try to set the alignment, if the attribute is properly set
std::string align = node.getAttributeValue("align");
GtkOrientation orientation = (align == "vertical") ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL;
gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar), orientation);
for (std::size_t i = 0; i < toolItemList.size(); i++) {
// Create and get the toolItem with the parsing
GtkWidget* toolItem = createToolItem(toolItemList[i]);
// It is possible that no toolItem is returned, only add it if it's safe to do so
if (toolItem != NULL) {
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(toolItem), -1);
}
}
}
else {
throw std::runtime_error("No elements in toolbar.");
}
return GTK_TOOLBAR(toolbar);
}
JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkToolbar_gtk_1toolbar_1set_1style
(
JNIEnv* env,
jclass cls,
jlong _self,
jint _style
)
{
GtkToolbar* self;
GtkToolbarStyle style;
// convert parameter self
self = (GtkToolbar*) _self;
// convert parameter style
style = (GtkToolbarStyle) _style;
// call function
gtk_toolbar_set_style(self, style);
// cleanup parameter self
// cleanup parameter style
}
int main( int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *toolbar;
GtkWidget *view;
GtkWidget *statusbar;
GtkToolItem *exit;
GtkTextBuffer *buffer;
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), "lines & cols");
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);
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);
view = gtk_text_view_new();
gtk_box_pack_start(GTK_BOX(vbox), view, TRUE, TRUE, 0);
gtk_widget_grab_focus(view);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
statusbar = gtk_statusbar_new();
gtk_box_pack_start(GTK_BOX(vbox), statusbar, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(exit), "clicked",
G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(buffer, "changed",
G_CALLBACK(update_statusbar), statusbar);
g_signal_connect_object(buffer, "mark_set",
G_CALLBACK(mark_set_callback), statusbar, 0);
g_signal_connect_swapped(G_OBJECT(window), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
gtk_widget_show_all(window);
update_statusbar(buffer, GTK_STATUSBAR (statusbar));
gtk_main();
return 0;
}
static void
change_toolbar_style (GtkWidget *option_menu, GtkWidget *toolbar)
{
GtkToolbarStyle style;
style = gtk_option_menu_get_history (GTK_OPTION_MENU (option_menu));
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), style);
}
static void
change_toolbar_style (GtkWidget *option_menu, GtkWidget *toolbar)
{
GtkToolbarStyle style;
style = gtk_combo_box_get_active (GTK_COMBO_BOX (option_menu));
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), style);
}
END_HANDLER
COMBO_CHANGED(comboButtonType, button_type)
{
nsgtk_scaffolding *current = scaf_list;
nsoption_set_int(button_type, nsoption_int(button_type) + 1);
/* value of 0 is reserved for 'unset' */
while (current) {
nsgtk_scaffolding_reset_offset(current);
switch(nsoption_int(button_type)) {
case 1:
gtk_toolbar_set_style(
GTK_TOOLBAR(nsgtk_scaffolding_toolbar(current)),
GTK_TOOLBAR_ICONS);
gtk_toolbar_set_icon_size(
GTK_TOOLBAR(nsgtk_scaffolding_toolbar(current)),
GTK_ICON_SIZE_SMALL_TOOLBAR);
break;
case 2:
gtk_toolbar_set_style(
GTK_TOOLBAR(nsgtk_scaffolding_toolbar(current)),
GTK_TOOLBAR_ICONS);
gtk_toolbar_set_icon_size(
GTK_TOOLBAR(nsgtk_scaffolding_toolbar(current)),
GTK_ICON_SIZE_LARGE_TOOLBAR);
break;
case 3:
gtk_toolbar_set_style(
GTK_TOOLBAR(nsgtk_scaffolding_toolbar(current)),
GTK_TOOLBAR_BOTH);
gtk_toolbar_set_icon_size(
GTK_TOOLBAR(nsgtk_scaffolding_toolbar(current)),
GTK_ICON_SIZE_LARGE_TOOLBAR);
break;
case 4:
gtk_toolbar_set_style(
GTK_TOOLBAR(nsgtk_scaffolding_toolbar(current)),
GTK_TOOLBAR_TEXT);
default:
break;
}
current = nsgtk_scaffolding_iterate(current);
}
}
void wxToolBar::GtkSetStyle()
{
GtkOrientation orient;
GtkToolbarStyle style;
GetGtkStyle(GetWindowStyle(), &orient, &style);
gtk_toolbar_set_orientation(m_toolbar, orient);
gtk_toolbar_set_style(m_toolbar, style);
}
/*
* Redraw all toolbars
*/
void
toolbar_redraw_all(void)
{
GtkWidget *main_tb;
GtkWidget *filter_tb;
main_tb = (GtkWidget *)g_object_get_data(G_OBJECT(top_level), E_TB_MAIN_KEY);
gtk_toolbar_set_style(GTK_TOOLBAR(main_tb),
(GtkToolbarStyle)prefs.gui_toolbar_main_style);
filter_tb = (GtkWidget *)g_object_get_data(G_OBJECT(top_level), E_TB_FILTER_KEY);
/* In case the filter toolbar hasn't been built */
if(filter_tb)
gtk_toolbar_set_style(GTK_TOOLBAR(filter_tb),
(GtkToolbarStyle)prefs.gui_toolbar_filter_style);
}
