static gboolean
gtk_menu_shell_accessible_add_selection (AtkSelection *selection,
gint i)
{
GList *kids;
GtkWidget *item;
guint length;
GtkWidget *widget;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
if (widget == NULL)
return FALSE;
kids = gtk_container_get_children (GTK_CONTAINER (widget));
length = g_list_length (kids);
if (i < 0 || i > length)
{
g_list_free (kids);
return FALSE;
}
item = g_list_nth_data (kids, i);
g_list_free (kids);
g_return_val_if_fail (GTK_IS_MENU_ITEM (item), FALSE);
gtk_menu_shell_select_item (GTK_MENU_SHELL (widget), item);
return TRUE;
}
static void m_menu_position(GtkMenu *menu,
gint *x,
gint *y,
gint *push_in,
gpointer user_data)
{
GtkWidget *active = gtk_menu_get_active(menu);
GdkEventButton *event = (GdkEventButton *) user_data;
int menu_xpos = event->x;
int menu_ypos = event->y;
GtkAllocation allocation;
GdkRectangle display_rect = m_get_monitor_geo();
if (active) {
gtk_menu_shell_select_item(GTK_MENU_SHELL(m_popup), active);
gtk_widget_get_allocation(active, &allocation);
}
gtk_widget_get_allocation(GTK_WIDGET(menu), &allocation);
if (display_rect.height - event->y_root < allocation.height)
menu_ypos -= allocation.height;
printf("DEBUG: %s (%d, %d)\n", __func__, menu_xpos, menu_ypos);
gdk_window_get_root_coords(gtk_widget_get_window(m_window),
menu_xpos, menu_ypos, &menu_xpos, &menu_ypos);
printf("DEBUG: %s (%d, %d)\n", __func__, menu_xpos, menu_ypos);
*x = menu_xpos;
*y = menu_ypos;
*push_in = TRUE;
}
void panel_menu_bar_popup_menu(PanelMenuBar* menubar, guint32 activate_time)
{
GtkMenu* menu;
GtkMenuShell* menu_shell;
g_return_if_fail(PANEL_IS_MENU_BAR(menubar));
menu = GTK_MENU(menubar->priv->applications_menu);
/*
* We need to call _gtk_menu_shell_activate() here as is done in
* window_key_press_handler in gtkmenubar.c which pops up menu
* when F10 is pressed.
*
* As that function is private its code is replicated here.
*/
menu_shell = GTK_MENU_SHELL(menubar);
#if !GTK_CHECK_VERSION (3, 0, 0)
if (!menu_shell->active)
{
gtk_grab_add(GTK_WIDGET(menu_shell));
menu_shell->have_grab = TRUE;
menu_shell->active = TRUE;
}
#endif
gtk_menu_shell_select_item(menu_shell, gtk_menu_get_attach_widget(menu));
}
void
panel_menu_bar_popup_menu (PanelMenuBar *menubar,
guint32 activate_time)
{
g_return_if_fail (PANEL_IS_MENU_BAR (menubar));
gtk_menu_shell_select_item (GTK_MENU_SHELL (menubar),
menubar->priv->applications_item);
}
static gboolean
qtcMenuShellButtonPress(GtkWidget *widget, GdkEventButton *event, void *data)
{
QTC_UNUSED(data);
if (GTK_IS_MENU_BAR(widget)) {
// QtCurve's menubars have a 2 pixel border ->
// but want the left/top to be 'active'...
int nx, ny;
gdk_window_get_origin(gtk_widget_get_window(widget), &nx, &ny);
if ((event->x_root - nx) <= 2.0 || (event->y_root - ny) <= 2.0) {
if ((event->x_root - nx) <= 2.0) {
event->x_root += 2.0;
}
if ((event->y_root - ny) <= 2.0) {
event->y_root += 2.0;
}
GtkMenuShell *menuShell = GTK_MENU_SHELL(widget);
GList *children =
gtk_container_get_children(GTK_CONTAINER(menuShell));
bool rv = false;
for (GList *child = children;child;child = child->next) {
GtkWidget *item = child->data;
QtcRect alloc = qtcWidgetGetAllocation(item);
int cx = alloc.x + nx;
int cy = alloc.y + ny;
int cw = alloc.width;
int ch = alloc.height;
if (cx <= event->x_root && cy <= event->y_root &&
(cx + cw) > event->x_root && (cy + ch) > event->y_root) {
if (menuIsSelectable(item)) {
if (event->type == GDK_BUTTON_PRESS) {
if (item != menuShell->active_menu_item) {
menuShell->active = false;
gtk_menu_shell_select_item(menuShell, item);
menuShell->active = true;
} else {
menuShell->active = true;
gtk_menu_shell_deselect(menuShell);
menuShell->active = false;
}
}
rv = true;
}
break;
}
}
if (children) {
g_list_free(children);
}
return rv;
}
}
return false;
}
void
gdict_sidebar_remove_page (GdictSidebar *sidebar,
const gchar *page_id)
{
GdictSidebarPrivate *priv;
SidebarPage *page;
GList *children, *l;
g_return_if_fail (GDICT_IS_SIDEBAR (sidebar));
g_return_if_fail (page_id != NULL);
priv = sidebar->priv;
if ((page = g_hash_table_lookup (priv->pages_by_id, page_id)) == NULL)
{
g_warning ("Attempting to remove a page from the sidebar with "
"id `%s', but there is no page with this id. Aborting...",
page_id);
return;
}
children = gtk_container_get_children (GTK_CONTAINER (priv->menu));
for (l = children; l != NULL; l = l->next)
{
GtkWidget *menu_item = l->data;
if (menu_item == page->menu_item)
{
gtk_container_remove (GTK_CONTAINER (priv->menu), menu_item);
break;
}
}
g_list_free (children);
gtk_notebook_remove_page (GTK_NOTEBOOK (priv->notebook), page->index);
g_hash_table_remove (priv->pages_by_id, page->id);
priv->pages = g_slist_remove (priv->pages, page);
sidebar_page_free (page);
/* select the first page, if present */
page = priv->pages->data;
if (page)
{
if (gtk_widget_get_realized (priv->menu))
gtk_menu_shell_select_item (GTK_MENU_SHELL (priv->menu),
page->menu_item);
gtk_label_set_text (GTK_LABEL (priv->label), page->name);
gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook), page->index);
}
else
gtk_widget_hide (GTK_WIDGET (sidebar));
}
void
gdict_sidebar_add_page (GdictSidebar *sidebar,
const gchar *page_id,
const gchar *page_name,
GtkWidget *page_widget)
{
GdictSidebarPrivate *priv;
SidebarPage *page;
GtkWidget *menu_item;
g_return_if_fail (GDICT_IS_SIDEBAR (sidebar));
g_return_if_fail (page_id != NULL);
g_return_if_fail (page_name != NULL);
g_return_if_fail (GTK_IS_WIDGET (page_widget));
priv = sidebar->priv;
if (g_hash_table_lookup (priv->pages_by_id, page_id))
{
g_warning ("Attempting to add a page to the sidebar with "
"id `%s', but there already is a page with the "
"same id. Aborting...",
page_id);
return;
}
/* add the page inside the page list */
page = sidebar_page_new (page_id, page_name, page_widget);
priv->pages = g_slist_append (priv->pages, page);
g_hash_table_insert (priv->pages_by_id, page->id, page);
page->index = gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook),
page_widget,
NULL);
/* add the menu item for the page */
menu_item = gtk_image_menu_item_new_with_label (page_name);
g_object_set_qdata_full (G_OBJECT (menu_item),
sidebar_page_id_quark,
g_strdup (page_id),
(GDestroyNotify) g_free);
g_signal_connect (menu_item, "activate",
G_CALLBACK (gdict_sidebar_menu_item_activate),
sidebar);
gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), menu_item);
gtk_widget_show (menu_item);
page->menu_item = menu_item;
if (gtk_widget_get_realized (priv->menu))
gtk_menu_shell_select_item (GTK_MENU_SHELL (priv->menu), menu_item);
gtk_label_set_text (GTK_LABEL (priv->label), page_name);
gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook), page->index);
}
int
clip_GTK_MENUSHELLSELECTITEM(ClipMachine * cm)
{
C_widget *cmns = _fetch_cw_arg(cm);
C_widget *cwid = _fetch_cwidget(cm,_clip_spar(cm,2));
CHECKCWID(cmns,GTK_IS_MENU_SHELL);
CHECKARG2(2,MAP_t,NUMERIC_t); CHECKCWID(cwid,GTK_IS_WIDGET);
gtk_menu_shell_select_item(GTK_MENU_SHELL(cmns->widget), cwid->widget);
return 0;
err:
return 1;
}
void
gdict_sidebar_view_page (GdictSidebar *sidebar,
const gchar *page_id)
{
GdictSidebarPrivate *priv;
SidebarPage *page;
g_return_if_fail (GDICT_IS_SIDEBAR (sidebar));
g_return_if_fail (page_id != NULL);
priv = sidebar->priv;
page = g_hash_table_lookup (priv->pages_by_id, page_id);
if (!page)
return;
gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook), page->index);
gtk_label_set_text (GTK_LABEL (priv->label), page->name);
gtk_menu_shell_select_item (GTK_MENU_SHELL (priv->menu), page->menu_item);
}
static gboolean matenu_menu_bar_real_move_selected (GtkMenuShell* base, gint distance) {
MatenuMenuBar * self;
gboolean result = FALSE;
self = (MatenuMenuBar*) base;
if (((GtkMenuShell*) self)->active_menu_item == GTK_WIDGET (self->priv->_overflown_arrow)) {
if (distance == 1) {
gtk_menu_shell_select_first ((GtkMenuShell*) self, TRUE);
} else {
{
gint i;
i = matenu_shell_get_length ((MatenuShell*) self) - 1;
{
gboolean _tmp0_;
_tmp0_ = TRUE;
while (TRUE) {
MatenuItem* item;
MatenuItem* _tmp1_;
GtkWidget* child;
if (!_tmp0_) {
i--;
}
_tmp0_ = FALSE;
if (!(i >= 0)) {
break;
}
item = matenu_shell_get_item ((MatenuShell*) self, i);
child = _g_object_ref0 ((_tmp1_ = item, GTK_IS_WIDGET (_tmp1_) ? ((GtkWidget*) _tmp1_) : NULL));
if (!matenu_menu_bar_child_need_overflown_arrow (self, child)) {
gtk_menu_shell_select_item ((GtkMenuShell*) self, child);
}
_g_object_unref0 (child);
_g_object_unref0 (item);
}
}
}
}
result = TRUE;
return result;
} else {
result = GTK_MENU_SHELL_CLASS (matenu_menu_bar_parent_class)->move_selected ((GtkMenuShell*) GTK_MENU_BAR (self), distance);
return result;
}
}
bool WebPopupMenuProxyGtk::typeAheadFind(GdkEventKey* event)
{
// If we were given a non-printable character just skip it.
gunichar unicodeCharacter = gdk_keyval_to_unicode(event->keyval);
if (!g_unichar_isprint(unicodeCharacter)) {
resetTypeAheadFindState();
return false;
}
glong charactersWritten;
GUniquePtr<gunichar2> utf16String(g_ucs4_to_utf16(&unicodeCharacter, 1, nullptr, &charactersWritten, nullptr));
if (!utf16String) {
resetTypeAheadFindState();
return false;
}
// If the character is the same as the last character, the user is probably trying to
// cycle through the menulist entries. This matches the WebCore behavior for collapsed menulists.
static const uint32_t searchTimeoutMs = 1000;
bool repeatingCharacter = unicodeCharacter != m_previousKeyEventCharacter;
if (event->time - m_previousKeyEventTimestamp > searchTimeoutMs)
m_currentSearchString = String(reinterpret_cast<UChar*>(utf16String.get()), charactersWritten);
else if (repeatingCharacter)
m_currentSearchString.append(String(reinterpret_cast<UChar*>(utf16String.get()), charactersWritten));
m_previousKeyEventTimestamp = event->time;
m_previousKeyEventCharacter = unicodeCharacter;
GUniquePtr<GList> children(gtk_container_get_children(GTK_CONTAINER(m_popup)));
if (!children)
return true;
// We case fold before searching, because strncmp does not handle non-ASCII characters.
GUniquePtr<gchar> searchStringWithCaseFolded(g_utf8_casefold(m_currentSearchString.utf8().data(), -1));
size_t prefixLength = strlen(searchStringWithCaseFolded.get());
// If a menu item has already been selected, start searching from the current
// item down the list. This will make multiple key presses of the same character
// advance the selection.
GList* currentChild = children.get();
if (m_currentlySelectedMenuItem) {
currentChild = g_list_find(children.get(), m_currentlySelectedMenuItem);
if (!currentChild) {
m_currentlySelectedMenuItem = nullptr;
currentChild = children.get();
}
// Repeating characters should iterate.
if (repeatingCharacter) {
if (GList* nextChild = g_list_next(currentChild))
currentChild = nextChild;
}
}
GList* firstChild = currentChild;
do {
currentChild = g_list_next(currentChild);
if (!currentChild)
currentChild = children.get();
GUniquePtr<gchar> itemText(g_utf8_casefold(gtk_menu_item_get_label(GTK_MENU_ITEM(currentChild->data)), -1));
if (!strncmp(searchStringWithCaseFolded.get(), itemText.get(), prefixLength)) {
gtk_menu_shell_select_item(GTK_MENU_SHELL(m_popup), GTK_WIDGET(currentChild->data));
break;
}
} while (currentChild != firstChild);
return true;
}
static VALUE
rg_select_item(VALUE self, VALUE menu_item)
{
gtk_menu_shell_select_item(_SELF(self), RVAL2GTKWIDGET(menu_item));
return self;
}
