Esempio n. 1
0
static void
sexy_icon_entry_size_request(GtkWidget *widget, GtkRequisition *requisition)
{
//	GtkEntry *gtkentry;
	SexyIconEntry *entry;
	gint icon_widths = 0;
	int i;

//	gtkentry = GTK_ENTRY(widget);
	entry    = SEXY_ICON_ENTRY(widget);

	for (i = 0; i < MAX_ICONS; i++)
	{
		int icon_width = get_icon_width(entry, i);

		if (icon_width > 0)
			icon_widths += icon_width + ICON_MARGIN;
	}

	GTK_WIDGET_CLASS(parent_class)->size_request(widget, requisition);

	if (icon_widths > requisition->width)
		requisition->width += icon_widths;
}
Esempio n. 2
0
static void
widget_overlay_class_init (WidgetOverlayClass *klass)
{
	GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
	GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);

	parent_class = g_type_class_peek_parent (klass);

	widget_class->realize = widget_overlay_realize;
	widget_class->unrealize = widget_overlay_unrealize;
	widget_class->get_preferred_width = widget_overlay_get_preferred_width;
	widget_class->get_preferred_height = widget_overlay_get_preferred_height;
	widget_class->size_allocate = widget_overlay_size_allocate;
	widget_class->draw = widget_overlay_draw;
	widget_class->event = widget_overlay_event;
	widget_class->show = widget_overlay_show;

	g_signal_override_class_closure (g_signal_lookup ("damage-event", GTK_TYPE_WIDGET),
					 WIDGET_OVERLAY_TYPE,
					 g_cclosure_new (G_CALLBACK (widget_overlay_damage),
							 NULL, NULL));

	container_class->add = widget_overlay_add;
	container_class->remove = widget_overlay_remove;
	container_class->forall = widget_overlay_forall;
	G_OBJECT_CLASS (klass)->dispose = widget_overlay_dispose;
	G_OBJECT_CLASS (klass)->finalize = widget_overlay_finalize;

	/* Properties */
        G_OBJECT_CLASS (klass)->set_property = widget_overlay_set_property;
        G_OBJECT_CLASS (klass)->get_property = widget_overlay_get_property;
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_ADD_SCALE,
                                         g_param_spec_boolean ("add-scale", NULL, NULL,
                                                               FALSE,
                                                               (G_PARAM_READABLE | G_PARAM_WRITABLE)));
}
Esempio n. 3
0
    static gboolean
