示例#1
0
static void _metadata_update_value_end(GtkLabel *label, const char *value)
{
  gboolean validated = g_utf8_validate(value, -1, NULL);
  const gchar *str = validated ? value : NODATA_STRING;
  gtk_label_set_text(GTK_LABEL(label), str);
  gtk_label_set_ellipsize(GTK_LABEL(label), PANGO_ELLIPSIZE_END);
  g_object_set(G_OBJECT(label), "tooltip-text", str, (char *)NULL);
}
示例#2
0
/* helper function for updating a metadata value */
static void _metadata_update_value(GtkLabel *label, const char *value)
{
  gboolean validated = g_utf8_validate(value, -1, NULL);
  const gchar *str = validated ? value : NODATA_STRING;
  gtk_label_set_text(GTK_LABEL(label), str);
  gtk_label_set_ellipsize(GTK_LABEL(label), PANGO_ELLIPSIZE_MIDDLE);
  gtk_widget_set_tooltip_text(GTK_WIDGET(label), str);
}
示例#3
0
static void
gu_openerror_create(gu_nav_page_t *gnp)
{
    prop_sub_t *s;
    GtkWidget *l;

    gnp->gnp_pageroot = gtk_vbox_new(FALSE, 3);
    gtk_container_add(GTK_CONTAINER(gnp->gnp_pagebin), gnp->gnp_pageroot);

    l = gtk_label_new(NULL);
    gtk_label_set_markup(GTK_LABEL(l),
                         "<span size=\"x-large\">Unable to open page</span>");
    gtk_box_pack_start(GTK_BOX(gnp->gnp_pageroot), l, FALSE, FALSE, 0);
    gtk_label_set_ellipsize(GTK_LABEL(l), PANGO_ELLIPSIZE_END);



    l = gtk_label_new(NULL);
    gtk_box_pack_start(GTK_BOX(gnp->gnp_pageroot), l, FALSE, FALSE, 0);
    gtk_label_set_ellipsize(GTK_LABEL(l), PANGO_ELLIPSIZE_END);

    s = prop_subscribe(PROP_SUB_DIRECT_UPDATE,
                       PROP_TAG_NAME("self", "url"),
                       PROP_TAG_CALLBACK_STRING, gu_subscription_set_label, l,
                       PROP_TAG_COURIER, glibcourier,
                       PROP_TAG_NAMED_ROOT, gnp->gnp_prop, "self",
                       NULL);
    gu_unsubscribe_on_destroy(GTK_OBJECT(l), s);



    l = gtk_label_new(NULL);
    gtk_box_pack_start(GTK_BOX(gnp->gnp_pageroot), l, FALSE, FALSE, 0);
    gtk_label_set_ellipsize(GTK_LABEL(l), PANGO_ELLIPSIZE_END);

    s = prop_subscribe(PROP_SUB_DIRECT_UPDATE,
                       PROP_TAG_NAME("self", "model", "error"),
                       PROP_TAG_CALLBACK_STRING, gu_subscription_set_label, l,
                       PROP_TAG_COURIER, glibcourier,
                       PROP_TAG_NAMED_ROOT, gnp->gnp_prop, "self",
                       NULL);
    gu_unsubscribe_on_destroy(GTK_OBJECT(l), s);

    gtk_widget_show_all(gnp->gnp_pageroot);
}
示例#4
0
void init(){
    uri_label = gtk_label_new("");
    gtk_label_set_selectable(GTK_LABEL(uri_label), TRUE);
    gtk_label_set_ellipsize(GTK_LABEL(uri_label), PANGO_ELLIPSIZE_MIDDLE);
    gtk_misc_set_alignment(GTK_MISC(uri_label), 1, 0.5);
    g_signal_connect(lumi->web_view, "notify::load-status", G_CALLBACK(update_uri), NULL);
    g_signal_connect(lumi->web_view, "hovering-over-link", G_CALLBACK(link_hovered), NULL);
    gtk_box_pack_start(GTK_BOX(lumi->status_bar), uri_label, TRUE, TRUE, 0);
}
示例#5
0
static GtkWidget *
build_tab_label (NautilusNotebook *nb, NautilusWindowSlot *slot)
{
	GtkWidget *hbox, *label, *close_button, *image, *spinner, *icon;

	/* set hbox spacing and label padding (see below) so that there's an
	 * equal amount of space around the label */
	hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
	gtk_widget_show (hbox);

	/* setup load feedback */
	spinner = gtk_spinner_new ();
	gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, FALSE, 0);

	/* setup site icon, empty by default */
	icon = gtk_image_new ();
	gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0);
	/* don't show the icon */

	/* setup label */
	label = gtk_label_new (NULL);
	gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
	gtk_label_set_single_line_mode (GTK_LABEL (label), TRUE);
	gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
	gtk_misc_set_padding (GTK_MISC (label), 0, 0);
	gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);
	gtk_widget_show (label);

	/* setup close button */
	close_button = gtk_button_new ();
	gtk_button_set_relief (GTK_BUTTON (close_button),
			       GTK_RELIEF_NONE);
	/* don't allow focus on the close button */
	gtk_button_set_focus_on_click (GTK_BUTTON (close_button), FALSE);

	gtk_widget_set_name (close_button, "nautilus-tab-close-button");

	image = gtk_image_new_from_icon_name ("window-close-symbolic", GTK_ICON_SIZE_MENU);
	gtk_widget_set_tooltip_text (close_button, _("Close tab"));
	g_signal_connect_object (close_button, "clicked",
				 G_CALLBACK (close_button_clicked_cb), slot, 0);

	gtk_container_add (GTK_CONTAINER (close_button), image);
	gtk_widget_show (image);

	gtk_box_pack_start (GTK_BOX (hbox), close_button, FALSE, FALSE, 0);
	gtk_widget_show (close_button);

	nautilus_drag_slot_proxy_init (hbox, NULL, slot);

	g_object_set_data (G_OBJECT (hbox), "label", label);
	g_object_set_data (G_OBJECT (hbox), "spinner", spinner);
	g_object_set_data (G_OBJECT (hbox), "icon", icon);
	g_object_set_data (G_OBJECT (hbox), "close-button", close_button);

	return hbox;
}
示例#6
0
static void
empathy_presence_chooser_init (EmpathyPresenceChooser *chooser)
{
	GtkWidget                  *arrow;
	GtkWidget                  *alignment;
	EmpathyPresenceChooserPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (chooser,
		EMPATHY_TYPE_PRESENCE_CHOOSER, EmpathyPresenceChooserPriv);

	chooser->priv = priv;
	gtk_button_set_relief (GTK_BUTTON (chooser), GTK_RELIEF_NONE);
	gtk_button_set_focus_on_click (GTK_BUTTON (chooser), FALSE);

	alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
	gtk_widget_show (alignment);
	gtk_container_add (GTK_CONTAINER (chooser), alignment);
	gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 1, 0);

	priv->hbox = gtk_hbox_new (FALSE, 1);
	gtk_widget_show (priv->hbox);
	gtk_container_add (GTK_CONTAINER (alignment), priv->hbox);

	priv->image = gtk_image_new ();
	gtk_widget_show (priv->image);
	gtk_box_pack_start (GTK_BOX (priv->hbox), priv->image, FALSE, TRUE, 0);

	priv->label = gtk_label_new (NULL);
	gtk_widget_show (priv->label);
	gtk_box_pack_start (GTK_BOX (priv->hbox), priv->label, TRUE, TRUE, 0);
	gtk_label_set_ellipsize (GTK_LABEL (priv->label), PANGO_ELLIPSIZE_END);
	gtk_misc_set_alignment (GTK_MISC (priv->label), 0, 0.5);
	gtk_misc_set_padding (GTK_MISC (priv->label), 4, 1);

	alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
	gtk_widget_show (alignment);
	gtk_box_pack_start (GTK_BOX (priv->hbox), alignment, FALSE, FALSE, 0);

	arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_OUT);
	gtk_widget_show (arrow);
	gtk_container_add (GTK_CONTAINER (alignment), arrow);

	g_signal_connect (chooser, "toggled",
			  G_CALLBACK (presence_chooser_toggled_cb),
			  NULL);
	g_signal_connect (chooser, "button-press-event",
			  G_CALLBACK (presence_chooser_button_press_event_cb),
			  NULL);
	g_signal_connect (chooser, "scroll-event",
			  G_CALLBACK (presence_chooser_scroll_event_cb),
			  NULL);

	priv->idle = empathy_idle_dup_singleton ();
	presence_chooser_presence_changed_cb (chooser);
	g_signal_connect_swapped (priv->idle, "notify",
				  G_CALLBACK (presence_chooser_presence_changed_cb),
				  chooser);
}
示例#7
0
文件: uzbl.c 项目: dusanx/uzbl
static GtkWidget*
create_mainbar () {
    mainbar = gtk_hbox_new (FALSE, 0);
    mainbar_label = gtk_label_new ("");  
    gtk_label_set_ellipsize(GTK_LABEL(mainbar_label), PANGO_ELLIPSIZE_END);
    gtk_misc_set_alignment (GTK_MISC(mainbar_label), 0, 0);
    gtk_misc_set_padding (GTK_MISC(mainbar_label), 2, 2);
    gtk_box_pack_start (GTK_BOX (mainbar), mainbar_label, TRUE, TRUE, 0);
    return mainbar;
}
示例#8
0
文件: tab-page.c 项目: Mic92/stuurman
static void fm_tab_page_init(FmTabPage *page)
{
    GtkPaned* paned = GTK_PANED(page);
    FmTabLabel* tab_label;
    FmFolderView* folder_view;
    GList* focus_chain = NULL;
    FmSidePaneMode mode = app_config->side_pane_mode;

    page->side_pane = fm_side_pane_new();
    fm_side_pane_set_mode(page->side_pane, (mode & FM_SP_MODE_MASK));
    /* TODO: add a close button to side pane */
    gtk_paned_add1(paned, GTK_WIDGET(page->side_pane));
    focus_chain = g_list_prepend(focus_chain, page->side_pane);

    /* handlers below will be used when FmMainWin detects new page added */
    folder_view = (FmFolderView*)fm_standard_view_new(app_config->view_mode,
                                                      update_files_popup,
                                                      open_folder_func);
    page->folder_view = folder_view;
    fm_folder_view_set_selection_mode(folder_view, GTK_SELECTION_MULTIPLE);
    page->nav_history = fm_nav_history_new();
    gtk_paned_add2(paned, GTK_WIDGET(page->folder_view));
    focus_chain = g_list_prepend(focus_chain, page->folder_view);

    /* We need this to change tab order to focus folder view before left pane. */
    gtk_container_set_focus_chain(GTK_CONTAINER(page), focus_chain);
    g_list_free(focus_chain);

    gtk_widget_show_all(GTK_WIDGET(page));
    if(mode & FM_SP_HIDE)
        gtk_widget_hide(GTK_WIDGET(page->side_pane));

    /* create tab label */
    tab_label = (FmTabLabel*)fm_tab_label_new("");
    gtk_label_set_max_width_chars(tab_label->label, app_config->max_tab_chars);
#if ! GTK_CHECK_VERSION(3, 0, 0)
    gtk_label_set_ellipsize(tab_label->label, PANGO_ELLIPSIZE_END);
#endif
    page->tab_label = tab_label;

    g_signal_connect(page->folder_view, "sel-changed",
                     G_CALLBACK(on_folder_view_sel_changed), page);
    /*
    g_signal_connect(page->folder_view, "chdir",
                     G_CALLBACK(on_folder_view_chdir), page);
    g_signal_connect(page->folder_view, "loaded",
                     G_CALLBACK(on_folder_view_loaded), page);
    g_signal_connect(page->folder_view, "error",
                     G_CALLBACK(on_folder_view_error), page);
    */

    /* the folder view is already loded, call the "loaded" callback ourself. */
    //if(fm_folder_view_is_loaded(folder_view))
    //    on_folder_view_loaded(folder_view, fm_folder_view_get_cwd(folder_view), page);
}
示例#9
0
static void
combo_changed_cb (GtkWidget *combo,
		  gpointer   data)
{
  GtkWidget *label = GTK_WIDGET (data);
  gint active;

  active = gtk_combo_box_get_active (GTK_COMBO_BOX (combo));

  gtk_label_set_ellipsize (GTK_LABEL (label), (PangoEllipsizeMode)active);
}
示例#10
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);
}
示例#11
0
static void
ephy_title_box_add_title_bar (EphyTitleBox *title_box)
{
  GtkStyleContext     *context;
  GtkWidget           *box;
  GtkWidget           *hbox;

  box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
  gtk_widget_set_valign (box, GTK_ALIGN_CENTER);
  gtk_widget_show (box);
  gtk_stack_add_named (GTK_STACK (title_box), box, "title-bar");

  title_box->title = gtk_label_new (NULL);
  gtk_widget_show (title_box->title);
  context = gtk_widget_get_style_context (title_box->title);
  gtk_style_context_add_class (context, "title");
  gtk_label_set_line_wrap (GTK_LABEL (title_box->title), FALSE);
  gtk_label_set_single_line_mode (GTK_LABEL (title_box->title), TRUE);
  gtk_label_set_ellipsize (GTK_LABEL (title_box->title), PANGO_ELLIPSIZE_END);
  gtk_box_pack_start (GTK_BOX (box), title_box->title, FALSE, FALSE, 0);

  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
  context = gtk_widget_get_style_context (hbox);
  gtk_style_context_add_class (context, "subtitle");
  gtk_widget_set_halign (hbox, GTK_ALIGN_CENTER);
  gtk_widget_set_valign (hbox, GTK_ALIGN_BASELINE);
  gtk_widget_show (hbox);
  gtk_box_pack_start (GTK_BOX (box), hbox, FALSE, FALSE, 0);

  title_box->lock_image = gtk_image_new_from_icon_name ("channel-secure-symbolic", GTK_ICON_SIZE_MENU);
  gtk_widget_set_valign (title_box->lock_image, GTK_ALIGN_BASELINE);
  gtk_box_pack_start (GTK_BOX (hbox), title_box->lock_image, FALSE, FALSE, 0);

  title_box->subtitle = gtk_label_new (NULL);
  gtk_widget_set_valign (title_box->subtitle, GTK_ALIGN_BASELINE);
  gtk_widget_show (title_box->subtitle);
  gtk_label_set_line_wrap (GTK_LABEL (title_box->subtitle), FALSE);
  gtk_label_set_single_line_mode (GTK_LABEL (title_box->subtitle), TRUE);
  gtk_label_set_ellipsize (GTK_LABEL (title_box->subtitle), PANGO_ELLIPSIZE_END);
  gtk_box_pack_start (GTK_BOX (hbox), title_box->subtitle, FALSE, FALSE, 0);
}
示例#12
0
static void mtpc_statusbar_init(MtpcStatusbar *statusbar)
{
	MtpcStatusbarPrivate *priv;

	priv = mtpc_statusbar_get_instance_private(statusbar);

	gtk_box_set_spacing(GTK_BOX(statusbar), 6);
	gtk_widget_set_margin_top(GTK_WIDGET(statusbar), 3);
	gtk_widget_set_margin_end(GTK_WIDGET(statusbar), 6);
	gtk_widget_set_margin_bottom(GTK_WIDGET(statusbar), 3);
	gtk_widget_set_margin_start(GTK_WIDGET(statusbar), 6);

	/* list info */
	priv->list_info = gtk_label_new(NULL);
	gtk_label_set_ellipsize(GTK_LABEL(priv->list_info),
				PANGO_ELLIPSIZE_END);
	gtk_box_pack_start(GTK_BOX(statusbar), priv->list_info,
			   FALSE, FALSE, 0);

	/* primary text */
	priv->primary_text = gtk_label_new(NULL);
	gtk_label_set_ellipsize(GTK_LABEL(priv->primary_text),
				PANGO_ELLIPSIZE_END);
	gtk_box_pack_start(GTK_BOX(statusbar), priv->primary_text,
			   FALSE, FALSE, 0);

	/* seconary text */
	priv->secondary_text = gtk_label_new(NULL);
	gtk_label_set_ellipsize(GTK_LABEL(priv->secondary_text),
				PANGO_ELLIPSIZE_END);
	gtk_box_pack_start(GTK_BOX(statusbar), priv->secondary_text,
			   FALSE, FALSE, 12);

	/* action area */
	priv->action_area = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
	gtk_widget_show(priv->action_area);
	gtk_box_pack_end(GTK_BOX(statusbar), priv->action_area,
			FALSE, FALSE, 0);

	mtpc_statusbar_show_section(statusbar, MTPC_STATUSBAR_SECTION_FILE_LIST);
}
static GObject *
terminal_tab_label_constructor (GType type,
                                guint n_construct_properties,
                                GObjectConstructParam *construct_params)
{
  GObject *object;
  TerminalTabLabel *tab_label;
  TerminalTabLabelPrivate *priv;
  GtkWidget *hbox, *label, *close_button, *image;

  object = G_OBJECT_CLASS (terminal_tab_label_parent_class)->constructor
             (type, n_construct_properties, construct_params);

  tab_label = TERMINAL_TAB_LABEL (object);
  hbox = GTK_WIDGET (tab_label);
  priv = tab_label->priv;

  g_assert (priv->screen != NULL);
  
  gtk_box_set_spacing (GTK_BOX (hbox), SPACING);

  priv->label = label = gtk_label_new (NULL);
  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
  gtk_misc_set_padding (GTK_MISC (label), 0, 0);
  gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
  gtk_label_set_single_line_mode (GTK_LABEL (label), TRUE);

  gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);

  priv->close_button = close_button = gtk_button_new ();
  gtk_button_set_relief (GTK_BUTTON (close_button), GTK_RELIEF_NONE);
  gtk_button_set_focus_on_click (GTK_BUTTON (close_button), FALSE);
  gtk_button_set_relief (GTK_BUTTON (close_button), GTK_RELIEF_NONE);
  gtk_widget_set_name (close_button, "gnome-terminal-tab-close-button");
  gtk_widget_set_tooltip_text (close_button, _("Close tab"));

  image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
  gtk_container_add (GTK_CONTAINER (close_button), image);
  gtk_box_pack_end (GTK_BOX (hbox), close_button, FALSE, FALSE, 0);

  sync_tab_label (priv->screen, NULL, label);
  g_signal_connect (priv->screen, "notify::title",
                    G_CALLBACK (sync_tab_label), label);

  g_signal_connect (close_button, "clicked",
		    G_CALLBACK (close_button_clicked_cb), tab_label);

  gtk_widget_show_all (hbox);

  return object;
}
示例#14
0
void
uzbl_status_bar_init (UzblStatusBar *status_bar)
{
    static const gint LABEL_MARGIN = 2;

    gtk_box_set_homogeneous (GTK_BOX (status_bar), FALSE);
    gtk_box_set_spacing (GTK_BOX (status_bar), 0);

    /* Create left panel. */
    status_bar->left_label = gtk_label_new ("");
    gtk_label_set_selectable (GTK_LABEL (status_bar->left_label), TRUE);
#if GTK_CHECK_VERSION (3, 10, 0)
    gtk_widget_set_halign (status_bar->left_label, GTK_ALIGN_START);
#else
    gtk_misc_set_alignment (GTK_MISC (status_bar->left_label), 0, 0);
#endif
    g_object_set (G_OBJECT (status_bar->left_label),
        "margin", LABEL_MARGIN,
        NULL);
    gtk_label_set_ellipsize (GTK_LABEL (status_bar->left_label), PANGO_ELLIPSIZE_END);

    /* Create right panel. */
    status_bar->right_label = gtk_label_new ("");
    gtk_label_set_selectable (GTK_LABEL (status_bar->right_label), TRUE);
#if GTK_CHECK_VERSION (3, 10, 0)
    gtk_widget_set_halign (status_bar->right_label, GTK_ALIGN_END);
#else
    gtk_misc_set_alignment (GTK_MISC (status_bar->right_label), 1, 0);
#endif
    g_object_set (G_OBJECT (status_bar->right_label),
        "margin", LABEL_MARGIN,
        NULL);
    gtk_label_set_ellipsize (GTK_LABEL (status_bar->right_label), PANGO_ELLIPSIZE_START);

    /* Add the labels to the status bar. */
    gtk_box_pack_start (GTK_BOX (status_bar), status_bar->left_label,  FALSE, FALSE, 0);
    gtk_box_pack_start (GTK_BOX (status_bar), status_bar->right_label, TRUE,  TRUE,  0);
}
static GtkWidget *
track_info_label_new ()
{
  GtkWidget *label;

  label = gtk_label_new (NULL);
  gtk_label_set_width_chars (GTK_LABEL (label), 25);
  gtk_label_set_max_width_chars (GTK_LABEL (label), 25);
  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
  gtk_widget_set_halign (label, GTK_ALIGN_START);
  gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_MIDDLE);

  return label;
}
示例#16
0
static gint
luaH_notebook_set_title(lua_State *L)
{
    size_t len;
    widget_t *w = luaH_checkwidget(L, 1);
    widget_t *child = luaH_checkwidget(L, 2);
    const gchar *title = luaL_checklstring(L, 3, &len);
    GtkWidget *label = gtk_label_new(title);
    gtk_label_set_ellipsize(GTK_LABEL(label), PANGO_ELLIPSIZE_MIDDLE);
    gtk_notebook_set_tab_label(GTK_NOTEBOOK(w->widget),
        child->widget, label);
    gtk_container_child_set(GTK_CONTAINER(w->widget), label, "tab-expand", TRUE, "tab-fill", TRUE, NULL);
    return 0;
}
示例#17
0
static int ellipsize_member(lua_State *L)
{
  lua_label label;
  luaA_to(L, lua_label, &label, 1);
  dt_lua_ellipsize_mode_t ellipsize;
  if(lua_gettop(L) > 2) {
    luaA_to(L, dt_lua_ellipsize_mode_t, &ellipsize, 3);
    gtk_label_set_ellipsize(GTK_LABEL(label->widget), ellipsize);
    return 0;
  }
  ellipsize = gtk_label_get_ellipsize(GTK_LABEL(label->widget));
  luaA_push(L, dt_lua_ellipsize_mode_t, &ellipsize);
  return 1;
}
示例#18
0
static GtkWidget *getTitleLabel() {
    GtkWidget *label = gtk_label_new (_("Home"));
    gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
    gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
    PangoAttrList *attr_list = pango_attr_list_new ();
    PangoAttribute *attr = pango_attr_weight_new (PANGO_WEIGHT_BOLD);
    pango_attr_list_insert (attr_list, attr);
    gtk_label_set_attributes (GTK_LABEL (label), attr_list);
    pango_attr_list_unref (attr_list);
    gtk_widget_set_hexpand (label, TRUE);
    gtk_widget_set_vexpand (label, TRUE);
    gtk_widget_set_valign (label, GTK_ALIGN_CENTER);
    return label;
}
示例#19
0
wxSize wxStaticText::DoGetBestSize() const
{
    // Do not return any arbitrary default value...
    wxASSERT_MSG( m_widget, wxT("wxStaticText::DoGetBestSize called before creation") );

    // GetBestSize is supposed to return unwrapped size but calling
    // gtk_label_set_line_wrap() from here is a bad idea as it queues another
    // size request by calling gtk_widget_queue_resize() and we end up in
    // infinite loop sometimes (notably when the control is in a toolbar)
    // With GTK3 however, there is no simple alternative, and the sizing loop
    // no longer seems to occur.
#ifdef __WXGTK3__
    gtk_label_set_line_wrap(GTK_LABEL(m_widget), false);
#else
    GTK_LABEL(m_widget)->wrap = FALSE;

    // Reset the ellipsize mode while computing the best size, otherwise it's
    // going to be too small as the control knows that it can be shrunk to the
    // bare minimum and just hide most of the text replacing it with ellipsis.
    // This is especially important because we can enable ellipsization
    // implicitly for GTK+ 2, see the code dealing with alignment in the ctor.
    const PangoEllipsizeMode ellipsizeMode = gtk_label_get_ellipsize(GTK_LABEL(m_widget));
    gtk_label_set_ellipsize(GTK_LABEL(m_widget), PANGO_ELLIPSIZE_NONE);
#endif
    wxSize size = wxStaticTextBase::DoGetBestSize();
#ifdef __WXGTK3__
    gtk_label_set_line_wrap(GTK_LABEL(m_widget), true);
#else
    gtk_label_set_ellipsize(GTK_LABEL(m_widget), ellipsizeMode);
    GTK_LABEL(m_widget)->wrap = TRUE; // restore old value
#endif

    // Adding 1 to width to workaround GTK sometimes wrapping the text needlessly
    size.x++;
    CacheBestSize(size);
    return size;
}
示例#20
0
static void create_entry(PROC_T *p){
    p->hbox=gtk_hbox_new(FALSE,0);
    char lb[12];
    snprintf(lb,12," %5d",p->pid);
    struct tm *tim=localtime(&(p->status.timstart));
    char stime[80];
    strftime(stime,80,"[%a %k:%M:%S]",tim);
    p->entry_start=new_label(stime,WIDTH_START,0.5);
    p->entry_pid=new_label(lb,WIDTH_PID,1);
    p->entry_path=new_label(p->path,WIDTH_PATH,1);
    gtk_label_set_selectable(GTK_LABEL(p->entry_path), TRUE);
    gtk_label_set_ellipsize(GTK_LABEL(p->entry_path),PANGO_ELLIPSIZE_START);
#if GTK_MAJOR_VERSION>=3 || GTK_MINOR_VERSION >= 12
    gtk_widget_set_tooltip_text(p->entry_path, p->path);
#endif
    p->entry_errlo=new_label("Lo (nm)",WIDTH_ERRLO,1);
    p->entry_errhi=new_label("Hi (nm)",WIDTH_ERRHI,1);
    gtk_label_set_max_width_chars(GTK_LABEL(p->entry_errlo),WIDTH_ERRLO);
    gtk_label_set_max_width_chars(GTK_LABEL(p->entry_errhi),WIDTH_ERRHI);
    p->entry_iseed=new_entry("seed",WIDTH_ISEED,0.5);
    p->entry_timing=new_entry("Timing",WIDTH_TIMING,1);
    gtk_box_pack_start(GTK_BOX(p->hbox),gtk_vseparator_new(),FALSE,FALSE,0);
    gtk_box_pack_start(GTK_BOX(p->hbox),p->entry_start,FALSE,FALSE,0);
    gtk_box_pack_start(GTK_BOX(p->hbox),gtk_vseparator_new(),FALSE,FALSE,0);
    gtk_box_pack_start(GTK_BOX(p->hbox),p->entry_pid,FALSE,FALSE,0);
    gtk_box_pack_start(GTK_BOX(p->hbox),gtk_vseparator_new(),FALSE,FALSE,0);
    gtk_box_pack_start(GTK_BOX(p->hbox),p->entry_path,TRUE,TRUE,0);
    gtk_box_pack_start(GTK_BOX(p->hbox),gtk_vseparator_new(),FALSE,FALSE,0);
    gtk_box_pack_start(GTK_BOX(p->hbox),p->entry_errlo,FALSE,FALSE,0);
    gtk_box_pack_start(GTK_BOX(p->hbox),gtk_vseparator_new(),FALSE,FALSE,0);
    gtk_box_pack_start(GTK_BOX(p->hbox),p->entry_errhi,FALSE,FALSE,0);
    gtk_box_pack_start(GTK_BOX(p->hbox),gtk_vseparator_new(),FALSE,FALSE,0);
    gtk_box_pack_start(GTK_BOX(p->hbox),p->entry_iseed,FALSE,FALSE,0);
    gtk_box_pack_start(GTK_BOX(p->hbox),gtk_vseparator_new(),FALSE,FALSE,0);
    gtk_box_pack_start(GTK_BOX(p->hbox),p->entry_timing,FALSE,FALSE,0);
    gtk_box_pack_start(GTK_BOX(p->hbox),gtk_vseparator_new(),FALSE,FALSE,0);
    change_button(p, GTK_STOCK_PREFERENCES, (void*)kill_job_event);
    gtk_box_pack_start(GTK_BOX(p->hbox),p->btn,FALSE,FALSE,0);
    p->vbox=gtk_vbox_new(FALSE,0);
    if(nproc[p->hid]==1){
	gtk_box_pack_start(GTK_BOX(p->vbox),gtk_hseparator_new(),FALSE,FALSE,0);
    }
    gtk_box_pack_start(GTK_BOX(p->vbox),p->hbox,FALSE,FALSE,0);
    gtk_box_pack_start(GTK_BOX(p->vbox),gtk_hseparator_new(),FALSE,FALSE,0);
    gtk_box_pack_start(GTK_BOX(pages[p->hid]),p->vbox,FALSE,FALSE,0);
    
    /*gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook),p->hid); */
    gtk_widget_show_all(p->vbox);
}
示例#21
0
文件: label.c 项目: amery/clip-itk
int
clip_GTK_LABELSETELLIPSIZE(ClipMachine * cm)
{
	C_widget *clbl = _fetch_cw_arg(cm);
        PangoEllipsizeMode mode = _clip_parni(cm, 2);

	CHECKCWID(clbl,GTK_IS_LABEL);
        CHECKARG(2, NUMERIC_t);

	gtk_label_set_ellipsize(GTK_LABEL(clbl->widget), mode);

	return 0;
err:
	return 1;
}
示例#22
0
static GtkWidget*
exo_toolbars_editor_create_item (ExoToolbarsEditor  *editor,
                                 GtkWidget          *image,
                                 const gchar        *text,
                                 GdkDragAction       action)
{
  GtkWidget   *ebox;
  GtkWidget   *vbox;
  GtkWidget   *label;
  gchar       *text_no_mnemonic;

  ebox = gtk_event_box_new ();
  gtk_drag_source_set (ebox, GDK_BUTTON1_MASK,
                       targets, G_N_ELEMENTS (targets),
                       action);
  g_signal_connect (G_OBJECT (ebox), "drag-data-get",
                    G_CALLBACK (exo_toolbars_editor_drag_data_get), editor);
  g_signal_connect_after (G_OBJECT (ebox), "realize",
                          G_CALLBACK (event_box_realize), image);
  g_signal_connect_swapped (G_OBJECT (ebox), "drag-data-delete",
                            G_CALLBACK (exo_toolbars_editor_update), editor);
  gtk_widget_show (ebox);

  if (action == GDK_ACTION_MOVE)
    {
      g_signal_connect (G_OBJECT (ebox), "drag-begin",
                        G_CALLBACK (gtk_widget_hide), NULL);
      g_signal_connect (G_OBJECT (ebox), "drag-end",
                        G_CALLBACK (gtk_widget_show), NULL);
    }

  vbox = gtk_vbox_new (0, FALSE);
  gtk_container_add (GTK_CONTAINER (ebox), vbox);
  gtk_widget_show (vbox);

  gtk_box_pack_start (GTK_BOX (vbox), image, FALSE, TRUE, 0);
  gtk_widget_show (image);

  text_no_mnemonic = exo_str_elide_underscores (text);
  label = gtk_label_new (text_no_mnemonic);
  gtk_widget_set_tooltip_text (ebox, text_no_mnemonic);
  gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
  gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
  g_free (text_no_mnemonic);
  gtk_widget_show (label);

  return ebox;
}
示例#23
0
文件: cvs.c 项目: khorben/DeforaOS
static GtkWidget * _init_label(GtkSizeGroup * group, char const * label,
		GtkWidget ** widget)
{
	GtkWidget * hbox;

	hbox = gtk_hbox_new(FALSE, 4);
	*widget = gtk_label_new(label);
	gtk_misc_set_alignment(GTK_MISC(*widget), 0.0, 0.0);
	gtk_size_group_add_widget(group, *widget);
	gtk_box_pack_start(GTK_BOX(hbox), *widget, FALSE, TRUE, 0);
	*widget = gtk_label_new("");
	gtk_label_set_ellipsize(GTK_LABEL(*widget), PANGO_ELLIPSIZE_MIDDLE);
	gtk_misc_set_alignment(GTK_MISC(*widget), 0.0, 0.0);
	gtk_box_pack_start(GTK_BOX(hbox), *widget, TRUE, TRUE, 0);
	return hbox;
}
示例#24
0
static void
connect_proxy_cb (GtkActionGroup *action_group,
                  GtkAction *action,
                  GtkWidget *proxy,
                  NautilusWindow *window)
{
	GtkLabel *label;

	if (!GTK_IS_MENU_ITEM (proxy))
		return;

	label = GTK_LABEL (gtk_bin_get_child (GTK_BIN (proxy)));

	gtk_label_set_ellipsize (label, PANGO_ELLIPSIZE_END);
	gtk_label_set_max_width_chars (label, MENU_ITEM_MAX_WIDTH_CHARS);
}
static void
awn_tooltip_constructed (GObject *object)
{
  AwnTooltip        *tooltip = AWN_TOOLTIP (object);
  AwnTooltipPrivate *priv = tooltip->priv;
  GtkWidget         *align;

  desktop_agnostic_config_client_bind (priv->client, AWN_THEME_GROUP, FONT_NAME,
                                       object, FONT_NAME, TRUE,
                                       DESKTOP_AGNOSTIC_CONFIG_BIND_METHOD_FALLBACK,
                                       NULL);

  desktop_agnostic_config_client_bind (priv->client, AWN_THEME_GROUP, FONT_COLOR,
                                       object, FONT_COLOR, TRUE,
                                       DESKTOP_AGNOSTIC_CONFIG_BIND_METHOD_FALLBACK,
                                       NULL);

  desktop_agnostic_config_client_bind (priv->client, AWN_THEME_GROUP, BACKGROUND,
                                       object, BACKGROUND, TRUE,
                                       DESKTOP_AGNOSTIC_CONFIG_BIND_METHOD_FALLBACK,
                                       NULL);

  desktop_agnostic_config_client_bind (priv->client, AWN_THEME_GROUP, OUTLINE_COLOR,
                                       object, OUTLINE_COLOR, TRUE,
                                       DESKTOP_AGNOSTIC_CONFIG_BIND_METHOD_FALLBACK,
                                       NULL);

  /* Setup internal widgets */
  align = gtk_alignment_new (0.5, 0.5, 1.0, 1.0);
  gtk_alignment_set_padding (GTK_ALIGNMENT (align), 5, 3, 8, 8);
  gtk_container_add (GTK_CONTAINER (tooltip), align);
  gtk_widget_show (align);

  priv->label = gtk_label_new (" ");
  gtk_label_set_line_wrap (GTK_LABEL (priv->label), FALSE);
  gtk_label_set_ellipsize (GTK_LABEL (priv->label), PANGO_ELLIPSIZE_NONE);
  gtk_container_add (GTK_CONTAINER (align), priv->label);
  gtk_widget_show (priv->label);

  gtk_window_set_resizable (GTK_WINDOW (tooltip), FALSE);

  g_signal_connect (tooltip, "leave-notify-event",
                    G_CALLBACK (awn_tooltip_hide), NULL);
  g_signal_connect (tooltip, "composited-changed",
                    G_CALLBACK (awn_tooltip_set_type_hint), NULL);
  awn_tooltip_set_type_hint (GTK_WIDGET (tooltip));
}
示例#26
0
static void
workspace_button_init (WorkspaceButton* self)
{
  PRIV (self) = G_TYPE_INSTANCE_GET_PRIVATE (self, WORKSPACE_TYPE_BUTTON, WorkspaceButtonPrivate);
  PRIV (self)->box = gtk_hbox_new (FALSE, 6);
  PRIV (self)->image = gtk_image_new ();
  PRIV (self)->label = wb_label_new ();
  gtk_label_set_ellipsize (GTK_LABEL (PRIV (self)->label), PANGO_ELLIPSIZE_MIDDLE);
  gtk_widget_show (PRIV (self)->label);
  gtk_box_pack_start (GTK_BOX (PRIV (self)->box), PRIV (self)->image,
                      FALSE, FALSE, 0);
  gtk_container_add (GTK_CONTAINER (PRIV (self)->box), PRIV (self)->label);
  gtk_widget_show (PRIV (self)->box);
  gtk_container_add (GTK_CONTAINER (self), PRIV (self)->box);

  gtk_widget_set_name (GTK_WIDGET (self), "workspace-button");
}
static void
connect_proxy_cb (GtkActionGroup *action_group,
                  GtkAction *action,
                  GtkWidget *proxy,
                  gpointer dummy)
{
	GtkLabel *label;

	if (!GTK_IS_MENU_ITEM (proxy))
		return;

	label = GTK_LABEL (GTK_BIN (proxy)->child);

	gtk_label_set_use_underline (label, FALSE);
	gtk_label_set_ellipsize (label, PANGO_ELLIPSIZE_END);
	gtk_label_set_max_width_chars (label, MENU_ITEM_MAX_WIDTH_CHARS);
}
示例#28
0
LifereaHtmlView *
browser_tabs_add_new (const gchar *url, const gchar *title, gboolean activate)
{
	GtkWidget 	*close_button, *labelBox;
	tabInfo		*tab;
	int		i;

	tab = g_new0 (tabInfo, 1);
	tab->htmlview = liferea_htmlview_new (TRUE /* internal browsing */);
	tab->widget = liferea_htmlview_get_widget (tab->htmlview);
	tabs->priv->list = g_slist_append (tabs->priv->list, tab);

	g_object_set_data (G_OBJECT (tab->widget), "tabInfo", tab);	

	g_signal_connect (tab->htmlview, "title-changed", G_CALLBACK (on_htmlview_title_changed), tab);
	g_signal_connect (tab->htmlview, "statusbar-changed", G_CALLBACK (on_htmlview_status_message), NULL);
	
	/* create tab widgets */

	tab->label = gtk_label_new (create_label_text (title));
	gtk_label_set_ellipsize (GTK_LABEL (tab->label), PANGO_ELLIPSIZE_END);
	gtk_label_set_width_chars (GTK_LABEL (tab->label), 17);

	labelBox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
	gtk_box_pack_start (GTK_BOX (labelBox), tab->label, FALSE, FALSE, 0);

	close_button = gedit_close_button_new ();
	gtk_box_pack_end (GTK_BOX (labelBox), close_button, FALSE, FALSE, 0);
	g_signal_connect ((gpointer)close_button, "clicked", G_CALLBACK (on_htmlview_close_tab), (gpointer)tab);

	gtk_widget_show_all (labelBox);
	
	i = gtk_notebook_append_page (tabs->priv->notebook, tab->widget, labelBox);
	g_signal_connect (gtk_notebook_get_nth_page (tabs->priv->notebook, i), 
	                  "key-press-event", G_CALLBACK (on_tab_key_press), (gpointer)tab);
	gtk_notebook_set_show_tabs (tabs->priv->notebook, TRUE);
	gtk_notebook_set_tab_reorderable (tabs->priv->notebook, tab->widget, TRUE);	
		
	if (activate && (i != -1))
		gtk_notebook_set_current_page (tabs->priv->notebook, i);
	 
	if (url)
		liferea_htmlview_launch_URL_internal (tab->htmlview, (gchar *)url);

	return tab->htmlview;
}
示例#29
0
void CInfoDlg::AddField(int field, int col, int row, const char *caption, int ellipsize)
{
	tFieldRec *rec = (tFieldRec*)g_malloc0(sizeof(tFieldRec));
	
	rec->id = field;
	rec->label = gtk_label_new(caption);
	gtk_misc_set_alignment(GTK_MISC(rec->label), 0.0, 0.5);
	gtk_table_attach(GTK_TABLE(m_Tab), rec->label, 2*col, 2*col+1, row, row+1, 
		GTK_FILL, (GtkAttachOptions)0, 4, 0);
	rec->value = gtk_label_new("");
	gtk_misc_set_alignment(GTK_MISC(rec->value), 0.0, 0.5);
	gtk_label_set_max_width_chars(GTK_LABEL(rec->value), 60);
	gtk_table_attach(GTK_TABLE(m_Tab), rec->value, 2*col+1, 2*col+2, row, row+1,
		(GtkAttachOptions)(GTK_FILL | GTK_EXPAND), (GtkAttachOptions)0, 4, 0);
	m_Labels = g_list_append(m_Labels, rec);
	if (ellipsize)
		gtk_label_set_ellipsize(GTK_LABEL(rec->value), (PangoEllipsizeMode)ellipsize);
}
static GObject *
terminal_tab_label_constructor (GType type,
                                guint n_construct_properties,
                                GObjectConstructParam *construct_params)
{
  GObject *object;
  TerminalTabLabel *tab_label;
  TerminalTabLabelPrivate *priv;
  GtkWidget *hbox, *label, *close_button;

  object = G_OBJECT_CLASS (terminal_tab_label_parent_class)->constructor
             (type, n_construct_properties, construct_params);

  tab_label = TERMINAL_TAB_LABEL (object);
  hbox = GTK_WIDGET (tab_label);
  priv = tab_label->priv;

  g_assert (priv->screen != NULL);
  
  gtk_box_set_spacing (GTK_BOX (hbox), SPACING);

  priv->label = label = gtk_label_new (NULL);
  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
  gtk_misc_set_padding (GTK_MISC (label), 0, 0);
  gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
  gtk_label_set_single_line_mode (GTK_LABEL (label), TRUE);

  gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0);

  priv->close_button = close_button = terminal_close_button_new ();
  gtk_widget_set_tooltip_text (close_button, _("Close tab"));
  gtk_box_pack_end (GTK_BOX (hbox), close_button, FALSE, FALSE, 0);

  sync_tab_label (priv->screen, NULL, label);
  g_signal_connect (priv->screen, "notify::title",
                    G_CALLBACK (sync_tab_label), label);

  g_signal_connect (close_button, "clicked",
		    G_CALLBACK (close_button_clicked_cb), tab_label);

  gtk_widget_show_all (hbox);

  return object;
}