コード例 #1
0
static GtkWidget *
add_row (CcPrivacyPanel *self,
         const gchar    *label,
         const gchar    *dialog_id,
         GtkWidget      *status)
{
  GtkWidget *box, *row, *w;

  row = gtk_list_box_row_new ();
  box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 50);
  gtk_container_add (GTK_CONTAINER (row), box);
  g_object_set_data (G_OBJECT (row), "dialog-id", (gpointer)dialog_id);
  gtk_widget_set_hexpand (box, TRUE);
  gtk_container_add (GTK_CONTAINER (self->priv->list_box), row);

  w = gtk_label_new (label);
  gtk_widget_set_halign (w, GTK_ALIGN_START);
  gtk_widget_set_margin_start (w, 20);
  gtk_widget_set_margin_end (w, 20);
  gtk_widget_set_margin_top (w, 12);
  gtk_widget_set_margin_bottom (w, 12);
  gtk_widget_set_halign (w, GTK_ALIGN_START);
  gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
  gtk_widget_set_hexpand (w, TRUE);
  gtk_box_pack_start (GTK_BOX (box), w, TRUE, TRUE, 0);
  gtk_widget_set_margin_start (status, 20);
  gtk_widget_set_margin_end (status, 20);
  gtk_widget_set_halign (status, GTK_ALIGN_END);
  gtk_widget_set_valign (status, GTK_ALIGN_CENTER);
  gtk_box_pack_end (GTK_BOX (box), status, FALSE, FALSE, 0);

  gtk_widget_show_all (row);

  return row;
}
コード例 #2
0
ファイル: testtoolbar.c プロジェクト: 3dfxmadscientist/gtk
static void
change_orientation (GtkWidget *button, GtkWidget *toolbar)
{
  GtkWidget *grid;
  GtkOrientation orientation;

  grid = gtk_widget_get_parent (toolbar);
  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)))
    orientation = GTK_ORIENTATION_VERTICAL;
  else
    orientation = GTK_ORIENTATION_HORIZONTAL;

  g_object_ref (toolbar);
  gtk_container_remove (GTK_CONTAINER (grid), toolbar);
  gtk_orientable_set_orientation (GTK_ORIENTABLE (toolbar), orientation);
  if (orientation == GTK_ORIENTATION_HORIZONTAL)
    {
      gtk_widget_set_hexpand (toolbar, TRUE);
      gtk_widget_set_vexpand (toolbar, FALSE);
      gtk_grid_attach (GTK_GRID (grid), toolbar, 0, 0, 2, 1);
    }
  else
    {
      gtk_widget_set_hexpand (toolbar, FALSE);
      gtk_widget_set_vexpand (toolbar, TRUE);
      gtk_grid_attach (GTK_GRID (grid), toolbar, 0, 0, 1, 5);
    }
  g_object_unref (toolbar);
}
コード例 #3
0
ファイル: pnl-tab.c プロジェクト: matthiasclasen/panel-gtk
static void
pnl_tab_update_edge (PnlTab *self)
{
  g_assert (PNL_IS_TAB (self));

  switch (self->edge)
    {
    case GTK_POS_TOP:
      gtk_label_set_angle (self->title, 0.0);
      gtk_widget_set_hexpand (GTK_WIDGET (self), TRUE);
      gtk_widget_set_vexpand (GTK_WIDGET (self), FALSE);
      break;

    case GTK_POS_BOTTOM:
      gtk_label_set_angle (self->title, 0.0);
      gtk_widget_set_hexpand (GTK_WIDGET (self), TRUE);
      gtk_widget_set_vexpand (GTK_WIDGET (self), FALSE);
      break;

    case GTK_POS_LEFT:
      gtk_label_set_angle (self->title, -90.0);
      gtk_widget_set_hexpand (GTK_WIDGET (self), FALSE);
      gtk_widget_set_vexpand (GTK_WIDGET (self), TRUE);
      break;

    case GTK_POS_RIGHT:
      gtk_label_set_angle (self->title, 90.0);
      gtk_widget_set_hexpand (GTK_WIDGET (self), FALSE);
      gtk_widget_set_vexpand (GTK_WIDGET (self), TRUE);
      break;

    default:
      g_assert_not_reached ();
    }
}
コード例 #4
0
static void
populate_flowbox_images (GtkFlowBox *flowbox)
{
  GtkWidget *widget, *image, *label;
  gint i;

  for (i = 0; i < N_ITEMS; i++)
    {
      gchar *text = g_strdup_printf ("Item %02d", i);

      widget = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
      gtk_widget_set_hexpand (widget, TRUE);

      image = gtk_image_new_from_icon_name ("face-wink", GTK_ICON_SIZE_DIALOG);
      gtk_widget_set_hexpand (image, TRUE);
      gtk_image_set_pixel_size (GTK_IMAGE (image), 256);

      label = gtk_label_new (text);

      gtk_container_add (GTK_CONTAINER (widget), image);
      gtk_container_add (GTK_CONTAINER (widget), label);
      gtk_widget_show_all (widget);

      if (text_orientation == GTK_ORIENTATION_VERTICAL)
        gtk_label_set_angle (GTK_LABEL (widget), 90);

      g_object_set_data_full (G_OBJECT (widget), "id", (gpointer)g_strdup (text), g_free);
      gtk_container_add (GTK_CONTAINER (flowbox), widget);

      g_free (text);
    }
}
コード例 #5
0
static GtkWidget* pocketvox_setup_get_notification_grid(PocketvoxSetup *setup)
{
	setup->priv = G_TYPE_INSTANCE_GET_PRIVATE (setup,
			TYPE_POCKETVOX_SETUP, PocketvoxSetupPrivate);
	PocketvoxSetupPrivate *priv = setup->priv;

	GtkWidget *grid = gtk_grid_new();
    GtkWidget *label_visual  = gtk_label_new(_("Allow visual notifications"));
    GtkWidget *label_sound   = gtk_label_new(_("Allow sound notifications"));

    gtk_misc_set_alignment(GTK_MISC(label_visual),        0.0, 0.5);
    gtk_misc_set_alignment(GTK_MISC(label_sound),         0.0, 0.5);
    gtk_widget_set_hexpand(label_visual,        TRUE);
    gtk_widget_set_hexpand(label_sound,         TRUE);

    GtkWidget* switch_sound  = gtk_switch_new();
    GtkWidget* switch_visual = gtk_switch_new();
    gtk_widget_set_tooltip_text(switch_sound, _("Allow sound notifications"));
    gtk_widget_set_tooltip_text(switch_visual, _("Allow visual notifications"));

	g_settings_bind(priv->settings, "visual-notification", switch_visual, "active", G_SETTINGS_BIND_DEFAULT);
	g_settings_bind(priv->settings, "sound-notification", switch_sound, "active", G_SETTINGS_BIND_DEFAULT);

    gtk_grid_attach(GTK_GRID(grid), label_visual,	0, 2, 2, 1);
    gtk_grid_attach(GTK_GRID(grid), switch_visual, 	2, 2, 1, 1);
    gtk_grid_attach(GTK_GRID(grid), label_sound, 	0, 3, 2, 1);
    gtk_grid_attach(GTK_GRID(grid), switch_sound,	2, 3, 1, 1);

    gtk_widget_show_all(grid);

    return grid;
}
コード例 #6
0
static void
cb_reply_indicator_init (CbReplyIndicator *self)
{
  GtkWidget *box;
  GtkWidget *w;

  gtk_widget_set_has_surface (GTK_WIDGET (self), FALSE);

  box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);

  w = gtk_image_new_from_icon_name ("go-up-symbolic");
  gtk_widget_set_hexpand (w, TRUE);
  gtk_widget_set_halign (w, GTK_ALIGN_END);
  gtk_container_add (GTK_CONTAINER (box), w);
  gtk_container_add (GTK_CONTAINER (box), gtk_label_new (_("Show Conversation")));
  w = gtk_image_new_from_icon_name ("go-up-symbolic");
  gtk_widget_set_hexpand (w, TRUE);
  gtk_widget_set_halign (w, GTK_ALIGN_START);
  gtk_container_add (GTK_CONTAINER (box), w);

  gtk_style_context_add_class (gtk_widget_get_style_context (box), "dim-label");

  self->button = gtk_button_new ();
  gtk_container_add (GTK_CONTAINER (self->button), box);
  self->revealer = gtk_revealer_new ();

  gtk_container_add (GTK_CONTAINER (self->revealer), self->button);
  gtk_widget_set_parent (self->revealer, GTK_WIDGET (self));

  g_signal_connect (self->button, "clicked", G_CALLBACK (button_clicked_cb), self);
}
コード例 #7
0
ファイル: ekiga-window.cpp プロジェクト: GNOME/ekiga
static void
ekiga_window_init_dialpad (EkigaWindow *mw)
{
  GtkWidget *dialpad = NULL;
  GtkWidget *grid = NULL;

  grid = gtk_grid_new ();
  gtk_grid_set_row_spacing (GTK_GRID (grid), 18);
  gtk_container_set_border_width (GTK_CONTAINER (grid), 18);

  dialpad = ekiga_dialpad_new (mw->priv->accel);
  gtk_widget_set_hexpand (dialpad, FALSE);
  gtk_widget_set_vexpand (dialpad, FALSE);
  gtk_widget_set_halign (dialpad, GTK_ALIGN_CENTER);
  gtk_widget_set_valign (dialpad, GTK_ALIGN_CENTER);
  gtk_grid_attach (GTK_GRID (grid), dialpad, 0, 0, 1, 1);
  g_signal_connect (dialpad, "button-clicked",
                    G_CALLBACK (dialpad_button_clicked_cb), mw);

  mw->priv->entry = ekiga_window_uri_entry_new (mw);
  gtk_widget_set_hexpand (dialpad, TRUE);
  gtk_widget_set_vexpand (dialpad, TRUE);
  gtk_widget_set_halign (mw->priv->entry, GTK_ALIGN_FILL);
  gtk_widget_set_valign (mw->priv->entry, GTK_ALIGN_END);
  gtk_grid_attach_next_to (GTK_GRID (grid), mw->priv->entry, dialpad,
                           GTK_POS_BOTTOM, 1, 1);

  gtk_stack_add_named (GTK_STACK (mw->priv->main_stack), grid, "dialpad");
  gtk_container_child_set (GTK_CONTAINER (mw->priv->main_stack),
                           grid,
                           "icon-name", "input-dialpad-symbolic", NULL);

  g_signal_connect (mw, "key-press-event",
                    G_CALLBACK (key_press_event_cb), mw);
}
コード例 #8
0
static void
chat_conversations_list_add_row_avatar (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
  ChatConversationsList *self = CHAT_CONVERSATIONS_LIST (user_data);
  TpContact *contact = TP_CONTACT (source_object);
  GError *error;
  GtkWidget *grid;
  GtkWidget *image;
  GtkWidget *label;
  GtkWidget *row;
  TplEvent *event;
  const gchar *alias;
  const gchar *message;
  gchar *markup;

  event = TPL_EVENT (g_object_get_data (G_OBJECT (contact), "chat-conversations-list-last-event"));
  alias = tp_contact_get_alias (contact);

  error = NULL;
  image = GTK_WIDGET (chat_utils_get_contact_avatar_finish (contact, res, &error));
  if (error != NULL)
    {
      image = GTK_WIDGET (chat_utils_get_contact_avatar_default ());
      g_warning ("Unable to get avatar for %s: %s", alias, error->message);
      g_error_free (error);
    }

  row = gtk_list_box_row_new ();
  g_object_set_data_full (G_OBJECT (row), "chat-conversations-list-contact", g_object_ref (contact), g_object_unref);
  gtk_container_add (GTK_CONTAINER (self), row);

  grid = gtk_grid_new ();
  gtk_orientable_set_orientation (GTK_ORIENTABLE (grid), GTK_ORIENTATION_HORIZONTAL);
  gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
  gtk_container_add (GTK_CONTAINER (row), grid);

  gtk_widget_set_hexpand (image, FALSE);
  gtk_container_add (GTK_CONTAINER (grid), image);

  message = tpl_text_event_get_message (TPL_TEXT_EVENT (event));
  markup = g_markup_printf_escaped ("<b>%s</b>\n%s", alias, message);
  label = gtk_label_new (NULL);
  gtk_widget_set_halign (label, GTK_ALIGN_START);
  gtk_widget_set_hexpand (label, TRUE);
  gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
  gtk_label_set_markup (GTK_LABEL (label), markup);
  gtk_container_add (GTK_CONTAINER (grid), label);
  g_free (markup);

  gtk_widget_show_all (row);

  g_object_set_data (G_OBJECT (contact), "chat-conversations-list-last-event", NULL);
  g_object_unref (self);
}
コード例 #9
0
ファイル: gtkboxexpand2.c プロジェクト: andlabs/misctestprogs
int main(void)
{
	GtkWidget *mainwin;
	GtkWidget *vbox;
	GtkWidget *e1, *e2;
	GtkWidget *da;
	GtkWidget *hbox;
	GtkWidget *b1, *b2;

	gtk_init(NULL, NULL);

	mainwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	g_signal_connect(mainwin, "destroy", G_CALLBACK(gtk_main_quit), NULL);

	vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
	gtk_container_add(GTK_CONTAINER(mainwin), vbox);

	e1 = gtk_entry_new();
	gtk_container_add(GTK_CONTAINER(vbox), e1);

	e2 = gtk_entry_new();
	gtk_container_add(GTK_CONTAINER(vbox), e2);

	da = gtk_drawing_area_new();
	gtk_widget_set_size_request(da, -1, 30);
	g_signal_connect(da, "draw", G_CALLBACK(drawMidline), NULL);
	gtk_widget_set_vexpand(da, TRUE);
	gtk_widget_set_valign(da, GTK_ALIGN_FILL);
	gtk_container_add(GTK_CONTAINER(vbox), da);

	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
	gtk_container_add(GTK_CONTAINER(vbox), hbox);

	b1 = gtk_button_new_with_label("Button 1");
	gtk_widget_set_hexpand(b1, TRUE);
	gtk_widget_set_halign(b1, GTK_ALIGN_FILL);
	gtk_container_add(GTK_CONTAINER(hbox), b1);

	b2 = gtk_button_new_with_label("Button 2");
	gtk_widget_set_hexpand(b2, TRUE);
	gtk_widget_set_halign(b2, GTK_ALIGN_FILL);
	gtk_container_add(GTK_CONTAINER(hbox), b2);

	b3 = gtk_button_new_with_label("3");
	gtk_widget_set_hexpand(b3, FALSE);
	gtk_container_add(GTK_CONTAINER(hbox), b3);

	g_signal_connect(e1, "changed", G_CALLBACK(changed), b1);
	g_signal_connect(e2, "changed", G_CALLBACK(changed), b2);

	gtk_widget_show_all(mainwin);
	gtk_main();
	return 0;
}
コード例 #10
0
ファイル: gtkcsscolor.c プロジェクト: andlabs/misctestprogs
int main(void)
{
	GtkWidget *mainwin;
	GtkWidget *grid;

	gtk_init(NULL, NULL);

	mainwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(mainwin), "Foreground Colors with CSS");
	gtk_container_set_border_width(GTK_CONTAINER(mainwin), 12);
	g_signal_connect(mainwin, "delete-event", G_CALLBACK(quit), NULL);

	grid = gtk_grid_new();
	gtk_grid_set_row_spacing(GTK_GRID(grid), 6);
	gtk_grid_set_column_spacing(GTK_GRID(grid), 12);
	gtk_container_add(GTK_CONTAINER(mainwin), grid);

	button = gtk_button_new_with_label("Color Me!");
	gtk_widget_set_hexpand(button, TRUE);
	gtk_widget_set_halign(button, GTK_ALIGN_FILL);
	gtk_widget_set_vexpand(button, TRUE);
	gtk_widget_set_halign(button, GTK_ALIGN_FILL);
	gtk_grid_attach_next_to(GTK_GRID(grid),
		button, NULL,
		GTK_POS_BOTTOM, 1, 1);

	foreground = gtk_color_button_new();
	g_signal_connect(foreground, "color-set", G_CALLBACK(changeColor), NULL);
	gtk_widget_set_hexpand(foreground, TRUE);
	gtk_widget_set_halign(foreground, GTK_ALIGN_FILL);
	gtk_grid_attach_next_to(GTK_GRID(grid),
		foreground, button,
		GTK_POS_BOTTOM, 1, 1);
	gtk_grid_attach_next_to(GTK_GRID(grid),
		gtk_label_new("Foreground"), foreground,
		GTK_POS_LEFT, 1, 1);

	background = gtk_color_button_new();
	g_signal_connect(background, "color-set", G_CALLBACK(changeColor), NULL);
	gtk_widget_set_hexpand(background, TRUE);
	gtk_widget_set_halign(background, GTK_ALIGN_FILL);
	gtk_grid_attach_next_to(GTK_GRID(grid),
		background, foreground,
		GTK_POS_BOTTOM, 1, 1);
	gtk_grid_attach_next_to(GTK_GRID(grid),
		gtk_label_new("Background"), background,
		GTK_POS_LEFT, 1, 1);

	gtk_widget_show_all(mainwin);
	gtk_main();
	return 0;
}
コード例 #11
0
static GtkWidget *
go_color_palette_setup (GOColorPalette *pal,
		     char const *no_color_label,
		     int cols, int rows,
		     GONamedColor const *color_names)
{
	GtkWidget	*w, *grid;
	int pos, row, col = 0;

	grid = gtk_grid_new ();

	if (no_color_label != NULL) {
		w = gtk_button_new_with_label (no_color_label);
		gtk_widget_set_hexpand (w, TRUE);
		gtk_grid_attach (GTK_GRID (grid), w, 0, 0, cols, 1);
		g_signal_connect (w,
			"button_release_event",
			G_CALLBACK (cb_default_release_event), pal);
	}

	for (row = 0; row < rows; row++)
		for (col = 0; col < cols; col++) {
			pos = row * cols + col;
			if (color_names [pos].name == NULL)
				goto custom_colors;
			go_color_palette_button_new ( pal,
				GTK_GRID (grid),
				&(color_names [pos]), col, row + 1);
		}

custom_colors :
	if (col > 0)
		row++;
	for (col = 0; col < cols && col < GO_COLOR_GROUP_HISTORY_SIZE; col++) {
		GONamedColor color_name = { 0, N_("custom") };
		color_name.color = pal->group->history [col];
		pal->swatches [col] = go_color_palette_button_new (pal,
			GTK_GRID (grid),
			&color_name, col, row + 1);
	}

	w = go_gtk_button_build_with_stock (_("Custom color..."),
		GTK_STOCK_SELECT_COLOR);
	gtk_button_set_alignment (GTK_BUTTON (w), 0., .5);
	gtk_widget_set_hexpand (w, TRUE);
	gtk_grid_attach (GTK_GRID (grid), w, 0, row + 2, cols, 1);
	g_signal_connect (G_OBJECT (w),
		"clicked",
		G_CALLBACK (cb_combo_custom_clicked), pal);

	return grid;
}
コード例 #12
0
ファイル: druid.c プロジェクト: kyoushuu/anjuta
static void
cb_druid_add_property (NPWProperty* property, gpointer user_data)
{
	GtkWidget* label;
	GtkWidget* entry;
	NPWDruidAddPropertyData* data = (NPWDruidAddPropertyData *)user_data;
	const gchar* description;


	entry = npw_property_create_widget (property);
	if (entry != NULL)
	{
		/* Not hidden property */
		description = npw_property_get_description (property);

		/* Set description tooltip */
		if (description && (*description != '\0'))
		{
			gtk_widget_set_tooltip_text (entry, description);
		}

		label = gtk_label_new (npw_property_get_label (property));
		gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
		gtk_misc_set_padding (GTK_MISC (label), 6, 6);

		gtk_widget_set_hexpand (entry, TRUE);
		switch (npw_property_get_type (property))
		{
			case NPW_PACKAGE_PROPERTY:
				gtk_widget_set_vexpand (entry, TRUE);
				gtk_grid_attach (data->table, label, 0, data->row, 1, 1);
				gtk_grid_attach (data->table, entry, 0, data->row + 1, 1, 1);
				data->row += 2;
				break;
			case NPW_BOOLEAN_PROPERTY:
				gtk_widget_set_hexpand (entry, FALSE);
				/* Fall through */	
			default:
				/* Add label and entry */
				gtk_grid_attach (data->table, label, 0, data->row, 1, 1);
				gtk_grid_attach (data->table, entry, 1, data->row, 1, 1);
				data->row++;
		}

		/* Set first entry */
		if (data->first_entry == NULL) data->first_entry = entry;
	}
};
コード例 #13
0
ファイル: testgrid.c プロジェクト: 3dfxmadscientist/gtk
static void
spanning_grid (void)
{
  GtkWidget *window;
  GtkWidget *g;
  GtkWidget *c;

  /* inspired by bug 698660
   * the row/column that are empty except for the spanning
   * child need to stay collapsed
   */

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title (GTK_WINDOW (window), "Spanning");

  g = gtk_grid_new ();
  gtk_container_add (GTK_CONTAINER (window), g);

  c = test_widget ("0", "blue");
  gtk_widget_set_hexpand (c, TRUE);
  gtk_grid_attach (GTK_GRID (g), c, 0, 4, 4, 1);

  c = test_widget ("1", "green");
  gtk_widget_set_vexpand (c, TRUE);
  gtk_grid_attach (GTK_GRID (g), c, 4, 0, 1, 4);

  c = test_widget ("2", "red");
  gtk_widget_set_hexpand (c, TRUE);
  gtk_widget_set_vexpand (c, TRUE);
  gtk_grid_attach (GTK_GRID (g), c, 3, 3, 1, 1);

  c = test_widget ("3", "yellow");
  gtk_grid_attach (GTK_GRID (g), c, 0, 3, 2, 1);

  c = test_widget ("4", "orange");
  gtk_grid_attach (GTK_GRID (g), c, 3, 0, 1, 2);

  c = test_widget ("5", "purple");
  gtk_grid_attach (GTK_GRID (g), c, 1, 1, 1, 1);

  c = test_widget ("6", "white");
  gtk_grid_attach (GTK_GRID (g), c, 0, 1, 1, 1);

  c = test_widget ("7", "cyan");
  gtk_grid_attach (GTK_GRID (g), c, 1, 0, 1, 1);

  gtk_widget_show_all (window);
}
コード例 #14
0
ファイル: cheese-avatar-widget.c プロジェクト: GNOME/cheese
/*
 * create_page:
 * @child: the #CheeseWidget to pack into the container
 * @button: the #GtkButton for taking a photo
 *
 * Create the widgets for the #CheeseAvatarWidget and pack them into a
 * container.
 *
 * Returns: a #GtkBox containing the individual #CheeseAvatarWidget widgets
 */
