static GtkWidget *create_media_ui(GtkWidget *window) {
GtkWidget *label = NULL, *vbox = NULL, *vhbox = NULL, *vvbox = NULL;
gchar str[1024] = {0};
snprintf(str, 1024, H1_FONT_FORMAT, _("M_usic"));
vbox = gtk_vbox_new(FALSE, 48);
vvbox = gtk_vbox_new(FALSE, 12);
vhbox = gtk_hbox_new(FALSE, 0);
label = gtk_label_new(NULL);
gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), str);
gtk_box_pack_start(GTK_BOX(vhbox), label, FALSE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(vvbox), vhbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vvbox), create_media_preview_ui_by_type(window, EBOX_MUSIC_UI), FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), vvbox, FALSE, TRUE, 0);
vvbox = gtk_vbox_new(FALSE, 12);
vhbox = gtk_hbox_new(FALSE, 0);
label = gtk_label_new(NULL);
bzero(str, 1024);
snprintf(str, 1024, H1_FONT_FORMAT, _("_Photos"));
gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), str);
gtk_box_pack_start(GTK_BOX(vhbox), label, FALSE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(vvbox), vhbox, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vvbox), create_media_preview_ui_by_type(window, EBOX_PHOTO_UI), FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), vvbox, FALSE, TRUE, 0);
return vbox;
}
/**************************************************************************
Changes the lable (with mnemonic) on an existing stockbutton. See
gtk_stockbutton_new.
**************************************************************************/
void gtk_stockbutton_set_label(GtkWidget *button, const gchar *label_text)
{
GtkWidget *label;
label = g_object_get_data(G_OBJECT(button), "label");
gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), label_text);
}
static void
mini_dialog_add_button(PidginMiniDialog *self,
const char *text,
PidginMiniDialogCallback clicked_cb,
gpointer user_data,
gboolean close_dialog_after_click)
{
PidginMiniDialogPrivate *priv = PIDGIN_MINI_DIALOG_GET_PRIVATE(self);
struct _mini_dialog_button_clicked_cb_data *callback_data
= g_new0(struct _mini_dialog_button_clicked_cb_data, 1);
GtkWidget *button = gtk_button_new();
GtkWidget *label = gtk_label_new(NULL);
char *button_text =
g_strdup_printf("<span size=\"smaller\">%s</span>", text);
gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), button_text);
g_free(button_text);
callback_data->mini_dialog = self;
callback_data->callback = clicked_cb;
callback_data->user_data = user_data;
callback_data->close_dialog_after_click = close_dialog_after_click;
g_signal_connect(G_OBJECT(button), "clicked",
(GCallback) mini_dialog_button_clicked_cb, callback_data);
g_signal_connect(G_OBJECT(button), "destroy",
(GCallback) mini_dialog_button_destroy_cb, callback_data);
gtk_misc_set_alignment(GTK_MISC(label), 0.5, 0.5);
gtk_container_add(GTK_CONTAINER(button), label);
gtk_box_pack_end(GTK_BOX(priv->buttons), button, FALSE, FALSE,
0);
gtk_widget_show_all(GTK_WIDGET(button));
}
/**
* rb_glade_boldify_label:
* @xml: GladeXML instance
* @name: name of the label to boldify
*
* Makes a label built from a glade xml file bold.
*/
void
rb_glade_boldify_label (GladeXML *xml, const char *name)
{
GtkWidget *widget;
widget = glade_xml_get_widget (xml, name);
if (widget == NULL) {
g_warning ("widget '%s' not found", name);
return;
}
/* this way is probably better, but for some reason doesn't work with
* labels with mnemonics.
static PangoAttrList *pattrlist = NULL;
if (pattrlist == NULL) {
PangoAttribute *attr;
pattrlist = pango_attr_list_new ();
attr = pango_attr_weight_new (PANGO_WEIGHT_BOLD);
attr->start_index = 0;
attr->end_index = G_MAXINT;
pango_attr_list_insert (pattrlist, attr);
}
gtk_label_set_attributes (GTK_LABEL (widget), pattrlist);*/
gchar *str_final;
str_final = g_strdup_printf ("<b>%s</b>", gtk_label_get_label (GTK_LABEL (widget)));
gtk_label_set_markup_with_mnemonic (GTK_LABEL (widget), str_final);
g_free (str_final);
}
GtkWidget *
util_image_menu_item(
const gchar * icon_stock_id,
const gchar * label_text,
GCallback activate_cb,
gpointer activate_user_data)
{
GtkWidget * item_w;
if(icon_stock_id) {
item_w = gtk_image_menu_item_new_with_label("");
gtk_image_menu_item_set_image(
GTK_IMAGE_MENU_ITEM(item_w),
gtk_image_new_from_stock(icon_stock_id, GTK_ICON_SIZE_MENU));
} else {
item_w = gtk_menu_item_new_with_label("");
}
gtk_label_set_markup_with_mnemonic(GTK_LABEL(GTK_BIN(item_w)->child), label_text);
/* hook up signal callback */
if(activate_cb)
g_signal_connect(G_OBJECT(item_w), "activate", activate_cb, activate_user_data);
return item_w;
}
void
lmplayer_interface_italicise_label (GtkBuilder *builder, const char *name)
{
GtkLabel *widget;
gchar *str_final;
widget = GTK_LABEL (gtk_builder_get_object (builder, name));
if (widget == NULL) {
g_warning ("widget '%s' not found", name);
return;
}
/* this way is probably better, but for some reason doesn't work with
* labels with mnemonics.
static PangoAttrList *pattrlist = NULL;
if (pattrlist == NULL) {
PangoAttribute *attr;
pattrlist = pango_attr_list_new ();
attr = pango_attr_style_new (PANGO_STYLE_ITALIC);
attr->start_index = 0;
attr->end_index = G_MAXINT;
pango_attr_list_insert (pattrlist, attr);
}
gtk_label_set_attributes (widget, pattrlist);*/
str_final = g_strdup_printf ("<i>%s</i>", gtk_label_get_label (widget));
gtk_label_set_markup_with_mnemonic (widget, str_final);
g_free (str_final);
}
void
FormDialog::private_text (const std::string name,
const std::string description,
const std::string value,
const std::string tooltip,
bool advanced)
{
GtkWidget *label = NULL;
GtkWidget *widget = NULL;
PrivateTextSubmitter *submitter = NULL;
gchar *label_text = NULL;
grow_fields (advanced);
label = gtk_label_new (NULL);
gtk_size_group_add_widget (labels_group, label);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
label_text = g_strdup_printf ("<b>%s</b>", description.c_str());
gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), label_text);
g_free (label_text);
widget = gtk_entry_new ();
gtk_widget_set_tooltip_text (widget, tooltip.c_str ());
gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
gtk_entry_set_activates_default (GTK_ENTRY (widget), true);
gtk_entry_set_visibility (GTK_ENTRY (widget), FALSE);
gtk_size_group_add_widget (options_group, widget);
gtk_entry_set_text (GTK_ENTRY (widget), value.c_str ());
if (advanced) {
gtk_table_attach (GTK_TABLE (advanced_fields), label,
0, 1, advanced_rows - 1, advanced_rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0, 0);
gtk_table_attach (GTK_TABLE (advanced_fields), widget,
1, 2, advanced_rows - 1, advanced_rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0, 0);
} else {
gtk_table_attach (GTK_TABLE (fields), label,
0, 1, rows - 1, rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0, 0);
gtk_table_attach (GTK_TABLE (fields), widget,
1, 2, rows - 1, rows,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
0, 0);
}
submitter = new PrivateTextSubmitter (name, description, advanced, widget);
submitters.push_back (submitter);
}
void GtkLabel_::set_markup_with_mnemonic(Php::Parameters ¶meters)
{
std::string s_str = parameters[0];
gchar *str = (gchar *)s_str.c_str();
gtk_label_set_markup_with_mnemonic (GTK_LABEL(instance), str);
}
static GtkWidget *
brasero_project_type_chooser_new_item (BraseroProjectTypeChooser *chooser,
ItemDescription *description)
{
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *image;
GtkWidget *label;
GtkWidget *eventbox;
gchar *description_str;
eventbox = gtk_button_new ();
g_signal_connect (eventbox,
"clicked",
G_CALLBACK (brasero_project_type_chooser_button_clicked),
chooser);
gtk_widget_show (eventbox);
if (description->tooltip)
gtk_widget_set_tooltip_text (eventbox, _(description->tooltip));
g_object_set_data (G_OBJECT (eventbox),
ID_KEY,
GINT_TO_POINTER (description->type));
g_object_set_data (G_OBJECT (eventbox),
DESCRIPTION_KEY,
description);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 4);
gtk_container_add (GTK_CONTAINER (eventbox), vbox);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, FALSE, 0);
image = gtk_image_new_from_icon_name (description->image, GTK_ICON_SIZE_DIALOG);
gtk_misc_set_alignment (GTK_MISC (image), 1.0, 0.5);
gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, TRUE, 0);
label = gtk_label_new (NULL);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), eventbox);
description_str = g_strdup_printf ("<big>%s</big>", _(description->text));
gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), description_str);
g_free (description_str);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
g_object_set_data (G_OBJECT (eventbox), LABEL_KEY, label);
label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_markup (GTK_LABEL (label), _(description->description));
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
return eventbox;
}
static GtkWidget *
menu_quick_item (char *cmd, char *label, GtkWidget * menu, int flags,
gpointer userdata, char *icon)
{
GtkWidget *img, *item;
if (!label)
item = gtk_menu_item_new ();
else
{
if (icon)
{
/*if (flags & XCMENU_MARKUP)
item = gtk_image_menu_item_new_with_markup (label);
else*/
item = gtk_image_menu_item_new_with_mnemonic (label);
img = gtk_image_new_from_file (icon);
if (img)
gtk_image_menu_item_set_image ((GtkImageMenuItem *)item, img);
else
{
img = gtk_image_new_from_stock (icon, GTK_ICON_SIZE_MENU);
if (img)
gtk_image_menu_item_set_image ((GtkImageMenuItem *)item, img);
}
}
else
{
if (flags & XCMENU_MARKUP)
{
item = gtk_menu_item_new_with_label ("");
if (flags & XCMENU_MNEMONIC)
gtk_label_set_markup_with_mnemonic (GTK_LABEL (GTK_BIN (item)->child), label);
else
gtk_label_set_markup (GTK_LABEL (GTK_BIN (item)->child), label);
} else
{
if (flags & XCMENU_MNEMONIC)
item = gtk_menu_item_new_with_mnemonic (label);
else
item = gtk_menu_item_new_with_label (label);
}
}
}
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
g_object_set_data (G_OBJECT (item), "u", userdata);
if (cmd)
g_signal_connect (G_OBJECT (item), "activate",
G_CALLBACK (popup_menu_cb), cmd);
if (flags & XCMENU_SHADED)
gtk_widget_set_sensitive (GTK_WIDGET (item), FALSE);
gtk_widget_show_all (item);
return item;
}
/**
* dialog_vbox_label_new:
* @labeltext: #const gchar * The label text.
* @xalign: #gfloat The horizontal alignment, from 0 (left) to 1 (right).
* @yalign: #gfloat the vertical alignment, from 0 (top) to 1 (bottom).
* @box: #GtkWidget * GtkBox the label is packed into.
*
* Creates a GtkLabel, aligns it, and packs it in a GtkBox.
*
* Return value: #GtkWidget * The new GtkLabel widget.
*/
static GtkWidget *
dialog_vbox_label_new(const gchar *labeltext, gfloat xalign, gfloat yalign, GtkWidget *box)
{
GtkWidget *label;
label = gtk_label_new (NULL);
gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), labeltext);
gtk_misc_set_alignment (GTK_MISC (label), xalign, yalign);
gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
return label;
}
static VALUE
label_set_markup(int argc, VALUE *argv, VALUE self)
{
VALUE str, with_mnemonic;
rb_scan_args(argc, argv, "02", &str, &with_mnemonic);
if (NIL_P(with_mnemonic) || ! RVAL2CBOOL(with_mnemonic)){
gtk_label_set_markup(_SELF(self), RVAL2CSTR(str));
} else {
gtk_label_set_markup_with_mnemonic(_SELF(self), RVAL2CSTR(str));
}
return self;
}
GtkWidget *
dialog_mnemonic_label_new(const gchar * labeltext, GtkWidget * m_widget)
{
GtkWidget *label;
label = gtk_label_new(NULL);
gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), labeltext);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
if (m_widget)
gtk_label_set_mnemonic_widget(GTK_LABEL(label), m_widget);
return label;
}
/**
@brief set new label for existing widget @a button
e2 uses non-standard dialog buttons, containing alignment
containing h/vbox, the latter with label packed after icon (if any)
@param button the button widget to be updated
@param label string optionally with mnemonic
@return
*/
void e2_button_set_label (GtkWidget *button, const gchar *label)
{
if (label != NULL && *label != '\0')
{
GtkWidget *bbox =
#ifdef USE_GTK2_14
gtk_bin_get_child (GTK_BIN (button));
bbox = gtk_bin_get_child (GTK_BIN (bbox));
GList *children = gtk_container_get_children (GTK_CONTAINER (bbox));
GtkWidget *child = (GtkWidget*) children->data;
if (!GTK_IS_LABEL (child))
child = (GtkWidget*) children->next->data;
gtk_label_set_markup_with_mnemonic (GTK_LABEL (child), label);
g_list_free (children);
#else
GTK_BIN (GTK_BIN (button)->child)->child;
GtkBoxChild *child = (GtkBoxChild *) GTK_BOX (bbox)->children->data;
if (!GTK_IS_LABEL (child->widget))
child = (GtkBoxChild *) GTK_BOX (bbox)->children->next->data;
gtk_label_set_markup_with_mnemonic (GTK_LABEL (child->widget), label);
#endif
}
}
void
FormDialog::error (const std::string _error)
{
GtkWidget *widget = NULL;
if (!_error.empty ()) {
widget = gtk_label_new (NULL);
gtk_label_set_line_wrap (GTK_LABEL (widget), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (widget), PANGO_WRAP_WORD);
gtk_label_set_markup_with_mnemonic (GTK_LABEL (widget),
("<span foreground=\"red\">" + _error + "</span>").c_str ());
gtk_container_add (GTK_CONTAINER (preamble), widget);
}
}
void
FormDialog::instructions (const std::string _instructions)
{
GtkWidget *widget = NULL;
InstructionsSubmitter *submitter = NULL;
gchar * label_text = NULL;
widget = gtk_label_new (NULL);
label_text = g_strdup_printf ("<i>%s</i>", _instructions.c_str());
gtk_label_set_markup_with_mnemonic (GTK_LABEL (widget), label_text);
g_free (label_text);
gtk_label_set_line_wrap (GTK_LABEL (widget), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (widget), PANGO_WRAP_WORD);
gtk_box_pack_start (GTK_BOX (preamble), widget, FALSE, FALSE, 0);
submitter = new InstructionsSubmitter (_instructions);
submitters.push_back (submitter);
}
/**
* rb_builder_boldify_label:
* @builder: a #GtkBuilder instance
* @name: name of the label to boldify
*
* Makes a label built from a GtkBuilder file bold.
*/
void
rb_builder_boldify_label (GtkBuilder *builder, const char *name)
{
GObject *widget;
gchar *str_final;
/* once we require gtk+ 2.16 or newer, we can set the attributes on
* the labels in the builder files, so we won't need this any more.
*/
widget = gtk_builder_get_object (builder, name);
if (widget == NULL) {
g_warning ("widget '%s' not found", name);
return;
}
str_final = g_strdup_printf ("<b>%s</b>", gtk_label_get_label (GTK_LABEL (widget)));
gtk_label_set_markup_with_mnemonic (GTK_LABEL (widget), str_final);
g_free (str_final);
}
void
FormDialog::link (const std::string _link,
const std::string _uri)
{
GtkWidget *widget = NULL;
GtkWidget *label = NULL;
gchar *label_text = NULL;
widget = gtk_button_new ();
label = gtk_label_new (NULL);
label_text = g_strdup_printf ("<span foreground=\"blue\"><u>%s</u></span>",
_link.c_str ());
gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), label_text);
g_free (label_text);
gtk_container_add (GTK_CONTAINER (widget), label);
gtk_button_set_relief (GTK_BUTTON (widget), GTK_RELIEF_NONE);
gtk_box_pack_start (GTK_BOX (preamble), widget, FALSE, FALSE, 0);
g_signal_connect_data (widget, "clicked",
G_CALLBACK (link_clicked_cb), (gpointer) g_strdup (_uri.c_str ()),
(GClosureNotify) g_free, (GConnectFlags) 0);
}
/**
* \param selection Selection to use; should not be NULL.
*/
static void
sp_item_widget_setup ( SPWidget *spw, Inkscape::Selection *selection )
{
g_assert (selection != NULL);
if (gtk_object_get_data (GTK_OBJECT (spw), "blocked"))
return;
if (!selection->singleItem()) {
gtk_widget_set_sensitive (GTK_WIDGET (spw), FALSE);
return;
} else {
gtk_widget_set_sensitive (GTK_WIDGET (spw), TRUE);
}
gtk_object_set_data (GTK_OBJECT (spw), "blocked", GUINT_TO_POINTER (TRUE));
SPItem *item = selection->singleItem();
/* Sensitive */
GtkWidget *w = GTK_WIDGET(gtk_object_get_data (GTK_OBJECT (spw), "sensitive"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), item->isLocked());
/* Hidden */
w = GTK_WIDGET(gtk_object_get_data (GTK_OBJECT (spw), "hidden"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), item->isExplicitlyHidden());
if (SP_OBJECT_IS_CLONED (item)) {
/* ID */
w = GTK_WIDGET(gtk_object_get_data (GTK_OBJECT (spw), "id"));
gtk_entry_set_text (GTK_ENTRY (w), "");
gtk_widget_set_sensitive (w, FALSE);
w = GTK_WIDGET(gtk_object_get_data (GTK_OBJECT (spw), "id_label"));
gtk_label_set_text (GTK_LABEL (w), _("Ref"));
/* Label */
w = GTK_WIDGET(gtk_object_get_data (GTK_OBJECT (spw), "label"));
gtk_entry_set_text (GTK_ENTRY (w), "");
gtk_widget_set_sensitive (w, FALSE);
w = GTK_WIDGET(gtk_object_get_data (GTK_OBJECT (spw), "label_label"));
gtk_label_set_text (GTK_LABEL (w), _("Ref"));
} else {
SPObject *obj = (SPObject*)item;
/* ID */
w = GTK_WIDGET(gtk_object_get_data (GTK_OBJECT (spw), "id"));
gtk_entry_set_text (GTK_ENTRY (w), obj->getId());
gtk_widget_set_sensitive (w, TRUE);
w = GTK_WIDGET(gtk_object_get_data (GTK_OBJECT (spw), "id_label"));
gtk_label_set_markup_with_mnemonic (GTK_LABEL (w), _("_Id"));
/* Label */
w = GTK_WIDGET(gtk_object_get_data (GTK_OBJECT (spw), "label"));
gtk_entry_set_text (GTK_ENTRY (w), obj->defaultLabel());
gtk_widget_set_sensitive (w, TRUE);
/* Title */
w = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), "title"));
gchar *title = obj->title();
if (title) {
gtk_entry_set_text(GTK_ENTRY(w), title);
g_free(title);
}
else gtk_entry_set_text(GTK_ENTRY(w), "");
gtk_widget_set_sensitive(w, TRUE);
/* Description */
w = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), "desc"));
GtkTextBuffer *buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(w));
gchar *desc = obj->desc();
if (desc) {
gtk_text_buffer_set_text(buf, desc, -1);
g_free(desc);
} else {
gtk_text_buffer_set_text(buf, "", 0);
}
w = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), "desc_frame"));
gtk_widget_set_sensitive(w, TRUE);
w = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), "interactivity"));
GtkWidget* int_table = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), "interactivity_table"));
if (int_table){
gtk_container_remove(GTK_CONTAINER(w), int_table);
}
const gchar* int_labels[10] = {"onclick", "onmouseover", "onmouseout", "onmousedown", "onmouseup", "onmousemove","onfocusin", "onfocusout", "onactivate", "onload"};
int_table = sp_attribute_table_new (obj, 10, int_labels, int_labels);
gtk_widget_show_all (int_table);
gtk_object_set_data(GTK_OBJECT(spw), "interactivity_table", int_table);
gtk_container_add (GTK_CONTAINER (w), int_table);
}
gtk_object_set_data (GTK_OBJECT (spw), "blocked", GUINT_TO_POINTER (FALSE));
} // end of sp_item_widget_setup()
static GcrDisplayItem*
create_display_item (GcrDisplayView *self, GcrRenderer *renderer)
{
GcrDisplayItem *item;
GtkTextTagTable *tags;
GtkTextIter iter;
GtkWidget *widget;
GtkWidget *label;
GtkWidget *alignment;
item = g_new0 (GcrDisplayItem, 1);
item->display_view = self;
item->renderer = renderer;
tags = gtk_text_buffer_get_tag_table (self->pv->buffer);
g_assert (!item->field_tag);
item->field_width = 0;
item->field_tag = g_object_new (GTK_TYPE_TEXT_TAG,
"left-margin", item->field_width + FIELD_MARGIN,
"indent", item->field_width,
"pixels-below-lines", 3,
"wrap-mode", GTK_WRAP_WORD_CHAR,
NULL);
gtk_text_tag_table_add (tags, item->field_tag);
g_assert (!item->details_tag);
item->details_tag = g_object_new (GTK_TYPE_TEXT_TAG, NULL);
gtk_text_tag_table_add (tags, item->details_tag);
/* The mark that determines the beginning of this item, with left gravity. */
gtk_text_buffer_get_end_iter (self->pv->buffer, &iter);
item->beginning = gtk_text_buffer_create_mark (self->pv->buffer, NULL, &iter, TRUE);
g_object_ref (item->beginning);
/* The mark that determines the end of this item, with right gravity. */
gtk_text_buffer_get_end_iter (self->pv->buffer, &iter);
item->ending = gtk_text_buffer_create_mark (self->pv->buffer, NULL, &iter, FALSE);
g_object_ref (item->ending);
widget = gtk_expander_new_with_mnemonic ("");
label = gtk_expander_get_label_widget (GTK_EXPANDER (widget));
gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), "<b>_Details</b>");
g_signal_connect (widget, "notify::expanded", G_CALLBACK (on_expander_expanded), item);
g_signal_connect (widget, "realize", G_CALLBACK (on_expander_realize), NULL);
item->expanded = gtk_expander_get_expanded (GTK_EXPANDER (widget));
alignment = gtk_alignment_new (0.5, 0.5, 0.5, 0.5);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 6, 9, 0, 0);
gtk_container_add (GTK_CONTAINER (alignment), widget);
gtk_widget_show_all (alignment);
item->details_widget = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (item->details_widget), alignment);
g_signal_connect (item->details_widget, "realize", G_CALLBACK (on_expander_realize), NULL);
g_object_ref (item->details_widget);
if (gtk_widget_get_realized (GTK_WIDGET (self)))
style_display_item (GTK_WIDGET (self), item);
/* TODO: Initialize the rest of the fields */
return item;
}
void wxControl::GTKSetLabelWithMarkupForLabel(GtkLabel *w, const wxString& label)
{
const wxString labelGTK = GTKConvertMnemonicsWithMarkup(label);
gtk_label_set_markup_with_mnemonic(w, wxGTK_CONV(labelGTK));
}
static void
gdaui_dsn_editor_init (GdauiDsnEditor *config, G_GNUC_UNUSED GdauiDsnEditorClass *klass)
{
GtkWidget *grid;
GtkWidget *label;
GtkWidget *exp;
gchar *str;
g_return_if_fail (GDAUI_IS_DSN_EDITOR (config));
gtk_orientable_set_orientation (GTK_ORIENTABLE (config), GTK_ORIENTATION_VERTICAL);
/* allocate private structure */
config->priv = g_new0 (GdauiDsnEditorPrivate, 1);
config->priv->dsn_info = g_new0 (GdaDsnInfo, 1);
config->priv->no_change_signal = TRUE;
/* data source's name and icon */
GtkWidget *hbox_header;
hbox_header = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (config), hbox_header, FALSE, FALSE, 6);
config->priv->icon = gtk_image_new ();
gtk_widget_set_size_request (config->priv->icon, -1, SUPPORT_ICON_SIZE);
gtk_box_pack_start (GTK_BOX (hbox_header), config->priv->icon, FALSE, FALSE, 0);
config->priv->wname = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox_header), config->priv->wname, FALSE, FALSE, 10);
GtkWidget *menu_button;
menu_button = gtk_menu_button_new ();
gtk_box_pack_end (GTK_BOX (hbox_header), menu_button, FALSE, FALSE, 0);
GtkWidget *menu_icon;
menu_icon = gtk_image_new_from_icon_name ("open-menu-symbolic", GTK_ICON_SIZE_MENU);
gtk_button_set_image (GTK_BUTTON (menu_button), menu_icon);
GMenu *smenu;
smenu = g_menu_new ();
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (menu_button), G_MENU_MODEL (smenu));
GMenuItem *mitem;
mitem = g_menu_item_new ("Test data source", "win.DSNTest");
g_menu_insert_item (smenu, -1, mitem);
mitem = g_menu_item_new ("Reset data source's changes", "win.DSNReset");
g_menu_insert_item (smenu, -1, mitem);
mitem = g_menu_item_new ("Duplicate data source", "win.DSNCopy");
g_menu_insert_item (smenu, -1, mitem);
GtkWindow *win;
win = gtk_application_get_active_window (GTK_APPLICATION (g_application_get_default ()));
g_action_map_add_action_entries (G_ACTION_MAP (win), win_entries, G_N_ELEMENTS (win_entries), config);
/* stack in a scrolled window */
GtkWidget *sw;
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_vexpand (sw, TRUE);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_NONE);
gtk_box_pack_start (GTK_BOX (config), sw, TRUE, TRUE, 6);
/* Stack */
config->priv->stack = gtk_stack_new ();
gtk_stack_set_transition_type (GTK_STACK (config->priv->stack), GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT);
gtk_container_add (GTK_CONTAINER (sw), config->priv->stack);
/* set up widgets */
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
gtk_widget_show (grid);
label = gtk_label_new_with_mnemonic (_("_System wide data source:"));
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_hexpand (label, FALSE);
g_object_set (G_OBJECT (label), "xalign", 0., NULL);
gtk_widget_show (label);
gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1);
config->priv->is_system = gtk_check_button_new ();
gtk_widget_show (config->priv->is_system);
g_signal_connect (G_OBJECT (config->priv->is_system), "toggled",
G_CALLBACK (field_toggled_cb), config);
gtk_grid_attach (GTK_GRID (grid), config->priv->is_system, 1, 1, 1, 1);
str = g_strdup_printf ("%s <span foreground='red' weight='bold'>*</span>", _("_Provider:"));
label = gtk_label_new ("");
gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), str);
g_free (str);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_hexpand (label, FALSE);
g_object_set (G_OBJECT (label), "xalign", 0., NULL);
gtk_widget_show (label);
gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1);
config->priv->wprovider = gdaui_provider_selector_new ();
gtk_widget_set_hexpand (config->priv->wprovider, TRUE);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), config->priv->wprovider);
gtk_widget_show (config->priv->wprovider);
g_signal_connect (G_OBJECT (config->priv->wprovider), "changed",
G_CALLBACK (field_changed_cb), config);
gtk_grid_attach (GTK_GRID (grid), config->priv->wprovider, 1, 2, 1, 1);
label = gtk_label_new_with_mnemonic (_("_Description:"));
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_widget_set_hexpand (label, FALSE);
g_object_set (G_OBJECT (label), "xalign", 0., NULL);
gtk_widget_show (label);
gtk_grid_attach (GTK_GRID (grid), label, 0, 3, 1, 1);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
config->priv->wdesc = gtk_text_view_new ();
gtk_container_add (GTK_CONTAINER (sw), config->priv->wdesc);
gtk_text_view_set_editable (GTK_TEXT_VIEW (config->priv->wdesc), TRUE);
gtk_widget_set_vexpand (config->priv->wdesc, TRUE);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), config->priv->wdesc);
g_signal_connect (gtk_text_view_get_buffer (GTK_TEXT_VIEW (config->priv->wdesc)), "changed",
G_CALLBACK (field_changed_cb), config);
gtk_grid_attach (GTK_GRID (grid), sw, 1, 3, 1, 1);
config->priv->warning = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (config->priv->warning),
_("<span foreground='red'>The database provider used by this data source is not available,\n"
"editing the data source's attributes is disabled</span>"));
gtk_widget_set_halign (config->priv->warning, GTK_ALIGN_CENTER);
gtk_widget_set_hexpand (config->priv->warning, TRUE);
g_object_set (G_OBJECT (config->priv->warning), "xalign", 0.5, NULL);
gtk_label_set_justify (GTK_LABEL (config->priv->warning), GTK_JUSTIFY_CENTER);
gtk_label_set_line_wrap (GTK_LABEL (config->priv->warning), TRUE);
gtk_grid_attach (GTK_GRID (grid), config->priv->warning, 0, 8, 2, 1);
gtk_stack_add_named (GTK_STACK (config->priv->stack), grid, PANE_DEFINITION);
/* connection's spec */
config->priv->dsn_spec = _gdaui_provider_spec_editor_new (gdaui_provider_selector_get_provider
(GDAUI_PROVIDER_SELECTOR (config->priv->wprovider)));
g_signal_connect (G_OBJECT (config->priv->dsn_spec), "changed",
G_CALLBACK (field_changed_cb), config);
gtk_widget_show (config->priv->dsn_spec);
gtk_stack_add_named (GTK_STACK (config->priv->stack), config->priv->dsn_spec, PANE_PARAMS);
/* connection's authentication */
config->priv->dsn_auth = _gdaui_provider_auth_editor_new (gdaui_provider_selector_get_provider
(GDAUI_PROVIDER_SELECTOR (config->priv->wprovider)));
g_signal_connect (G_OBJECT (config->priv->dsn_auth), "changed",
G_CALLBACK (field_changed_cb), config);
gtk_widget_show (config->priv->dsn_auth);
gtk_stack_add_named (GTK_STACK (config->priv->stack), config->priv->dsn_auth, PANE_AUTH);
config->priv->no_change_signal = FALSE;
}
static void create_window (void)
{
jump_to_track_win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_type_hint(GTK_WINDOW(jump_to_track_win),
GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_title(GTK_WINDOW(jump_to_track_win), _("Jump to Song"));
g_signal_connect (jump_to_track_win, "key_press_event", (GCallback) keypress_cb, NULL);
g_signal_connect (jump_to_track_win, "delete-event", (GCallback) delete_cb, NULL);
gtk_container_set_border_width(GTK_CONTAINER(jump_to_track_win), 10);
gtk_window_set_default_size(GTK_WINDOW(jump_to_track_win), 600, 500);
GtkWidget * vbox = gtk_vbox_new (FALSE, 5);
gtk_container_add(GTK_CONTAINER(jump_to_track_win), vbox);
treeview = mlpgui_list_new (& callbacks, NULL, 0);
gtk_tree_view_set_headers_visible ((GtkTreeView *) treeview, FALSE);
mlpgui_list_add_column (treeview, NULL, 0, G_TYPE_INT, 7);
mlpgui_list_add_column (treeview, NULL, 1, G_TYPE_STRING, -1);
g_signal_connect (gtk_tree_view_get_selection ((GtkTreeView *) treeview),
"changed", (GCallback) selection_changed, NULL);
g_signal_connect (treeview, "row-activated", (GCallback) do_jump, NULL);
GtkWidget * hbox = gtk_hbox_new (FALSE, 3);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3);
/* filter box */
GtkWidget * search_label = gtk_label_new (_("Filter: "));
gtk_label_set_markup_with_mnemonic(GTK_LABEL(search_label), _("_Filter:"));
gtk_box_pack_start(GTK_BOX(hbox), search_label, FALSE, FALSE, 0);
filter_entry = gtk_entry_new ();
gtk_label_set_mnemonic_widget ((GtkLabel *) search_label, filter_entry);
g_signal_connect (filter_entry, "changed", (GCallback) fill_list, NULL);
gtk_entry_set_activates_default ((GtkEntry *) filter_entry, TRUE);
gtk_box_pack_start ((GtkBox *) hbox, filter_entry, TRUE, TRUE, 3);
/* remember text entry */
GtkWidget * toggle2 = gtk_check_button_new_with_label (_("Remember"));
gtk_toggle_button_set_active ((GtkToggleButton *) toggle2, mlp_get_bool
("mlpgui", "remember_jtf_entry"));
gtk_box_pack_start(GTK_BOX(hbox), toggle2, FALSE, FALSE, 0);
g_signal_connect (toggle2, "clicked", (GCallback) toggle_button_cb, "remember_jtf_entry");
/* clear button */
GtkWidget * rescan = gtk_button_new_with_mnemonic (_("Clea_r"));
gtk_button_set_image ((GtkButton *) rescan, gtk_image_new_from_stock
(GTK_STOCK_CLEAR, GTK_ICON_SIZE_BUTTON));
gtk_box_pack_start(GTK_BOX(hbox), rescan, FALSE, FALSE, 0);
g_signal_connect (rescan, "clicked", (GCallback) clear_cb, NULL);
GtkWidget * scrollwin = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add(GTK_CONTAINER(scrollwin), treeview);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrollwin),
GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(vbox), scrollwin, TRUE, TRUE, 0);
GtkWidget * bbox = gtk_hbutton_box_new ();
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(bbox), 4);
gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
/* close dialog toggle */
GtkWidget * toggle = gtk_check_button_new_with_label(_("Close on Jump"));
gtk_toggle_button_set_active ((GtkToggleButton *) toggle, mlp_get_bool
("mlpgui", "close_jtf_dialog"));
gtk_box_pack_start(GTK_BOX(bbox), toggle, FALSE, FALSE, 0);
g_signal_connect (toggle, "clicked", (GCallback) toggle_button_cb, "close_jtf_dialog");
/* queue button */
queue_button = gtk_button_new_with_mnemonic(_("_Queue"));
gtk_button_set_image ((GtkButton *) queue_button, gtk_image_new_from_stock
(AUD_STOCK_QUEUETOGGLE, GTK_ICON_SIZE_BUTTON));
gtk_box_pack_start ((GtkBox *) bbox, queue_button, FALSE, FALSE, 0);
g_signal_connect (queue_button, "clicked", (GCallback) do_queue, NULL);
/* jump button */
GtkWidget * jump = gtk_button_new_from_stock (GTK_STOCK_JUMP_TO);
gtk_box_pack_start(GTK_BOX(bbox), jump, FALSE, FALSE, 0);
g_signal_connect (jump, "clicked", (GCallback) do_jump, NULL);
gtk_widget_set_can_default(jump, TRUE);
gtk_widget_grab_default(jump);
/* close button */
GtkWidget * close = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
gtk_box_pack_start(GTK_BOX(bbox), close, FALSE, FALSE, 0);
g_signal_connect (close, "clicked", (GCallback) mlpgui_jump_to_track_hide,
NULL);
gtk_widget_set_can_default(close, TRUE);
}
void show_login()
{
GtkWidget *image;
GtkWidget *hbox_toplevel;
GtkWidget *vbox;
GtkWidget *button;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *vbox2;
GtkWidget *table;
#ifdef GAIM_SMALL_SCREEN
#ifdef ENABLE_HILDON
GtkWidget *hbox1;
GtkWidget *vbox1;
#endif
GtkWidget *hseparator;
#endif
/* Do we already have a main window opened? If so, bring it back, baby... ribs... yeah */
#ifdef ENABLE_HILDON
if (login_app_view) {
hildon_app_set_appview(HILDON_APP(app), HILDON_APPVIEW(login_app_view));
g_object_unref(login_app_view);
return;
}
mainwindow = current_app_view = login_app_view = hildon_appview_new(_("Login"));
hildon_app_set_appview(HILDON_APP(app), HILDON_APPVIEW(login_app_view));
hbox_toplevel = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(login_app_view), hbox_toplevel);
g_signal_connect(G_OBJECT(login_app_view), "delete_event",
G_CALLBACK(login_window_closed), login_app_view);
#else
if (mainwindow) {
gtk_window_present(GTK_WINDOW(mainwindow));
return;
}
#ifdef GAIM_SMALL_SCREEN
mainwindow = gtk_dialog_new();
gtk_window_set_modal(GTK_WINDOW(mainwindow), TRUE);
gtk_dialog_set_has_separator(mainwindow, FALSE);
#else
mainwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
#endif
gtk_window_set_role(GTK_WINDOW(mainwindow), "login");
gtk_window_set_resizable(GTK_WINDOW(mainwindow), FALSE);
gtk_window_set_title(GTK_WINDOW(mainwindow), _("Login"));
gtk_container_set_border_width(GTK_CONTAINER(mainwindow), 5);
g_signal_connect(G_OBJECT(mainwindow), "delete_event",
G_CALLBACK(login_window_closed), mainwindow);
hbox_toplevel = gtk_hbox_new(FALSE, 0);
#ifdef GAIM_SMALL_SCREEN
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(mainwindow)->vbox), hbox_toplevel);
#else
gtk_container_add(GTK_CONTAINER(mainwindow), hbox_toplevel);
#endif
#endif
vbox_toplevel = vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_toplevel), vbox, FALSE, FALSE, BOX_SPACING);
#ifdef GAIM_SMALL_SCREEN
/* Now for the button box */
hbox = gtk_hbox_new(FALSE, 0);
#ifdef ENABLE_HILDON
hbox1 = gtk_hbox_new(FALSE, BOX_SPACING);
vbox1 = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox1, TRUE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hbox1), vbox1, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox1), hbox, FALSE, FALSE, 0);
vbox = vbox1;
#else
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
#endif
/* lets put the image also in the hbox */
image = gtk_image_new_from_stock(GAIM_STOCK_LOGO, gtk_icon_size_from_name(GAIM_ICON_SIZE_LOGO));
#ifdef ENABLE_HILDON
gtk_box_pack_start(GTK_BOX(hbox1), image, FALSE, FALSE, 0);
#else
gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0);
#endif
/* And now for the buttons */
button = gaim_pixbuf_button_from_stock(_("A_ccounts"), GAIM_STOCK_ACCOUNTS, GAIM_BUTTON_VERTICAL);
gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(gaim_gtk_accounts_window_show), mainwindow);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
button = gaim_pixbuf_button_from_stock(_("P_references"), GTK_STOCK_PREFERENCES, GAIM_BUTTON_VERTICAL);
gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(gaim_gtk_prefs_show), mainwindow);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
button = gaim_pixbuf_button_from_stock(_("_Sign on"), GAIM_STOCK_SIGN_ON, GAIM_BUTTON_VERTICAL);
gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(dologin), mainwindow);
g_signal_connect(G_OBJECT(button), "button-press-event", G_CALLBACK(domiddleclick), NULL);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox), hseparator, FALSE, TRUE, 2);
#else
image = gtk_image_new_from_stock(GAIM_STOCK_LOGO, gtk_icon_size_from_name(GAIM_ICON_SIZE_LOGO));
gtk_box_pack_start(GTK_BOX(vbox), image, FALSE, FALSE, 0);
#endif
table = gtk_table_new (2, 2, FALSE);
gtk_widget_show (table);
gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_table_set_col_spacings (GTK_TABLE (table), 2);
/* why isn't there a gtk_label_new_with_markup? */
label = gtk_label_new(NULL);
gtk_widget_show (label);
gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), _("<b>_Account:</b>"));
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
name = gaim_gtk_account_option_menu_new(NULL, TRUE, G_CALLBACK(combo_changed), NULL, NULL);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), name);
gtk_widget_show (name);
gtk_table_attach (GTK_TABLE (table), name, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
label = gtk_label_new(NULL);
gtk_widget_show (label);
gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), _("<b>_Password:</b>"));
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
pass = gtk_entry_new();
gtk_label_set_mnemonic_widget(GTK_LABEL(label), pass);
gtk_entry_set_visibility(GTK_ENTRY(pass), FALSE);
gtk_table_attach (GTK_TABLE (table), pass, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
#ifndef GAIM_SMALL_SCREEN
g_signal_connect(G_OBJECT(pass), "activate",
G_CALLBACK(dologin), mainwindow);
/*
gtk_box_pack_start(GTK_BOX(vbox2), pass, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), vbox2, FALSE, TRUE, 0);
*/
/* Now for the button box */
hbox = gtk_hbox_new(TRUE, 0);
/*
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 5);
*/
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5);
/* And now for the buttons */
button = gaim_pixbuf_button_from_stock(_("A_ccounts"), GAIM_STOCK_ACCOUNTS, GAIM_BUTTON_VERTICAL);
gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(gaim_gtk_accounts_window_show), mainwindow);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
button = gaim_pixbuf_button_from_stock(_("P_references"), GTK_STOCK_PREFERENCES, GAIM_BUTTON_VERTICAL);
gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(gaim_gtk_prefs_show), mainwindow);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
button = gaim_pixbuf_button_from_stock(_("_Sign on"), GAIM_STOCK_SIGN_ON, GAIM_BUTTON_VERTICAL);
gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(dologin), mainwindow);
g_signal_connect(G_OBJECT(button), "button-press-event", G_CALLBACK(domiddleclick), NULL);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
#endif
/* Now grab the focus that we need */
if (gaim_accounts_get_all()) {
GaimAccount *account = gaim_accounts_get_all()->data;
if (gaim_account_get_remember_password(account)) {
combo_changed(NULL, account, NULL);
gtk_widget_grab_focus(button);
} else {
gtk_widget_grab_focus(pass);
}
} else {
gaim_gtk_accounts_window_show();
gtk_widget_grab_focus(button);
}
#ifndef ENABLE_HILDON
/* And raise the curtain! */
gtk_widget_show_all(mainwindow);
#else
gtk_widget_show_all(login_app_view);
#endif
}
GtkWidget *
entry_create_widget (GtkWidget * dlg)
{
GtkWidget *c, *l = NULL, *w = NULL;
#if !GTK_CHECK_VERSION(3,0,0)
w = gtk_hbox_new (FALSE, 5);
#else
w = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
#endif
if (options.entry_data.entry_label)
{
l = gtk_label_new (NULL);
if (options.data.no_markup)
gtk_label_set_text_with_mnemonic (GTK_LABEL (l), options.entry_data.entry_label);
else
gtk_label_set_markup_with_mnemonic (GTK_LABEL (l), options.entry_data.entry_label);
gtk_widget_set_name (l, "yad-entry-label");
gtk_box_pack_start (GTK_BOX (w), l, FALSE, FALSE, 1);
}
if (options.entry_data.numeric)
{
gdouble min, max, step, val;
guint prec;
min = 0.0;
max = 65535.0;
step = 1.0;
prec = 0;
if (options.extra_data && options.extra_data[0])
{
min = g_ascii_strtod (options.extra_data[0], NULL);
if (options.extra_data[1])
max = g_ascii_strtod (options.extra_data[1], NULL);
if (options.extra_data[2])
step = g_ascii_strtod (options.extra_data[2], NULL);
if (options.extra_data[3])
{
prec = (guint) g_ascii_strtoull (options.extra_data[3], NULL, 0);
if (prec > 20)
prec = 20;
}
}
c = entry = gtk_spin_button_new_with_range (min, max, step);
gtk_entry_set_alignment (GTK_ENTRY (c), 1.0);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (c), prec);
gtk_widget_set_name (entry, "yad-entry-spin");
if (options.entry_data.entry_text)
{
val = g_ascii_strtod (options.entry_data.entry_text, NULL);
if (min >= max)
{
g_printerr (_("Maximum value must be greater than minimum value.\n"));
min = 0.0;
max = 65535.0;
}
if (val < min)
{
g_printerr (_("Initial value less than minimal.\n"));
val = min;
}
else if (val > max)
{
g_printerr (_("Initial value greater than maximum.\n"));
val = max;
}
gtk_spin_button_set_value (GTK_SPIN_BUTTON (c), val);
}
}
else if (!options.entry_data.completion && options.extra_data && *options.extra_data)
{
gint active, i;
if (options.common_data.editable || settings.combo_always_editable)
{
#if GTK_CHECK_VERSION(2,24,0)
c = gtk_combo_box_text_new_with_entry ();
#else
c = gtk_combo_box_entry_new_text ();
#endif
gtk_widget_set_name (c, "yad-entry-edit-combo");
entry = gtk_bin_get_child (GTK_BIN (c));
if (options.entry_data.licon)
{
GdkPixbuf *pb = get_pixbuf (options.entry_data.licon, YAD_SMALL_ICON);
if (pb)
gtk_entry_set_icon_from_pixbuf (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, pb);
}
if (options.entry_data.ricon)
{
GdkPixbuf *pb = get_pixbuf (options.entry_data.ricon, YAD_SMALL_ICON);
if (pb)
gtk_entry_set_icon_from_pixbuf (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, pb);
}
}
else
{
#if GTK_CHECK_VERSION(2,24,0)
c = entry = gtk_combo_box_text_new ();
#else
c = entry = gtk_combo_box_new_text ();
#endif
gtk_widget_set_name (c, "yad-entry-combo");
is_combo = TRUE;
}
i = 0;
active = -1;
while (options.extra_data[i] != NULL)
{
if (options.entry_data.entry_text &&
g_ascii_strcasecmp (options.extra_data[i], options.entry_data.entry_text) == 0)
active = i;
#if GTK_CHECK_VERSION(2,24,0)
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (c), options.extra_data[i]);
#else
gtk_combo_box_append_text (GTK_COMBO_BOX (c), options.extra_data[i]);
#endif
i++;
}
if (options.entry_data.entry_text && active == -1)
{
#if GTK_CHECK_VERSION(2,24,0)
gtk_combo_box_text_prepend_text (GTK_COMBO_BOX_TEXT (c), options.entry_data.entry_text);
#else
gtk_combo_box_prepend_text (GTK_COMBO_BOX (c), options.entry_data.entry_text);
#endif
}
/* set first iter active */
if (!options.common_data.editable)
gtk_combo_box_set_active (GTK_COMBO_BOX (c), (active != -1 ? active : 0));
}
else
{
c = entry = gtk_entry_new ();
gtk_widget_set_name (c, "yad-entry-widget");
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
if (options.entry_data.entry_text)
gtk_entry_set_text (GTK_ENTRY (entry), options.entry_data.entry_text);
if (options.entry_data.hide_text)
g_object_set (G_OBJECT (entry), "visibility", FALSE, NULL);
if (options.entry_data.completion)
{
GtkEntryCompletion *completion;
GtkTreeModel *completion_model;
completion = gtk_entry_completion_new ();
gtk_entry_set_completion (GTK_ENTRY (entry), completion);
completion_model = create_completion_model ();
gtk_entry_completion_set_model (completion, completion_model);
g_object_unref (completion_model);
gtk_entry_completion_set_text_column (completion, 0);
g_object_unref (completion);
}
if (options.entry_data.licon)
{
GdkPixbuf *pb = get_pixbuf (options.entry_data.licon, YAD_SMALL_ICON);
if (pb)
gtk_entry_set_icon_from_pixbuf (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, pb);
}
if (options.entry_data.ricon)
{
GdkPixbuf *pb = get_pixbuf (options.entry_data.ricon, YAD_SMALL_ICON);
if (pb)
gtk_entry_set_icon_from_pixbuf (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, pb);
}
}
if (l)
gtk_label_set_mnemonic_widget (GTK_LABEL (l), entry);
if (!is_combo)
g_signal_connect (G_OBJECT (entry), "activate", G_CALLBACK (entry_activate_cb), dlg);
else
g_signal_connect (G_OBJECT (entry), "key-press-event", G_CALLBACK (combo_activate_cb), dlg);
if (options.entry_data.licon || options.entry_data.ricon)
g_signal_connect (G_OBJECT (entry), "icon-press", G_CALLBACK (icon_cb), NULL);
gtk_box_pack_start (GTK_BOX (w), c, TRUE, TRUE, 1);
return w;
}
/**
@brief create button
This is used for toolbar buttons, and (maybe indirectly) for dialog buttons
@param label button label which may contain markup and/or mnemonic, or NULL
@param stock string describing icon, or NULL
@param size code for size of button-icon
@param tip tooltip for the button, or NULL
@param callback callback function for button's "clicked" signal, or NULL
@param data data specified for the callback
@param flags flags indicating button properties
@return the (unshown) button widget
*/
GtkWidget *e2_button_get_full (const gchar *label, const gchar *stock, GtkIconSize size,
const gchar *tip, void (*callback)(/*GtkButton*,gpointer*/), gpointer data,
E2_ButtonFlags flags)
{
GtkWidget *button = gtk_button_new ();
#ifdef USE_GTK2_18
gtk_widget_set_can_default (button, (flags & E2_BUTTON_CAN_DEFAULT) > 0);
gtk_widget_set_can_focus (button, (flags & E2_BUTTON_CAN_FOCUS) > 0);
#else
if (flags & E2_BUTTON_CAN_DEFAULT)
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
else
GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_DEFAULT);
if (flags & E2_BUTTON_CAN_FOCUS)
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_FOCUS);
else
GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
#endif
if (tip != NULL)
e2_widget_set_safetip (button, tip);
if (callback != NULL)
g_signal_connect_data (G_OBJECT (button), "clicked",
G_CALLBACK (callback), data,
(flags & E2_BUTTON_FREE_DATA) ? (GClosureNotify) g_free : NULL, 0);
GtkWidget *bbox;
#ifdef USE_GTK3_0
if (flags & E2_BUTTON_ICON_ABOVE_LABEL)
bbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); //constant gap, not E2_PADDING_XSMALL
else
bbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
#else
if (flags & E2_BUTTON_ICON_ABOVE_LABEL)
bbox = gtk_vbox_new (FALSE, 2);
else
bbox = gtk_hbox_new (FALSE, 2);
#endif
gboolean need_align = FALSE;
if (stock != NULL)
{
GtkWidget *img = e2_widget_get_icon (stock, size);
if (img == NULL && (flags & E2_BUTTON_SHOW_MISSING_ICON))
img = e2_widget_get_icon (STOCK_NAME_MISSING_IMAGE, size);
if (img != NULL)
{
gtk_box_pack_start (GTK_BOX (bbox),
img, FALSE, FALSE, 0);
need_align = TRUE;
}
}
if ((label != NULL) && (*label != '\0'))
{
GtkWidget *wlab = gtk_label_new ("");
gtk_label_set_markup_with_mnemonic (GTK_LABEL (wlab), label);
gtk_label_set_mnemonic_widget ((GtkLabel*)wlab, button); //NEEDED? label not a child of button
gtk_box_pack_start (GTK_BOX (bbox), wlab, TRUE, TRUE, 0);
need_align = TRUE;
}
if (need_align)
{
GtkWidget *align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
gtk_container_add (GTK_CONTAINER (align), bbox);
gtk_container_add (GTK_CONTAINER (button), align);
}
else //should never happen
gtk_container_add (GTK_CONTAINER (button), bbox);
return button;
}
static void
OutputImageDialogSetupItem(GtkWidget *w, struct OutputImageDialog *d)
{
int i;
GtkWidget *vlabel;
#if GTK_CHECK_VERSION(3, 0, 0)
GtkWidget *window;
GtkRequisition minimum_size;
#endif
vlabel = get_mnemonic_label(d->version);
gtk_label_set_text(GTK_LABEL(vlabel), "");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->use_opacity), FALSE);
combo_box_clear(d->version);
switch (d->DlgType) {
case MenuIdOutputPSFile:
case MenuIdOutputEPSFile:
for (i = 0; PsVersion[i]; i++) {
combo_box_append_text(d->version, PsVersion[i]);
}
set_widget_visibility_with_label(d->dpi, FALSE);
set_widget_visibility_with_label(d->version, TRUE);
gtk_widget_set_visible(d->t2p, TRUE);
gtk_label_set_markup_with_mnemonic(GTK_LABEL(vlabel), _("_PostScript Version:"));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(d->dpi), 72);
combo_box_set_active(d->version, Menulocal.ps_version);
break;
case MenuIdOutputPNGFile:
set_widget_visibility_with_label(d->dpi, TRUE);
set_widget_visibility_with_label(d->version, FALSE);
gtk_widget_set_visible(d->t2p, FALSE);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(d->dpi), Menulocal.png_dpi);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->use_opacity), Menulocal.use_opacity);
break;
case MenuIdOutputPDFFile:
set_widget_visibility_with_label(d->dpi, FALSE);
set_widget_visibility_with_label(d->version, FALSE);
gtk_widget_set_visible(d->t2p, TRUE);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(d->dpi), 72);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->use_opacity), Menulocal.use_opacity);
break;
case MenuIdOutputSVGFile:
for (i = 0; PsVersion[i]; i++) {
combo_box_append_text(d->version, SvgVersion[i]);
}
set_widget_visibility_with_label(d->dpi, FALSE);
set_widget_visibility_with_label(d->version, TRUE);
gtk_widget_set_visible(d->t2p, TRUE);
gtk_label_set_markup_with_mnemonic(GTK_LABEL(vlabel), _("_SVG Version:"));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(d->dpi), 72);
combo_box_set_active(d->version, Menulocal.svg_version);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->use_opacity), Menulocal.use_opacity);
break;
#ifdef CAIRO_HAS_WIN32_SURFACE
case MenuIdOutputCairoEMFFile:
set_widget_visibility_with_label(d->dpi, TRUE);
set_widget_visibility_with_label(d->version, FALSE);
gtk_widget_set_visible(d->t2p, FALSE);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(d->dpi), Menulocal.emf_dpi);
break;
#endif /* CAIRO_HAS_WIN32_SURFACE */
}
#if GTK_CHECK_VERSION(3, 0, 0)
window = gtk_widget_get_parent(GTK_WIDGET(d->vbox));
if (GTK_IS_WINDOW(window)) {
gtk_widget_get_preferred_size(GTK_WIDGET(d->vbox), &minimum_size, NULL);
gtk_window_resize(GTK_WINDOW(window), minimum_size.width, minimum_size.height);
}
#endif
}
static void
sp_item_widget_label_changed( GtkWidget */*widget*/, SPWidget *spw )
{
if (gtk_object_get_data (GTK_OBJECT (spw), "blocked"))
return;
SPItem *item = sp_desktop_selection(SP_ACTIVE_DESKTOP)->singleItem();
g_return_if_fail (item != NULL);
gtk_object_set_data (GTK_OBJECT (spw), "blocked", GUINT_TO_POINTER (TRUE));
/* Retrieve the label widget for the object's id */
GtkWidget *id_entry = GTK_WIDGET(gtk_object_get_data (GTK_OBJECT (spw), "id"));
gchar *id = (gchar *) gtk_entry_get_text (GTK_ENTRY (id_entry));
g_strcanon (id, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.:", '_');
GtkWidget *id_label = GTK_WIDGET(gtk_object_get_data (GTK_OBJECT (spw), "id_label"));
if (!strcmp (id, item->getId())) {
gtk_label_set_markup_with_mnemonic (GTK_LABEL (id_label), _("_Id"));
} else if (!*id || !isalnum (*id)) {
gtk_label_set_text (GTK_LABEL (id_label), _("Id invalid! "));
} else if (SP_ACTIVE_DOCUMENT->getObjectById(id) != NULL) {
gtk_label_set_text (GTK_LABEL (id_label), _("Id exists! "));
} else {
SPException ex;
gtk_label_set_markup_with_mnemonic (GTK_LABEL (id_label), _("_Id"));
SP_EXCEPTION_INIT (&ex);
sp_object_setAttribute (SP_OBJECT (item), "id", id, &ex);
sp_document_done (SP_ACTIVE_DOCUMENT, SP_VERB_DIALOG_ITEM,
_("Set object ID"));
}
/* Retrieve the label widget for the object's label */
GtkWidget *label_entry = GTK_WIDGET(gtk_object_get_data (GTK_OBJECT (spw), "label"));
gchar *label = (gchar *)gtk_entry_get_text (GTK_ENTRY (label_entry));
g_assert(label != NULL);
/* Give feedback on success of setting the drawing object's label
* using the widget's label text
*/
SPObject *obj = (SPObject*)item;
if (strcmp (label, obj->defaultLabel())) {
obj->setLabel(label);
sp_document_done (SP_ACTIVE_DOCUMENT, SP_VERB_DIALOG_ITEM,
_("Set object label"));
}
/* Retrieve the title */
GtkWidget *w = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), "title"));
gchar *title = (gchar *)gtk_entry_get_text(GTK_ENTRY (w));
if (obj->setTitle(title))
sp_document_done(SP_ACTIVE_DOCUMENT, SP_VERB_DIALOG_ITEM,
_("Set object title"));
/* Retrieve the description */
GtkTextView *tv = GTK_TEXT_VIEW(gtk_object_get_data(GTK_OBJECT(spw), "desc"));
GtkTextBuffer *buf = gtk_text_view_get_buffer(tv);
GtkTextIter start, end;
gtk_text_buffer_get_bounds(buf, &start, &end);
gchar *desc = gtk_text_buffer_get_text(buf, &start, &end, TRUE);
if (obj->setDesc(desc))
sp_document_done(SP_ACTIVE_DOCUMENT, SP_VERB_DIALOG_ITEM,
_("Set object description"));
g_free(desc);
gtk_object_set_data (GTK_OBJECT (spw), "blocked", GUINT_TO_POINTER (FALSE));
} // end of sp_item_widget_label_changed()
GtkWidget* file_properties_dlg_new( GtkWindow* parent,
const char* dir_path,
GList* sel_files, int page )
{
GtkBuilder* builder = _gtk_builder_new_from_file( PACKAGE_UI_DIR "/file_properties.ui", NULL );
GtkWidget * dlg = (GtkWidget*)gtk_builder_get_object( builder, "dlg" );
GtkNotebook* notebook = (GtkNotebook*)gtk_builder_get_object( builder, "notebook" );
xset_set_window_icon( GTK_WINDOW( dlg ) );
FilePropertiesDialogData* data;
gboolean need_calc_size = TRUE;
VFSFileInfo *file, *file2;
VFSMimeType* mime;
const char* multiple_files = _( "( multiple files )" );
const char* calculating;
GtkWidget* name = (GtkWidget*)gtk_builder_get_object( builder, "file_name" );
GtkWidget* label_name = (GtkWidget*)gtk_builder_get_object( builder, "label_filename" );
GtkWidget* location = (GtkWidget*)gtk_builder_get_object( builder, "location" );
gtk_editable_set_editable ( GTK_EDITABLE( location ), FALSE );
GtkWidget* target = (GtkWidget*)gtk_builder_get_object( builder, "target" );
GtkWidget* label_target = (GtkWidget*)gtk_builder_get_object( builder, "label_target" );
gtk_editable_set_editable ( GTK_EDITABLE( target ), FALSE );
GtkWidget* mime_type = (GtkWidget*)gtk_builder_get_object( builder, "mime_type" );
GtkWidget* open_with = (GtkWidget*)gtk_builder_get_object( builder, "open_with" );
char buf[ 64 ];
char buf2[ 32 ];
const char* time_format = "%Y-%m-%d %H:%M:%S";
gchar* disp_path;
gchar* file_type;
int i;
GList* l;
gboolean same_type = TRUE;
gboolean is_dirs = FALSE;
char *owner_group, *tmp;
gtk_dialog_set_alternative_button_order( GTK_DIALOG(dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1 );
ptk_dialog_fit_small_screen( GTK_DIALOG(dlg) );
int width = xset_get_int( "app_dlg", "s" );
int height = xset_get_int( "app_dlg", "z" );
if ( width && height )
gtk_window_set_default_size( GTK_WINDOW( dlg ), width, -1 );
data = g_slice_new0( FilePropertiesDialogData );
/* FIXME: When will the data be freed??? */
g_object_set_data( G_OBJECT( dlg ), "DialogData", data );
data->file_list = sel_files;
data->dlg = dlg;
data->dir_path = g_strdup( dir_path );
disp_path = g_filename_display_name( dir_path );
//gtk_label_set_text( GTK_LABEL( location ), disp_path );
gtk_entry_set_text( GTK_ENTRY( location ), disp_path );
g_free( disp_path );
data->total_size_label = GTK_LABEL( (GtkWidget*)gtk_builder_get_object( builder, "total_size" ) );
data->size_on_disk_label = GTK_LABEL( (GtkWidget*)gtk_builder_get_object( builder, "size_on_disk" ) );
data->count_label = GTK_LABEL( (GtkWidget*)gtk_builder_get_object( builder, "count" ) );
data->owner = GTK_ENTRY( (GtkWidget*)gtk_builder_get_object( builder, "owner" ) );
data->group = GTK_ENTRY( (GtkWidget*)gtk_builder_get_object( builder, "group" ) );
data->mtime = GTK_ENTRY( (GtkWidget*)gtk_builder_get_object( builder, "mtime" ) );
data->atime = GTK_ENTRY( (GtkWidget*)gtk_builder_get_object( builder, "atime" ) );
for ( i = 0; i < N_CHMOD_ACTIONS; ++i )
{
data->chmod_btns[ i ] = GTK_TOGGLE_BUTTON( (GtkWidget*)gtk_builder_get_object( builder, chmod_names[ i ] ) );
}
//MOD
VFSMimeType* type;
VFSMimeType* type2 = NULL;
for ( l = sel_files; l ; l = l->next )
{
file = ( VFSFileInfo* ) l->data;
type = vfs_file_info_get_mime_type( file );
if ( !type2 )
type2 = vfs_file_info_get_mime_type( file );
if ( vfs_file_info_is_dir( file ) )
is_dirs = TRUE;
if ( type != type2 )
same_type = FALSE;
vfs_mime_type_unref( type );
if ( is_dirs && !same_type )
break;
}
if ( type2 )
vfs_mime_type_unref( type2 );
data->recurse = (GtkWidget*)gtk_builder_get_object( builder, "recursive" );
gtk_widget_set_sensitive( data->recurse, is_dirs );
/* //MOD
for ( l = sel_files; l && l->next; l = l->next )
{
VFSMimeType *type, *type2;
file = ( VFSFileInfo* ) l->data;
file2 = ( VFSFileInfo* ) l->next->data;
type = vfs_file_info_get_mime_type( file );
type2 = vfs_file_info_get_mime_type( file2 );
if ( type != type2 )
{
vfs_mime_type_unref( type );
vfs_mime_type_unref( type2 );
same_type = FALSE;
break;
}
vfs_mime_type_unref( type );
vfs_mime_type_unref( type2 );
}
*/
file = ( VFSFileInfo* ) sel_files->data;
if ( same_type )
{
mime = vfs_file_info_get_mime_type( file );
file_type = g_strdup_printf( "%s\n%s",
vfs_mime_type_get_description( mime ),
vfs_mime_type_get_type( mime ) );
gtk_label_set_text( GTK_LABEL( mime_type ), file_type );
g_free( file_type );
vfs_mime_type_unref( mime );
}
else
{
gtk_label_set_text( GTK_LABEL( mime_type ), _( "( multiple types )" ) );
}
/* Open with...
* Don't show this option menu if files of different types are selected,
* ,the selected file is a folder, or its type is unknown.
*/
if( ! same_type ||
vfs_file_info_is_desktop_entry( file ) ||
/* vfs_file_info_is_unknown_type( file ) || */
vfs_file_info_is_executable( file, NULL ) )
{
/* if open with shouldn't show, destroy it. */
gtk_widget_destroy( open_with );
open_with = NULL;
gtk_widget_destroy( (GtkWidget*)gtk_builder_get_object( builder, "open_with_label" ) );
}
else /* Add available actions to the option menu */
{
GtkTreeIter it;
char **action, **actions;
mime = vfs_file_info_get_mime_type( file );
actions = vfs_mime_type_get_actions( mime );
GtkCellRenderer* renderer;
GtkListStore* model;
gtk_cell_layout_clear( GTK_CELL_LAYOUT(open_with) );
renderer = gtk_cell_renderer_pixbuf_new();
gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(open_with), renderer, FALSE);
gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT(open_with), renderer,
"pixbuf", 0, NULL );
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(open_with), renderer, TRUE);
gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT(open_with),renderer,
"text", 1, NULL );
model = gtk_list_store_new( 3, GDK_TYPE_PIXBUF,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING );
if( actions )
{
for( action = actions; *action; ++action )
{
VFSAppDesktop* desktop;
GdkPixbuf* icon;
desktop = vfs_app_desktop_new( *action );
gtk_list_store_append( model, &it );
icon = vfs_app_desktop_get_icon(desktop, 20, TRUE);
gtk_list_store_set( model, &it,
0, icon,
1, vfs_app_desktop_get_disp_name(desktop),
2, *action, -1 );
if( icon )
g_object_unref( icon );
vfs_app_desktop_unref( desktop );
}
}
else
{
g_object_set_data( G_OBJECT(open_with), "prev_sel", GINT_TO_POINTER(-1) );
}
/* separator */
gtk_list_store_append( model, &it );
gtk_list_store_append( model, &it );
gtk_list_store_set( model, &it,
0, NULL,
1, _("Choose..."), -1 );
gtk_combo_box_set_model( GTK_COMBO_BOX(open_with),
GTK_TREE_MODEL(model) );
gtk_combo_box_set_row_separator_func(
GTK_COMBO_BOX(open_with), combo_sep,
NULL, NULL );
gtk_combo_box_set_active(GTK_COMBO_BOX(open_with), 0);
g_signal_connect( open_with, "changed",
G_CALLBACK(on_combo_change), mime );
/* vfs_mime_type_unref( mime ); */
/* We can unref mime when combo box gets destroyed */
g_object_weak_ref( G_OBJECT(open_with),
(GWeakNotify)vfs_mime_type_unref, mime );
}
g_object_set_data( G_OBJECT(dlg), "open_with", open_with );
/* Multiple files are selected */
if ( sel_files && sel_files->next )
{
gtk_widget_set_sensitive( name, FALSE );
gtk_entry_set_text( GTK_ENTRY( name ), multiple_files );
data->orig_mtime = NULL;
data->orig_atime = NULL;
for ( i = 0; i < N_CHMOD_ACTIONS; ++i )
{
gtk_toggle_button_set_inconsistent ( data->chmod_btns[ i ], TRUE );
data->chmod_states[ i ] = 2; /* Don't touch this bit */
g_signal_connect( G_OBJECT( data->chmod_btns[ i ] ), "toggled",
G_CALLBACK( on_chmod_btn_toggled ), data );
}
}
else
{
/* special processing for files with special display names */
if( vfs_file_info_is_desktop_entry( file ) )
{
char* disp_name = g_filename_display_name( file->name );
gtk_entry_set_text( GTK_ENTRY( name ),
disp_name );
g_free( disp_name );
}
else
{
if ( vfs_file_info_is_dir( file ) &&
!vfs_file_info_is_symlink( file ) )
gtk_label_set_markup_with_mnemonic( GTK_LABEL( label_name ),
_("<b>Folder _Name:</b>") );
gtk_entry_set_text( GTK_ENTRY( name ),
vfs_file_info_get_disp_name( file ) );
}
gtk_editable_set_editable ( GTK_EDITABLE( name ), FALSE );
if ( ! vfs_file_info_is_dir( file ) )
{
/* Only single "file" is selected, so we don't need to
caculate total file size */
need_calc_size = FALSE;
sprintf( buf, _("%s ( %lu bytes )"),
vfs_file_info_get_disp_size( file ),
( guint64 ) vfs_file_info_get_size( file ) );
gtk_label_set_text( data->total_size_label, buf );
vfs_file_size_to_string( buf2,
vfs_file_info_get_blocks( file ) * 512 );
sprintf( buf, _("%s ( %lu bytes )"), buf2,
( guint64 ) vfs_file_info_get_blocks( file ) * 512 );
gtk_label_set_text( data->size_on_disk_label, buf );
gtk_label_set_text( data->count_label, _("1 file") );
}
// Modified / Accessed
//gtk_entry_set_text( GTK_ENTRY( mtime ),
// vfs_file_info_get_disp_mtime( file ) );
strftime( buf, sizeof( buf ),
time_format, localtime( vfs_file_info_get_mtime( file ) ) );
gtk_entry_set_text( GTK_ENTRY( data->mtime ), buf );
data->orig_mtime = g_strdup( buf );
strftime( buf, sizeof( buf ),
time_format, localtime( vfs_file_info_get_atime( file ) ) );
gtk_entry_set_text( GTK_ENTRY( data->atime ), buf );
data->orig_atime = g_strdup( buf );
// Permissions
owner_group = (char *) vfs_file_info_get_disp_owner( file );
tmp = strchr( owner_group, ':' );
data->owner_name = g_strndup( owner_group, tmp - owner_group );
gtk_entry_set_text( GTK_ENTRY( data->owner ), data->owner_name );
data->group_name = g_strdup( tmp + 1 );
gtk_entry_set_text( GTK_ENTRY( data->group ), data->group_name );
for ( i = 0; i < N_CHMOD_ACTIONS; ++i )
{
if ( data->chmod_states[ i ] != 2 ) /* allow to touch this bit */
{
data->chmod_states[ i ] = ( vfs_file_info_get_mode( file ) & chmod_flags[ i ] ? 1 : 0 );
gtk_toggle_button_set_active( data->chmod_btns[ i ], data->chmod_states[ i ] );
}
}
// target
if ( vfs_file_info_is_symlink( file ) )
{
gtk_label_set_markup_with_mnemonic( GTK_LABEL( label_name ),
_("<b>Link _Name:</b>") );
disp_path = g_build_filename( dir_path, file->name, NULL );
char* target_path = g_file_read_link( disp_path, NULL );
if ( target_path )
{
gtk_entry_set_text( GTK_ENTRY( target ), target_path );
if ( target_path[0] && target_path[0] != '/' )
{
// relative link to absolute
char* str = target_path;
target_path = g_build_filename( dir_path, str, NULL );
g_free( str );
}
if ( !g_file_test( target_path, G_FILE_TEST_EXISTS ) )
gtk_label_set_text( GTK_LABEL( mime_type ),
_("( broken link )") );
g_free( target_path );
}
else
gtk_entry_set_text( GTK_ENTRY( target ), _("( read link error )") );
g_free( disp_path );
gtk_widget_show( target );
gtk_widget_show( label_target );
}
}
if ( need_calc_size )
{
/* The total file size displayed in "File Properties" is not
completely calculated yet. So "Calculating..." is displayed. */
calculating = _( "Calculating..." );
gtk_label_set_text( data->total_size_label, calculating );
gtk_label_set_text( data->size_on_disk_label, calculating );
g_object_set_data( G_OBJECT( dlg ), "calc_size", data );
data->calc_size_thread = g_thread_create ( ( GThreadFunc ) calc_size,
data, TRUE, NULL );
data->update_label_timer = g_timeout_add( 250,
( GSourceFunc ) on_update_labels,
data );
}
g_signal_connect( dlg, "response",
G_CALLBACK(on_dlg_response), dlg );
g_signal_connect_swapped( gtk_builder_get_object(builder, "ok_button"),
"clicked",
G_CALLBACK(gtk_widget_destroy), dlg );
g_signal_connect_swapped( gtk_builder_get_object(builder, "cancel_button"),
"clicked",
G_CALLBACK(gtk_widget_destroy), dlg );
g_object_unref( builder );
gtk_notebook_set_current_page( notebook, page );
gtk_window_set_transient_for( GTK_WINDOW( dlg ), parent );
return dlg;
}
void TextMenuItemAccelerator::setAccelerator(const std::string& newAccel) {
if (_accel != NULL) {
_accelLabelText = newAccel;
gtk_label_set_markup_with_mnemonic(GTK_LABEL(_accel), newAccel.c_str());
}
}
