static void
terminal_profile_editor_focus_widget (GtkWidget *editor,
const char *widget_name)
{
GtkBuilder *builder;
GtkWidget *widget, *page, *page_parent;
if (widget_name == NULL)
return;
builder = g_object_get_data (G_OBJECT (editor), "builder");
widget = GTK_WIDGET (gtk_builder_get_object (builder, widget_name));
if (widget == NULL)
return;
page = widget;
while (page != NULL &&
(page_parent = gtk_widget_get_parent (page)) != NULL &&
!GTK_IS_NOTEBOOK (page_parent))
page = page_parent;
page_parent = gtk_widget_get_parent (page);
if (page != NULL && GTK_IS_NOTEBOOK (page_parent))
{
GtkNotebook *notebook;
notebook = GTK_NOTEBOOK (page_parent);
gtk_notebook_set_current_page (notebook, gtk_notebook_page_num (notebook, page));
}
if (gtk_widget_is_sensitive (widget))
gtk_widget_grab_focus (widget);
}
static bool
childrenUseEvent(GtkWidget *widget, GdkEventButton *event, bool inNoteBook)
{
// accept, by default
bool usable = true;
// get children and check
GList *children = gtk_container_get_children(GTK_CONTAINER(widget));
for (GList *child = children;child && usable;child = g_list_next(child)) {
// cast child to GtkWidget
if (GTK_IS_WIDGET(child->data)) {
GtkWidget *childWidget = GTK_WIDGET(child->data);
GdkWindow *window = nullptr;
// check widget state and type
if (gtk_widget_get_state(childWidget) == GTK_STATE_PRELIGHT) {
// if widget is prelight, we don't need to check where event
// happen, any prelight widget indicate we can't do a move
usable = false;
continue;
}
window = gtk_widget_get_window(childWidget);
if (!(window && gdk_window_is_visible(window)))
continue;
if (GTK_IS_NOTEBOOK(childWidget))
inNoteBook = true;
if(!(event && withinWidget(childWidget, event)))
continue;
// check special cases for which grab should not be enabled
if((isBlackListed(G_OBJECT(childWidget))) ||
(GTK_IS_NOTEBOOK(widget) && Tab::isLabel(GTK_NOTEBOOK(widget),
childWidget)) ||
(GTK_IS_BUTTON(childWidget) &&
gtk_widget_get_state(childWidget) != GTK_STATE_INSENSITIVE) ||
(gtk_widget_get_events(childWidget) &
(GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK)) ||
(GTK_IS_MENU_ITEM(childWidget)) ||
(GTK_IS_SCROLLED_WINDOW(childWidget) &&
(!inNoteBook || gtk_widget_is_focus(childWidget)))) {
usable = false;
}
// if child is a container and event has been accepted so far,
// also check it, recursively
if (usable && GTK_IS_CONTAINER(childWidget)) {
usable = childrenUseEvent(childWidget, event, inNoteBook);
}
}
}
if (children) {
g_list_free(children);
}
return usable;
}
/**
* callback for fullscreen mode gtk_container_foreach()
*/
static void
fullscreen_toggle_widget_visible(GtkWidget *wid, gpointer user_data) {
gchar* data_label;
struct FullscreenData *fdata;
gboolean old_v;
gchar *propName;
fdata = user_data;
// remove shadow of scrolled window
if (GTK_IS_SCROLLED_WINDOW(wid)) {
GtkShadowType shadow_type;
data_label = "fullscreen_shadow_type";
propName = "shadow-type";
if (fdata->visible == FALSE) {
g_object_get(G_OBJECT(wid),
propName, &shadow_type, NULL);
g_object_set(G_OBJECT(wid),
propName, GTK_SHADOW_NONE, NULL);
g_object_set_data(G_OBJECT(wid), data_label,
GINT_TO_POINTER(shadow_type));
} else {
shadow_type = GPOINTER_TO_INT(g_object_steal_data(
G_OBJECT(wid), data_label));
if (shadow_type && shadow_type != GTK_SHADOW_NONE) {
g_object_set(G_OBJECT(wid),
propName, shadow_type, NULL);
}
}
}
if (wid == fdata->me && !GTK_IS_NOTEBOOK(wid)) {
return;
}
data_label = "fullscreen_visible";
if (GTK_IS_NOTEBOOK(wid)) {
propName = "show-tabs";
} else {
propName = "visible";
}
if (fdata->visible == FALSE) {
g_object_get(G_OBJECT(wid), propName, &old_v, NULL);
g_object_set(G_OBJECT(wid), propName, FALSE, NULL);
g_object_set_data(G_OBJECT(wid), data_label,
GINT_TO_POINTER(old_v));
} else {
old_v = GPOINTER_TO_INT(g_object_steal_data(
G_OBJECT(wid), data_label));
if (old_v == TRUE) {
g_object_set(G_OBJECT(wid), propName, TRUE, NULL);
}
}
}
static GtkWidget *
gnc_prefs_find_page (GtkNotebook *notebook, const gchar *name)
{
int n_pages, i;
GtkWidget *child;
const gchar *child_name;
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), NULL);
g_return_val_if_fail (name, NULL);
ENTER("");
n_pages = gtk_notebook_get_n_pages (notebook);
for (i = 0; i < n_pages; i++)
{
child = gtk_notebook_get_nth_page (notebook, i);
g_return_val_if_fail (child, NULL);
child_name = gtk_notebook_get_tab_label_text (notebook, child);
g_return_val_if_fail (child_name, NULL);
if (g_utf8_collate (name, child_name) == 0)
{
LEAVE("found at index: %d", i);
return child;
}
}
LEAVE("not found");
return NULL;
}
static gboolean
gail_switch_page_watcher (GSignalInvocationHint *ihint,
guint n_param_values,
const GValue *param_values,
gpointer data)
{
GObject *object;
GtkWidget *widget;
GtkNotebook *notebook;
object = g_value_get_object (param_values + 0);
g_return_val_if_fail (GTK_IS_WIDGET(object), FALSE);
widget = GTK_WIDGET (object);
if (!GTK_IS_NOTEBOOK (widget))
return TRUE;
notebook = GTK_NOTEBOOK (widget);
if (!notebook->focus_tab)
return TRUE;
gail_focus_notify_when_idle (widget);
return TRUE;
}
static void
jam_dialog_set_contents_container(GtkDialog *dlg, GtkWidget *container) {
gtk_container_set_border_width(GTK_CONTAINER(container), 12);
gtk_box_pack_start(GTK_BOX(dlg->vbox), container, TRUE, TRUE, 0);
gtk_widget_show_all(dlg->vbox);
if (GTK_IS_NOTEBOOK(container))
gtk_dialog_set_has_separator(dlg, FALSE);
}
static AtkObject*
get_accessible_for_widget (GtkWidget *widget,
gboolean *transient)
{
AtkObject *obj = NULL;
*transient = FALSE;
if (!widget)
return NULL;
if (GTK_IS_ENTRY (widget))
;
else if (GTK_IS_NOTEBOOK (widget))
{
GtkNotebook *notebook;
gint page_num = -1;
notebook = GTK_NOTEBOOK (widget);
page_num = gtk_notebook_get_current_page (notebook);
if (page_num != -1)
{
obj = gtk_widget_get_accessible (widget);
obj = atk_object_ref_accessible_child (obj, page_num);
g_object_unref (obj);
}
}
else if (GTK_IS_TOGGLE_BUTTON (widget))
{
GtkWidget *other_widget = gtk_widget_get_parent (widget);
if (GTK_IS_COMBO_BOX (other_widget))
{
gail_set_focus_widget (other_widget, widget);
widget = other_widget;
}
}
if (obj == NULL)
{
AtkObject *focus_object;
obj = gtk_widget_get_accessible (widget);
focus_object = g_object_get_qdata (G_OBJECT (obj), quark_focus_object);
/*
* We check whether the object for this focus_object has been deleted.
* This can happen when navigating to an empty directory in nautilus.
* See bug #141907.
*/
if (ATK_IS_GOBJECT_ACCESSIBLE (focus_object))
{
if (!atk_gobject_accessible_get_object (ATK_GOBJECT_ACCESSIBLE (focus_object)))
focus_object = NULL;
}
if (focus_object)
obj = focus_object;
}
return obj;
}
void
aurora_get_parent_bg (const GtkWidget *widget, AuroraRGB *color)
{
GtkStateType state_type;
const GtkWidget *parent;
GdkColor *gcolor;
gboolean stop;
GtkShadowType shadow = GTK_SHADOW_NONE;
if (widget == NULL)
return;
parent = widget->parent;
stop = FALSE;
while (parent && !stop)
{
stop = FALSE;
stop |= !GTK_WIDGET_NO_WINDOW (parent);
stop |= GTK_IS_NOTEBOOK (parent) &&
gtk_notebook_get_show_tabs (GTK_NOTEBOOK (parent)) &&
gtk_notebook_get_show_border (GTK_NOTEBOOK (parent));
if (GTK_IS_FRAME(parent))
{
shadow = gtk_frame_get_shadow_type(GTK_FRAME(parent));
stop |= (shadow != GTK_SHADOW_NONE);
}
else if (GTK_IS_TOOLBAR (parent))
{
gtk_widget_style_get (GTK_WIDGET (parent), "shadow-type", &shadow, NULL);
stop |= (shadow != GTK_SHADOW_NONE);
}
if (!stop)
parent = parent->parent;
}
if (parent == NULL)
return;
state_type = GTK_WIDGET_STATE (parent);
gcolor = &parent->style->bg[state_type];
aurora_gdk_color_to_rgb (gcolor, &color->r, &color->g, &color->b);
if (GTK_IS_FRAME (parent) && shadow != GTK_SHADOW_NONE) {
if (shadow == (GTK_SHADOW_IN || GTK_SHADOW_ETCHED_IN))
aurora_shade (color, color, 0.97);
else
aurora_shade (color, color, 1.04);
}
}
AtkObject*
gail_notebook_page_new (GtkNotebook *notebook,
gint pagenum)
{
GObject *object;
AtkObject *atk_object;
GailNotebookPage *page;
GtkWidget *child;
GtkWidget *label;
GList *list;
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), NULL);
child = gtk_notebook_get_nth_page (notebook, pagenum);
if (!child)
return NULL;
object = g_object_new (GAIL_TYPE_NOTEBOOK_PAGE, NULL);
g_return_val_if_fail (object != NULL, NULL);
page = GAIL_NOTEBOOK_PAGE (object);
page->notebook = notebook;
g_object_add_weak_pointer (G_OBJECT (page->notebook), (gpointer *)&page->notebook);
page->index = pagenum;
list = g_list_nth (notebook->children, pagenum);
page->page = list->data;
page->textutil = NULL;
atk_object = ATK_OBJECT (page);
atk_object->role = ATK_ROLE_PAGE_TAB;
atk_object->layer = ATK_LAYER_WIDGET;
page->notify_child_added_id = gdk_threads_add_idle (notify_child_added, atk_object);
/*
* We get notified of changes to the label
*/
label = get_label_from_notebook_page (page);
if (GTK_IS_LABEL (label))
{
if (gtk_widget_get_mapped (label))
gail_notebook_page_init_textutil (page, label);
else
g_signal_connect (label,
"map",
G_CALLBACK (gail_notebook_page_label_map_gtk),
page);
}
return atk_object;
}
/**
* seahorse_prefs_remove_tab:
* @swidget: The preferences window
* @tab: The tab to be removed
*
* Removes a tab from the preferences window
**/
void
seahorse_prefs_remove_tab (SeahorseWidget *swidget, GtkWidget *tab)
{
GtkWidget *tabs;
gint pos;
g_return_if_fail (GTK_IS_WIDGET (tab));
tabs = GTK_WIDGET (seahorse_widget_get_widget (swidget, "notebook"));
g_return_if_fail (GTK_IS_NOTEBOOK (tabs));
pos = gtk_notebook_page_num (GTK_NOTEBOOK (tabs), tab);
if (pos != -1)
gtk_notebook_remove_page (GTK_NOTEBOOK (tabs), pos);
}
static AtkObject *
gtk_widget_accessible_get_parent (AtkObject *accessible)
{
AtkObject *parent;
GtkWidget *widget, *parent_widget;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
if (widget == NULL)
return NULL;
parent = accessible->accessible_parent;
if (parent != NULL)
return parent;
parent_widget = gtk_widget_get_parent (widget);
if (parent_widget == NULL)
return NULL;
/* For a widget whose parent is a GtkNoteBook, we return the
* accessible object corresponding the GtkNotebookPage containing
* the widget as the accessible parent.
*/
if (GTK_IS_NOTEBOOK (parent_widget))
{
gint page_num;
GtkWidget *child;
GtkNotebook *notebook;
page_num = 0;
notebook = GTK_NOTEBOOK (parent_widget);
while (TRUE)
{
child = gtk_notebook_get_nth_page (notebook, page_num);
if (!child)
break;
if (child == widget)
{
parent = gtk_widget_get_accessible (parent_widget);
parent = atk_object_ref_accessible_child (parent, page_num);
g_object_unref (parent);
return parent;
}
page_num++;
}
}
parent = gtk_widget_get_accessible (parent_widget);
return parent;
}
/* A tab of a browser was reordered */
static void _interface_tweaks_on_tab_reordered(InterfaceTweaks *self,
GtkWidget *inChild,
guint inPageNumber,
gpointer inUserData)
{
g_return_if_fail(IS_INTERFACE_TWEAKS(self));
g_return_if_fail(MIDORI_IS_VIEW(inChild));
g_return_if_fail(GTK_IS_NOTEBOOK(inUserData));
InterfaceTweaksPrivate *priv=self->priv;
MidoriView *view=MIDORI_VIEW(inChild);
GtkNotebook *notebook=GTK_NOTEBOOK(inUserData);
MidoriBrowser *browser;
gboolean minimized;
gint firstMaximizedPosition;
/* Check if tab we should group minimized tabs to front */
if(!priv->groupMinimizedTabs) return;
/* Check if tab was minimized */
minimized=FALSE;
g_object_get(view, "minimized", &minimized, NULL);
/* Get browser of tab */
browser=midori_browser_get_for_widget(GTK_WIDGET(view));
if(!browser) return;
/* Find position of first maximized tab */
firstMaximizedPosition=_interface_tweak_get_browser_first_maximized_tab_position(browser, view);
/* If tab is maximized then it moves away from front and
* the position must be decreased by one to get the first maximized tab
*/
if(!minimized) firstMaximizedPosition--;
/* Reorder tab now */
if(firstMaximizedPosition<0) firstMaximizedPosition=0;
if((minimized==TRUE && inPageNumber>=firstMaximizedPosition) ||
(minimized==FALSE && inPageNumber<firstMaximizedPosition))
{
g_signal_handlers_block_by_func(view, G_CALLBACK(_interface_tweaks_on_notify_minimized_tab_for_group_tabs), self);
gtk_notebook_reorder_child(GTK_NOTEBOOK(notebook), GTK_WIDGET(view), firstMaximizedPosition);
g_signal_handlers_unblock_by_func(view, G_CALLBACK(_interface_tweaks_on_notify_minimized_tab_for_group_tabs), self);
}
}
void
setup(GtkWidget *widget)
{
QTC_RET_IF_FAIL(widget);
GtkWidget *parent = nullptr;
if (GTK_IS_WINDOW(widget) &&
!gtk_window_get_decorated(GTK_WINDOW(widget))) {
return;
}
if (GTK_IS_EVENT_BOX(widget) &&
gtk_event_box_get_above_child(GTK_EVENT_BOX(widget)))
return;
parent = gtk_widget_get_parent(widget);
// widgets used in tabs also must be ignored (happens, unfortunately)
if (GTK_IS_NOTEBOOK(parent) && Tab::isLabel(GTK_NOTEBOOK(parent), widget))
return;
/*
check event mask (for now we only need to do that for GtkWindow)
The idea is that if the window has been set to receive button_press
and button_release events (which is not done by default), it likely
means that it does something with such events, in which case we should
not use them for grabbing
*/
if (oneOf(gTypeName(widget), "GtkWindow") &&
(gtk_widget_get_events(widget) &
(GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK)))
return;
GtkWidgetProps props(widget);
if (!isFakeGtk() && !props->wmMoveHacked) {
props->wmMoveHacked = true;
gtk_widget_add_events(widget, GDK_BUTTON_RELEASE_MASK |
GDK_BUTTON_PRESS_MASK | GDK_LEAVE_NOTIFY_MASK |
GDK_BUTTON1_MOTION_MASK);
registerBtnReleaseHook();
props->wmMoveDestroy.conn("destroy-event", destroy);
props->wmMoveStyleSet.conn("style-set", styleSet);
props->wmMoveMotion.conn("motion-notify-event", motion);
props->wmMoveLeave.conn("leave-notify-event", leave);
props->wmMoveButtonPress.conn("button-press-event", buttonPress);
}
}
void
dialog_tool_preset_to_range (GenericToolState *state)
{
GnmRange const *sel;
GtkWidget *w;
g_return_if_fail (state != NULL);
g_return_if_fail (state->gdao != NULL);
sel = selection_first_range (state->sv, NULL, NULL);
gnm_dao_load_range (GNM_DAO (state->gdao), sel);
gnm_dao_focus_output_range (GNM_DAO (state->gdao));
w = glade_xml_get_widget (state->gui, "notebook1");
g_return_if_fail (w && GTK_IS_NOTEBOOK (w));
gtk_notebook_set_current_page (GTK_NOTEBOOK(w), 0);
}
static void cl_get_window_style_state (GtkWidget *widget, GtkStyle **style, GtkStateType *state_type)
{
GtkStyle *windowstyle = NULL;
GtkWidget *tmpwidget = widget;
GtkStateType windowstate;
if (widget && GTK_IS_ENTRY (widget))
tmpwidget = tmpwidget->parent;
while (tmpwidget && GTK_WIDGET_NO_WINDOW (tmpwidget) && !GTK_IS_NOTEBOOK(tmpwidget))
{
tmpwidget = tmpwidget->parent;
}
*style = tmpwidget->style;
*state_type = GTK_WIDGET_STATE(tmpwidget);
}
void
on_clear_history_activate (gpointer notebook, GtkWidget *menu_item)
{
Netinfo *netinfo;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
/* Pages all share a history id for host entry except whois */
netinfo = g_object_get_data (G_OBJECT (notebook), "pinger");
gn_combo_history_clear (netinfo->history);
netinfo = g_object_get_data (G_OBJECT (notebook), "finger");
gn_combo_history_clear (netinfo->history);
gn_combo_history_clear (netinfo->history_user);
netinfo = g_object_get_data (G_OBJECT (notebook), "whois");
gn_combo_history_clear (netinfo->history);
}
void
on_copy_activate (gpointer notebook, GtkWidget *menu_item)
{
gint page;
Netinfo *netinfo;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
page = gtk_notebook_get_current_page (GTK_NOTEBOOK (notebook));
netinfo = get_netinfo_for_page (GTK_NOTEBOOK (notebook), page);
if (!netinfo)
return;
if (netinfo->copy_output != NULL) {
(netinfo->copy_output) ((gpointer) netinfo, NULL);
}
}
static bool
useEvent(GtkWidget *widget, GdkEventButton *event)
{
if(lastRejectedEvent && lastRejectedEvent==event)
return false;
if(!GTK_IS_CONTAINER(widget))
return true;
// if widget is a notebook, accept if there is no hovered tab
if (GTK_IS_NOTEBOOK(widget)) {
return (!Tab::hasVisibleArrows(GTK_NOTEBOOK(widget)) &&
Tab::currentHoveredIndex(widget) == -1 &&
childrenUseEvent(widget, event, false));
} else {
return childrenUseEvent(widget, event, false);
}
}
//____________________________________________________________________________________________
gboolean Animations::realizationHook( GSignalInvocationHint*, guint, const GValue* params, gpointer data )
{
// get widget from params
GtkWidget* widget( GTK_WIDGET( g_value_get_object( params ) ) );
// check type
if( !GTK_IS_WIDGET( widget ) ) return FALSE;
if( GTK_IS_NOTEBOOK( widget ) )
{ gtk_notebook_set_show_border( GTK_NOTEBOOK(widget), FALSE ); }
#if ENABLE_GROUPBOX_HACK
if( GTK_IS_LABEL( widget ) && GTK_IS_FRAME( gtk_widget_get_parent( widget ) ) )
{
GtkFrame *frame( GTK_FRAME( gtk_widget_get_parent( widget ) ) );
if( widget == gtk_frame_get_label_widget( frame ) && !Gtk::gtk_widget_find_parent( widget, "GtkPizza" ) )
{
#if OXYGEN_DEBUG
std::cout
<< "Oxygen::Animations::realizationHook -"
<< " widget: " << widget << " (" << G_OBJECT_TYPE_NAME( widget ) << ")"
<< " parent: " << frame << " (" << G_OBJECT_TYPE_NAME( frame ) << ")"
<< std::endl;
#endif
// modify alignment
gtk_frame_set_label_align( frame, 0.5, 0.0 );
gtk_frame_set_shadow_type( frame, GTK_SHADOW_OUT );
// register to engine
Animations& animations( *static_cast<Animations*>(data) );
animations.groupBoxLabelEngine().registerWidget( widget );
animations.groupBoxLabelEngine().adjustSize( widget );
}
}
#endif
return TRUE;
}
/**
* hildon_wizard_dialog_new:
* @parent: a #GtkWindow
* @wizard_name: the name of dialog
* @notebook: the notebook to be shown on the dialog
*
* Creates a new #HildonWizardDialog.
*
* Returns: a new #HildonWizardDialog
*/
GtkWidget*
hildon_wizard_dialog_new (GtkWindow *parent,
const char *wizard_name,
GtkNotebook *notebook)
{
GtkWidget *widget;
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), NULL);
widget = GTK_WIDGET (g_object_new
(HILDON_TYPE_WIZARD_DIALOG,
"wizard-name", wizard_name,
"wizard-notebook", notebook, NULL));
if (parent)
gtk_window_set_transient_for (GTK_WINDOW (widget), parent);
return widget;
}
static void
gnc_prefs_sort_pages (GtkNotebook *notebook)
{
gint n_pages, i;
GList *tabs = NULL, *iter = NULL;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
/* gather tabs */
n_pages = gtk_notebook_get_n_pages (notebook);
for (i = n_pages - 1; i >= 0; i--)
tabs = g_list_prepend (tabs, gtk_notebook_get_nth_page (notebook, i));
/* sort in local copy */
tabs = g_list_sort_with_data (tabs, (GCompareDataFunc) tab_cmp, notebook);
/* reorder tabs */
for (i = 0, iter = tabs; iter; i++, iter = iter->next)
gtk_notebook_reorder_child (notebook, GTK_WIDGET (iter->data), i);
g_list_free (tabs);
}
//_____________________________________________
GdkRectangle TabWidgetStateData::dirtyRect( void ) const
{
// FIXME: it might be enough to union the rects of the current and previous tab
if( GTK_IS_NOTEBOOK( _target ) )
{
GdkRectangle rect( Gtk::gdk_rectangle() );
Gtk::gtk_notebook_get_tabbar_rect( GTK_NOTEBOOK( _target ), &rect );
#if OXYGEN_DEBUG
std::cerr << "Oxygen::TabWidgetData::dirtyRect - " << rect << std::endl;
#endif
return rect;
} else {
return Gtk::gtk_widget_get_allocation( _target );
}
}
static bool
withinWidget(GtkWidget *widget, GdkEventButton *event)
{
// get top level widget
GtkWidget *topLevel=gtk_widget_get_toplevel(widget);;
GdkWindow *window = topLevel ? gtk_widget_get_window(topLevel) : nullptr;
if (window) {
QtcRect allocation;
int wx=0, wy=0, nx=0, ny=0;
// translate widget position to topLevel
gtk_widget_translate_coordinates(widget, topLevel, wx, wy, &wx, &wy);
// translate to absolute coordinates
gdk_window_get_origin(window, &nx, &ny);
wx += nx;
wy += ny;
// get widget size.
// for notebooks, only consider the tabbar rect
if (GTK_IS_NOTEBOOK(widget)) {
QtcRect widgetAlloc = Widget::getAllocation(widget);
allocation = Tab::getTabbarRect(GTK_NOTEBOOK(widget));
allocation.x += wx - widgetAlloc.x;
allocation.y += wy - widgetAlloc.y;
} else {
allocation = Widget::getAllocation(widget);
allocation.x = wx;
allocation.y = wy;
}
return allocation.x<=event->x_root && allocation.y<=event->y_root &&
(allocation.x+allocation.width)>event->x_root && (allocation.y+allocation.height)>event->y_root;
}
return true;
}
void
pannode_delete (struct pan_node *xq)
{
gint id;
acc_debug ("delete accxq: %p\n", xq);
if (xq->accxq && xq->accxq->panlist)
{
xq->accxq->panlist = g_list_remove (xq->accxq->panlist, xq);
}
if (GTK_IS_NOTEBOOK (xq->parent))
{
id = gtk_notebook_page_num (GTK_NOTEBOOK (xq->parent), xq->widget);
gtk_notebook_remove_page (GTK_NOTEBOOK (xq->parent), id);
}
if (xq->qipu)
{
qipu_destroy (xq->qipu);
}
g_list_free (xq->cur_moves);
xq->cur_moves = NULL;
if (xq->parterthread)
{
g_thread_join (xq->parterthread);
}
session_delete (xq->session);
if (xq->name)
{
g_free (xq->name);
}
free (xq);
}
void
clearlooks_get_parent_bg (const GtkWidget *widget, CairoColor *color)
{
GtkStateType state_type;
const GtkWidget *parent;
GdkColor *gcolor;
if (widget == NULL)
return;
parent = widget->parent;
while (parent && GTK_WIDGET_NO_WINDOW (parent) && !((GTK_IS_NOTEBOOK (parent)) || (GTK_IS_TOOLBAR (parent))))
parent = parent->parent;
if (parent == NULL)
return;
state_type = GTK_WIDGET_STATE (parent);
gcolor = &parent->style->bg[state_type];
ge_gdk_color_to_cairo (gcolor, color);
}
static AtkObject*
gail_get_accessible_for_widget (GtkWidget *widget,
gboolean *transient)
{
AtkObject *obj = NULL;
GType gnome_canvas;
gnome_canvas = g_type_from_name ("GnomeCanvas");
*transient = FALSE;
if (!widget)
return NULL;
if (GTK_IS_ENTRY (widget))
{
GtkWidget *other_widget = widget->parent;
if (GTK_IS_COMBO (other_widget))
{
gail_set_focus_widget (other_widget, widget);
widget = other_widget;
}
}
else if (GTK_IS_NOTEBOOK (widget))
{
GtkNotebook *notebook;
gint page_num = -1;
notebook = GTK_NOTEBOOK (widget);
/*
* Report the currently focused tab rather than the currently selected tab
*/
if (notebook->focus_tab)
{
page_num = g_list_index (notebook->children, notebook->focus_tab->data);
}
if (page_num != -1)
{
obj = gtk_widget_get_accessible (widget);
obj = atk_object_ref_accessible_child (obj, page_num);
g_object_unref (obj);
}
}
else if (GTK_CHECK_TYPE ((widget), gnome_canvas))
{
GObject *focused_item;
GValue value = {0, };
g_value_init (&value, G_TYPE_OBJECT);
g_object_get_property (G_OBJECT (widget), "focused_item", &value);
focused_item = g_value_get_object (&value);
if (focused_item)
{
AtkObject *tmp;
obj = atk_gobject_accessible_for_object (G_OBJECT (focused_item));
tmp = g_object_get_qdata (G_OBJECT (obj), quark_focus_object);
if (tmp != NULL)
obj = tmp;
}
}
else if (GTK_IS_TOGGLE_BUTTON (widget))
{
GtkWidget *other_widget = widget->parent;
if (GTK_IS_COMBO_BOX (other_widget))
{
gail_set_focus_widget (other_widget, widget);
widget = other_widget;
}
}
if (obj == NULL)
{
AtkObject *focus_object;
obj = gtk_widget_get_accessible (widget);
focus_object = g_object_get_qdata (G_OBJECT (obj), quark_focus_object);
/*
* We check whether the object for this focus_object has been deleted.
* This can happen when navigating to an empty directory in nautilus.
* See bug #141907.
*/
if (ATK_IS_GOBJECT_ACCESSIBLE (focus_object))
{
if (!atk_gobject_accessible_get_object (ATK_GOBJECT_ACCESSIBLE (focus_object)))
focus_object = NULL;
}
if (focus_object)
obj = focus_object;
}
return obj;
}
/*!
\brief bind_data() is a recursive function that is called for every container
widget in a glade frame and it's purpose is to search the datamap file passed
for the widget names in the glade file and if it's fond in the datamap to
load all the attribues listed and bind them to the object using GTK+'s
object model.
\param widget is the widget passed to load attributes on
\param user_data is the pointer to a BingGroup structure.
*/
G_MODULE_EXPORT void bind_data(GtkWidget *widget, gpointer user_data)
{
BindGroup *bindgroup = (BindGroup *)user_data;
ConfigFile *cfgfile = bindgroup->cfgfile;
GHashTable *groups = bindgroup->groups;
gchar * tmpbuf = NULL;
gchar * section = NULL;
gchar ** keys = NULL;
gint num_keys = 0;
gint offset = 0;
gint page = 0;
gint index = 0;
gchar * initializer = NULL;
GdkColor color;
gchar *size = NULL;
gint count = 0;
gint tmpi = 0;
gboolean hidden = FALSE;
gchar *ptr = NULL;
gchar **vector = NULL;
gchar **vec2 = NULL;
void (*func)(void) = NULL;
GList *list = NULL;
GList *list2 = NULL;
const gchar *name = NULL;
gboolean indexed = FALSE;
Firmware_Details *firmware = NULL;
GList ***ecu_widgets = NULL;
GList *tab_widgets = NULL;
void (*load_dep_obj)(GObject *, ConfigFile *,const gchar *,const gchar *) = NULL;
ENTER();
MTXDBG(TABLOADER,_("Entered"));
ecu_widgets = (GList ***)DATA_GET(global_data,"ecu_widgets");
firmware = (Firmware_Details *)DATA_GET(global_data,"firmware");
g_return_if_fail(ecu_widgets);
g_return_if_fail(firmware);
if (!GTK_IS_WIDGET(widget))
{
EXIT();
return;
}
if (GTK_IS_WIDGET(widget))
if (GTK_IS_CONTAINER(widget))
gtk_container_foreach(GTK_CONTAINER(widget),bind_data,user_data);
name = gtk_widget_get_name(widget);
if (!name)
{
EXIT();
return;
}
if (NULL != (ptr = g_strrstr_len(name,strlen(name),"_of_")))
{
indexed = TRUE;
ptr = g_strrstr_len(name,ptr-name,"_");
tmpbuf = g_strdelimit(g_strdup(ptr),"_",' ');
section = g_strndup(name,ptr-name);
/*printf("(indexed) section is %s\n",section);*/
gint result = sscanf(tmpbuf,"%d of %d",&index,&count);
/*printf("sscanf result %i\n",result);*
* printf("Found indexed value for \"%s\", index %i, count %i\n",tmpbuf,index,count);
*/
g_free(tmpbuf);
}
else
section = g_strdup(name);
if(cfg_read_string(cfgfile, section, "keys", &tmpbuf))
{
keys = parse_keys(tmpbuf,&num_keys,",");
MTXDBG(TABLOADER,_("Number of keys for %s is %i\n"),section,num_keys);
g_free(tmpbuf);
}
else
{
g_free(section);
EXIT();
return;
}
page = -1;
/* Store ptr to self in qdata, needed for bind_to_lists from groups*/
OBJ_SET(widget,"self",widget);
/* Bind the data in the "defaults" group per tab to EVERY var in that
* tab
*/
page = bind_group_data(cfgfile, G_OBJECT(widget), groups, "defaults");
if(cfg_read_string(cfgfile, section, "group", &tmpbuf))
{
page = bind_group_data(cfgfile,G_OBJECT(widget),groups,tmpbuf);
g_free(tmpbuf);
}
if ((!cfg_read_int(cfgfile, section, "page", &page)) && (page == -1))
{
MTXDBG(TABLOADER|CRITICAL,_("Object %s doesn't have a page assigned!!!!\n"),section);
}
/* Bind widgets to lists if they have the bind_to_list flag set...
*/
tmpbuf = NULL;
if (cfg_read_string(cfgfile, section, "bind_to_list", &tmpbuf))
{
bind_to_lists(widget, tmpbuf);
g_free(tmpbuf);
}
if (cfg_read_boolean(cfgfile,section,"ellipsize",&tmpi))
{
if ((GTK_IS_LABEL(widget)) && (tmpi))
{
OBJ_SET(widget,"ellipsize_preferred",GINT_TO_POINTER(TRUE));
if (DATA_GET(global_data,"ellipsize_tabs"))
gtk_label_set_ellipsize(GTK_LABEL(widget),PANGO_ELLIPSIZE_END);
}
}
/* Color selections */
if (cfg_read_string(cfgfile, section, "active_fg", &tmpbuf))
{
gdk_color_parse(tmpbuf, &color);
gtk_widget_modify_fg(widget, GTK_STATE_NORMAL, &color);
g_free(tmpbuf);
}
if (cfg_read_string(cfgfile, section, "inactive_fg", &tmpbuf))
{
gdk_color_parse(tmpbuf, &color);
gtk_widget_modify_fg(widget, GTK_STATE_INSENSITIVE, &color);
g_free(tmpbuf);
}
/* If this widget has a "depend_on" tag we need to load the dependancy
* information and store it for use when needed...
*/
if (cfg_read_string(cfgfile,section,"depend_on",&tmpbuf))
{
if (get_symbol("load_dependencies_obj",(void **)&load_dep_obj))
load_dep_obj(G_OBJECT(widget),cfgfile,section,"depend_on");
g_free(tmpbuf);
}
/* If this widget (a textview) has "create_tags" we call a special
* handler just for that..
*/
if (cfg_read_string(cfgfile,section,"create_tags",&tmpbuf))
{
load_tags(G_OBJECT(widget),cfgfile,section);
g_free(tmpbuf);
}
/* If this widget has "tooltip" set the tip on the widget */
if (cfg_read_string(cfgfile,section,"tooltip",&tmpbuf))
{
gtk_widget_set_tooltip_text(widget,tmpbuf);
g_free(tmpbuf);
}
/* If this widget (a label) has "set_label" we set the label on it
*/
if (cfg_read_string(cfgfile,section,"set_label",&tmpbuf))
{
/* printf("setting label on %s to \"%s\"\n",glade_get_widget_name(widget),tmpbuf);*/
gtk_label_set_text(GTK_LABEL(widget),tmpbuf);
g_free(tmpbuf);
}
/* If this widget is temp dependant, set the current units on it
*/
if (cfg_read_string(cfgfile,section,"temp_dep",&tmpbuf))
{
OBJ_SET(widget,"widget_temp",DATA_GET(global_data,"mtx_temp_units"));
g_free(tmpbuf);
}
/* If this widget has "register_as", register it with the supplied name
*/
if (cfg_read_string(cfgfile,section,"register_as",&tmpbuf))
{
register_widget(tmpbuf,widget);
g_free(tmpbuf);
}
/* If this widget has visible_functions defined */
if (cfg_read_string(cfgfile,section,"visible_functions",&tmpbuf))
{
vector = g_strsplit(tmpbuf,",",-1);
g_free(tmpbuf);
for (guint i=0;i<g_strv_length(vector);i++)
{
vec2 = g_strsplit(vector[i],":",2);
if (g_strv_length(vec2) != 2)
{
printf("ERROR in %s, visible_functions param is missing the framerate parameter (func:fps)\n",cfgfile->filename);
g_strfreev(vec2);
continue;
}
gint fps = (GINT)g_strtod(vec2[1],NULL);
get_symbol(vec2[0],(void **)&func);
if (func)
{
list = g_list_prepend(list,(gpointer)func);
list2 = g_list_prepend(list2,GINT_TO_POINTER(fps));
}
g_strfreev(vec2);
}
g_strfreev(vector);
OBJ_SET_FULL(widget,"func_list",list,g_list_free);
OBJ_SET_FULL(widget,"func_fps_list",list2,g_list_free);
}
/* If this widget has "initializer" there's a global variable
* with it's name on it
*/
if (cfg_read_string(cfgfile,section,"initializer",&initializer))
{
gint widget_type = 0;
if (!cfg_read_string(cfgfile,section,"widget_type",&tmpbuf))
MTXDBG(TABLOADER|CRITICAL,_("Object %s has initializer, but no widget_type!!!!\n"),section);
else
widget_type = translate_string(tmpbuf);
g_free(tmpbuf);
switch (widget_type)
{
case MTX_RANGE:
gtk_range_set_value(GTK_RANGE(widget),(GINT)DATA_GET(global_data,initializer));
break;
case MTX_SPINBUTTON:
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),(GINT)DATA_GET(global_data,initializer));
break;
case MTX_ENTRY:
gtk_entry_set_text(GTK_ENTRY(widget),(gchar *)DATA_GET(global_data,initializer));
default:
break;
}
g_free(initializer);
}
/* Hidden widgets have special handlers and should NOT be updated normally */
cfg_read_boolean(cfgfile,section, "hidden", &hidden);
offset = -1;
cfg_read_int(cfgfile,section, "offset", &offset);
if (offset >= 0 && indexed)
{
/*printf("indexed widget %s\n",name); */
if (cfg_read_string(cfgfile, section, "size", &size))
{
offset += index * get_multiplier ((DataSize)translate_string (size));
g_free(size);
}
else
{
if(OBJ_GET(widget, "size"))
{
offset += index * get_multiplier ((DataSize)(GINT)OBJ_GET(widget, "size"));
}
else
{
MTXDBG(TABLOADER|CRITICAL,_("Indexed Object %s has index and offset, but no size!!!!\n"),section);
g_free(section);
EXIT();
return;
}
}
/*printf("widget %s, offset %i\n",name,offset);*/
OBJ_SET(widget,"offset",GINT_TO_POINTER(offset));
}
if (offset >= 0)
{
/* The way we do it now is to STORE widgets in LISTS for each
* offset, thus we can have multiple on screen controls bound
* to single data offset in the ECU
*/
if (page < 0)
{
MTXDBG(TABLOADER|CRITICAL,_("Attempting to append widget beyond bounds of Firmware Parameters, there is a bug with this datamap widget %s, page %i, at offset %i...\n\n"),section,page,offset);
g_free(section);
EXIT();
return;
}
if (page < firmware->total_pages)
{
if (offset >= firmware->page_params[page]->length)
MTXDBG(TABLOADER|CRITICAL,_("Attempting to append widget beyond bounds of Firmware Parameters, there is a bug with this datamap widget %s, at offset %i...\n\n"),section,offset);
else if (!hidden)
{
tab_widgets = OBJ_GET(bindgroup->topframe,"tab_widgets");
tab_widgets = g_list_prepend(tab_widgets, widget);
OBJ_SET(bindgroup->topframe,"tab_widgets",tab_widgets);
ecu_widgets[page][offset] = g_list_prepend(
ecu_widgets[page][offset],
(gpointer)widget);
}
}
else
MTXDBG(TABLOADER|CRITICAL,_("Attempting to append widget beyond bounds of Firmware Parameters, there is a bug with this datamap for widget %s, at page %i offset %i...\n\n"),section,page,offset);
}
/* If there is a "group" key in a section it means that it gets the
* rest of it's setting from the groupname listed. This reduces
* redundant keys all throughout the file...
*/
bind_keys(G_OBJECT(widget), cfgfile, section, keys, num_keys);
g_strfreev(keys);
/* If this widget has the "choices" key (combobox)
*/
if (cfg_read_string(cfgfile,section,"choices",&tmpbuf))
{
combo_setup(G_OBJECT(widget),cfgfile,section);
g_free(tmpbuf);
}
if (cfg_read_string(cfgfile,section,"post_functions_with_arg",&tmpbuf))
{
run_post_functions_with_arg(tmpbuf,widget);
g_free(tmpbuf);
}
if (cfg_read_string(cfgfile,section,"post_functions",&tmpbuf))
{
run_post_functions(tmpbuf);
g_free(tmpbuf);
}
if (cfg_read_boolean(cfgfile,section,"show_widget",&tmpi))
{
if (tmpi)
gtk_widget_show(widget);
else
gtk_widget_hide(widget);
}
if (cfg_read_string(cfgfile,section,"set_tab_labels",&tmpbuf))
{
if (GTK_IS_NOTEBOOK(widget))
{
vector=g_strsplit(tmpbuf,",",-1);
if (gtk_notebook_get_n_pages(GTK_NOTEBOOK(widget)) == g_strv_length(vector))
{
for (int i=0;i<g_strv_length(vector);i++)
{
gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(widget),
gtk_notebook_get_nth_page(GTK_NOTEBOOK(widget),i),
vector[i]);
}
}
g_strfreev(vector);
}
g_free(tmpbuf);
}
g_free(section);
MTXDBG(TABLOADER,_("Leaving"));
EXIT();
return;
}
/* Draw a normal (toggle)button. Not spinbuttons.*/
void cl_draw_button(GtkStyle *style, GdkWindow *window,
GtkStateType state_type, GtkShadowType shadow_type,
GdkRectangle *area,
GtkWidget *widget, const gchar *detail,
gint x, gint y, gint width, gint height)
{
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE(style);
int my_state_type = (state_type == GTK_STATE_ACTIVE) ? 2 : 0;
GdkGC *bg_gc = NULL;
gboolean is_active = FALSE;
CLRectangle r;
/* Get the background color of the window we're on */
bg_gc = cl_get_window_bg_gc(widget);
cl_rectangle_set_button (&r, style, state_type,
GTK_WIDGET_HAS_DEFAULT (widget),
GTK_WIDGET_HAS_FOCUS (widget),
CL_CORNER_ROUND, CL_CORNER_ROUND,
CL_CORNER_ROUND, CL_CORNER_ROUND);
if (state_type == GTK_STATE_ACTIVE)
is_active = TRUE;
if (GTK_IS_TOGGLE_BUTTON(widget) &&
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(widget)) &&
state_type == GTK_STATE_PRELIGHT)
{
cl_rectangle_set_gradient (&r.fill_gradient, &clearlooks_style->shade[1], &clearlooks_style->shade[1]);
r.topleft = clearlooks_style->shade_gc[3];
r.bottomright = clearlooks_style->shade_gc[1];
is_active = TRUE;
}
if (!is_active)
r.fillgc = NULL;
if (!GTK_IS_NOTEBOOK (widget->parent))
{
gdk_draw_rectangle (window, bg_gc, FALSE, x, y, width-1, height-1);
/* Draw "sunken" look when border thickness is more than 2 pixels. */
if (style->xthickness > 2 && style->ythickness > 2)
cl_draw_inset (style, window, widget, area, x, y, width, height,
CL_CORNER_ROUND, CL_CORNER_ROUND,
CL_CORNER_ROUND, CL_CORNER_ROUND);
}
/* Draw "sunken" look when border thickness is more than 2 pixels.*/
if (style->xthickness > 2 && style->ythickness > 2)
{
x++;
y++;
height-=2;
width-=2;
}
/* Don't draw the normal gradient for normal buttons. */
cl_rectangle_set_clip_rectangle (&r, area);
cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
if (!is_active)
{
int tmp_height = (float)height*0.25;
gdk_gc_set_clip_rectangle (style->bg_gc[state_type], area);
draw_hgradient (window, style->bg_gc[state_type], style,
x+2,y+2,width-4,tmp_height,
&clearlooks_style->button_g1[state_type],
&clearlooks_style->button_g2[state_type]);
draw_hgradient (window, style->bg_gc[state_type], style,
x+2, y+2+tmp_height, width-4, height-3-tmp_height*2,
&clearlooks_style->button_g2[state_type],
&clearlooks_style->button_g3[state_type]);
draw_hgradient (window, style->bg_gc[state_type], style,
x+2,y+height-tmp_height-1,width-4,tmp_height,
&clearlooks_style->button_g3[state_type],
&clearlooks_style->button_g4[state_type]);
gdk_gc_set_clip_rectangle (style->bg_gc[state_type], NULL);
}
cl_draw_shadow (window, widget, style, x, y, width, height, &r);
cl_rectangle_reset_clip_rectangle (&r);
}
void
dialog_so_styled (WBCGtk *wbcg, GObject *so, GOStyle *default_style,
char const *title, so_styled_t extent)
{
DialogSOStyled *state;
GtkWidget *dialog, *help, *editor;
GOStyle *style;
/* Only pop up one copy per workbook */
if (gnm_dialog_raise_if_exists (wbcg, GNM_SO_STYLED_KEY)) {
g_object_unref (default_style);
return;
}
state = g_new0 (DialogSOStyled, 1);
state->so = G_OBJECT (so);
state->wbcg = wbcg;
state->orig_props = go_object_properties_collect (so);
force_new_style (state->so);
dialog = gtk_dialog_new_with_buttons
(title,
wbcg_toplevel (state->wbcg),
GTK_DIALOG_DESTROY_WITH_PARENT,
NULL, NULL);
state->extent = extent;
gnm_dialog_setup_destroy_handlers (GTK_DIALOG (dialog),
state->wbcg,
GNM_DIALOG_DESTROY_CURRENT_SHEET_REMOVED);
help = gtk_dialog_add_button (GTK_DIALOG (dialog),
GTK_STOCK_HELP, GTK_RESPONSE_HELP);
gnm_init_help_button (help, "sect-graphics-drawings");
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
GNM_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GNM_STOCK_OK, GTK_RESPONSE_OK,
NULL);
g_object_get (so, "style", &style, NULL);
editor = go_style_get_editor (style, default_style,
GO_CMD_CONTEXT (wbcg), G_OBJECT (so));
g_object_unref (style);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
editor, TRUE, TRUE, TRUE);
g_object_unref (default_style);
if (extent & SO_STYLED_TEXT) {
GtkWidget *text_w = dialog_so_styled_text_widget (state);
gtk_widget_show_all (text_w);
if (GTK_IS_NOTEBOOK (editor))
gtk_notebook_append_page (GTK_NOTEBOOK (editor),
text_w,
gtk_label_new (_("Content")));
else
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
text_w, TRUE, TRUE, TRUE);
}
if (extent & SO_STYLED_LINE) {
GtkWidget *w = dialog_so_styled_line_widget (state, "end-arrow");
gtk_widget_show_all (w);
if (GTK_IS_NOTEBOOK (editor))
gtk_notebook_append_page (GTK_NOTEBOOK (editor), w,
gtk_label_new (_("Head")));
else
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
w, TRUE, TRUE, TRUE);
}
if (extent & SO_STYLED_LINE) {
GtkWidget *w = dialog_so_styled_line_widget (state, "start-arrow");
gtk_widget_show_all (w);
if (GTK_IS_NOTEBOOK (editor))
gtk_notebook_append_page (GTK_NOTEBOOK (editor), w,
gtk_label_new (_("Tail")));
else
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
w, TRUE, TRUE, TRUE);
}
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (cb_dialog_so_styled_response), state);
gnm_keyed_dialog (state->wbcg, GTK_WINDOW (dialog),
GNM_SO_STYLED_KEY);
g_object_set_data_full (G_OBJECT (dialog),
"state", state, (GDestroyNotify) dialog_so_styled_free);
go_gtk_nonmodal_dialog (wbcg_toplevel (state->wbcg),
GTK_WINDOW (dialog));
wbc_gtk_attach_guru (state->wbcg, dialog);
gtk_widget_show (dialog);
}