static GtkWidget *
create_page (GtkWidget *child,
             GtkWidget *button)
{
    GtkWidget *vgrid, *bar;
    GtkStyleContext *context;

    vgrid = gtk_grid_new ();
    gtk_grid_attach (GTK_GRID (vgrid),
                     child, 0, 0, 1, 1);
    gtk_widget_set_hexpand (child, TRUE);
    gtk_widget_set_vexpand (child, TRUE);

    bar = gtk_header_bar_new ();
    context = gtk_widget_get_style_context (GTK_WIDGET (bar));
    gtk_style_context_remove_class (context, "header-bar");
    gtk_style_context_add_class (context, "inline-toolbar");
    gtk_style_context_add_class (context, "toolbar");
    gtk_style_context_add_class (context, GTK_STYLE_CLASS_HORIZONTAL);

    g_object_set (G_OBJECT (button), "margin-top", 6, "margin-bottom", 6, NULL);
    gtk_header_bar_set_custom_title (GTK_HEADER_BAR (bar), button);
    gtk_grid_attach (GTK_GRID (vgrid),
                     bar, 0, 1, 1, 1);

    return vgrid;
}
コード例 #15
0
ファイル: digitalClock.c プロジェクト: ranrangor/widgets-gtk
static void digital_clock_init(DigitalClock * dclock)
{

    DigitalClockPriv *priv;
    GtkWidget *w = GTK_WIDGET(dclock);

    dclock->priv = DIGITAL_CLOCK_GET_PRIV(dclock);
    priv = dclock->priv;
    priv->x = priv->y = 0;
    priv->width = priv->height = -1;
    priv->fsiz = 0;
    priv->mode12 = TRUE;

    priv->time_val=g_slice_alloc0(LENTIMESTR);

//  g_signal_connect (G_OBJECT (dclock), "draw", G_CALLBACK (_draw), dclock);
    dclock->priv->timeoutid =
	g_timeout_add(TimeOutVal, (GSourceFunc) flushtime_cb, dclock);

    GtkStyleContext *stylecontext = gtk_widget_get_style_context(w);
    gtk_style_context_add_class(stylecontext, GTK_STYLE_CLASS_BUTTON);
    gtk_style_context_add_class(stylecontext, "suggested-action");

    gtk_widget_set_hexpand(w,TRUE);
    gtk_widget_set_vexpand(w,TRUE);

}
コード例 #16
0
ファイル: mv-demo-clipping.c プロジェクト: GNOME/goocanvas
GtkWidget *
create_clipping_page (void)
{
  GtkWidget *vbox, *scrolled_win, *canvas;

  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
  g_object_set (vbox, "margin", 4, NULL);
  gtk_widget_show (vbox);

  scrolled_win = gtk_scrolled_window_new (NULL, NULL);
  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win),
				       GTK_SHADOW_IN);
  gtk_widget_show (scrolled_win);
  gtk_box_pack_start (GTK_BOX (vbox), scrolled_win);
  gtk_widget_set_halign (scrolled_win, GTK_ALIGN_FILL);
  gtk_widget_set_valign (scrolled_win, GTK_ALIGN_FILL);
  gtk_widget_set_hexpand (scrolled_win, TRUE);
  gtk_widget_set_vexpand (scrolled_win, TRUE);

  canvas = goo_canvas_new ();
  gtk_widget_set_size_request (canvas, 600, 450);
  goo_canvas_set_bounds (GOO_CANVAS (canvas), 0, 0, 1000, 1000);
  gtk_widget_show (canvas);
  gtk_container_add (GTK_CONTAINER (scrolled_win), canvas);

  setup_canvas (GOO_CANVAS (canvas));

  return vbox;
}
コード例 #17
0
static void
add_entry (GtkWidget     *grid1,
           GtkWidget     *grid2,
           const gchar   *text,
           GtkWidget    **out_entry)
{
  GtkStyleContext *context;
  GtkWidget *label;
  GtkWidget *entry;

  label = gtk_label_new_with_mnemonic (text);
  context = gtk_widget_get_style_context (label);
  gtk_style_context_add_class (context, GTK_STYLE_CLASS_DIM_LABEL);
  gtk_widget_set_vexpand (label, TRUE);
  gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5);
  gtk_container_add (GTK_CONTAINER (grid1), label);

  entry = gtk_entry_new ();
  gtk_widget_set_hexpand (entry, TRUE);
  gtk_widget_set_vexpand (entry, TRUE);
  gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
  gtk_entry_set_max_length (GTK_ENTRY (entry), 132);
  gtk_container_add (GTK_CONTAINER (grid2), entry);

  gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);
  if (out_entry != NULL)
    *out_entry = entry;
}
コード例 #18
0
ファイル: sprite.c プロジェクト: Ygrex/remany
/* {{{ append_sprite_pic(…) - append an image to a sprite */
static Sprite *append_sprite_pic(Sprite *s, GdkPixbuf *pic) {
	debug(">>> append_sprite_pic()");
	/* FIXME animated images must be supported */
	GtkWidget *w = gtk_image_new_from_pixbuf(pic);
	if (w == NULL) {
		warn("append_sprite_pic(): gtk_image_new_from_pixbuf()");
		goto LBL_return;
	}
	gtk_widget_set_vexpand(w, TRUE);
	gtk_widget_set_hexpand(w, TRUE);
	gtk_widget_set_vexpand_set(w, TRUE);
	gtk_widget_set_hexpand_set(w, TRUE);
	/* shrink large images */
	float width = (float)gdk_pixbuf_get_width(pic);
	float height = (float)gdk_pixbuf_get_height(pic);
	float ratio = (float)width / height;
	/* FIXME avoid magic numbers */
	if ((ratio > 1) && (width > 128)) {
		width = 128;
		height = ratio * width;
	} else if ((ratio <= 1) && (height > 128)) {
		height = 128;
		width = height * ratio;
	}
	gtk_widget_set_size_request(w, (gint)width, (gint)height);
	append_sprite_widget(s, w);
	LBL_return:
	debug("<<< append_sprite_pic()");
	return s;
}
コード例 #19
0
static void
photos_error_box_constructed (GObject *object)
{
  PhotosErrorBox *self = PHOTOS_ERROR_BOX (object);

  G_OBJECT_CLASS (photos_error_box_parent_class)->constructed (object);

  gtk_widget_set_halign (GTK_WIDGET (self), GTK_ALIGN_CENTER);
  gtk_widget_set_hexpand (GTK_WIDGET (self), TRUE);
  gtk_widget_set_valign (GTK_WIDGET (self), GTK_ALIGN_CENTER);
  gtk_widget_set_vexpand (GTK_WIDGET (self), TRUE);
  gtk_orientable_set_orientation (GTK_ORIENTABLE (self), GTK_ORIENTATION_VERTICAL);
  gtk_grid_set_row_spacing (GTK_GRID (self), 12);

  self->image = gtk_image_new_from_icon_name ("dialog-error", GTK_ICON_SIZE_INVALID);
  gtk_image_set_pixel_size (GTK_IMAGE (self->image), 128);
  gtk_widget_set_halign (self->image, GTK_ALIGN_CENTER);
  gtk_widget_set_valign (self->image, GTK_ALIGN_CENTER);
  gtk_container_add (GTK_CONTAINER (self), self->image);

  self->primary_label = gtk_label_new (NULL);
  gtk_label_set_use_markup (GTK_LABEL (self->primary_label), TRUE);
  gtk_widget_set_halign (self->primary_label, GTK_ALIGN_CENTER);
  gtk_widget_set_valign (self->primary_label, GTK_ALIGN_CENTER);
  gtk_container_add (GTK_CONTAINER (self), self->primary_label);

  self->secondary_label = gtk_label_new (NULL);
  gtk_label_set_use_markup (GTK_LABEL (self->secondary_label), TRUE);
  gtk_label_set_line_wrap (GTK_LABEL (self->secondary_label), TRUE);
  gtk_widget_set_halign (self->secondary_label, GTK_ALIGN_CENTER);
  gtk_widget_set_valign (self->secondary_label, GTK_ALIGN_CENTER);
  gtk_container_add (GTK_CONTAINER (self), self->secondary_label);

  gtk_widget_show_all (GTK_WIDGET (self));
}
コード例 #20
0
ファイル: testlist3.c プロジェクト: Zekom/gtk
int
main (int argc, char *argv[])
{
    GtkWidget *window, *list, *sw, *row;
    GtkWidget *hbox, *vbox, *combo, *button;
    gint i;
    gchar *text;

    gtk_init (NULL, NULL);

    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_window_set_default_size (GTK_WINDOW (window), -1, 300);

    hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
    gtk_container_add (GTK_CONTAINER (window), hbox);
    vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
    g_object_set (vbox, "margin", 12, NULL);
    gtk_container_add (GTK_CONTAINER (hbox), vbox);

    list = gtk_list_box_new ();
    gtk_list_box_set_selection_mode (GTK_LIST_BOX (list), GTK_SELECTION_NONE);

    g_signal_connect (list, "row-activated", G_CALLBACK (on_row_activated), NULL);
    g_signal_connect (list, "selected-rows-changed", G_CALLBACK (on_selected_children_changed), NULL);
    g_signal_connect (gtk_widget_get_accessible (list), "selection-changed", G_CALLBACK (a11y_selection_changed), NULL);

    sw = gtk_scrolled_window_new (NULL, NULL);
    gtk_widget_set_hexpand (sw, TRUE);
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
    gtk_container_add (GTK_CONTAINER (hbox), sw);
    gtk_container_add (GTK_CONTAINER (sw), list);

    button = gtk_check_button_new_with_label ("Activate on single click");
    g_object_bind_property (list, "activate-on-single-click",
                            button, "active",
                            G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
    gtk_container_add (GTK_CONTAINER (vbox), button);

    combo = gtk_combo_box_text_new ();
    gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "None");
    gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "Single");
    gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "Browse");
    gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "Multiple");
    g_signal_connect (combo, "changed", G_CALLBACK (selection_mode_changed), list);
    gtk_container_add (GTK_CONTAINER (vbox), combo);
    gtk_combo_box_set_active (GTK_COMBO_BOX (combo), gtk_list_box_get_selection_mode (GTK_LIST_BOX (list)));

    for (i = 0; i < 20; i++)
    {
        text = g_strdup_printf ("Row %d", i);
        row = create_row (text);
        gtk_list_box_insert (GTK_LIST_BOX (list), row, -1);
    }

    gtk_widget_show_all (window);

    gtk_main ();

    return 0;
}
コード例 #21
0
ファイル: glade-editor-table.c プロジェクト: zlongshen/glade
static GladeEditorProperty *
append_item (GladeEditorTable   *table,
             GladePropertyClass *klass,
             gboolean            from_query_dialog)
{
  GladeEditorProperty *property;
  GtkWidget *label;

  if (!(property = glade_widget_adaptor_create_eprop
        (glade_property_class_get_adaptor (klass), klass, from_query_dialog == FALSE)))
    {
      g_critical ("Unable to create editor for property '%s' of class '%s'",
                  glade_property_class_id (klass), 
		  glade_widget_adaptor_get_name (glade_property_class_get_adaptor (klass)));
      return NULL;
    }

  gtk_widget_show (GTK_WIDGET (property));
  gtk_widget_show_all (glade_editor_property_get_item_label (property));

  label = glade_editor_property_get_item_label (property);
  gtk_widget_set_hexpand (label, FALSE);

  glade_editor_table_attach (table, label, 0, table->priv->rows);
  glade_editor_table_attach (table, GTK_WIDGET (property), 1, table->priv->rows);

  table->priv->rows++;

  return property;
}
コード例 #22
0
ファイル: gs-editor.c プロジェクト: GNOME/gnome-software
static void
gs_editor_refresh_choice (GsEditor *self)
{
	GPtrArray *apps;
	GtkContainer *container;

	/* add all apps */
	container = GTK_CONTAINER (gtk_builder_get_object (self->builder,
							   "flowbox_main"));
	gs_container_remove_all (GTK_CONTAINER (container));
	apps = as_store_get_apps (self->store);
	for (guint i = 0; i < apps->len; i++) {
		AsApp *item = g_ptr_array_index (apps, i);
		GtkWidget *tile = NULL;
		g_autoptr(GsApp) app = NULL;

		app = gs_editor_convert_app (self, item);
		tile = gs_summary_tile_new (app);
		g_signal_connect (tile, "clicked",
				  G_CALLBACK (gs_editor_app_tile_clicked_cb),
				  self);
		gtk_widget_set_visible (tile, TRUE);
		gtk_widget_set_vexpand (tile, FALSE);
		gtk_widget_set_hexpand (tile, FALSE);
		gtk_widget_set_size_request (tile, 300, 50);
		gtk_widget_set_valign (tile, GTK_ALIGN_START);
		gtk_container_add (GTK_CONTAINER (container), tile);
	}
}
コード例 #23
0
ファイル: hig.c プロジェクト: AllardJ/Tomato
void
hig_workarea_add_section_title_widget (GtkWidget * t, guint * row, GtkWidget * w)
{
    gtk_widget_set_hexpand (w, TRUE);
    gtk_grid_attach (GTK_GRID (t), w, 0, *row, 2, 1);
    ++ * row;
}
コード例 #24
0
ファイル: testgrid.c プロジェクト: 3dfxmadscientist/gtk
static void
empty_line (void)
{
  GtkWidget *window;
  GtkWidget *grid;
  GtkWidget *child;

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title (GTK_WINDOW (window), "Empty row");
  grid = gtk_grid_new ();
  gtk_container_add (GTK_CONTAINER (window), grid);

  gtk_grid_set_row_spacing (GTK_GRID (grid), 10);
  gtk_grid_set_column_spacing (GTK_GRID (grid), 10);

  child = test_widget ("(0, 0)", "red");
  gtk_grid_attach (GTK_GRID (grid), child, 0, 0, 1, 1);
  gtk_widget_set_hexpand (child, TRUE);
  gtk_widget_set_vexpand (child, TRUE);

  gtk_grid_attach (GTK_GRID (grid), test_widget ("(0, 1)", "blue"), 0, 1, 1, 1);

  gtk_grid_attach (GTK_GRID (grid), test_widget ("(10, 0)", "green"), 10, 0, 1, 1);
  gtk_grid_attach (GTK_GRID (grid), test_widget ("(10, 1)", "magenta"), 10, 1, 1, 1);

  gtk_widget_show_all (window);
}
コード例 #25
0
ファイル: testfilechooserbutton.c プロジェクト: sam-m888/gtk
static void
add_new_filechooser_button (const gchar          *mnemonic,
                            const gchar          *chooser_title,
                            GtkFileChooserAction  action,
                            GtkWidget            *group_box,
                            GtkSizeGroup         *label_group)
{
  GtkWidget *hbox, *label, *chooser, *button;

  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
  gtk_box_pack_start (GTK_BOX (group_box), hbox);

  label = gtk_label_new_with_mnemonic (mnemonic);
  gtk_size_group_add_widget (GTK_SIZE_GROUP (label_group), label);
  gtk_label_set_xalign (GTK_LABEL (label), 0.0);
  gtk_box_pack_start (GTK_BOX (hbox), label);

  chooser = gtk_file_chooser_button_new (g_strconcat(chooser_title,
                                                     " - testfilechooserbutton", NULL),
                                         action);
  gtk_widget_set_hexpand (chooser, TRUE);
  gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL);
  gtk_file_chooser_remove_shortcut_folder (GTK_FILE_CHOOSER (chooser), gtk_src_dir, NULL);
  gtk_label_set_mnemonic_widget (GTK_LABEL (label), chooser);
  g_signal_connect (chooser, "current-folder-changed",
		    G_CALLBACK (chooser_current_folder_changed_cb), NULL);
  g_signal_connect (chooser, "selection-changed", G_CALLBACK (chooser_selection_changed_cb), NULL);
  g_signal_connect (chooser, "file-activated", G_CALLBACK (chooser_file_activated_cb), NULL);
  g_signal_connect (chooser, "update-preview", G_CALLBACK (chooser_update_preview_cb), NULL);
  gtk_box_pack_start (GTK_BOX (hbox), chooser);

  button = gtk_button_new_with_label ("Tests");
  g_signal_connect (button, "clicked", G_CALLBACK (tests_button_clicked_cb), chooser);
  gtk_box_pack_start (GTK_BOX (hbox), button);
}
コード例 #26
0
ファイル: foreigndrawing.c プロジェクト: GNOME/gtk
GtkWidget *
do_foreigndrawing (GtkWidget *do_widget)
{
  static GtkWidget *window = NULL;

  if (!window)
    {
      GtkWidget *box;
      GtkWidget *da;

      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
      gtk_window_set_title (GTK_WINDOW (window), "Foreign drawing");
      gtk_window_set_display (GTK_WINDOW (window),
                              gtk_widget_get_display (do_widget));
      g_signal_connect (window, "destroy",
                        G_CALLBACK (gtk_widget_destroyed), &window);

      box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
      gtk_container_add (GTK_CONTAINER (window), box);
      da = gtk_drawing_area_new ();
      gtk_drawing_area_set_content_width (GTK_DRAWING_AREA (da), 400);
      gtk_drawing_area_set_content_height (GTK_DRAWING_AREA (da), 400);
      gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (da), draw_func, NULL, NULL);
      gtk_widget_set_hexpand (da, TRUE);
      gtk_widget_set_vexpand (da, TRUE);
      gtk_container_add (GTK_CONTAINER (box), da);
    }

  if (!gtk_widget_get_visible (window))
    gtk_widget_show (window);
  else
    gtk_widget_destroy (window);

  return window;
}
コード例 #27
0
ファイル: gimpwidgetsutils.c プロジェクト: jiapei100/gimp
/**
 * gimp_grid_attach_aligned:
 * @grid:       The #GtkGrid the widgets will be attached to.
 * @left:       The column to start with.
 * @top:        The row to attach the widgets.
 * @label_text: The text for the #GtkLabel which will be attached left of
 *              the widget.
 * @xalign:     The horizontal alignment of the #GtkLabel.
 * @yalign:     The vertical alignment of the #GtkLabel.
 * @widget:     The #GtkWidget to attach right of the label.
 * @columns:    The number of columns the widget will use.
 *
 * Note that the @label_text can be %NULL and that the widget will be
 * attached starting at (@column + 1) in this case, too.
 *
 * Returns: The created #GtkLabel.
 **/
