/*
* Creates a new GtkWidget of class GtkToggleToolButton, performing any specialized
* initialization needed for the widget to work correctly in this environment.
* If a dialog box is used to initialize the widget, return NULL from this
* function, and call data->callback with your new widget when it is done.
*/
static GtkWidget*
gb_toggle_tool_button_new (GbWidgetNewData *data)
{
GtkWidget *new_widget, *image;
GbWidget *pixmap_gbwidget;
/* Place the pixmap icon in the button initially (even when loading). */
pixmap_gbwidget = gb_widget_lookup_class ("GtkImage");
if (pixmap_gbwidget)
{
image = gtk_image_new_from_pixmap (pixmap_gbwidget->gdkpixmap,
pixmap_gbwidget->mask);
}
else
{
image = gtk_image_new ();
g_warning ("Couldn't find GtkPixmap data");
}
gtk_widget_show (image);
new_widget = (GtkWidget*) gtk_toggle_tool_button_new ();
gtk_tool_button_set_label (GTK_TOOL_BUTTON (new_widget), "");
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (new_widget), image);
return new_widget;
}
static void
schema_browser_perspective_customize (BrowserPerspective *perspective, GtkToolbar *toolbar, GtkHeaderBar *header)
{
g_print ("%s ()\n", __FUNCTION__);
customization_data_init (G_OBJECT (perspective), toolbar, header);
/* add perspective's actions */
customization_data_add_actions (G_OBJECT (perspective), win_entries, G_N_ELEMENTS (win_entries));
/* add to toolbar */
GtkToolItem *titem;
titem = gtk_toggle_tool_button_new ();
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "user-bookmarks-symbolic");
gtk_widget_set_tooltip_text (GTK_WIDGET (titem), _("Show favorites"));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1);
gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.show-favorites");
gtk_widget_show (GTK_WIDGET (titem));
customization_data_add_part (G_OBJECT (perspective), G_OBJECT (titem));
#ifdef HAVE_GOOCANVAS
titem = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "tab-new-symbolic");
gtk_widget_set_tooltip_text (GTK_WIDGET (titem), _("Create a new diagram"));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1);
gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.action-diagram-new");
gtk_widget_show (GTK_WIDGET (titem));
customization_data_add_part (G_OBJECT (perspective), G_OBJECT (titem));
#endif
}
void Sidebar::initPages(GtkWidget* sidebar, GladeGui* gui)
{
XOJ_CHECK_TYPE(Sidebar);
addPage(new SidebarIndexPage(this->control));
addPage(new SidebarPreviewPages(this->control));
#ifdef UNSTABLE_LAYERS_SIDEBAR
addPage(new SidebarPreviewLayers(this->control));
#endif //UNSTABLE_LAYERS_SIDEBAR
// Init toolbar with icons
int i = 0;
for (AbstractSidebarPage* p : this->pages)
{
GtkToolItem* it = gtk_toggle_tool_button_new();
p->tabButton = it;
gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(it), gui->loadIcon(p->getIconName().c_str()));
g_signal_connect(it, "clicked", G_CALLBACK(&buttonClicked), new SidebarPageButton(this, i, p));
gtk_tool_item_set_tooltip_text(it, p->getName().c_str());
gtk_tool_button_set_label(GTK_TOOL_BUTTON(it), p->getName().c_str());
gtk_toolbar_insert(tbSelectPage, it, -1);
// Add widget to sidebar
gtk_box_pack_start(GTK_BOX(sidebar), p->getWidget(), TRUE, TRUE, 0);
i++;
}
gtk_widget_show_all(GTK_WIDGET(this->tbSelectPage));
updateEnableDisableButtons();
}
static VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE arg, buffer;
GtkToolItem *item = NULL;
rb_scan_args(argc, argv, "01", &arg);
if (NIL_P(arg)) {
item = gtk_toggle_tool_button_new();
} else if (TYPE(arg) == T_HASH) {
VALUE stock_id;
rbg_scan_options(arg,
"stock_id", &stock_id,
NULL);
if (!NIL_P(stock_id))
item = gtk_toggle_tool_button_new_from_stock(RVAL2GLIBID(stock_id, buffer));
} else {
item = gtk_toggle_tool_button_new_from_stock(RVAL2GLIBID(arg, buffer));
}
if (!item)
rb_raise(rb_eArgError, "Invalid arguments.");
RBGTK_INITIALIZE(self, item);
return Qnil;
}
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);
}
GtkToolItem * ToolButton::newItem() {
XOJ_CHECK_TYPE(ToolButton);
GtkToolItem * it;
if (!stock.isEmpty()) {
if (popupMenu) {
it = gtk_menu_tool_button_new_from_stock(stock.c_str());
gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(it), popupMenu);
} else {
it = gtk_tool_button_new_from_stock(stock.c_str());
}
} else if (group != GROUP_NOGROUP) {
if (popupMenu) {
it = gtk_menu_tool_toggle_button_new(this->gui->loadIcon(iconName.c_str()), description.c_str());
gtk_menu_tool_toggle_button_set_menu(GTK_MENU_TOOL_TOGGLE_BUTTON(it), popupMenu);
} else {
it = gtk_toggle_tool_button_new();
gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(it), this->gui->loadIcon(iconName.c_str()));
}
} else {
if (popupMenu) {
it = gtk_menu_tool_button_new(this->gui->loadIcon(iconName.c_str()), description.c_str());
gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(it), popupMenu);
} else {
it = gtk_tool_button_new(this->gui->loadIcon(iconName.c_str()), description.c_str());
}
}
gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(it), description.c_str());
gtk_tool_button_set_label(GTK_TOOL_BUTTON(it), description.c_str());
return it;
}
/*#
@class GtkToggleToolButton
@brief A GtkToolItem containing a toggle button
A GtkToggleToolButton is a GtkToolItem that contains a toggle button.
*/
FALCON_FUNC ToggleToolButton::init( VMARG )
{
MYSELF;
if ( self->getObject() )
return;
NO_ARGS
self->setObject( (GObject*) gtk_toggle_tool_button_new() );
}
static GtkToolItem * toggle_button_new (const char * icon,
void (* toggled) (GtkToggleToolButton * button))
{
GtkToolItem * item = gtk_toggle_tool_button_new ();
gtk_tool_button_set_icon_name ((GtkToolButton *) item, icon);
g_signal_connect (item, "toggled", (GCallback) toggled, NULL);
return item;
}
/* 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;
}
GtkToolItem * ColorToolItem::newItem() {
XOJ_CHECK_TYPE(ColorToolItem);
this->iconWidget = selectcolor_new(this->color);
selectcolor_set_circle(this->iconWidget, !isSelector());
GtkToolItem * it = gtk_toggle_tool_button_new();
gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(it), this->name.c_str());
gtk_tool_button_set_label(GTK_TOOL_BUTTON(it), this->name.c_str());
gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(it), this->iconWidget);
return it;
}
static GtkToolItem * toggle_button_new (const gchar * icon, const gchar * alt,
void (* toggled) (GtkToggleToolButton * button))
{
GtkToolItem * item = gtk_toggle_tool_button_new ();
if (! alt)
gtk_tool_button_set_stock_id ((GtkToolButton *) item, icon);
else if (gtk_icon_theme_has_icon (gtk_icon_theme_get_default (), icon))
gtk_tool_button_set_icon_name ((GtkToolButton *) item, icon);
else
gtk_tool_button_set_label ((GtkToolButton *) item, alt);
g_signal_connect (item, "toggled", (GCallback) toggled, NULL);
return item;
}
GtkToolItem *hwidget_get_tool_button(const gchar *image_file,
const gchar *label,
const gchar *tooltips_string,
gpointer callback,
gpointer data,
guint type)
{
GtkToolItem *button;
GtkWidget *pixmap;
GtkTooltips *tooltips;
switch (type) {
case HWIDGET_TOGGLE_TOOL_BUTTON:
button = gtk_toggle_tool_button_new();
if (callback) {
g_signal_connect(G_OBJECT(button), "toggled",
G_CALLBACK(callback), data);
}
break;
case HWIDGET_TOOL_BUTTON:
button = gtk_tool_button_new(NULL, NULL);
if (callback) {
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(callback), data);
}
break;
default:
return NULL;
}
if (image_file) {
pixmap = hutil_create_pixmap(image_file);
gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(button),
pixmap);
}
if (label) {
gtk_tool_button_set_label(GTK_TOOL_BUTTON(button), label);
}
if (tooltips_string) {
tooltips = gtk_tooltips_new();
gtk_tool_item_set_tooltip(button, tooltips, tooltips_string,
NULL);
}
return button;
}
void show_menu (bool_t show)
{
aud_set_bool ("gtkui", "menu_visible", show);
if (show)
{
/* remove menu button from toolbar and show menu bar */
if (menu_main)
gtk_widget_destroy (menu_main);
if (menu_button)
gtk_widget_destroy ((GtkWidget *) menu_button);
if (! menu)
{
menu = make_menu_bar (accel);
g_signal_connect (menu, "destroy", (GCallback) gtk_widget_destroyed,
& menu);
gtk_widget_show (menu);
gtk_box_pack_start ((GtkBox *) menu_box, menu, TRUE, TRUE, 0);
}
}
else
{
/* hide menu bar and add menu item to toolbar */
if (menu)
gtk_widget_destroy (menu);
if (! menu_main)
{
menu_main = make_menu_main (accel);
g_signal_connect (menu_main, "destroy", (GCallback)
gtk_widget_destroyed, & menu_main);
g_signal_connect (menu_main, "hide", (GCallback) menu_hide_cb, NULL);
}
if (! menu_button)
{
menu_button = gtk_toggle_tool_button_new ();
gtk_tool_button_set_icon_name ((GtkToolButton *) menu_button, "audacious");
g_signal_connect (menu_button, "destroy", (GCallback)
gtk_widget_destroyed, & menu_button);
gtk_widget_show ((GtkWidget *) menu_button);
gtk_toolbar_insert ((GtkToolbar *) toolbar, menu_button, 0);
g_signal_connect (menu_button, "toggled", (GCallback) menu_button_cb, NULL);
}
}
}
static VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE stock_id;
GtkToolItem* item;
rb_scan_args(argc, argv, "01", &stock_id);
if (NIL_P(stock_id)){
item = gtk_toggle_tool_button_new();
} else {
if (TYPE(stock_id) == T_SYMBOL){
item = gtk_toggle_tool_button_new_from_stock(rb_id2name(SYM2ID(stock_id)));
} else {
item = gtk_toggle_tool_button_new_from_stock(RVAL2CSTR(stock_id));
}
}
RBGTK_INITIALIZE(self, item);
return Qnil;
}
GtkToolItem *ZLGtkApplicationWindow::createGtkToolButton(const ZLToolbar::AbstractButtonItem &button) {
GtkToolItem *gtkItem = 0;
static std::string imagePrefix =
ZLibrary::ApplicationImageDirectory() + ZLibrary::FileNameDelimiter;
GtkWidget *image = gtk_image_new_from_file(
(imagePrefix + button.iconName() + ".png").c_str()
);
switch (button.type()) {
case ZLToolbar::Item::PLAIN_BUTTON:
gtkItem = gtk_tool_button_new(image, button.tooltip().c_str());
break;
case ZLToolbar::Item::TOGGLE_BUTTON:
gtkItem = gtk_toggle_tool_button_new();
gtk_tool_button_set_label(GTK_TOOL_BUTTON(gtkItem), button.tooltip().c_str());
gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(gtkItem), image);
break;
case ZLToolbar::Item::MENU_BUTTON:
{
gtkItem = gtk_menu_tool_button_new(image, button.tooltip().c_str());
const ZLToolbar::MenuButtonItem &menuButton =
(const ZLToolbar::MenuButtonItem&)button;
shared_ptr<ZLPopupData> popupData = menuButton.popupData();
myPopupIdMap[gtkItem] =
popupData.isNull() ? (size_t)-1 : (popupData->id() - 1);
gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(gtkItem), gtk_menu_new());
gtk_menu_tool_button_set_arrow_tooltip(GTK_MENU_TOOL_BUTTON(gtkItem), myToolbar->tooltips, menuButton.popupTooltip().c_str(), 0);
break;
}
default:
break;
}
gtk_tool_item_set_tooltip(gtkItem, myToolbar->tooltips, button.tooltip().c_str(), 0);
ZLGtkSignalUtil::connectSignal(GTK_OBJECT(gtkItem), "clicked", GTK_SIGNAL_FUNC(onButtonClicked), this);
//GTK_WIDGET_UNSET_FLAGS(gtkItem, GTK_CAN_FOCUS);
return gtkItem;
}
JNIEXPORT jlong JNICALL
Java_org_gnome_gtk_GtkToggleToolButton_gtk_1toggle_1tool_1button_1new
(
JNIEnv* env,
jclass cls
)
{
GtkToolItem* result;
jlong _result;
// call function
result = gtk_toggle_tool_button_new();
// translate return value to JNI type
_result = (jlong) result;
// cleanup return value
if (result != NULL) {
bindings_java_memory_cleanup((GObject*)result, TRUE);
}
// and finally
return _result;
}
static void qq_chatwidget_init(QQChatWidget *widget)
{
QQChatWidgetPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE(widget
, qq_chatwidget_get_type()
, QQChatWidgetPriv);
GtkWidget *scrolled_win;
gchar buf[100];
// message text view
priv -> message_textview = qq_chat_textview_new();
scrolled_win= gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_win)
, GTK_SHADOW_ETCHED_IN);
gtk_container_add(GTK_CONTAINER(scrolled_win), priv -> message_textview);
gtk_box_pack_start(GTK_BOX(widget), scrolled_win, TRUE, TRUE, 0);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(priv -> message_textview)
, FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(priv -> message_textview)
, GTK_WRAP_CHAR);
gtk_text_view_set_editable(GTK_TEXT_VIEW(priv -> message_textview)
, FALSE);
// font tools
priv -> font_tool_box = gtk_hbox_new(FALSE, 5);
g_object_ref(priv -> font_tool_box);
priv -> font_cb = gtk_combo_box_text_new();
gint i;
for(i = 0; font_names[i] != NULL; ++i){
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv -> font_cb)
, font_names[i]);
}
gtk_box_pack_start(GTK_BOX(priv -> font_tool_box), priv -> font_cb
, FALSE, FALSE, 0);
priv -> size_cb = gtk_combo_box_text_new();
for(i = 8; i < 23; ++i){
g_snprintf(buf, 10, "%d", i);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv -> size_cb)
, buf);
}
gtk_box_pack_start(GTK_BOX(priv -> font_tool_box), priv -> size_cb
, FALSE, FALSE, 0);
priv -> bold_btn = qq_toggle_button_new_with_stock(GTK_STOCK_BOLD);
priv -> italic_btn = qq_toggle_button_new_with_stock(GTK_STOCK_ITALIC);
priv -> underline_btn = qq_toggle_button_new_with_stock(
GTK_STOCK_UNDERLINE);
gtk_box_pack_start(GTK_BOX(priv -> font_tool_box), priv -> bold_btn
, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(priv -> font_tool_box), priv -> italic_btn
, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(priv -> font_tool_box), priv -> underline_btn
, FALSE, FALSE, 0);
priv -> color_btn = gtk_color_button_new();
gtk_box_pack_start(GTK_BOX(priv -> font_tool_box), priv -> color_btn
, FALSE, FALSE, 0);
gtk_widget_show_all(priv -> font_tool_box);
g_signal_connect(G_OBJECT(priv -> font_cb), "changed"
, G_CALLBACK(qq_chat_widget_font_changed), widget);
g_signal_connect(G_OBJECT(priv -> size_cb), "changed"
, G_CALLBACK(qq_chat_widget_font_changed), widget);
g_signal_connect(G_OBJECT(priv -> bold_btn), "toggled"
, G_CALLBACK(qq_chat_widget_font_changed), widget);
g_signal_connect(G_OBJECT(priv -> italic_btn), "toggled"
, G_CALLBACK(qq_chat_widget_font_changed), widget);
g_signal_connect(G_OBJECT(priv -> underline_btn), "toggled"
, G_CALLBACK(qq_chat_widget_font_changed), widget);
g_signal_connect(G_OBJECT(priv -> color_btn), "color-set"
, G_CALLBACK(qq_chat_widget_font_changed), widget);
// tool bar
priv -> tool_bar = gtk_toolbar_new();
GtkWidget *img = NULL;
img = gtk_image_new_from_file(IMGDIR"/selectfont.png");
priv -> font_item = gtk_toggle_tool_button_new();
g_signal_connect(G_OBJECT(priv -> font_item), "toggled"
, G_CALLBACK(qq_chat_view_font_button_clicked)
, widget);
gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(priv -> font_item), img);
gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar), priv -> font_item, -1);
img = gtk_image_new_from_file(IMGDIR"/selectface.png");
priv -> face_item = gtk_tool_button_new(img, NULL);
gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar), priv -> face_item, -1);
gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar)
, gtk_separator_tool_item_new() , -1);
g_signal_connect(G_OBJECT(priv -> face_item), "clicked",
G_CALLBACK(face_tool_button_clicked), widget);
img = gtk_image_new_from_file(IMGDIR"/sendfile.png");
priv -> sendfile_item = gtk_tool_button_new(img, NULL);
gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar), priv -> sendfile_item, -1);
img = gtk_image_new_from_file(IMGDIR"/sendpic.png");
priv -> sendpic_item = gtk_tool_button_new(img, NULL);
gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar), priv -> sendpic_item, -1);
gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar)
, gtk_separator_tool_item_new() , -1);
img = gtk_image_new_from_file(IMGDIR"/clearscreen.png");
priv -> clear_item = gtk_tool_button_new(img, NULL);
gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar), priv -> clear_item, -1);
gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar)
, gtk_separator_tool_item_new() , -1);
g_signal_connect(G_OBJECT(priv -> clear_item), "clicked",
G_CALLBACK(clear_button_clicked), widget);
img = gtk_image_new_from_file(IMGDIR"/showhistory.png");
priv -> history_item = gtk_tool_button_new(img, NULL);
gtk_toolbar_insert(GTK_TOOLBAR(priv -> tool_bar), priv -> history_item, -1);
gtk_box_pack_start(GTK_BOX(widget), priv -> tool_bar
, FALSE, FALSE, 0);
// input text view
priv -> input_textview = qq_chat_textview_new();
gtk_text_view_set_indent(GTK_TEXT_VIEW(priv -> input_textview), 1);
scrolled_win= gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrolled_win),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_win)
, GTK_SHADOW_ETCHED_IN);
gtk_container_add(GTK_CONTAINER(scrolled_win), priv -> input_textview);
#ifndef USE_UNITY
gtk_box_pack_start(GTK_BOX(widget), scrolled_win, FALSE, FALSE, 0);
#else
/* On ubuntu unity, there is a f**k bug if we pack the textview
with the argument FALSE, FALSE, it cant be shown, how f**k it is. */
gtk_box_pack_start(GTK_BOX(widget), scrolled_win, TRUE, TRUE, 0);
#endif /* USE_UNITY */
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(priv -> input_textview)
, GTK_WRAP_CHAR);
gtk_combo_box_set_active(GTK_COMBO_BOX(priv -> font_cb), 1);
gtk_combo_box_set_active(GTK_COMBO_BOX(priv -> size_cb), 3);
gtk_widget_grab_focus(priv -> input_textview);
priv -> facepopupwindow = qq_face_popup_window_new();
g_signal_connect(G_OBJECT(priv -> facepopupwindow), "face-clicked"
, G_CALLBACK(qq_chatwidget_face_clicked)
, priv);
}
static void
egg_find_bar_init (EggFindBar *find_bar)
{
EggFindBarPrivate *priv;
GtkWidget *label;
GtkWidget *alignment;
GtkWidget *box;
GtkToolItem *item;
GtkWidget *arrow;
/* Data */
priv = EGG_FIND_BAR_GET_PRIVATE (find_bar);
find_bar->priv = priv;
priv->search_string = NULL;
gtk_toolbar_set_style (GTK_TOOLBAR (find_bar), GTK_TOOLBAR_BOTH_HORIZ);
/* Find: |_____| */
item = gtk_tool_item_new ();
box = gtk_hbox_new (FALSE, 12);
alignment = gtk_alignment_new (0.0, 0.5, 1.0, 0.0);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 2, 2);
label = gtk_label_new_with_mnemonic (_("Find:"));
priv->find_entry = gtk_entry_new ();
gtk_entry_set_width_chars (GTK_ENTRY (priv->find_entry), 32);
gtk_entry_set_max_length (GTK_ENTRY (priv->find_entry), 512);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), priv->find_entry);
/* Prev */
arrow = gtk_arrow_new (GTK_ARROW_LEFT, GTK_SHADOW_NONE);
priv->previous_button = gtk_tool_button_new (arrow, Q_("Find Previous"));
gtk_tool_item_set_is_important (priv->previous_button, TRUE);
gtk_tool_item_set_tooltip (priv->previous_button, GTK_TOOLBAR (find_bar)->tooltips,
_("Find previous occurrence of the search string"),
NULL);
/* Next */
arrow = gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_NONE);
priv->next_button = gtk_tool_button_new (arrow, Q_("Find Next"));
gtk_tool_item_set_is_important (priv->next_button, TRUE);
gtk_tool_item_set_tooltip (priv->next_button, GTK_TOOLBAR (find_bar)->tooltips,
_("Find next occurrence of the search string"),
NULL);
/* Separator*/
priv->status_separator = gtk_separator_tool_item_new();
/* Case button */
priv->case_button = gtk_toggle_tool_button_new ();
g_object_set (G_OBJECT (priv->case_button), "label", _("C_ase Sensitive"), NULL);
gtk_tool_button_set_use_underline (GTK_TOOL_BUTTON (priv->case_button), TRUE);
gtk_tool_item_set_is_important (priv->case_button, TRUE);
gtk_tool_item_set_tooltip (priv->case_button, GTK_TOOLBAR (find_bar)->tooltips,
_("Toggle case sensitive search"),
NULL);
/* Status */
priv->status_item = gtk_tool_item_new();
gtk_tool_item_set_expand (priv->status_item, TRUE);
priv->status_label = gtk_label_new (NULL);
gtk_label_set_ellipsize (GTK_LABEL (priv->status_label),
PANGO_ELLIPSIZE_END);
gtk_misc_set_alignment (GTK_MISC (priv->status_label), 0.0, 0.5);
g_signal_connect (priv->find_entry, "changed",
G_CALLBACK (entry_changed_callback),
find_bar);
g_signal_connect (priv->find_entry, "activate",
G_CALLBACK (entry_activate_callback),
find_bar);
g_signal_connect (priv->next_button, "clicked",
G_CALLBACK (next_clicked_callback),
find_bar);
g_signal_connect (priv->previous_button, "clicked",
G_CALLBACK (previous_clicked_callback),
find_bar);
g_signal_connect (priv->case_button, "toggled",
G_CALLBACK (case_sensitive_toggled_callback),
find_bar);
gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box), priv->find_entry, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (alignment), box);
gtk_container_add (GTK_CONTAINER (item), alignment);
gtk_toolbar_insert (GTK_TOOLBAR (find_bar), item, -1);
gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->previous_button, -1);
gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->next_button, -1);
gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->case_button, -1);
gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->status_separator, -1);
gtk_container_add (GTK_CONTAINER (priv->status_item), priv->status_label);
gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->status_item, -1);
/* don't show status separator/label until they are set */
gtk_widget_show_all (GTK_WIDGET (item));
gtk_widget_show_all (GTK_WIDGET (priv->next_button));
gtk_widget_show_all (GTK_WIDGET (priv->previous_button));
gtk_widget_show (priv->status_label);
}
static void
moko_talking_init (MokoTalking *talking)
{
MokoTalkingPrivate *priv;
GtkWidget *notebook;
GtkWidget *toolbar, *image, *vbox, *hbox, *label, *align, *frame, *main_vbox;
GtkWidget *duration;
GtkToolItem *item;
gint i;
priv = talking->priv = MOKO_TALKING_GET_PRIVATE (talking);
/* initialize dtimer to NULL */
priv->dtimer = NULL;
notebook = gtk_notebook_new ();
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_BOTTOM);
priv->notebook = notebook;
/* status page */
main_vbox = gtk_vbox_new (FALSE, 0);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), main_vbox,
gtk_image_new_from_file (PKGDATADIR"/phone.png"));
gtk_container_child_set (GTK_CONTAINER (notebook), main_vbox, "tab-expand",
TRUE, NULL);
priv->incoming_bar = toolbar = gtk_toolbar_new ();
gtk_box_pack_start (GTK_BOX (main_vbox), toolbar, FALSE, FALSE, 0);
image = gtk_image_new_from_icon_name (MOKO_STOCK_CALL_ANSWER, GTK_ICON_SIZE_BUTTON);
item = gtk_tool_button_new (image, "Answer");
gtk_tool_item_set_expand (item, TRUE);
g_signal_connect (item, "clicked", G_CALLBACK (on_answer_clicked), talking);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
image = gtk_image_new_from_icon_name (MOKO_STOCK_CALL_IGNORE, GTK_ICON_SIZE_BUTTON);
item = gtk_tool_button_new (image, "Ignore");
gtk_tool_item_set_expand (item, TRUE);
g_signal_connect (item, "clicked", G_CALLBACK (on_silence_clicked), talking);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
image = gtk_image_new_from_icon_name (MOKO_STOCK_CALL_REJECT, GTK_ICON_SIZE_BUTTON);
item = gtk_tool_button_new (image, "Reject");
gtk_tool_item_set_expand (item, TRUE);
g_signal_connect (item, "clicked", G_CALLBACK (on_reject_clicked), talking);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
/* Volume controls */
priv->headphone = moko_alsa_volume_control_new ();
moko_alsa_volume_control_set_device_from_name (priv->headphone, "neo1973");
moko_alsa_volume_control_set_element_from_name (priv->headphone, "Headphone");
priv->volume = moko_alsa_volume_scale_new (GTK_ORIENTATION_HORIZONTAL);
moko_alsa_volume_scale_set_control (MOKO_ALSA_VOLUME_SCALE (priv->volume),
priv->headphone);
/* Outgoing call and talking share the same toolbar */
priv->main_bar = toolbar = gtk_toolbar_new ();
gtk_box_pack_start (GTK_BOX (main_vbox), toolbar, FALSE, FALSE, 0);
image = gtk_image_new_from_icon_name (MOKO_STOCK_SPEAKER,
GTK_ICON_SIZE_BUTTON);
item = gtk_toggle_tool_button_new ();
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (item), image);
gtk_tool_item_set_expand (item, TRUE);
g_signal_connect (item, "toggled", G_CALLBACK (on_speaker_toggled), talking);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
priv->speaker_toggle_btn = item;
image = gtk_image_new_from_icon_name (MOKO_STOCK_CALL_HANGUP, GTK_ICON_SIZE_BUTTON);
item = gtk_tool_button_new (image, "Hangup");
gtk_tool_item_set_expand (item, TRUE);
g_signal_connect (item, "clicked", G_CALLBACK (on_cancel_clicked), talking);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
/* The title label and image */
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);
priv->title = label = gtk_label_new ("Incoming Call");
gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
align = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_box_pack_start (GTK_BOX (vbox), align, FALSE, FALSE, 8);
priv->icon = image = gtk_image_new ();
gtk_container_add (GTK_CONTAINER (align), image);
priv->duration = duration = gtk_label_new ("00:00:00");
gtk_misc_set_alignment (GTK_MISC (duration), 0.5, 0.5);
gtk_box_pack_start (GTK_BOX (vbox), duration, FALSE, FALSE, 0);
/* The status area */
align = gtk_alignment_new (0.5, 0.5, 1, 0 );
gtk_box_pack_start (GTK_BOX (vbox), align, TRUE, TRUE, 0);
frame = gtk_frame_new (NULL);
gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
gtk_container_add (GTK_CONTAINER (align), frame);
hbox = gtk_hbox_new (FALSE, 12);
gtk_container_add (GTK_CONTAINER (frame), hbox);
priv->person = image = gtk_image_new ();
gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
priv->status = label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
/* The volume control */
gtk_box_pack_start (GTK_BOX (vbox), priv->volume, FALSE, TRUE, 12);
/* Load the pixbufs */
for (i = 0; i < N_PICS; i++)
{
if (i == 0)
priv->talking[i] = gdk_pixbuf_new_from_file (PKGDATADIR"/talking.png",
NULL);
else
{
gchar *name = g_strdup_printf ("%s/talking_%d.png", PKGDATADIR, i-1);
priv->talking[i] = gdk_pixbuf_new_from_file (name, NULL);
g_free (name);
}
if (G_IS_OBJECT (priv->talking[i]))
g_object_ref (priv->talking[i]);
}
for (i = 0; i < N_PICS-1; i++)
{
gchar *name = g_strdup_printf ("%s/outgoing_%d.png", PKGDATADIR, i);
priv->outgoing[i] = gdk_pixbuf_new_from_file (name, NULL);
g_free (name);
if (G_IS_OBJECT (priv->outgoing[i]))
g_object_ref (priv->outgoing[i]);
}
for (i = 0; i < N_PICS-1; i++)
{
gchar *name = g_strdup_printf ("%s/incoming_%d.png", PKGDATADIR, i);
priv->incoming[i] = gdk_pixbuf_new_from_file (name, NULL);
g_free (name);
if (G_IS_OBJECT (priv->incoming[i]))
g_object_ref (priv->incoming[i]);
}
/* dtmf page */
GtkWidget *pad, *display;
main_vbox = gtk_vbox_new (FALSE, 0);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), main_vbox,
gtk_image_new_from_file (PKGDATADIR"/dtmf.png"));
gtk_container_child_set (GTK_CONTAINER (notebook), main_vbox, "tab-expand",
TRUE, NULL);
display = moko_dialer_textview_new ();
gtk_box_pack_start_defaults (GTK_BOX (main_vbox), display);
priv->dtmf_display = display;
pad = moko_dialer_panel_new ();
gtk_box_pack_start_defaults (GTK_BOX (main_vbox), pad);
g_signal_connect (pad, "user_input", G_CALLBACK (on_pad_user_input), talking);
priv->dtmf_pad = pad;
priv->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (priv->window, "delete-event", G_CALLBACK (window_delete_event_cb), talking);
gtk_container_add (GTK_CONTAINER (priv->window), notebook);
gtk_widget_show_all (notebook);
}
bool wxToolBar::DoInsertTool(size_t pos, wxToolBarToolBase *toolBase)
{
wxToolBarTool* tool = static_cast<wxToolBarTool*>(toolBase);
GSList* radioGroup;
GtkWidget* bin_child;
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);
#ifdef __WXGTK3__
g_signal_connect(image, "draw",
G_CALLBACK(image_draw), tool);
#else
g_signal_connect(image, "expose_event",
G_CALLBACK(image_expose_event), tool);
#endif
}
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())
{
#if GTK_CHECK_VERSION(2, 12, 0)
if (GTK_CHECK_VERSION(3,0,0) || gtk_check_version(2,12,0) == NULL)
{
gtk_tool_item_set_tooltip_text(tool->m_item,
wxGTK_CONV(tool->GetShortHelp()));
}
else
#endif
{
#ifndef __WXGTK3__
gtk_tool_item_set_tooltip(tool->m_item,
m_tooltips, wxGTK_CONV(tool->GetShortHelp()), "");
#endif
}
}
bin_child = gtk_bin_get_child(GTK_BIN(tool->m_item));
g_signal_connect(bin_child, "button_press_event",
G_CALLBACK(button_press_event), tool);
g_signal_connect(bin_child, "enter_notify_event",
G_CALLBACK(enter_notify_event), tool);
g_signal_connect(bin_child, "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();
if ( tool->IsStretchable() )
{
gtk_separator_tool_item_set_draw
(
GTK_SEPARATOR_TOOL_ITEM(tool->m_item),
FALSE
);
gtk_tool_item_set_expand(tool->m_item, TRUE);
}
gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos));
break;
case wxTOOL_STYLE_CONTROL:
wxWindow* control = tool->GetControl();
if (gtk_widget_get_parent(control->m_widget) == NULL)
AddChildGTK(control);
tool->m_item = GTK_TOOL_ITEM(gtk_widget_get_parent(gtk_widget_get_parent(control->m_widget)));
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);
}
break;
}
gtk_widget_show(GTK_WIDGET(tool->m_item));
InvalidateBestSize();
return true;
}
static void
ui_formgrid_init (UiFormGrid *formgrid)
{
GtkWidget *sw;
GtkWidget *hbox, *button;
formgrid->priv = g_new0 (UiFormGridPriv, 1);
formgrid->priv->raw_grid = NULL;
formgrid->priv->info = NULL;
formgrid->priv->flags = GDAUI_DATA_PROXY_INFO_CURRENT_ROW | GDAUI_DATA_PROXY_INFO_ROW_MODIFY_BUTTONS;
formgrid->priv->tcnc = NULL;
formgrid->priv->autoupdate = TRUE;
formgrid->priv->autoupdate_possible = FALSE;
formgrid->priv->scroll_form = FALSE;
formgrid->priv->compute_mod_stmt = FALSE;
formgrid->priv->refresh_callback = NULL;
formgrid->priv->refresh_user_data = NULL;
gtk_orientable_set_orientation (GTK_ORIENTABLE (formgrid), GTK_ORIENTATION_VERTICAL);
/* notebook */
formgrid->priv->nb = gtk_notebook_new ();
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (formgrid->priv->nb), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (formgrid->priv->nb), FALSE);
gtk_box_pack_start (GTK_BOX (formgrid), formgrid->priv->nb, TRUE, TRUE, 0);
gtk_widget_show (formgrid->priv->nb);
/* grid on 1st page of notebook, not added there */
formgrid->priv->raw_grid = gdaui_raw_grid_new (NULL);
gdaui_data_proxy_column_show_actions (GDAUI_DATA_PROXY (formgrid->priv->raw_grid), -1, FALSE);
g_signal_connect (formgrid->priv->raw_grid, "populate-popup",
G_CALLBACK (form_grid_populate_popup_cb), formgrid);
/* form on the 2nd page of the notebook, not added there */
formgrid->priv->raw_form = gdaui_raw_form_new (NULL);
gdaui_data_proxy_column_show_actions (GDAUI_DATA_PROXY (formgrid->priv->raw_form), -1, FALSE);
g_signal_connect (formgrid->priv->raw_form, "populate-popup",
G_CALLBACK (form_grid_populate_popup_cb), formgrid);
/* info widget and toggle button at last */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (formgrid), hbox, FALSE, TRUE, 0);
gtk_widget_show (hbox);
/* button to toggle between auto update and not */
button = gtk_toggle_button_new ();
GtkWidget *img = gtk_image_new_from_icon_name (_("_Execute"), GTK_ICON_SIZE_MENU);
gtk_button_set_image (GTK_BUTTON (button), img);
formgrid->priv->autoupdate_toggle = button;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), formgrid->priv->autoupdate);
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, TRUE, 0);
g_signal_connect (G_OBJECT (button), "toggled",
G_CALLBACK (form_grid_autoupdate_cb), formgrid);
gtk_widget_set_tooltip_text (button, _("Enable or disable auto update of data"));
/* Proxy info */
formgrid->priv->info = gdaui_data_proxy_info_new (GDAUI_DATA_PROXY (formgrid->priv->raw_grid),
formgrid->priv->flags |
GDAUI_DATA_PROXY_INFO_CURRENT_ROW |
GDAUI_DATA_PROXY_INFO_CHUNCK_CHANGE_BUTTONS);
button = GTK_WIDGET (gtk_toggle_tool_button_new ());
gtk_widget_set_tooltip_text (button, _("Toggle between grid and form presentations"));
gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (button), TRUE);
gtk_toolbar_insert (GTK_TOOLBAR (formgrid->priv->info), GTK_TOOL_ITEM (button), 0);
gtk_widget_show (button);
g_signal_connect (button, "toggled",
G_CALLBACK (form_grid_toggled_cb), formgrid);
/* refresh button, don't show it yet */
button = GTK_WIDGET (gtk_tool_button_new (NULL, NULL));
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (button), "view-refresh-symbolic");
gtk_widget_set_tooltip_text (button, _("Refresh data"));
gtk_toolbar_insert (GTK_TOOLBAR (formgrid->priv->info), GTK_TOOL_ITEM (button), 0);
formgrid->priv->refresh_button = button;
/* keep data in sync */
g_signal_connect (formgrid->priv->raw_grid, "selection-changed",
G_CALLBACK (selection_changed_cb), formgrid);
g_signal_connect (formgrid->priv->raw_form, "selection-changed",
G_CALLBACK (selection_changed_cb), formgrid);
}
static void
GyahtzeeCreateMainWindow (void)
{
GtkWidget *hbox, *vbox;
GtkWidget *toolbar;
GtkWidget *tmp;
GtkWidget *dicebox;
GtkAccelGroup *accel_group;
GtkBuilder *builder;
GtkUIManager *ui_manager;
int i, j;
window = gtk_application_window_new (application);
gtk_window_set_application (GTK_WINDOW (window), application);
gtk_window_set_title (GTK_WINDOW (window), _(appName));
gtk_window_set_hide_titlebar_when_maximized (GTK_WINDOW (window), TRUE);
//games_conf_add_window (GTK_WINDOW (window), NULL);
g_signal_connect (G_OBJECT (window), "delete_event",
G_CALLBACK (quit_game), NULL);
g_signal_connect (G_OBJECT (window), "key_press_event",
G_CALLBACK (key_press), NULL);
statusbar = gtk_statusbar_new ();
ui_manager = gtk_ui_manager_new ();
builder = gtk_builder_new ();
gtk_builder_add_from_string (builder, builder_description, -1, NULL);
games_stock_prepare_for_statusbar_tooltips (ui_manager, statusbar);
/*---- Menus ----*/
create_menus (ui_manager);
accel_group = gtk_ui_manager_get_accel_group (ui_manager);
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
g_action_map_add_action_entries (G_ACTION_MAP (application), app_entries, G_N_ELEMENTS (app_entries), application);
gtk_application_set_app_menu (GTK_APPLICATION (application), G_MENU_MODEL (gtk_builder_get_object (builder, "app-menu")));
/*---- Content ----*/
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), statusbar, FALSE, FALSE, 0);
gtk_widget_show (statusbar);
/* Retreive dice pixmaps from memory or files */
LoadDicePixmaps ();
/* Put all the dice in a vertical column */
dicebox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), dicebox, FALSE, TRUE, 0);
gtk_widget_show (dicebox);
rollLabel = gtk_label_new (NULL);
gtk_label_set_use_markup (GTK_LABEL (rollLabel), TRUE);
gtk_widget_show (rollLabel);
gtk_box_pack_start (GTK_BOX (dicebox), rollLabel, FALSE, TRUE, 5);
mbutton = gtk_button_new_with_label (_("Roll!"));
gtk_box_pack_end (GTK_BOX (dicebox), mbutton, FALSE, FALSE, 5);
g_signal_connect (G_OBJECT (mbutton), "clicked",
G_CALLBACK (roll_dice), NULL);
gtk_widget_show (GTK_WIDGET (mbutton));
toolbar = gtk_toolbar_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (toolbar),
GTK_ORIENTATION_VERTICAL);
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
gtk_toolbar_set_show_arrow (GTK_TOOLBAR (toolbar), FALSE);
gtk_box_pack_end (GTK_BOX (dicebox), toolbar, TRUE, TRUE, 0);
for (i = 0; i < NUMBER_OF_DICE; i++) {
tmp = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
for (j = 0; j < NUMBER_OF_PIXMAPS; j++) {
gtk_box_pack_start (GTK_BOX (tmp), dicePixmaps[i][j][GAME_YAHTZEE], FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (tmp), dicePixmaps[i][j][GAME_KISMET], FALSE, FALSE, 0);
}
diceBox[i] = gtk_toggle_tool_button_new ();
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (diceBox[i]), tmp);
g_signal_connect (G_OBJECT (diceBox[i]), "clicked",
G_CALLBACK (modify_dice), &DiceValues[i]);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar),
GTK_TOOL_ITEM (diceBox[i]), -1);
gtk_widget_show (GTK_WIDGET (diceBox[i]));
gtk_widget_show (tmp);
/*gtk_widget_show (dicePixmaps[i][0][game_type]);*/
}
gtk_widget_show (toolbar);
/* Scores displayed in score list */
ScoreList = create_score_list ();
gtk_box_pack_end (GTK_BOX (hbox), ScoreList, TRUE, TRUE, 0);
setup_score_list (ScoreList);
gtk_widget_show (ScoreList);
gtk_widget_show (hbox);
gtk_widget_show (vbox);
gtk_widget_show (window);
GyahtzeeNewGame ();
}
GtkWidget* ptk_toolbar_add_items_from_data( GtkWidget* toolbar,
PtkToolItemEntry* entries,
gpointer cb_data,
GtkTooltips* tooltips )
{
GtkWidget* btn;
PtkToolItemEntry* ent;
GtkWidget* image;
GtkWidget* menu;
GtkIconSize icon_size = gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar));
GSList* radio_group = NULL;
for( ent = entries; ; ++ent )
{
/* Normal tool item */
if( G_LIKELY( ent->stock_icon || ent->tooltip || ent->label ) )
{
/* Stock item */
if( G_LIKELY(ent->stock_icon) )
image = gtk_image_new_from_stock( ent->stock_icon, icon_size );
else
image = NULL;
if( G_LIKELY( ! ent->menu ) ) { /* Normal button */
if( G_UNLIKELY( PTK_IS_STOCK_ITEM(ent) ) )
btn = GTK_WIDGET(gtk_tool_button_new_from_stock ( ent->label ));
else
btn = GTK_WIDGET(gtk_tool_button_new ( image, _(ent->label) ));
}
else if( G_UNLIKELY( PTK_IS_CHECK_TOOL_ITEM(ent) ) ) {
if( G_UNLIKELY( PTK_IS_STOCK_ITEM(ent) ) )
btn = GTK_WIDGET(gtk_toggle_tool_button_new_from_stock(ent->label));
else {
btn = GTK_WIDGET(gtk_toggle_tool_button_new ());
gtk_tool_button_set_icon_widget( GTK_TOOL_BUTTON(btn), image );
gtk_tool_button_set_label(GTK_TOOL_BUTTON(btn), _(ent->label));
}
}
else if( G_UNLIKELY( PTK_IS_RADIO_TOOL_ITEM(ent) ) ) {
if( G_UNLIKELY( PTK_IS_STOCK_ITEM(ent) ) )
btn = GTK_WIDGET(gtk_radio_tool_button_new_from_stock( radio_group, ent->label ));
else {
btn = GTK_WIDGET(gtk_radio_tool_button_new( radio_group ));
if( G_LIKELY( PTK_IS_RADIO_TOOL_ITEM( (ent + 1) ) ) )
radio_group = gtk_radio_tool_button_get_group( GTK_RADIO_TOOL_BUTTON(btn) );
else
radio_group = NULL;
gtk_tool_button_set_icon_widget( GTK_TOOL_BUTTON(btn), image );
gtk_tool_button_set_label(GTK_TOOL_BUTTON(btn), _(ent->label));
}
}
else if( ent->menu ) {
if( G_UNLIKELY( PTK_IS_STOCK_ITEM(ent) ) )
btn = GTK_WIDGET(gtk_menu_tool_button_new_from_stock ( ent->label ));
else {
btn = GTK_WIDGET(gtk_menu_tool_button_new ( image, _(ent->label) ));
if( G_LIKELY( 3 < (int)ent->menu ) ) { /* Sub menu */
menu = ptk_menu_new_from_data( ent->menu, cb_data, NULL );
gtk_menu_tool_button_set_menu( GTK_MENU_TOOL_BUTTON(btn), menu );
}
}
}
if( G_LIKELY(ent->callback) ) { /* Callback */
if( G_LIKELY( ent->menu == NULL || ent->menu == PTK_EMPTY_MENU) )
g_signal_connect( btn, "clicked", ent->callback, cb_data);
else
g_signal_connect( btn, "toggled", ent->callback, cb_data);
}
if( G_LIKELY(ent->tooltip) )
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (btn), tooltips, _(ent->tooltip), NULL);
}
else
{
if( ! PTK_IS_SEPARATOR_TOOL_ITEM(ent) ) /* End of menu */
break;
btn = (GtkWidget*)gtk_separator_tool_item_new ();
}
gtk_toolbar_insert ( GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(btn), -1 );
if( G_UNLIKELY(ent->ret) ) {/* Return */
*ent->ret = btn;
ent->ret = NULL;
}
}
return NULL;
}
gint
main (gint argc, gchar **argv)
{
GtkWidget *window, *toolbar, *grid, *treeview, *scrolled_window;
GtkWidget *hbox, *hbox1, *hbox2, *checkbox, *option_menu, *menu;
gint i;
static const gchar *toolbar_styles[] = { "icons", "text", "both (vertical)",
"both (horizontal)" };
GtkToolItem *item;
GtkListStore *store;
GtkWidget *image;
GtkWidget *menuitem;
GtkWidget *button;
GtkWidget *label;
GIcon *gicon;
GSList *group;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
grid = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (window), grid);
toolbar = gtk_toolbar_new ();
gtk_widget_set_vexpand (toolbar, TRUE);
gtk_grid_attach (GTK_GRID (grid), toolbar, 0, 0, 2, 1);
hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
gtk_container_set_border_width (GTK_CONTAINER (hbox1), 5);
gtk_widget_set_vexpand (hbox1, TRUE);
gtk_grid_attach (GTK_GRID (grid), hbox1, 1, 1, 1, 1);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_container_set_border_width (GTK_CONTAINER (hbox2), 5);
gtk_widget_set_vexpand (hbox2, TRUE);
gtk_grid_attach (GTK_GRID (grid), hbox2, 1, 2, 1, 1);
checkbox = gtk_check_button_new_with_mnemonic("_Vertical");
gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
g_signal_connect (checkbox, "toggled",
G_CALLBACK (change_orientation), toolbar);
checkbox = gtk_check_button_new_with_mnemonic("_Show Arrow");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE);
gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
g_signal_connect (checkbox, "toggled",
G_CALLBACK (change_show_arrow), toolbar);
checkbox = gtk_check_button_new_with_mnemonic("_Set Toolbar Style:");
g_signal_connect (checkbox, "toggled", G_CALLBACK (set_toolbar_style_toggled), toolbar);
gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
option_menu = gtk_combo_box_text_new ();
gtk_widget_set_sensitive (option_menu, FALSE);
g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu);
for (i = 0; i < G_N_ELEMENTS (toolbar_styles); i++)
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), toolbar_styles[i]);
gtk_combo_box_set_active (GTK_COMBO_BOX (option_menu),
gtk_toolbar_get_style (GTK_TOOLBAR (toolbar)));
gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0);
g_signal_connect (option_menu, "changed",
G_CALLBACK (change_toolbar_style), toolbar);
checkbox = gtk_check_button_new_with_mnemonic("_Set Icon Size:");
g_signal_connect (checkbox, "toggled", G_CALLBACK (set_icon_size_toggled), toolbar);
gtk_box_pack_start (GTK_BOX (hbox2), checkbox, FALSE, FALSE, 0);
option_menu = gtk_combo_box_text_new ();
g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu);
gtk_widget_set_sensitive (option_menu, FALSE);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), "small toolbar");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), "large toolbar");
gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0);
g_signal_connect (option_menu, "changed",
G_CALLBACK (icon_size_history_changed), toolbar);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_hexpand (scrolled_window, TRUE);
gtk_widget_set_vexpand (scrolled_window, TRUE);
gtk_grid_attach (GTK_GRID (grid), scrolled_window, 1, 3, 1, 1);
store = create_items_list (&treeview);
gtk_container_add (GTK_CONTAINER (scrolled_window), treeview);
item = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "document-new");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Custom label");
add_item_to_list (store, item, "New");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb, item);
gtk_tool_item_set_expand (item, TRUE);
menu = gtk_menu_new ();
for (i = 0; i < 20; i++)
{
char *text;
text = g_strdup_printf ("Menuitem %d", i);
menuitem = gtk_menu_item_new_with_label (text);
g_free (text);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
}
item = gtk_menu_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "document-open");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Open");
gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu);
add_item_to_list (store, item, "Open");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb1, item);
menu = gtk_menu_new ();
for (i = 0; i < 20; i++)
{
char *text;
text = g_strdup_printf ("A%d", i);
menuitem = gtk_menu_item_new_with_label (text);
g_free (text);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
}
item = gtk_menu_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-previous");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Back");
gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu);
add_item_to_list (store, item, "BackWithHistory");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_separator_tool_item_new ();
add_item_to_list (store, item, "-----");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
image = gtk_image_new_from_icon_name ("dialog-warning", GTK_ICON_SIZE_DIALOG);
item = gtk_tool_item_new ();
gtk_widget_show (image);
gtk_container_add (GTK_CONTAINER (item), image);
add_item_to_list (store, item, "(Custom Item)");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-previous");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Back");
add_item_to_list (store, item, "Back");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_separator_tool_item_new ();
add_item_to_list (store, item, "-----");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-next");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Forward");
add_item_to_list (store, item, "Forward");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_toggle_tool_button_new ();
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-text-bold");
g_signal_connect (item, "toggled", G_CALLBACK (bold_toggled), NULL);
add_item_to_list (store, item, "Bold");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gtk_widget_set_sensitive (GTK_WIDGET (item), FALSE);
item = gtk_separator_tool_item_new ();
add_item_to_list (store, item, "-----");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gtk_tool_item_set_expand (item, TRUE);
gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE);
g_assert (gtk_toolbar_get_nth_item (GTK_TOOLBAR (toolbar), 0) != 0);
item = gtk_radio_tool_button_new (NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-left");
group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item));
add_item_to_list (store, item, "Left");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_radio_tool_button_new (group);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-center");
make_prop_editor (G_OBJECT (item));
group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item));
add_item_to_list (store, item, "Center");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_radio_tool_button_new (group);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-right");
add_item_to_list (store, item, "Right");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new (gtk_image_new_from_file ("apple-red.png"), "_Apple");
add_item_to_list (store, item, "Apple");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gtk_tool_button_set_use_underline (GTK_TOOL_BUTTON (item), TRUE);
gicon = g_content_type_get_icon ("video/ogg");
image = gtk_image_new_from_gicon (gicon, GTK_ICON_SIZE_LARGE_TOOLBAR);
g_object_unref (gicon);
item = gtk_tool_button_new (image, "Video");
add_item_to_list (store, item, "Video");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
image = gtk_image_new_from_icon_name ("utilities-terminal", GTK_ICON_SIZE_LARGE_TOOLBAR);
item = gtk_tool_button_new (image, "Terminal");
add_item_to_list (store, item, "Terminal");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
image = gtk_spinner_new ();
gtk_spinner_start (GTK_SPINNER (image));
item = gtk_tool_button_new (image, "Spinner");
add_item_to_list (store, item, "Spinner");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_widget_set_hexpand (hbox, TRUE);
gtk_grid_attach (GTK_GRID (grid), hbox, 1, 4, 1, 1);
button = gtk_button_new_with_label ("Drag me to the toolbar");
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
label = gtk_label_new ("Drop index:");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
checkbox = gtk_check_button_new_with_mnemonic("_Right to left");
if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE);
else
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), FALSE);
g_signal_connect (checkbox, "toggled", G_CALLBACK (rtl_toggled), NULL);
gtk_box_pack_end (GTK_BOX (hbox), checkbox, FALSE, FALSE, 0);
gtk_drag_source_set (button, GDK_BUTTON1_MASK,
target_table, G_N_ELEMENTS (target_table),
GDK_ACTION_MOVE);
gtk_drag_dest_set (toolbar, GTK_DEST_DEFAULT_DROP,
target_table, G_N_ELEMENTS (target_table),
GDK_ACTION_MOVE);
g_signal_connect (toolbar, "drag_motion",
G_CALLBACK (toolbar_drag_motion), NULL);
g_signal_connect (toolbar, "drag_leave",
G_CALLBACK (toolbar_drag_leave), NULL);
g_signal_connect (toolbar, "drag_drop",
G_CALLBACK (toolbar_drag_drop), label);
gtk_widget_show_all (window);
make_prop_editor (G_OBJECT (toolbar));
g_signal_connect (window, "delete_event", G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect (toolbar, "popup_context_menu", G_CALLBACK (popup_context_menu), NULL);
gtk_main ();
return 0;
}
static void
pragha_toolbar_init (PraghaToolbar *toolbar)
{
PraghaPreferences *preferences;
GtkToolItem *prev_button, *play_button, *stop_button, *next_button;
GtkToolItem *unfull_button, *shuffle_button, *repeat_button;
GtkWidget *vol_button;
const GBindingFlags binding_flags =
G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL;
preferences = pragha_preferences_get();
/* Setup Left control buttons */
prev_button = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON(prev_button), "media-skip-backward");
gtk_widget_set_tooltip_text(GTK_WIDGET(prev_button), _("Previous Track"));
toolbar->prev_button = prev_button;
play_button = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON(play_button), "media-playback-start");
gtk_widget_set_tooltip_text(GTK_WIDGET(play_button), _("Play / Pause Track"));
toolbar->play_button = play_button;
stop_button = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON(stop_button), "media-playback-stop");
gtk_widget_set_tooltip_text(GTK_WIDGET(stop_button), _("Stop playback"));
toolbar->stop_button = stop_button;
next_button = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON(next_button), "media-skip-forward");
gtk_widget_set_tooltip_text(GTK_WIDGET(next_button), _("Next Track"));
toolbar->next_button = next_button;
#if GTK_CHECK_VERSION (3, 12, 0)
gtk_header_bar_pack_start(GTK_HEADER_BAR(toolbar), GTK_WIDGET(prev_button));
gtk_header_bar_pack_start(GTK_HEADER_BAR(toolbar), GTK_WIDGET(play_button));
gtk_header_bar_pack_start(GTK_HEADER_BAR(toolbar), GTK_WIDGET(stop_button));
gtk_header_bar_pack_start(GTK_HEADER_BAR(toolbar), GTK_WIDGET(next_button));
#else
gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(prev_button));
gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(play_button));
gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(stop_button));
gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(next_button));
#endif
/* Song info Box */
#if !GTK_CHECK_VERSION (3, 12, 0)
GtkToolItem *boxitem = gtk_tool_item_new ();
gtk_tool_item_set_expand (GTK_TOOL_ITEM(boxitem), TRUE);
gtk_toolbar_insert (GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(boxitem), -1);
GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_add (GTK_CONTAINER(boxitem), box);
GtkWidget *playing = pragha_toolbar_get_song_box (toolbar);
gtk_box_pack_start (GTK_BOX(box), playing, TRUE, TRUE, 5);
#endif
/* Setup Right control buttons */
unfull_button = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON(unfull_button), "view-restore");
gtk_widget_set_tooltip_text(GTK_WIDGET(unfull_button), _("Leave Fullscreen"));
toolbar->unfull_button = unfull_button;
shuffle_button = gtk_toggle_tool_button_new();
gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(shuffle_button), "media-playlist-shuffle");
gtk_widget_set_tooltip_text(GTK_WIDGET(shuffle_button), _("Play songs in a random order"));
repeat_button = gtk_toggle_tool_button_new ();
gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(repeat_button), "media-playlist-repeat");
gtk_widget_set_tooltip_text(GTK_WIDGET(repeat_button), _("Repeat playback list at the end"));
vol_button = gtk_volume_button_new();
g_object_set(vol_button, "use-symbolic", FALSE, NULL);
gtk_button_set_relief(GTK_BUTTON(vol_button), GTK_RELIEF_NONE);
g_object_set(G_OBJECT(vol_button), "size", GTK_ICON_SIZE_LARGE_TOOLBAR, NULL);
toolbar->vol_button = vol_button;
toolbar->extra_button_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
#if GTK_CHECK_VERSION (3, 12, 0)
gtk_header_bar_pack_end(GTK_HEADER_BAR(toolbar), GTK_WIDGET(toolbar->extra_button_box));
gtk_header_bar_pack_end(GTK_HEADER_BAR(toolbar), GTK_WIDGET(vol_button));
gtk_header_bar_pack_end(GTK_HEADER_BAR(toolbar), GTK_WIDGET(repeat_button));
gtk_header_bar_pack_end(GTK_HEADER_BAR(toolbar), GTK_WIDGET(shuffle_button));
gtk_header_bar_pack_end(GTK_HEADER_BAR(toolbar), GTK_WIDGET(unfull_button));
#else
gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(unfull_button));
gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(shuffle_button));
gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(repeat_button));
gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(vol_button));
gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(toolbar->extra_button_box));
#endif
/* Connect signals */
g_signal_connect(G_OBJECT(prev_button), "clicked",
G_CALLBACK(prev_button_handler), toolbar);
g_signal_connect(G_OBJECT(play_button), "clicked",
G_CALLBACK(play_button_handler), toolbar);
g_signal_connect(G_OBJECT(stop_button), "clicked",
G_CALLBACK(stop_button_handler), toolbar);
g_signal_connect(G_OBJECT(next_button), "clicked",
G_CALLBACK(next_button_handler), toolbar);
g_signal_connect(G_OBJECT(unfull_button), "clicked",
G_CALLBACK(unfull_button_handler), toolbar);
/*g_signal_connect(G_OBJECT (prev_button), "key-press-event",
G_CALLBACK(panel_button_key_press), toolbar);
g_signal_connect(G_OBJECT (play_button), "key-press-event",
G_CALLBACK(panel_button_key_press), toolbar);
g_signal_connect(G_OBJECT (stop_button), "key-press-event",
G_CALLBACK(panel_button_key_press), toolbar);
g_signal_connect(G_OBJECT (next_button), "key-press-event",
G_CALLBACK(panel_button_key_press), toolbar);
g_signal_connect(G_OBJECT (next_button), "key-press-event",
G_CALLBACK(panel_button_key_press), toolbar);
g_signal_connect(G_OBJECT (unfull_button), "key-press-event",
G_CALLBACK(panel_button_key_press), toolbar);
g_signal_connect(G_OBJECT (shuffle_button), "key-press-event",
G_CALLBACK(panel_button_key_press), toolbar);
g_signal_connect(G_OBJECT (repeat_button), "key-press-event",
G_CALLBACK(panel_button_key_press), toolbar);
g_signal_connect(G_OBJECT (vol_button), "key-press-event",
G_CALLBACK(panel_button_key_press), toolbar);*/
g_signal_connect (G_OBJECT (vol_button), "value-changed",
G_CALLBACK (vol_button_value_changed), toolbar);
g_object_bind_property(preferences, "shuffle", shuffle_button, "active", binding_flags);
g_object_bind_property(preferences, "repeat", repeat_button, "active", binding_flags);
/* Fix styling */
#if GTK_CHECK_VERSION (3, 12, 0)
pragha_toolbar_set_style(toolbar,
pragha_preferences_get_gnome_style (preferences));
#endif
gtk_widget_show(GTK_WIDGET(prev_button));
gtk_widget_show(GTK_WIDGET(play_button));
gtk_widget_show(GTK_WIDGET(stop_button));
gtk_widget_show(GTK_WIDGET(next_button));
gtk_widget_show(GTK_WIDGET(shuffle_button));
gtk_widget_show(GTK_WIDGET(repeat_button));
gtk_widget_show(GTK_WIDGET(vol_button));
gtk_widget_hide(GTK_WIDGET(toolbar->unfull_button));
gtk_widget_show(GTK_WIDGET(toolbar));
g_object_unref(preferences);
}
static GObject *
debug_dialog_constructor (GType type,
guint n_construct_params,
GObjectConstructParam *construct_params)
{
GObject *object;
EmpathyDebugDialogPriv *priv;
GtkWidget *vbox;
GtkWidget *toolbar;
GtkWidget *image;
GtkWidget *label;
GtkToolItem *item;
GtkCellRenderer *renderer;
GtkListStore *level_store;
GtkTreeIter iter;
object = G_OBJECT_CLASS (empathy_debug_dialog_parent_class)->constructor
(type, n_construct_params, construct_params);
priv = GET_PRIV (object);
gtk_window_set_title (GTK_WINDOW (object), _("Debug Window"));
gtk_window_set_default_size (GTK_WINDOW (object), 800, 400);
vbox = GTK_DIALOG (object)->vbox;
toolbar = gtk_toolbar_new ();
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH_HORIZ);
gtk_toolbar_set_show_arrow (GTK_TOOLBAR (toolbar), TRUE);
gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar),
GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_widget_show (toolbar);
gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0);
/* CM */
priv->cm_chooser = gtk_combo_box_new_text ();
priv->cms = gtk_list_store_new (NUM_COLS_CM, G_TYPE_STRING, G_TYPE_STRING);
gtk_combo_box_set_model (GTK_COMBO_BOX (priv->cm_chooser),
GTK_TREE_MODEL (priv->cms));
gtk_widget_show (priv->cm_chooser);
item = gtk_tool_item_new ();
gtk_widget_show (GTK_WIDGET (item));
gtk_container_add (GTK_CONTAINER (item), priv->cm_chooser);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
g_signal_connect (priv->cm_chooser, "changed",
G_CALLBACK (debug_dialog_cm_chooser_changed_cb), object);
gtk_widget_show (GTK_WIDGET (priv->cm_chooser));
item = gtk_separator_tool_item_new ();
gtk_widget_show (GTK_WIDGET (item));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
/* Save */
priv->save_button = gtk_tool_button_new_from_stock (GTK_STOCK_SAVE);
g_signal_connect (priv->save_button, "clicked",
G_CALLBACK (debug_dialog_save_clicked_cb), object);
gtk_widget_show (GTK_WIDGET (priv->save_button));
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (priv->save_button), TRUE);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->save_button, -1);
/* Copy */
priv->copy_button = gtk_tool_button_new_from_stock (GTK_STOCK_COPY);
g_signal_connect (priv->copy_button, "clicked",
G_CALLBACK (debug_dialog_copy_clicked_cb), object);
gtk_widget_show (GTK_WIDGET (priv->copy_button));
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (priv->copy_button), TRUE);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->copy_button, -1);
/* Clear */
priv->clear_button = gtk_tool_button_new_from_stock (GTK_STOCK_CLEAR);
g_signal_connect (priv->clear_button, "clicked",
G_CALLBACK (debug_dialog_clear_clicked_cb), object);
gtk_widget_show (GTK_WIDGET (priv->clear_button));
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (priv->clear_button), TRUE);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->clear_button, -1);
item = gtk_separator_tool_item_new ();
gtk_widget_show (GTK_WIDGET (item));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
/* Pause */
priv->paused = FALSE;
image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_PAUSE,
GTK_ICON_SIZE_MENU);
gtk_widget_show (image);
priv->pause_button = gtk_toggle_tool_button_new ();
gtk_toggle_tool_button_set_active (
GTK_TOGGLE_TOOL_BUTTON (priv->pause_button), priv->paused);
g_signal_connect (priv->pause_button, "toggled",
G_CALLBACK (debug_dialog_pause_toggled_cb), object);
gtk_widget_show (GTK_WIDGET (priv->pause_button));
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (priv->pause_button), TRUE);
gtk_tool_button_set_label (GTK_TOOL_BUTTON (priv->pause_button), _("Pause"));
gtk_tool_button_set_icon_widget (
GTK_TOOL_BUTTON (priv->pause_button), image);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->pause_button, -1);
item = gtk_separator_tool_item_new ();
gtk_widget_show (GTK_WIDGET (item));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
/* Level */
priv->level_label = gtk_tool_item_new ();
gtk_widget_show (GTK_WIDGET (priv->level_label));
label = gtk_label_new (_("Level "));
gtk_widget_show (label);
gtk_container_add (GTK_CONTAINER (priv->level_label), label);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->level_label, -1);
priv->level_filter = gtk_combo_box_new_text ();
gtk_widget_show (priv->level_filter);
item = gtk_tool_item_new ();
gtk_widget_show (GTK_WIDGET (item));
gtk_container_add (GTK_CONTAINER (item), priv->level_filter);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
level_store = gtk_list_store_new (NUM_COLS_LEVEL,
G_TYPE_STRING, G_TYPE_UINT);
gtk_combo_box_set_model (GTK_COMBO_BOX (priv->level_filter),
GTK_TREE_MODEL (level_store));
gtk_list_store_append (level_store, &iter);
gtk_list_store_set (level_store, &iter,
COL_LEVEL_NAME, _("Debug"),
COL_LEVEL_VALUE, EMP_DEBUG_LEVEL_DEBUG,
-1);
gtk_list_store_append (level_store, &iter);
gtk_list_store_set (level_store, &iter,
COL_LEVEL_NAME, _("Info"),
COL_LEVEL_VALUE, EMP_DEBUG_LEVEL_INFO,
-1);
gtk_list_store_append (level_store, &iter);
gtk_list_store_set (level_store, &iter,
COL_LEVEL_NAME, _("Message"),
COL_LEVEL_VALUE, EMP_DEBUG_LEVEL_MESSAGE,
-1);
gtk_list_store_append (level_store, &iter);
gtk_list_store_set (level_store, &iter,
COL_LEVEL_NAME, _("Warning"),
COL_LEVEL_VALUE, EMP_DEBUG_LEVEL_WARNING,
-1);
gtk_list_store_append (level_store, &iter);
gtk_list_store_set (level_store, &iter,
COL_LEVEL_NAME, _("Critical"),
COL_LEVEL_VALUE, EMP_DEBUG_LEVEL_CRITICAL,
-1);
gtk_list_store_append (level_store, &iter);
gtk_list_store_set (level_store, &iter,
COL_LEVEL_NAME, _("Error"),
COL_LEVEL_VALUE, EMP_DEBUG_LEVEL_ERROR,
-1);
gtk_combo_box_set_active (GTK_COMBO_BOX (priv->level_filter), 0);
g_signal_connect (priv->level_filter, "changed",
G_CALLBACK (debug_dialog_filter_changed_cb), object);
/* Debug treeview */
priv->view = gtk_tree_view_new ();
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (priv->view), TRUE);
g_signal_connect (priv->view, "button-press-event",
G_CALLBACK (debug_dialog_button_press_event_cb), object);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "yalign", 0, NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->view),
-1, _("Time"), renderer, "text", COL_DEBUG_TIMESTAMP, NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->view),
-1, _("Domain"), renderer, "text", COL_DEBUG_DOMAIN, NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->view),
-1, _("Category"), renderer, "text", COL_DEBUG_CATEGORY, NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->view),
-1, _("Level"), renderer, "text", COL_DEBUG_LEVEL_STRING, NULL);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "family", "Monospace", NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->view),
-1, _("Message"), renderer, "text", COL_DEBUG_MESSAGE, NULL);
priv->store = gtk_list_store_new (NUM_DEBUG_COLS, G_TYPE_DOUBLE,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_UINT);
priv->store_filter = gtk_tree_model_filter_new (
GTK_TREE_MODEL (priv->store), NULL);
gtk_tree_model_filter_set_visible_func (
GTK_TREE_MODEL_FILTER (priv->store_filter),
debug_dialog_visible_func, object, NULL);
gtk_tree_view_set_model (GTK_TREE_VIEW (priv->view), priv->store_filter);
/* Scrolled window */
priv->scrolled_win = g_object_ref (gtk_scrolled_window_new (NULL, NULL));
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->scrolled_win),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_show (priv->view);
gtk_container_add (GTK_CONTAINER (priv->scrolled_win), priv->view);
gtk_widget_show (priv->scrolled_win);
/* Not supported label */
priv->not_supported_label = g_object_ref (gtk_label_new (
_("The selected connection manager does not support the remote "
"debugging extension.")));
gtk_widget_show (priv->not_supported_label);
gtk_box_pack_start (GTK_BOX (vbox), priv->not_supported_label, TRUE, TRUE, 0);
priv->view_visible = FALSE;
debug_dialog_set_toolbar_sensitivity (EMPATHY_DEBUG_DIALOG (object), FALSE);
debug_dialog_fill_cm_chooser (EMPATHY_DEBUG_DIALOG (object));
gtk_widget_show (GTK_WIDGET (object));
return object;
}
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;
}
static void
GyahtzeeCreateMainWindow (GApplication *app, gpointer user_data)
{
GtkWidget *hbox, *vbox;
GtkWidget *toolbar;
GtkWidget *tmp;
GtkWidget *dicebox;
GtkWidget *undo_button;
GtkWidget *menu_button;
GtkWidget *icon;
GtkBuilder *builder;
GMenuModel *appmenu;
int i, j;
window = gtk_application_window_new (application);
gtk_window_set_application (GTK_WINDOW (window), application);
gtk_window_set_title (GTK_WINDOW (window), _(appName));
gtk_window_set_hide_titlebar_when_maximized (GTK_WINDOW (window), FALSE);
gtk_window_set_icon_name (GTK_WINDOW (window), "org.gnome.Tali");
//games_conf_add_window (GTK_WINDOW (window), NULL);
g_signal_connect (GTK_WIDGET (window), "key_press_event",
G_CALLBACK (key_press), NULL);
g_action_map_add_action_entries (G_ACTION_MAP (application), app_entries, G_N_ELEMENTS (app_entries), application);
const gchar *vaccels_help[] = {"F1", NULL};
const gchar *vaccels_new[] = {"<Primary>n", NULL};
const gchar *vaccels_roll[] = {"<Primary>r", NULL};
const gchar *vaccels_undo[] = {"<Primary>z", NULL};
gtk_application_set_accels_for_action (application, "app.help", vaccels_help);
gtk_application_set_accels_for_action (application, "app.new-game", vaccels_new);
gtk_application_set_accels_for_action (application, "app.roll", vaccels_roll);
gtk_application_set_accels_for_action (application, "app.undo", vaccels_undo);
scores_action = g_action_map_lookup_action (G_ACTION_MAP (application), "scores");
undo_action = g_action_map_lookup_action (G_ACTION_MAP (application), "undo");
update_undo_sensitivity ();
/*--- Headerbar ---*/
hbar = gtk_header_bar_new ();
gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (hbar), TRUE);
gtk_header_bar_set_title (GTK_HEADER_BAR (hbar), _(appName));
gtk_widget_show (hbar);
gtk_window_set_titlebar (GTK_WINDOW (window), hbar);
if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
undo_button = gtk_button_new_from_icon_name ("edit-undo-rtl-symbolic", GTK_ICON_SIZE_BUTTON);
else
undo_button = gtk_button_new_from_icon_name ("edit-undo-symbolic", GTK_ICON_SIZE_BUTTON);
gtk_widget_set_valign (undo_button, GTK_ALIGN_CENTER);
gtk_actionable_set_action_name (GTK_ACTIONABLE (undo_button), "app.undo");
gtk_widget_set_tooltip_text (undo_button, _("Undo your most recent move"));
gtk_widget_show (undo_button);
gtk_header_bar_pack_start (GTK_HEADER_BAR (hbar), undo_button);
builder = gtk_builder_new_from_resource ("/org/gnome/Tali/ui/menus.ui");
appmenu = (GMenuModel *) gtk_builder_get_object (builder, "app-menu");
menu_button = gtk_menu_button_new();
icon = gtk_image_new_from_icon_name ("open-menu-symbolic", GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON (menu_button), icon);
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (menu_button), appmenu);
gtk_widget_show (menu_button);
gtk_header_bar_pack_end (GTK_HEADER_BAR (hbar), menu_button);
/*---- Content ----*/
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
/* Retreive dice pixmaps from memory or files */
LoadDicePixmaps ();
/* Put all the dice in a vertical column */
dicebox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), dicebox, FALSE, TRUE, 0);
gtk_widget_show (dicebox);
rollLabel = gtk_label_new (NULL);
gtk_label_set_use_markup (GTK_LABEL (rollLabel), TRUE);
gtk_widget_show (rollLabel);
gtk_box_pack_start (GTK_BOX (dicebox), rollLabel, FALSE, TRUE, 5);
mbutton = gtk_button_new_with_label (_("Roll!"));
gtk_box_pack_end (GTK_BOX (dicebox), mbutton, FALSE, FALSE, 5);
g_signal_connect (GTK_BUTTON (mbutton), "clicked",
G_CALLBACK (roll_button_pressed_cb), NULL);
gtk_widget_show (GTK_WIDGET (mbutton));
toolbar = gtk_toolbar_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (toolbar),
GTK_ORIENTATION_VERTICAL);
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
gtk_toolbar_set_show_arrow (GTK_TOOLBAR (toolbar), FALSE);
gtk_box_pack_end (GTK_BOX (dicebox), toolbar, TRUE, TRUE, 0);
for (i = 0; i < NUMBER_OF_DICE; i++) {
tmp = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
for (j = 0; j < NUMBER_OF_PIXMAPS; j++) {
gtk_box_pack_start (GTK_BOX (tmp), dicePixmaps[i][j][GAME_YAHTZEE], FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (tmp), dicePixmaps[i][j][GAME_KISMET], FALSE, FALSE, 0);
}
diceBox[i] = gtk_toggle_tool_button_new ();
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (diceBox[i]), tmp);
g_signal_connect (GTK_TOOL_BUTTON (diceBox[i]), "clicked",
G_CALLBACK (modify_dice), &DiceValues[i]);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar),
GTK_TOOL_ITEM (diceBox[i]), -1);
gtk_widget_show (GTK_WIDGET (diceBox[i]));
gtk_widget_show (tmp);
/*gtk_widget_show (dicePixmaps[i][0][game_type]);*/
}
gtk_widget_show (toolbar);
/* Scores displayed in score list */
ScoreList = create_score_list ();
gtk_box_pack_end (GTK_BOX (hbox), ScoreList, TRUE, TRUE, 0);
setup_score_list (ScoreList);
gtk_widget_show (ScoreList);
gtk_widget_show (hbox);
gtk_widget_show (vbox);
}