gtk_form_draw(GtkWidget *widget, cairo_t *cr)
{
    GList   *tmp_list = NULL;
    GtkForm *form     = NULL;

    g_return_val_if_fail(GTK_IS_FORM(widget), FALSE);

    gtk_form_render_background(widget, cr);

    form = GTK_FORM(widget);
    for (tmp_list = form->children; tmp_list; tmp_list = tmp_list->next)
    {
	GtkFormChild * const formchild = tmp_list->data;

	if (!gtk_widget_get_has_window(formchild->widget) &&
		gtk_cairo_should_draw_window(cr, formchild->window))
	{
	    /* To get gtk_widget_draw() to work, it is required to call
	     * gtk_widget_size_allocate() in advance with a well-posed
	     * allocation for a given child widget in order to set a
	     * certain private GtkWidget variable, called
	     * widget->priv->alloc_need, to the proper value; otherwise,
	     * gtk_widget_draw() fails and the relevant scrollbar won't
	     * appear on the screen.
	     *
	     * Calling gtk_form_position_child() like this is one of ways
	     * to make sure of that. */
	    gtk_form_position_child(form, formchild, TRUE);

	    gtk_form_render_background(formchild->widget, cr);
	}
    }

    return GTK_WIDGET_CLASS(gtk_form_parent_class)->draw(widget, cr);
}
static void
gb_terminal_view_class_init (GbTerminalViewClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
  IdeLayoutViewClass *view_class = IDE_LAYOUT_VIEW_CLASS (klass);

  object_class->finalize = gb_terminal_view_finalize;
  object_class->set_property = gb_terminal_view_set_property;

  widget_class->realize = gb_terminal_realize;
  widget_class->get_preferred_width = gb_terminal_get_preferred_width;
  widget_class->get_preferred_height = gb_terminal_get_preferred_height;
  widget_class->grab_focus = gb_terminal_grab_focus;

  view_class->get_title = gb_terminal_get_title;
  view_class->create_split = gb_terminal_create_split;
  view_class->set_split_view =  gb_terminal_set_split_view;

  gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/builder/plugins/terminal/gb-terminal-view.ui");
  gtk_widget_class_bind_template_child (widget_class, GbTerminalView, terminal_top);
  gtk_widget_class_bind_template_child (widget_class, GbTerminalView, bottom_container);

  g_type_ensure (VTE_TYPE_TERMINAL);

  properties [PROP_FONT_NAME] =
    g_param_spec_string ("font-name",
                         "Font Name",
                         "Font Name",
                         NULL,
                         (G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));

  g_object_class_install_properties (object_class, LAST_PROP, properties);

  g_type_ensure (GB_TYPE_TERMINAL);
}
static void
contact_list_view_drag_begin (GtkWidget      *widget,
			      GdkDragContext *context)
{
	EmpathyContactListViewPriv *priv;
	GtkTreeSelection          *selection;
	GtkTreeModel              *model;
	GtkTreePath               *path;
	GtkTreeIter                iter;

	priv = GET_PRIV (widget);

	GTK_WIDGET_CLASS (empathy_contact_list_view_parent_class)->drag_begin (widget,
									      context);

	selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
	if (!gtk_tree_selection_get_selected (selection, &model, &iter)) {
		return;
	}

	path = gtk_tree_model_get_path (model, &iter);
	priv->drag_row = gtk_tree_row_reference_new (model, path);
	gtk_tree_path_free (path);
}
Esempio n. 6
0
static void
gb_search_box_map (GtkWidget *widget)
{
  GbSearchBox *self = (GbSearchBox *)widget;
  GtkWidget *toplevel;

  g_return_if_fail (GB_IS_SEARCH_BOX (self));

  GTK_WIDGET_CLASS (gb_search_box_parent_class)->map (widget);

  gtk_widget_set_sensitive (GTK_WIDGET (self->button), FALSE);
  toplevel = gtk_widget_get_toplevel (widget);

  if (GB_IS_WORKBENCH (toplevel))
    {
      gb_set_weak_pointer (toplevel, &self->workbench);
      self->set_focus_handler =
        g_signal_connect_object (toplevel,
                                 "set-focus",
                                 G_CALLBACK (gb_search_box_workbench_set_focus),
                                 self,
                                 G_CONNECT_SWAPPED | G_CONNECT_AFTER);
    }
}
Esempio n. 7
0
File: led.c Progetto: pwithnall/mcus
static AtkObject *
mcus_led_get_accessible (GtkWidget *widget)
{
	static gboolean first_time = TRUE;

	if (first_time) {
		AtkObjectFactory *factory;
		AtkRegistry *registry;
		GType derived_type, derived_atk_type;

		/* Figure out whether accessibility is enabled by looking at the type of the accessible object which would be created for
		 * the parent type of MCUSLED. */
		derived_type = g_type_parent (MCUS_TYPE_LED);

		registry = atk_get_default_registry ();
		factory = atk_registry_get_factory (registry, derived_type);
		derived_atk_type = atk_object_factory_get_accessible_type (factory);
		if (g_type_is_a (derived_atk_type, GTK_TYPE_ACCESSIBLE))
			atk_registry_set_factory_type (registry, MCUS_TYPE_LED, mcus_led_accessible_factory_get_type ());
		first_time = FALSE;
	}

	return GTK_WIDGET_CLASS (mcus_led_parent_class)->get_accessible (widget);
}
Esempio n. 8
0
static void ygtk_fixed_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
{
	YGtkFixed *fixed = YGTK_FIXED (widget);
	fixed->set_size_cb (fixed, allocation->width, allocation->height, fixed->data);

	GSList *i;
	for (i = fixed->children; i; i = i->next) {
		YGtkFixedChild *child = i->data;
		int x = child->x;
		if (gtk_widget_get_default_direction() == GTK_TEXT_DIR_RTL)
			x = allocation->width - (child->x + child->width);
		x += allocation->x;
		int y = child->y + allocation->y;
		GtkAllocation child_alloc =
			{ x, y, MAX (child->width, 1), MAX (child->height, 1) };

		GtkRequisition min_child_req;
		GtkRequisition nat_child_req;
		gtk_widget_get_preferred_size (child->widget, &min_child_req, &nat_child_req);

		gtk_widget_size_allocate (child->widget, &child_alloc);
	}
	GTK_WIDGET_CLASS (ygtk_fixed_parent_class)->size_allocate (widget, allocation);
}
Esempio n. 9
0
static void
gtk_revealer_real_get_preferred_width (GtkWidget *widget,
                                       gint      *minimum_width_out,
                                       gint      *natural_width_out)
{
  GtkRevealer *revealer = GTK_REVEALER (widget);
  GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer);
  gint minimum_width;
  gint natural_width;
  GtkRevealerTransitionType transition;

  GTK_WIDGET_CLASS (gtk_revealer_parent_class)->get_preferred_width (widget, &minimum_width, &natural_width);

  transition = effective_transition (revealer);
  if (transition == GTK_REVEALER_TRANSITION_TYPE_NONE ||
      transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT ||
      transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT)
    natural_width = round (natural_width * priv->current_pos);

  minimum_width = MIN (minimum_width, natural_width);

  *minimum_width_out = minimum_width;
  *natural_width_out = natural_width;
}
static void
gimp_unit_combo_box_style_set (GtkWidget *widget,
                               GtkStyle  *prev_style)
{
  GtkCellLayout   *layout;
  GtkCellRenderer *cell;
  gdouble          scale;

  GTK_WIDGET_CLASS (parent_class)->style_set (widget, prev_style);

  gtk_widget_style_get (widget, "label-scale", &scale, NULL);

  /*  hackedehack ...  */
  layout = GTK_CELL_LAYOUT (gtk_bin_get_child (GTK_BIN (widget)));
  gtk_cell_layout_clear (layout);

  cell = g_object_new (GTK_TYPE_CELL_RENDERER_TEXT,
                       "scale", scale,
                       NULL);
  gtk_cell_layout_pack_start (layout, cell, TRUE);
  gtk_cell_layout_set_attributes (layout, cell,
                                  "text",  GIMP_UNIT_STORE_UNIT_SHORT_FORMAT,
                                  NULL);
}
Esempio n. 11
0
static void
gtk_revealer_real_get_preferred_height (GtkWidget *widget,
                                        gint      *minimum_height_out,
                                        gint      *natural_height_out)
{
  GtkRevealer *revealer = GTK_REVEALER (widget);
  GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer);
  gint minimum_height;
  gint natural_height;
  GtkRevealerTransitionType transition;

  GTK_WIDGET_CLASS (gtk_revealer_parent_class)->get_preferred_height (widget, &minimum_height, &natural_height);

  transition = effective_transition (revealer);
  if (transition == GTK_REVEALER_TRANSITION_TYPE_NONE ||
      transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP ||
      transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN)
    natural_height = round (natural_height * priv->current_pos);

  minimum_height = MIN (minimum_height, natural_height);

  *minimum_height_out = minimum_height;
  *natural_height_out = natural_height;
}
static gboolean
matecomponent_plug_expose_event (GtkWidget      *widget,
			  GdkEventExpose *event)
{
	gboolean retval;

	retval = GTK_WIDGET_CLASS (matecomponent_plug_parent_class)->expose_event (widget, event);

	dbgprintf ("matecomponent_plug_expose_event %p (%d, %d), (%d, %d)"
		 "%s (%d && %d == %d)\n",
		 widget,
		 event->area.x, event->area.y,
		 event->area.width, event->area.height,
		 GTK_WIDGET_TOPLEVEL (widget) ? "toplevel" : "bin class",
		 GTK_WIDGET_VISIBLE (widget),
		 GTK_WIDGET_MAPPED (widget),
		 GTK_WIDGET_DRAWABLE (widget));

#ifdef DEBUG_CONTROL
	gdk_draw_line (widget->window,
		       widget->style->black_gc,
		       event->area.x + event->area.width,
		       event->area.y,
		       event->area.x, 
		       event->area.y + event->area.height);

	gdk_draw_line (widget->window,
		       widget->style->black_gc,
		       widget->allocation.x,
		       widget->allocation.y,
		       widget->allocation.x + widget->allocation.width,
		       widget->allocation.y + widget->allocation.height);
#endif

	return retval;
}
Esempio n. 13
0
static void class_init(void* g_class, void*)
{
    GtkWidgetClass* widget_class = (GtkWidgetClass*)g_class;
    widget_class->size_allocate = size_allocate;
    widget_class->realize = realize;
    widget_class->unrealize = unrealize;
    widget_class->map = map;
    widget_class->unmap = unmap;
    wxPizzaClass* klass = (wxPizzaClass*)g_class;

    // needed to make widget appear scrollable to GTK+
    klass->set_scroll_adjustments = set_scroll_adjustments;
    widget_class->set_scroll_adjustments_signal =
        g_signal_new(
            "set_scroll_adjustments",
            G_TYPE_FROM_CLASS(g_class),
            G_SIGNAL_RUN_LAST,
            G_STRUCT_OFFSET(wxPizzaClass, set_scroll_adjustments),
            NULL, NULL,
            g_cclosure_user_marshal_VOID__OBJECT_OBJECT,
            G_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);

    parent_class = GTK_WIDGET_CLASS(g_type_class_peek_parent(g_class));
}
Esempio n. 14
0
static void
mosaic_search_box_class_init (MosaicSearchBoxClass *klass)
{
  GObjectClass *gobject_class;
  GtkWidgetClass *widget_class;

  gobject_class = G_OBJECT_CLASS (klass);
  widget_class = GTK_WIDGET_CLASS (klass);

  gobject_class->constructor = mosaic_search_box_constructor;
  gobject_class->dispose = mosaic_search_box_dispose;
  gobject_class->set_property = mosaic_search_box_set_property;
  gobject_class->get_property = mosaic_search_box_get_property;

  widget_class->expose_event = mosaic_search_box_expose_event;
  widget_class->size_request = mosaic_search_box_size_request;

  obj_properties[PROP_TEXT] =
    g_param_spec_string ("text",
			 "Text in the search entry",
			 "Text, displayed in search entry",
			 NULL,
			 G_PARAM_CONSTRUCT | G_PARAM_READWRITE);

  g_object_class_install_property (gobject_class, PROP_TEXT, obj_properties [PROP_TEXT]);

  search_box_signals [CHANGED] =
    g_signal_new ("changed",
		  G_TYPE_FROM_CLASS (gobject_class),
		  G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
		  G_STRUCT_OFFSET (MosaicSearchBoxClass, changed),
		  NULL, NULL,
		  g_cclosure_marshal_VOID__VOID,
		  G_TYPE_NONE, 0);

}
Esempio n. 15
0
static void
gimp_spin_scale_class_init (GimpSpinScaleClass *klass)
{
  GObjectClass       *object_class      = G_OBJECT_CLASS (klass);
  GtkWidgetClass     *widget_class      = GTK_WIDGET_CLASS (klass);
  GtkSpinButtonClass *spin_button_class = GTK_SPIN_BUTTON_CLASS (klass);

  object_class->dispose              = gimp_spin_scale_dispose;
  object_class->finalize             = gimp_spin_scale_finalize;
  object_class->set_property         = gimp_spin_scale_set_property;
  object_class->get_property         = gimp_spin_scale_get_property;

  widget_class->style_set            = gimp_spin_scale_style_set;
#if WITH_GTKMM_3_0
  widget_class->get_preferred_width  = gimp_spin_scale_get_preferred_width;
  widget_class->get_preferred_height = gimp_spin_scale_get_preferred_height;
  widget_class->draw                 = gimp_spin_scale_draw;
#else
  widget_class->size_request         = gimp_spin_scale_size_request;
  widget_class->expose_event         = gimp_spin_scale_expose;
#endif
  widget_class->button_press_event   = gimp_spin_scale_button_press;
  widget_class->button_release_event = gimp_spin_scale_button_release;
  widget_class->motion_notify_event  = gimp_spin_scale_motion_notify;
  widget_class->leave_notify_event   = gimp_spin_scale_leave_notify;
  widget_class->key_press_event      = gimp_spin_scale_keypress;

  spin_button_class->value_changed   = gimp_spin_scale_value_changed;

  g_object_class_install_property (object_class, PROP_LABEL,
                                   g_param_spec_string ("label", NULL, NULL,
                                                        NULL,
                                                        G_PARAM_READWRITE));

  g_type_class_add_private (klass, sizeof (GimpSpinScalePrivate));
}
Esempio n. 16
0
static gboolean
on_draw(XmrWaitingWnd *wnd, cairo_t *cr, gpointer data)
{
	PangoLayout *layout;
	gint w, h;
	XmrWaitingWndPrivate *priv = wnd->priv;
	
	if (priv->tasks == NULL || priv->tasks->data == NULL)
		return FALSE;
	
	cairo_set_source_rgba(cr, 0, 0, 0, 0.7);
	cairo_paint(cr);
	
	layout = gtk_widget_create_pango_layout(GTK_WIDGET(wnd), ((Task *)priv->tasks->data)->info);
	
	pango_layout_get_pixel_size(layout, &w, &h);
	cairo_move_to(cr, (WAITING_WND_W - w) / 2, (WAITING_WND_H - h) / 2);
	cairo_set_source_rgb(cr, 1, 1, 1);
	pango_cairo_show_layout(cr, layout);
	
	g_object_unref(layout);
	
	return GTK_WIDGET_CLASS(xmr_waiting_wnd_parent_class)->draw(GTK_WIDGET(wnd), cr);
}
Esempio n. 17
0
static gboolean
file_view_button_press_event (GtkWidget *widget, GdkEventButton *event)
{
	gint retval = 
		GTK_WIDGET_CLASS (file_view_parent_class)->button_press_event (widget,
																	   event);
	/* Ignore double-clicks and triple-clicks */
	if (event->button == 3 && event->type == GDK_BUTTON_PRESS)
    {
		GtkTreePath *path;

		/* Select file under cursor if not selected */
        if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget),
                        event->x,event->y, &path, NULL, NULL, NULL))
		{
			GtkTreeSelection *selection;

			selection = gtk_tree_view_get_selection(GTK_TREE_VIEW (widget));
	        if (!gtk_tree_selection_path_is_selected(selection, path))
    	    {
        	    gtk_tree_selection_unselect_all(selection);
	            gtk_tree_selection_select_path(selection, path);
    	        gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget),
        	                        path, NULL, FALSE);
        	}
        	gtk_tree_path_free (path);
			
			file_view_do_popup_menu (widget, event);
		
      		return TRUE;
		}
    }

	return 	retval;
		
}
Esempio n. 18
0
static void
gtk_radio_menu_item_destroy (GtkWidget *widget)
{
  GtkRadioMenuItem *radio_menu_item = GTK_RADIO_MENU_ITEM (widget);
  GtkRadioMenuItemPrivate *priv = radio_menu_item->priv;
  GtkWidget *old_group_singleton = NULL;
  GtkRadioMenuItem *tmp_menu_item;
  GSList *tmp_list;
  gboolean was_in_group;

  was_in_group = priv->group && priv->group->next;

  priv->group = g_slist_remove (priv->group, radio_menu_item);
  if (priv->group && !priv->group->next)
    old_group_singleton = priv->group->data;

  tmp_list = priv->group;

  while (tmp_list)
    {
      tmp_menu_item = tmp_list->data;
      tmp_list = tmp_list->next;

      tmp_menu_item->priv->group = priv->group;
    }

  /* this radio menu item is no longer in the group */
  priv->group = NULL;
  
  if (old_group_singleton)
    g_signal_emit (old_group_singleton, group_changed_signal, 0);
  if (was_in_group)
    g_signal_emit (radio_menu_item, group_changed_signal, 0);

  GTK_WIDGET_CLASS (gtk_radio_menu_item_parent_class)->destroy (widget);
}
static void
gtk_scrollbox_class_init (gpointer g_class, gpointer g_class_data)
{
  
  GObjectClass *gobject_class = G_OBJECT_CLASS(g_class);
  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(g_class);
  
  GParamSpec *scrollbox_param_spec;

  gobject_class->set_property = gtk_scrollbox_set_property;
  gobject_class->get_property = gtk_scrollbox_get_property;
  
  scrollbox_param_spec = g_param_spec_boolean("enablecb",
                  "Enable callback",
                  "Enable or disable the callback",
                  FALSE,
                  G_PARAM_READWRITE);
  g_object_class_install_property (gobject_class,
           GTK_SCROLLBOX_ENABLECB,
           scrollbox_param_spec);

  widget_class->expose_event = gtk_scrollbox_expose;
  gobject_class->finalize = gtk_scrollbox_finalize;
}
Esempio n. 20
0
static gboolean
athena_entry_motion_notify (GtkWidget *widget, GdkEventMotion *event)
{
	int result;
	gboolean old_had, new_had;
	int old_start, old_end, new_start, new_end;
	GtkEditable *editable;

	editable = GTK_EDITABLE (widget);

	old_had = gtk_editable_get_selection_bounds (editable, &old_start, &old_end);

	result = GTK_WIDGET_CLASS (athena_entry_parent_class)->motion_notify_event (widget, event);

	/* Send a signal if dragging the mouse caused the selection to change. */
	if (result) {
		new_had = gtk_editable_get_selection_bounds (editable, &new_start, &new_end);
		if (old_had != new_had || (old_had && (old_start != new_start || old_end != new_end))) {
			g_signal_emit (widget, signals[SELECTION_CHANGED], 0);
		}
	}
	
	return result;
}
Esempio n. 21
0
static void
ide_editor_perspective_class_init (IdeEditorPerspectiveClass *klass)
{
  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
  GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
  DzlDockBinClass *dock_bin_class = DZL_DOCK_BIN_CLASS (klass);

  widget_class->destroy = ide_editor_perspective_destroy;
  widget_class->hierarchy_changed = ide_editor_perspective_hierarchy_changed;
  widget_class->grab_focus = ide_editor_perspective_grab_focus;

  container_class->add = ide_editor_perspective_add;

  dock_bin_class->create_edge = ide_editor_perspective_create_edge;

  gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/builder/ui/ide-editor-perspective.ui");
  gtk_widget_class_bind_template_child (widget_class, IdeEditorPerspective, grid);
  gtk_widget_class_bind_template_child (widget_class, IdeEditorPerspective, overlay);
  gtk_widget_class_bind_template_child (widget_class, IdeEditorPerspective, properties);

  g_type_ensure (IDE_TYPE_EDITOR_PROPERTIES);
  g_type_ensure (IDE_TYPE_EDITOR_SIDEBAR);
  g_type_ensure (IDE_TYPE_LAYOUT_GRID);
}
Esempio n. 22
0
static void
gtr_message_table_class_init (GtrMessageTableClass * klass)
{
    GObjectClass *object_class = G_OBJECT_CLASS (klass);
    GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);

    object_class->finalize = gtr_message_table_finalize;
    object_class->set_property = gtr_message_table_set_property;
    object_class->get_property = gtr_message_table_get_property;

    g_object_class_install_property (object_class,
                                     PROP_TAB,
                                     g_param_spec_object ("tab",
                                             "TAB",
                                             "The active tab",
                                             GTR_TYPE_TAB,
                                             G_PARAM_READWRITE |
                                             G_PARAM_CONSTRUCT_ONLY));

    gtk_widget_class_set_template_from_resource (widget_class,
            "/org/gnome/translator/gtr-message-table.ui");

    gtk_widget_class_bind_template_child_private (widget_class, GtrMessageTable, treeview);
}
Esempio n. 23
0
static gboolean 
panel_applet_focus (GtkWidget        *widget,
		    GtkDirectionType  dir)
{
	gboolean ret;
	GtkWidget *previous_focus_child;

	g_return_val_if_fail (PANEL_IS_APPLET (widget), FALSE);

	previous_focus_child = gtk_container_get_focus_child (GTK_CONTAINER (widget));
	if (!previous_focus_child && !gtk_widget_has_focus (widget)) {
		if (gtk_widget_get_has_tooltip (widget)) {
			gtk_widget_set_can_focus (widget, TRUE);
			gtk_widget_grab_focus (widget);
			gtk_widget_set_can_focus (widget, FALSE);
			return TRUE;
		}
	}
	ret = GTK_WIDGET_CLASS (panel_applet_parent_class)->focus (widget, dir);

	if (!ret && !previous_focus_child) {
		if (!gtk_widget_has_focus (widget))  {
			/*
			 * Applet does not have a widget which can focus so set
			 * the focus on the applet unless it already had focus
			 * because it had a tooltip.
			 */ 
			gtk_widget_set_can_focus (widget, TRUE);
			gtk_widget_grab_focus (widget);
			gtk_widget_set_can_focus (widget, FALSE);
			ret = TRUE;
		}
	}

	return ret;
}
Esempio n. 24
0
static void
unrealize (GtkWidget *widget)
{
    CajaDesktopWindow *window;
	CajaDesktopWindowDetails *details;
    GdkWindow *root_window;

    window = CAJA_DESKTOP_WINDOW (widget);
	details = window->details;

    root_window = gdk_screen_get_root_window (
                      gtk_window_get_screen (GTK_WINDOW (window)));

    gdk_property_delete (root_window,
                         gdk_atom_intern ("CAJA_DESKTOP_WINDOW_ID", TRUE));

	if (details->size_changed_id != 0) {
		g_signal_handler_disconnect (gtk_window_get_screen (GTK_WINDOW (window)),
					     details->size_changed_id);
		details->size_changed_id = 0;
	}

    GTK_WIDGET_CLASS (caja_desktop_window_parent_class)->unrealize (widget);
}
Esempio n. 25
0
static void
clock_map_class_init (ClockMapClass *this_class)
{
        GObjectClass *g_obj_class = G_OBJECT_CLASS (this_class);
        GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (g_obj_class);

        g_obj_class->finalize = clock_map_finalize;

        /* GtkWidget signals */

        widget_class->size_allocate = clock_map_size_allocate;
        widget_class->draw = clock_map_draw;
	widget_class->get_preferred_width = clock_map_get_preferred_width;
	widget_class->get_preferred_height = clock_map_get_preferred_height;

        g_type_class_add_private (this_class, sizeof (ClockMapPrivate));

	/**
	 * ClockMap::need-locations
	 *
	 * The map widget emits this signal when it needs to know which
	 * locations to display.
	 *
	 * Returns: the handler should return a (GList *) of (ClockLocation *).
	 * The map widget will not modify this list, so the caller should keep
	 * it alive.
	 */
	signals[NEED_LOCATIONS] = g_signal_new ("need-locations",
						G_TYPE_FROM_CLASS (g_obj_class),
						G_SIGNAL_RUN_LAST,
						G_STRUCT_OFFSET (ClockMapClass, need_locations),
						NULL,
						NULL,
						_clock_marshal_POINTER__VOID,
						G_TYPE_POINTER, 0);
}
Esempio n. 26
0
static void
gt_browse_header_bar_class_init(GtBrowseHeaderBarClass* klass)
{
    GObjectClass* object_class = G_OBJECT_CLASS(klass);

    object_class->finalize = finalize;
    object_class->get_property = get_property;
    object_class->set_property = set_property;

    props[PROP_CHANNELS_VIEW] = g_param_spec_object("channels-view",
                                                    "Channels View",
                                                    "Channels View",
                                                    GT_TYPE_CHANNELS_VIEW,
                                                    G_PARAM_READWRITE);
    props[PROP_GAMES_VIEW] = g_param_spec_object("games-view",
                                                 "Games View",
                                                 "Games View",
                                                 GT_TYPE_GAMES_VIEW,
                                                 G_PARAM_READWRITE);
    props[PROP_FAVOURITES_VIEW] = g_param_spec_object("favourites-view",
                                                      "Favourites View",
                                                      "Favourites View",
                                                      GT_TYPE_FAVOURITES_VIEW,
                                                      G_PARAM_READWRITE);

    g_object_class_install_properties(object_class,
                                      NUM_PROPS,
                                      props);

    gtk_widget_class_set_template_from_resource(GTK_WIDGET_CLASS(klass), 
                                                "/com/gnome-twitch/ui/gt-browse-header-bar.ui");
    gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS(klass), GtBrowseHeaderBar, nav_buttons_stack);
    gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS(klass), GtBrowseHeaderBar, nav_buttons_revealer);
    gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS(klass), GtBrowseHeaderBar, search_button);
    gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS(klass), GtBrowseHeaderBar, refresh_button);
    gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS(klass), GtBrowseHeaderBar, refresh_revealer);
    gtk_widget_class_bind_template_child_private(GTK_WIDGET_CLASS(klass), GtBrowseHeaderBar, search_revealer);
}
Esempio n. 27
0
static void
gis_password_page_class_init (GisPasswordPageClass *klass)
{
  GisPageClass *page_class = GIS_PAGE_CLASS (klass);
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass), "/org/gnome/initial-setup/gis-password-page.ui");

  gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass), GisPasswordPage, password_entry);
  gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass), GisPasswordPage, confirm_entry);
  gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass), GisPasswordPage, password_strength);
  gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass), GisPasswordPage, password_explanation);
  gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass), GisPasswordPage, confirm_explanation);

  page_class->page_id = PAGE_ID;
  page_class->locale_changed = gis_password_page_locale_changed;
  page_class->save_data = gis_password_page_save_data;
  page_class->shown = gis_password_page_shown;

  object_class->constructed = gis_password_page_constructed;
  object_class->dispose = gis_password_page_dispose;
}
Esempio n. 28
0
static void
gtk_image_menu_item_size_allocate (GtkWidget     *widget,
                                   GtkAllocation *allocation)
{
    GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (widget);
    GtkImageMenuItemPrivate *priv = image_menu_item->priv;
    GtkAllocation widget_allocation;
    GtkPackDirection pack_dir;
    GtkWidget *parent;

    parent = gtk_widget_get_parent (widget);

    if (GTK_IS_MENU_BAR (parent))
        pack_dir = gtk_menu_bar_get_child_pack_direction (GTK_MENU_BAR (parent));
    else
        pack_dir = GTK_PACK_DIRECTION_LTR;

    GTK_WIDGET_CLASS (gtk_image_menu_item_parent_class)->size_allocate (widget, allocation);

    if (priv->image && gtk_widget_get_visible (priv->image))
    {
        gint x, y, offset;
        GtkStyleContext *context;
        GtkStateFlags state;
        GtkBorder padding;
        GtkRequisition child_requisition;
        GtkAllocation child_allocation;
        guint horizontal_padding, toggle_spacing;
        gint toggle_size;

        toggle_size = GTK_MENU_ITEM (image_menu_item)->priv->toggle_size;
        gtk_widget_style_get (widget,
                              "horizontal-padding", &horizontal_padding,
                              "toggle-spacing", &toggle_spacing,
                              NULL);

        /* Man this is lame hardcoding action, but I can't
         * come up with a solution that's really better.
         */

        gtk_widget_get_preferred_size (priv->image, &child_requisition, NULL);

        gtk_widget_get_allocation (widget, &widget_allocation);

        context = gtk_widget_get_style_context (widget);
        state = gtk_widget_get_state_flags (widget);
        gtk_style_context_get_padding (context, state, &padding);
        offset = gtk_container_get_border_width (GTK_CONTAINER (image_menu_item));

        if (pack_dir == GTK_PACK_DIRECTION_LTR ||
                pack_dir == GTK_PACK_DIRECTION_RTL)
        {
            if ((gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR) ==
                    (pack_dir == GTK_PACK_DIRECTION_LTR))
                x = offset + horizontal_padding + padding.left +
                    (toggle_size - toggle_spacing - child_requisition.width) / 2;
            else
                x = widget_allocation.width - offset - horizontal_padding - padding.right -
                    toggle_size + toggle_spacing +
                    (toggle_size - toggle_spacing - child_requisition.width) / 2;

            y = (widget_allocation.height - child_requisition.height) / 2;
        }
        else
        {
            if ((gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR) ==
                    (pack_dir == GTK_PACK_DIRECTION_TTB))
                y = offset + horizontal_padding + padding.top +
                    (toggle_size - toggle_spacing - child_requisition.height) / 2;
            else
                y = widget_allocation.height - offset - horizontal_padding - padding.bottom -
                    toggle_size + toggle_spacing +
                    (toggle_size - toggle_spacing - child_requisition.height) / 2;

            x = (widget_allocation.width - child_requisition.width) / 2;
        }

        child_allocation.width = child_requisition.width;
        child_allocation.height = child_requisition.height;
        child_allocation.x = widget_allocation.x + MAX (x, 0);
        child_allocation.y = widget_allocation.y + MAX (y, 0);

        gtk_widget_size_allocate (priv->image, &child_allocation);
    }
}
Esempio n. 29
0
/*
 * Standard Gtk+ function
 */
static gint Dw_gtk_viewport_expose (GtkWidget *widget,
                                    GdkEventExpose *event)
{
   Dw_gtk_viewport_paint (widget, &(event->area), event);
   return GTK_WIDGET_CLASS(parent_class)->expose_event (widget, event);
}
Esempio n. 30
0
/*
 * Standard Gtk+ function
 */
static void Dw_gtk_viewport_draw (GtkWidget *widget,
                                  GdkRectangle *area)
{
   Dw_gtk_viewport_paint (widget, area, NULL);
   GTK_WIDGET_CLASS(parent_class)->draw (widget, area);
}