GtkWidget *
gimp_grid_attach_aligned (GtkGrid     *grid,
                          gint         left,
                          gint         top,
                          const gchar *label_text,
                          gfloat       xalign,
                          gfloat       yalign,
                          GtkWidget   *widget,
                          gint         columns)
{
  GtkWidget *label = NULL;

  if (label_text)
    {
      GtkWidget *mnemonic_widget;

      label = gtk_label_new_with_mnemonic (label_text);
      gtk_label_set_xalign (GTK_LABEL (label), xalign);
      gtk_label_set_yalign (GTK_LABEL (label), yalign);
      gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
      gtk_grid_attach (grid, label, left, top, 1, 1);
      gtk_widget_show (label);

      mnemonic_widget = find_mnemonic_widget (widget, 0);

      if (mnemonic_widget)
        gtk_label_set_mnemonic_widget (GTK_LABEL (label), mnemonic_widget);
    }

  gtk_widget_set_hexpand (widget, TRUE);
  gtk_grid_attach (grid, widget, left + 1, top, columns, 1);
  gtk_widget_show (widget);

  return label;
}
コード例 #28
0
ファイル: action-dialog.c プロジェクト: cotigao/gupnp-tools
static void
populate_action_arguments_grid (GtkWidget                     *grid,
                                GList                         *arguments,
                                GUPnPServiceActionArgDirection direction,
                                GUPnPServiceIntrospection     *introspection)
{
        GList *arg_node;
        GtkWidget *last_aligner_grid = NULL;

        g_assert (introspection != NULL);

        prepare_action_arguments_grid (GTK_CONTAINER (grid),
                                       direction,
                                       arguments);

        gtk_widget_set_size_request (dialog, 0, 0);

        for (arg_node = arguments;
             arg_node;
             arg_node = arg_node->next) {
                GUPnPServiceActionArgInfo *arg_info;
                GtkWidget                 *aligner_grid;
                GtkWidget                 *label;
                GtkWidget                 *input_widget;

                arg_info = (GUPnPServiceActionArgInfo *) arg_node->data;

                /* First add the name */
                /* GTK_ALIGN_START seems to have a bug in a size group:
                 * use a container for alignment */
                aligner_grid = gtk_grid_new ();
                gtk_grid_attach_next_to (GTK_GRID (grid),
                                         aligner_grid,
                                         last_aligner_grid,
                                         GTK_POS_BOTTOM,
                                         1, 1);
                last_aligner_grid = aligner_grid;

                label = gtk_label_new (arg_info->name);
                gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
                gtk_widget_set_vexpand (label, TRUE);
                gtk_widget_set_halign (label, GTK_ALIGN_START);
                gtk_grid_attach (GTK_GRID (aligner_grid), label,
                                 0, 0, 1, 1);
                gtk_size_group_add_widget (label_container_group,
                                           aligner_grid);
                gtk_widget_show_all (aligner_grid);

                /* Then the input widget */
                input_widget = create_widget_for_argument (arg_info,
                                                           introspection);
                gtk_widget_set_hexpand (input_widget, TRUE);
                gtk_grid_attach_next_to (GTK_GRID (grid),
                                         input_widget,
                                         aligner_grid,
                                         GTK_POS_RIGHT,
                                         1,1);
                gtk_widget_show_all (input_widget);
        }
}
コード例 #29
0
ファイル: hig.c プロジェクト: AllardJ/Tomato
void
hig_workarea_add_wide_tall_control (GtkWidget * t, guint * row, GtkWidget * w)
{
    gtk_widget_set_hexpand (w, TRUE);
    gtk_widget_set_vexpand (w, TRUE);
    hig_workarea_add_wide_control (t, row, w);
}
コード例 #30
0
ファイル: gnm-dao.c プロジェクト: nzinfo/gnumeric
GtkWidget *
gnm_dao_new (WBCGtk *wbcg, gchar *inplace_str)
{
	GnmDao *gdao = GNM_DAO (g_object_new (GNM_DAO_TYPE, NULL));
	GtkGrid *grid;

	g_return_val_if_fail (wbcg != NULL, NULL);
	gdao->wbcg = wbcg;

	/* Create the output range expression entry */
	grid = GTK_GRID (go_gtk_builder_get_widget (gdao->gui, "output-grid"));
	gdao->output_entry = gnm_expr_entry_new (wbcg, TRUE);
	gnm_expr_entry_set_flags (gdao->output_entry,
				  GNM_EE_SINGLE_RANGE, GNM_EE_MASK);
	gtk_widget_set_hexpand (GTK_WIDGET (gdao->output_entry), TRUE);
	gtk_grid_attach (grid, GTK_WIDGET (gdao->output_entry),
			  1, 3, 1, 1);
	go_atk_setup_label (gdao->output_range,
			     GTK_WIDGET (gdao->output_entry));
	gtk_widget_show (GTK_WIDGET (gdao->output_entry));
	/* Finished creating the output range expression entry */

	gnm_dao_set_inplace (gdao, inplace_str);
	gnm_dao_setup_signals (gdao);
	cb_set_sensitivity (NULL, gdao);

	return GTK_WIDGET (gdao);
}