GtkWidget *make_filebrowser(const gchar *title, gboolean save)
{
GtkWidget *dialog;
GtkWidget *button;
g_return_val_if_fail(title != NULL, NULL);
dialog =
gtk_file_chooser_dialog_new(title, GTK_WINDOW(mainwin),
save ? GTK_FILE_CHOOSER_ACTION_SAVE :
GTK_FILE_CHOOSER_ACTION_OPEN, NULL, NULL);
button =
gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT);
gtk_button_set_use_stock(GTK_BUTTON(button), TRUE);
gtk_widget_set_can_default (button, TRUE);
button =
gtk_dialog_add_button(GTK_DIALOG(dialog),
save ? GTK_STOCK_SAVE : GTK_STOCK_OPEN,
GTK_RESPONSE_ACCEPT);
gtk_button_set_use_stock(GTK_BUTTON(button), TRUE);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER); /* centering */
return dialog;
}
void wxButton::SetLabel( const wxString &lbl )
{
wxCHECK_RET( m_widget != NULL, wxT("invalid button") );
wxString label(lbl);
if (label.empty() && wxIsStockID(m_windowId))
label = wxGetStockLabel(m_windowId);
wxControl::SetLabel(label);
const wxString labelGTK = GTKConvertMnemonics(label);
if (wxIsStockID(m_windowId) && wxIsStockLabel(m_windowId, label))
{
const char *stock = wxGetStockGtkID(m_windowId);
if (stock)
{
gtk_button_set_label(GTK_BUTTON(m_widget), stock);
gtk_button_set_use_stock(GTK_BUTTON(m_widget), TRUE);
return;
}
}
gtk_button_set_label(GTK_BUTTON(m_widget), wxGTK_CONV(labelGTK));
gtk_button_set_use_stock(GTK_BUTTON(m_widget), FALSE);
ApplyWidgetStyle( false );
}
void wxButton::SetLabel( const wxString &lbl )
{
wxCHECK_RET( m_widget != NULL, wxT("invalid button") );
wxString label(lbl);
if (label.empty() && wxIsStockID(m_windowId))
label = wxGetStockLabel(m_windowId);
wxControl::SetLabel(label);
#ifdef __WXGTK20__
if (wxIsStockID(m_windowId) && wxIsStockLabel(m_windowId, label))
{
const char *stock = wxGetStockGtkID(m_windowId);
if (stock)
{
gtk_button_set_label(GTK_BUTTON(m_widget), stock);
gtk_button_set_use_stock(GTK_BUTTON(m_widget), TRUE);
return;
}
}
wxString label2 = PrepareLabelMnemonics(label);
gtk_button_set_label(GTK_BUTTON(m_widget), wxGTK_CONV(label2));
gtk_button_set_use_stock(GTK_BUTTON(m_widget), FALSE);
ApplyWidgetStyle( false );
#else
gtk_label_set(GTK_LABEL(BUTTON_CHILD(m_widget)), wxGTK_CONV(GetLabel()));
#endif
}
/****f* widget/gnoclConfigLinkButtonText
* AUTHOR
* PGB
* SOURCE
*/
int gnoclConfigLinkButtonText ( Tcl_Interp *interp, GtkWidget *widget, Tcl_Obj *txtObj )
{
GnoclStringType type = gnoclGetStringType ( txtObj );
if ( type & GNOCL_STR_STOCK )
{
GtkStockItem sp;
if ( gnoclGetStockItem ( txtObj, interp, &sp ) != TCL_OK )
return TCL_ERROR;
gtk_button_set_label ( widget, sp.stock_id );
gtk_button_set_use_stock ( widget, 1 );
}
else
{
GtkLabel *label;
char *txt = gnoclGetString ( txtObj );
gtk_button_set_label ( widget, txt );
gtk_button_set_use_stock ( widget, 0 );
label = GTK_LABEL ( gnoclFindChild ( GTK_WIDGET ( widget ), GTK_TYPE_LABEL ) );
assert ( label );
/* TODO? pango_parse_markup for error message */
gtk_label_set_use_markup ( label, ( type & GNOCL_STR_MARKUP ) != 0 );
gtk_label_set_use_underline ( label, ( type & GNOCL_STR_UNDERLINE ) != 0 );
}
return TCL_OK;
}
void
empathy_new_individual_dialog_show_with_individual (GtkWindow *parent,
FolksIndividual *individual)
{
GtkWidget *dialog;
GtkWidget *button;
EmpathyContact *contact = NULL;
GtkWidget *contact_widget;
g_return_if_fail (individual == NULL || FOLKS_IS_INDIVIDUAL (individual));
if (new_individual_dialog)
{
gtk_window_present (GTK_WINDOW (new_individual_dialog));
return;
}
/* Create dialog */
dialog = gtk_dialog_new ();
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_window_set_title (GTK_WINDOW (dialog), _("New Contact"));
/* Cancel button */
button = gtk_button_new_with_label (GTK_STOCK_CANCEL);
gtk_button_set_use_stock (GTK_BUTTON (button), TRUE);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button,
GTK_RESPONSE_CANCEL);
gtk_widget_show (button);
/* Add button */
button = gtk_button_new_with_label (GTK_STOCK_ADD);
gtk_button_set_use_stock (GTK_BUTTON (button), TRUE);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button, GTK_RESPONSE_OK);
gtk_widget_show (button);
/* Contact info widget */
if (individual != NULL)
contact = empathy_contact_dup_from_folks_individual (individual);
contact_widget = empathy_contact_widget_new (contact);
gtk_container_set_border_width (GTK_CONTAINER (contact_widget), 8);
gtk_box_pack_start (
GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
contact_widget, TRUE, TRUE, 0);
empathy_contact_widget_set_account_filter (contact_widget,
can_add_contact_to_account, NULL);
gtk_widget_show (contact_widget);
new_individual_dialog = dialog;
g_signal_connect (dialog, "response", G_CALLBACK (new_individual_response_cb),
contact_widget);
if (parent != NULL)
gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
gtk_widget_show (dialog);
tp_clear_object (&contact);
}
void
empathy_new_contact_dialog_show (GtkWindow *parent)
{
GtkWidget *dialog;
GtkWidget *button;
GtkWidget *contact_widget;
if (new_contact_dialog) {
gtk_window_present (GTK_WINDOW (new_contact_dialog));
return;
}
/* Create dialog */
dialog = gtk_dialog_new ();
gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_window_set_title (GTK_WINDOW (dialog), _("New Contact"));
/* Cancel button */
button = gtk_button_new_with_label (GTK_STOCK_CANCEL);
gtk_button_set_use_stock (GTK_BUTTON (button), TRUE);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog),
button,
GTK_RESPONSE_CANCEL);
gtk_widget_show (button);
/* Add button */
button = gtk_button_new_with_label (GTK_STOCK_ADD);
gtk_button_set_use_stock (GTK_BUTTON (button), TRUE);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog),
button,
GTK_RESPONSE_OK);
gtk_widget_show (button);
/* Contact info widget */
contact_widget = empathy_contact_widget_new (NULL,
EMPATHY_CONTACT_WIDGET_EDIT_ALIAS |
EMPATHY_CONTACT_WIDGET_EDIT_ACCOUNT |
EMPATHY_CONTACT_WIDGET_EDIT_ID |
EMPATHY_CONTACT_WIDGET_EDIT_GROUPS);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
contact_widget,
TRUE, TRUE, 0);
empathy_contact_widget_set_account_filter (contact_widget,
can_add_contact_to_account,
NULL);
gtk_widget_show (contact_widget);
new_contact_dialog = dialog;
g_signal_connect (dialog, "response",
G_CALLBACK (new_contact_response_cb),
contact_widget);
if (parent) {
gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
}
gtk_widget_show (dialog);
}
static VALUE
tbtn_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE label, use_underline;
GtkWidget *widget;
if (rb_scan_args(argc, argv, "02", &label, &use_underline) > 0) {
if (TYPE(label) == T_STRING){
if (NIL_P(use_underline) || RVAL2CBOOL(use_underline)){
widget = gtk_toggle_button_new_with_mnemonic(RVAL2CSTR(label));
} else {
widget = gtk_toggle_button_new_with_label(RVAL2CSTR(label));
}
} else if (TYPE(label) == T_SYMBOL){
widget = gtk_toggle_button_new_with_label(rb_id2name(SYM2ID(label)));
gtk_button_set_use_stock(GTK_BUTTON(widget), TRUE);
} else {
rb_raise(rb_eArgError, "invalid argument %s (expect Symbol(Gtk::Stock constants) or String)",
rb_class2name(CLASS_OF(label)));
}
} else {
widget = gtk_toggle_button_new();
}
RBGTK_INITIALIZE(self, widget);
return Qnil;
}
int main (int argc, char **argv)
{
GtkWidget *window, *button, *image;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
button = idol_glow_button_new ();
image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_PLAY, GTK_ICON_SIZE_MENU);
gtk_button_set_image (GTK_BUTTON (button), image);
#if 0
gtk_button_set_label (GTK_BUTTON (button), GTK_STOCK_MEDIA_PLAY);
gtk_button_set_use_stock (GTK_BUTTON (button), TRUE);
#endif
gtk_container_add (GTK_CONTAINER(window), button);
idol_glow_button_set_glow (IDOL_GLOW_BUTTON (button), TRUE);
// g_timeout_add_seconds (1, idle_cb, button);
g_timeout_add_seconds (5, idle_un_cb, button);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
void
vnr_message_area_show_with_button (VnrMessageArea *msg_area,
gboolean critical,
const char *message,
gboolean close_image,
const gchar *button_stock_id,
GCallback c_handler)
{
vnr_message_area_show_basic(msg_area, critical, message, close_image);
gtk_button_set_use_stock (GTK_BUTTON(msg_area->user_button), TRUE);
gtk_button_set_label (GTK_BUTTON(msg_area->user_button), button_stock_id);
if(msg_area->with_button)
g_signal_handlers_disconnect_by_func (msg_area->user_button,
msg_area->c_handler,
msg_area->vnr_win);
else
msg_area->with_button = TRUE;
msg_area->c_handler = c_handler;
g_signal_connect(msg_area->user_button, "clicked", c_handler, msg_area->vnr_win);
gtk_widget_show_all(GTK_WIDGET (msg_area->hbox));
}
static void udpate_widgets(GtkWidget *button, GtkWidget *spin)
{
gtk_button_set_use_stock(GTK_BUTTON(button), TRUE);
gtk_button_set_label(GTK_BUTTON(button), logger_enabled ? GTK_STOCK_STOP : GTK_STOCK_OK); // GTK_STOCK_START
gtk_widget_set_sensitive(spin, !logger_enabled);
}
static void
gtk_button_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkButton *button;
button = GTK_BUTTON (object);
switch (prop_id)
{
case PROP_LABEL:
gtk_button_set_label (button, g_value_get_string (value));
break;
case PROP_RELIEF:
gtk_button_set_relief (button, g_value_get_enum (value));
break;
case PROP_USE_UNDERLINE:
gtk_button_set_use_underline (button, g_value_get_boolean (value));
break;
case PROP_USE_STOCK:
gtk_button_set_use_stock (button, g_value_get_boolean (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
void
empathy_contact_information_dialog_show (EmpathyContact *contact,
GtkWindow *parent)
{
GtkWidget *dialog;
GtkWidget *button;
GtkWidget *contact_widget;
GList *l;
g_return_if_fail (EMPATHY_IS_CONTACT (contact));
l = g_list_find_custom (information_dialogs,
contact,
(GCompareFunc) contact_dialogs_find);
if (l) {
gtk_window_present (GTK_WINDOW (l->data));
return;
}
/* Create dialog */
dialog = gtk_dialog_new ();
gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_window_set_title (GTK_WINDOW (dialog),
empathy_contact_get_name (contact));
/* Close button */
button = gtk_button_new_with_label (GTK_STOCK_CLOSE);
gtk_button_set_use_stock (GTK_BUTTON (button), TRUE);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog),
button,
GTK_RESPONSE_CLOSE);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_window_set_default (GTK_WINDOW (dialog), button);
gtk_widget_show (button);
/* Contact info widget */
contact_widget = empathy_contact_widget_new (contact,
EMPATHY_CONTACT_WIDGET_SHOW_LOCATION |
EMPATHY_CONTACT_WIDGET_EDIT_NONE);
gtk_container_set_border_width (GTK_CONTAINER (contact_widget), 8);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
contact_widget,
TRUE, TRUE, 0);
gtk_widget_show (contact_widget);
g_object_set_data (G_OBJECT (dialog), "contact_widget", contact_widget);
information_dialogs = g_list_prepend (information_dialogs, dialog);
g_signal_connect (dialog, "response",
G_CALLBACK (contact_dialogs_response_cb),
&information_dialogs);
if (parent) {
gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
}
gtk_widget_show (dialog);
}
gboolean
pluma_file_browser_utils_confirmation_dialog (PlumaWindow * window,
GtkMessageType type,
gchar const *message,
gchar const *secondary,
gchar const * button_stock,
gchar const * button_label)
{
GtkWidget *dlg;
gint ret;
GtkWidget *button;
dlg = gtk_message_dialog_new (GTK_WINDOW (window),
GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT,
type,
GTK_BUTTONS_NONE, "%s", message);
if (secondary)
gtk_message_dialog_format_secondary_text
(GTK_MESSAGE_DIALOG (dlg), "%s", secondary);
/* Add a cancel button */
button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
gtk_widget_show (button);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_set_can_default (button, TRUE);
#else
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
#endif
gtk_dialog_add_action_widget (GTK_DIALOG (dlg),
button,
GTK_RESPONSE_CANCEL);
/* Add custom button */
button = gtk_button_new_from_stock (button_stock);
if (button_label) {
gtk_button_set_use_stock (GTK_BUTTON (button), FALSE);
gtk_button_set_label (GTK_BUTTON (button), button_label);
}
gtk_widget_show (button);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_set_can_default (button, TRUE);
#else
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
#endif
gtk_dialog_add_action_widget (GTK_DIALOG (dlg),
button,
GTK_RESPONSE_OK);
ret = gtk_dialog_run (GTK_DIALOG (dlg));
gtk_widget_destroy (dlg);
return (ret == GTK_RESPONSE_OK);
}
/**
* mcm_calibrate_set_button_ok_id:
**/
void
mcm_calibrate_dialog_set_button_ok_id (McmCalibrateDialog *calibrate_dialog, const gchar *button_id)
{
GtkWidget *widget;
McmCalibrateDialogPrivate *priv = calibrate_dialog->priv;
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "button_ok"));
gtk_button_set_label (GTK_BUTTON (widget), button_id);
gtk_button_set_use_stock (GTK_BUTTON (widget), g_str_has_prefix (button_id, "gtk-"));
}
static void on_search_button_clicked(GtkButton *button,
gpointer user_data)
{
if (search_active) {
terminate_search = TRUE;
#ifdef HAVE_GTK_310
gtk_button_set_image((GtkButton *)remember_search,
gtk_image_new_from_icon_name("edit-find-symbolic", GTK_ICON_SIZE_BUTTON));
#else
gtk_button_set_label((GtkButton *)remember_search,
"gtk-find");
gtk_button_set_use_stock((GtkButton *)remember_search,
TRUE);
#endif
sync_windows();
} else {
#ifdef HAVE_GTK_310
gtk_button_set_image((GtkButton *)remember_search,
gtk_image_new_from_icon_name("process-stop-symbolic",
GTK_ICON_SIZE_BUTTON));
#else
gtk_button_set_label((GtkButton *)remember_search,
"gtk-stop");
gtk_button_set_use_stock((GtkButton *)remember_search,
TRUE);
#endif
// do the search
main_do_sidebar_search(user_data);
#ifdef HAVE_GTK_310
gtk_button_set_image((GtkButton *)remember_search,
gtk_image_new_from_icon_name("edit-find-symbolic", GTK_ICON_SIZE_BUTTON));
#else
gtk_button_set_label((GtkButton *)remember_search,
"gtk-find");
gtk_button_set_use_stock((GtkButton *)remember_search,
TRUE);
#endif
}
}
void wxButton::SetLabel( const wxString &lbl )
{
wxCHECK_RET( m_widget != NULL, wxT("invalid button") );
wxString label(lbl);
if (label.empty() && wxIsStockID(m_windowId))
label = wxGetStockLabel(m_windowId);
wxAnyButton::SetLabel(label);
// don't use label if it was explicitly disabled
if ( HasFlag(wxBU_NOTEXT) )
return;
#if !defined(__WXGTK3__) || !GTK_CHECK_VERSION(3,10,0)
if (wxIsStockID(m_windowId) && wxIsStockLabel(m_windowId, label))
{
const char *stock = wxGetStockGtkID(m_windowId);
if (stock)
{
gtk_button_set_label(GTK_BUTTON(m_widget), stock);
gtk_button_set_use_stock(GTK_BUTTON(m_widget), TRUE);
return;
}
}
#endif // GTK < 3.10
// this call is necessary if the button had been initially created without
// a (text) label -- then we didn't use gtk_button_new_with_mnemonic() and
// so "use-underline" GtkButton property remained unset
gtk_button_set_use_underline(GTK_BUTTON(m_widget), TRUE);
const wxString labelGTK = GTKConvertMnemonics(label);
gtk_button_set_label(GTK_BUTTON(m_widget), wxGTK_CONV(labelGTK));
#if !defined(__WXGTK3__) || !GTK_CHECK_VERSION(3,10,0)
gtk_button_set_use_stock(GTK_BUTTON(m_widget), FALSE);
#endif // GTK < 3.10
GTKApplyWidgetStyle( false );
}
void
empathy_contact_personal_dialog_show (GtkWindow *parent)
{
GtkWidget *button;
GtkWidget *contact_widget;
if (personal_dialog) {
gtk_window_present (GTK_WINDOW (personal_dialog));
return;
}
/* Create dialog */
personal_dialog = gtk_dialog_new ();
gtk_dialog_set_has_separator (GTK_DIALOG (personal_dialog), FALSE);
gtk_window_set_resizable (GTK_WINDOW (personal_dialog), FALSE);
gtk_window_set_title (GTK_WINDOW (personal_dialog), _("Personal Information"));
/* Close button */
button = gtk_button_new_with_label (GTK_STOCK_CLOSE);
gtk_button_set_use_stock (GTK_BUTTON (button), TRUE);
gtk_dialog_add_action_widget (GTK_DIALOG (personal_dialog),
button,
GTK_RESPONSE_CLOSE);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_window_set_default (GTK_WINDOW (personal_dialog), button);
gtk_widget_show (button);
/* Contact info widget */
contact_widget = empathy_contact_widget_new (NULL,
EMPATHY_CONTACT_WIDGET_EDIT_ACCOUNT |
EMPATHY_CONTACT_WIDGET_EDIT_ALIAS |
EMPATHY_CONTACT_WIDGET_EDIT_AVATAR);
gtk_container_set_border_width (GTK_CONTAINER (contact_widget), 8);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (personal_dialog)->vbox),
contact_widget,
TRUE, TRUE, 0);
empathy_contact_widget_set_account_filter (contact_widget,
empathy_account_chooser_filter_is_connected, NULL);
gtk_widget_show (contact_widget);
g_signal_connect (personal_dialog, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
g_object_add_weak_pointer (G_OBJECT (personal_dialog),
(gpointer) &personal_dialog);
if (parent) {
gtk_window_set_transient_for (GTK_WINDOW (personal_dialog), parent);
}
gtk_widget_show (personal_dialog);
}
/* the stock item for the button. */
int
clip_GTK_BUTTONSETUSESTOCK(ClipMachine * ClipMachineMemory)
{
C_widget *cbtn = _fetch_cw_arg(ClipMachineMemory);
gboolean use_stock = _clip_parl(ClipMachineMemory, 2);
CHECKCWID(cbtn, GTK_IS_BUTTON);
CHECKOPT(2, LOGICAL_type_of_ClipVarType);
gtk_button_set_use_stock(GTK_BUTTON(cbtn->widget), use_stock);
return 0;
err:
return 1;
}
static GtkWidget*
create_button(VALUE group, VALUE label, VALUE use_underline)
{
GtkWidget* widget = NULL;
if (TYPE(label) == T_STRING){
if (NIL_P(use_underline) || RVAL2CBOOL(use_underline)){
widget = gtk_radio_button_new_with_mnemonic_from_widget(_GROUP(group), RVAL2CSTR(label));
} else {
widget = gtk_radio_button_new_with_label_from_widget(_GROUP(group), RVAL2CSTR(label));
}
} else if (TYPE(label) == T_SYMBOL){
widget = gtk_radio_button_new_with_label_from_widget(_GROUP(group), rb_id2name(SYM2ID(label)));
gtk_button_set_use_stock(GTK_BUTTON(widget), TRUE);
} else if (NIL_P(label)){
widget = gtk_radio_button_new_from_widget(_GROUP(group));
} else {
rb_raise(rb_eArgError, "invalid argument %s (expect Symbol(Gtk::Stock constants) or String)",
rb_class2name(CLASS_OF(label)));
}
return widget;
}
static void
empathy_individual_edit_dialog_init (
EmpathyIndividualEditDialog *dialog)
{
GtkWidget *button;
EmpathyIndividualEditDialogPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (
dialog, EMPATHY_TYPE_INDIVIDUAL_EDIT_DIALOG,
EmpathyIndividualEditDialogPriv);
dialog->priv = priv;
priv->individual = NULL;
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_window_set_title (GTK_WINDOW (dialog), _("Edit Contact Information"));
/* Individual widget */
priv->individual_widget = empathy_individual_widget_new (priv->individual,
EMPATHY_INDIVIDUAL_WIDGET_EDIT_ALIAS |
EMPATHY_INDIVIDUAL_WIDGET_EDIT_GROUPS |
EMPATHY_INDIVIDUAL_WIDGET_EDIT_FAVOURITE);
gtk_container_set_border_width (GTK_CONTAINER (priv->individual_widget), 8);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (
GTK_DIALOG (dialog))), priv->individual_widget, TRUE, TRUE, 0);
gtk_widget_show (priv->individual_widget);
/* Close button */
button = gtk_button_new_with_label (GTK_STOCK_CLOSE);
gtk_button_set_use_stock (GTK_BUTTON (button), TRUE);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button,
GTK_RESPONSE_CLOSE);
gtk_widget_set_can_default (button, TRUE);
gtk_window_set_default (GTK_WINDOW (dialog), button);
gtk_widget_show (button);
g_signal_connect (dialog, "response",
G_CALLBACK (individual_dialogs_response_cb), &edit_dialogs);
}
static void
mucharmap_mini_font_selection_init (MucharmapMiniFontSelection *fontsel)
{
GtkCellRenderer *renderer;
GtkStyle *style;
AtkObject *accessib;
gtk_widget_ensure_style (GTK_WIDGET (fontsel));
style = gtk_widget_get_style (GTK_WIDGET (fontsel));
fontsel->font_desc = pango_font_description_copy (style->font_desc);
fontsel->default_size = -1;
fontsel->size_adj = gtk_adjustment_new (MIN_FONT_SIZE,
MIN_FONT_SIZE, MAX_FONT_SIZE, 1, 8, 0);
accessib = gtk_widget_get_accessible (GTK_WIDGET (fontsel));
atk_object_set_name (accessib, _("Font"));
gtk_box_set_spacing (GTK_BOX (fontsel), 6);
fontsel->family = gtk_combo_box_new ();
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (fontsel->family), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (fontsel->family), renderer,
"text", COL_FAMILIY,
NULL);
gtk_widget_show (fontsel->family);
accessib = gtk_widget_get_accessible (fontsel->family);
atk_object_set_name (accessib, _("Font Family"));
fontsel->bold = gtk_toggle_button_new_with_mnemonic (GTK_STOCK_BOLD);
gtk_button_set_use_stock (GTK_BUTTON (fontsel->bold), TRUE);
gtk_widget_show (fontsel->bold);
g_signal_connect (fontsel->bold, "toggled",
G_CALLBACK (bold_toggled), fontsel);
fontsel->italic = gtk_toggle_button_new_with_mnemonic (GTK_STOCK_ITALIC);
gtk_button_set_use_stock (GTK_BUTTON (fontsel->italic), TRUE);
gtk_widget_show (fontsel->italic);
g_signal_connect (fontsel->italic, "toggled",
G_CALLBACK (italic_toggled), fontsel);
fontsel->size = gtk_spin_button_new (GTK_ADJUSTMENT (fontsel->size_adj),
0, 0);
gtk_widget_show (fontsel->size);
accessib = gtk_widget_get_accessible (fontsel->size);
atk_object_set_name (accessib, _("Font Size"));
g_signal_connect (fontsel->size_adj, "value-changed",
G_CALLBACK (font_size_changed), fontsel);
fill_font_families_combo (fontsel);
gtk_combo_box_set_active (GTK_COMBO_BOX (fontsel->family), -1);
g_signal_connect (fontsel->family, "changed",
G_CALLBACK (family_combo_changed), fontsel);
gtk_box_pack_start (GTK_BOX (fontsel), fontsel->family, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (fontsel), fontsel->bold, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (fontsel), fontsel->italic, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (fontsel), fontsel->size, FALSE, FALSE, 0);
gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (fontsel->family), FALSE);
gtk_button_set_focus_on_click (GTK_BUTTON (fontsel->bold), FALSE);
gtk_button_set_focus_on_click (GTK_BUTTON (fontsel->italic), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (fontsel), 6);
gtk_widget_show_all (GTK_WIDGET (fontsel));
}
int fileio_load_archive(const char *filename, unsigned char **dataout, int *datasize, int *dataoffset, const char *filetoload, char *outname)
{
FILE *f;
unsigned char idbuf[4];
int filesFound = 0;
std::vector<char *> filelist; // list of files we can load in this archive
// default case: outname is filename
if (outname)
{
strcpy(outname, filename);
}
f = fopen(filename, "rb");
if (!f)
{
return 0; // no good
}
fread(idbuf, 4, 1, f);
fclose(f);
// printf("ID bytes %c %c %x %x\n", idbuf[0], idbuf[1], idbuf[2], idbuf[3]);
// Handle all archives with common libarchive code
if ((idbuf[0] == 'P') && (idbuf[1] == 'K') && (idbuf[2] == 0x03) && (idbuf[3] == 0x04) || // zip
((idbuf[0] == '7') && (idbuf[1] == 'z') && (idbuf[2] == 0xbc) && (idbuf[3] == 0xaf)) || // 7zip
((idbuf[0] == 0xfd) && (idbuf[1] == 0x37) && (idbuf[2] == 0x7a) && (idbuf[3] == 0x58)) || // txz
((idbuf[0] == 0x1f) && (idbuf[1] == 0x8b) && (idbuf[2] == 0x08) && (idbuf[3] == 0x00)) || // tgz
((idbuf[0] == 0x42) && (idbuf[1] == 0x5a) && (idbuf[2] == 0x68) && (idbuf[3] == 0x39)) // tbz
) {
a = archive_read_new();
archive_read_support_filter_all(a);
archive_read_support_format_all(a);
r = archive_read_open_filename(a, filename, 10240);
int64_t entry_size;
if (r != ARCHIVE_OK) {
print_message("Archive failed to open.");
}
while (archive_read_next_header(a, &entry) == ARCHIVE_OK) {
const char *currentFile = archive_entry_pathname(entry);
unsigned char *fileContents;
entry_size = archive_entry_size(entry);
fileContents = (unsigned char *)malloc(entry_size);
if (filetoload != NULL) {
if (!strcmp(currentFile, filetoload)) {
archive_read_data(a, fileContents, entry_size);
archive_read_data_skip(a);
r = archive_read_free(a);
*datasize = entry_size;
*dataout = fileContents;
*dataoffset = 0;
return 1;
}
}
else {
if (checkExtension(currentFile))
{
char *tmpstr;
tmpstr = (char *)malloc(strlen(currentFile)+1);
strcpy(tmpstr, currentFile);
// add to the file list
filelist.push_back(tmpstr);
filesFound++;
}
}
}
}
else if ((idbuf[0] == 'R') && (idbuf[1] == 'a') && (idbuf[2] == 'r') && (idbuf[3] == '!'))
{ // it's rar
print_message("Rar files are not supported.");
}
// if we found any files and weren't forced to load them, handle accordingly
if (filesFound)
{
// only 1 file found, just run it
if (filesFound == 1)
{
char fname[512];
strcpy(fname, filelist[0]);
free(filelist[0]);
filelist.clear();
strcpy(outname, fname);
return fileio_load_archive(filename, dataout, datasize, dataoffset, fname, NULL);
}
else // multiple files we can handle found, give the user a choice
{
int sel;
char fname[512];
GtkWidget *archselect = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW (archselect), "Pick game in archive");
gtk_window_set_modal(GTK_WINDOW (archselect), TRUE);
GtkWidget *archbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(archselect), archbox);
gtk_widget_show(archbox);
GtkWidget *scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(archbox), scrolledwindow, TRUE, TRUE, 0);
gtk_widget_set_size_request(scrolledwindow, 340, 340);
gtk_widget_show(scrolledwindow);
GtkWidget *buttonbox = gtk_widget_new(GTK_TYPE_BOX, "halign", GTK_ALIGN_END, NULL);
gtk_box_pack_start(GTK_BOX(archbox), buttonbox, FALSE, TRUE, 0);
gtk_widget_show(buttonbox);
GtkWidget *archtree = gtk_tree_view_new();
gtk_container_add(GTK_CONTAINER (scrolledwindow), archtree);
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW (archtree), FALSE);
g_signal_connect(G_OBJECT(archtree), "button_press_event", G_CALLBACK(check_list_double), NULL);
gtk_widget_show(archtree);
// set up our tree store
treestore = gtk_tree_store_new(1, G_TYPE_STRING);
// attach the store to the tree
gtk_tree_view_set_model(GTK_TREE_VIEW(archtree), GTK_TREE_MODEL(treestore));
for (int fn = 0; fn < filelist.size(); fn++)
{
gtk_tree_store_insert(treestore, &treeiters[fn], NULL, 999999);
gtk_tree_store_set(treestore, &treeiters[fn], 0, filelist[fn], -1);
}
// create a cell renderer using the stock text one
renderer = gtk_cell_renderer_text_new();
// create a display column using the renderer
column = gtk_tree_view_column_new_with_attributes ("NES file",
renderer,
"text", 0,
NULL);
// add the display column and renderer to the tree view
gtk_tree_view_append_column(GTK_TREE_VIEW (archtree), column);
GtkWidget *archcancel = gtk_widget_new(GTK_TYPE_BUTTON, "label", GTK_STOCK_CANCEL, "halign", GTK_ALIGN_END, "margin-top", 8, "margin-bottom", 8, "margin-right", 8, NULL);
gtk_button_set_use_stock(GTK_BUTTON(archcancel), TRUE);
gtk_box_pack_start(GTK_BOX(buttonbox), archcancel, FALSE, FALSE, 0);
gtk_widget_show(archcancel);
GtkWidget *archok = gtk_widget_new(GTK_TYPE_BUTTON, "label", GTK_STOCK_OK, "halign", GTK_ALIGN_END, "margin-top", 8, "margin-bottom", 8, "margin-right", 8, NULL);
gtk_button_set_use_stock(GTK_BUTTON(archok), TRUE);
gtk_box_pack_start(GTK_BOX(buttonbox), archok, FALSE, FALSE, 0);
gtk_widget_show(archok);
// get the selection object too
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(archtree));
g_signal_connect(G_OBJECT(archcancel), "clicked",
G_CALLBACK(on_archcancel_clicked), NULL);
g_signal_connect(G_OBJECT(archok), "clicked",
G_CALLBACK(on_archok_clicked), NULL);
g_signal_connect(G_OBJECT(archselect), "destroy",
G_CALLBACK(on_archselect_destroyed), NULL);
gtk_widget_show(archselect);
run_picker = true;
cancelled = false;
while (run_picker)
{
gtk_main_iteration_do(TRUE);
}
sel = find_current_selection();
gtk_widget_destroy(archselect);
// was something picked?
if ((sel != -1) && (!cancelled))
{
strcpy(fname, filelist[sel]);
}
// free all the temp filenames
for (int fn = 0; fn < filelist.size(); fn++)
{
free(filelist[fn]);
}
// and wipe the vector
filelist.clear();
if ((sel != -1) && (!cancelled))
{
if (outname)
{
strcpy(outname, fname);
}
return fileio_load_archive(filename, dataout, datasize, dataoffset, fname, NULL);
}
}
}
return 0;
}
static void
html_editor_paragraph_dialog_constructed (GObject *object)
{
GtkGrid *main_layout, *grid;
GtkWidget *widget;
EHTMLEditor *editor;
EHTMLEditorParagraphDialog *dialog;
/* Chain up to parent's method. */
G_OBJECT_CLASS (e_html_editor_paragraph_dialog_parent_class)->constructed (object);
dialog = E_HTML_EDITOR_PARAGRAPH_DIALOG (object);
editor = e_html_editor_dialog_get_editor (E_HTML_EDITOR_DIALOG (dialog));
main_layout = e_html_editor_dialog_get_container (E_HTML_EDITOR_DIALOG (dialog));
/* == General == */
widget = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (widget), _("<b>General</b>"));
gtk_misc_set_alignment (GTK_MISC (widget), 0, 0.5);
gtk_grid_attach (main_layout, widget, 0, 0, 1, 1);
grid = GTK_GRID (gtk_grid_new ());
gtk_grid_set_row_spacing (grid, 5);
gtk_grid_set_column_spacing (grid, 5);
gtk_grid_attach (main_layout, GTK_WIDGET (grid), 0, 1, 1, 1);
gtk_widget_set_margin_left (GTK_WIDGET (grid), 10);
/* Style */
widget = e_action_combo_box_new_with_action (
GTK_RADIO_ACTION (e_html_editor_get_action (editor, "style-normal")));
gtk_widget_set_hexpand (widget, TRUE);
gtk_grid_attach (grid, widget, 1, 0, 1, 1);
dialog->priv->style_combo = widget;
widget = gtk_label_new_with_mnemonic (_("_Style:"));
gtk_label_set_justify (GTK_LABEL (widget), GTK_JUSTIFY_RIGHT);
gtk_label_set_mnemonic_widget (GTK_LABEL (widget), dialog->priv->style_combo);
gtk_grid_attach (grid, widget, 0, 0, 1, 1);
/* == Alignment == */
widget = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (widget), _("<b>Alignment</b>"));
gtk_misc_set_alignment (GTK_MISC (widget), 0, 0.5);
gtk_grid_attach (main_layout, widget, 0, 2, 1, 1);
grid = GTK_GRID (gtk_grid_new ());
gtk_grid_set_row_spacing (grid, 5);
gtk_grid_set_column_spacing (grid, 5);
gtk_grid_attach (main_layout, GTK_WIDGET (grid), 0, 3, 1, 1);
gtk_widget_set_margin_left (GTK_WIDGET (grid), 10);
/* Left */
widget = gtk_toggle_button_new_with_label (_("_Left"));
gtk_button_set_use_stock (GTK_BUTTON (widget), TRUE);
gtk_activatable_set_related_action (
GTK_ACTIVATABLE (widget),
e_html_editor_get_action (editor, "justify-left"));
gtk_grid_attach (grid, widget, 0, 0, 1, 1);
dialog->priv->left_button = widget;
/* Center */
widget = gtk_toggle_button_new_with_label (_("_Center"));
gtk_button_set_use_stock (GTK_BUTTON (widget), TRUE);
gtk_grid_attach (grid, widget, 1, 0, 1, 1);
gtk_activatable_set_related_action (
GTK_ACTIVATABLE (widget),
e_html_editor_get_action (editor, "justify-center"));
dialog->priv->center_button = widget;
/* Right */
widget = gtk_toggle_button_new_with_label (_("_Right"));
gtk_button_set_use_stock (GTK_BUTTON (widget), TRUE);
gtk_grid_attach (grid, widget, 2, 0, 1, 1);
gtk_activatable_set_related_action (
GTK_ACTIVATABLE (widget),
e_html_editor_get_action (editor, "justify-right"));
dialog->priv->right_button = widget;
gtk_widget_show_all (GTK_WIDGET (main_layout));
}
bool gtkui_archive_handle(const char *filename, char *reqfile, size_t reqsize) {
// Select a filename to pull out of the archive
struct archive *a;
struct archive_entry *entry;
int r, numarchives = 0;
cancelled = false;
a = archive_read_new();
archive_read_support_filter_all(a);
archive_read_support_format_all(a);
r = archive_read_open_filename(a, filename, 10240);
// Test if it's actually an archive
if (r != ARCHIVE_OK) {
r = archive_read_free(a);
return false;
}
// If it is an archive, handle it
else {
// Don't try to bring up a GUI selector if the GUI is disabled
if (conf.misc_disable_gui) {
// Fill the treestore with the filenames
while (archive_read_next_header(a, &entry) == ARCHIVE_OK) {
const char *currentfile = archive_entry_pathname(entry);
if (nst_archive_checkext(currentfile)) {
snprintf(reqfile, reqsize, "%s", currentfile);
break;
}
}
archive_read_data_skip(a);
// Free the archive
r = archive_read_free(a);
return true;
}
// Set up the archive window
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreeSelection *selection;
archivewindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(archivewindow), "Choose File from Archive");
gtk_window_set_modal(GTK_WINDOW(archivewindow), TRUE);
GtkWidget *archivebox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(archivewindow), archivebox);
gtk_widget_show(archivebox);
GtkWidget *scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(archivebox), scrolledwindow, TRUE, TRUE, 0);
gtk_widget_set_size_request(scrolledwindow, 340, 340);
gtk_widget_show(scrolledwindow);
GtkWidget *buttonbox = gtk_widget_new(GTK_TYPE_BOX, "halign", GTK_ALIGN_END, NULL);
gtk_box_pack_start(GTK_BOX(archivebox), buttonbox, FALSE, TRUE, 0);
gtk_widget_show(buttonbox);
GtkWidget *treeview = gtk_tree_view_new();
gtk_container_add(GTK_CONTAINER(scrolledwindow), treeview);
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW (treeview), FALSE);
gtk_widget_show(treeview);
GtkTreeStore *treestore = gtk_tree_store_new(1, G_TYPE_STRING);
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(treestore));
// Fill the treestore with the filenames
while (archive_read_next_header(a, &entry) == ARCHIVE_OK) {
const char *currentfile = archive_entry_pathname(entry);
if (nst_archive_checkext(currentfile)) {
gtk_tree_store_append(treestore, &iter, NULL);
gtk_tree_store_set(treestore, &iter, 0, currentfile, -1);
numarchives++;
snprintf(reqfile, reqsize, "%s", currentfile);
}
archive_read_data_skip(a);
}
// Free the archive
r = archive_read_free(a);
// If there are no valid files in the archive, return
if (numarchives == 0) { return false; }
// If there's only one file, don't bring up the selector
else if (numarchives == 1) { return true; }
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes(
"NES file",
renderer,
"text", 0,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW (treeview), column);
GtkWidget *cancelbutton = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", GTK_STOCK_CANCEL,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_button_set_use_stock(GTK_BUTTON(cancelbutton), TRUE);
gtk_box_pack_start(GTK_BOX(buttonbox), cancelbutton, FALSE, FALSE, 0);
gtk_widget_show(cancelbutton);
GtkWidget *okbutton = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", GTK_STOCK_OK,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_button_set_use_stock(GTK_BUTTON(okbutton), TRUE);
gtk_box_pack_start(GTK_BOX(buttonbox), okbutton, FALSE, FALSE, 0);
gtk_widget_show(okbutton);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
g_signal_connect(G_OBJECT(okbutton), "clicked",
G_CALLBACK(gtkui_archive_ok), NULL);
g_signal_connect(G_OBJECT(cancelbutton), "clicked",
G_CALLBACK(gtkui_archive_cancel), NULL);
g_signal_connect(G_OBJECT(treeview), "row-activated",
G_CALLBACK(gtkui_archive_ok), NULL);
g_signal_connect(G_OBJECT(archivewindow), "destroy",
G_CALLBACK(gtkui_archive_cancel), NULL);
gtk_widget_show(archivewindow);
// Freeze the rest of the program until a selection is made
windowopen = true;
while (windowopen) {
gtk_main_iteration_do(TRUE);
if (cancelled) { return false; }
}
gchar *reqbuf;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
gtk_tree_selection_get_selected(selection, &model, &iter);
gtk_tree_model_get(model, &iter, 0, &reqbuf, -1);
gtk_widget_destroy(archivewindow);
snprintf(reqfile, reqsize, "%s", reqbuf);
return true;
}
return false;
}
void
empathy_contact_information_dialog_show (EmpathyContact *contact,
GtkWindow *parent,
gboolean edit,
gboolean is_user)
{
GtkWidget *dialog;
GtkWidget *button;
GtkWidget *contact_widget;
GList *l;
EmpathyContactWidgetFlags flags = 0;
g_return_if_fail (EMPATHY_IS_CONTACT (contact));
l = g_list_find_custom (information_dialogs,
contact,
(GCompareFunc) contact_dialogs_find);
if (l) {
gtk_window_present (GTK_WINDOW (l->data));
return;
}
/* Create dialog */
dialog = gtk_dialog_new ();
gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
if (is_user) {
gtk_window_set_title (GTK_WINDOW (dialog), _("Personal Information"));
}
else if (edit) {
gtk_window_set_title (GTK_WINDOW (dialog), _("Edit Contact Information"));
}
else {
gtk_window_set_title (GTK_WINDOW (dialog), _("Contact Information"));
}
/* Close button */
button = gtk_button_new_with_label (GTK_STOCK_CLOSE);
gtk_button_set_use_stock (GTK_BUTTON (button), TRUE);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog),
button,
GTK_RESPONSE_CLOSE);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_window_set_default (GTK_WINDOW (dialog), button);
gtk_widget_show (button);
/* Contact info widget */
if (edit) {
flags |= EMPATHY_CONTACT_WIDGET_EDIT_ALIAS;
}
if (is_user) {
flags |= EMPATHY_CONTACT_WIDGET_EDIT_ACCOUNT;
flags |= EMPATHY_CONTACT_WIDGET_EDIT_AVATAR;
}
if (!is_user && edit) {
flags |= EMPATHY_CONTACT_WIDGET_EDIT_GROUPS;
}
contact_widget = empathy_contact_widget_new (contact, flags);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
contact_widget,
TRUE, TRUE, 0);
if (flags & EMPATHY_CONTACT_WIDGET_EDIT_ACCOUNT) {
empathy_contact_widget_set_account_filter (contact_widget,
empathy_account_chooser_filter_is_connected,
NULL);
}
g_object_set_data (G_OBJECT (dialog), "contact_widget", contact_widget);
information_dialogs = g_list_prepend (information_dialogs, dialog);
g_signal_connect (dialog, "response",
G_CALLBACK (contact_information_response_cb),
contact_widget);
if (parent) {
gtk_window_set_transient_for (GTK_WINDOW (dialog), parent);
}
gtk_widget_show (dialog);
}
GtkWidget *gtkui_cheats() {
// Create the Cheats window
if (cheatwindow) { return NULL; }
cheatwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW (cheatwindow), "Cheat Manager");
GtkWidget *cheatbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(cheatwindow), cheatbox);
GtkWidget *scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), scrolledwindow, TRUE, TRUE, 0);
gtk_widget_set_size_request(scrolledwindow, 512, 256);
treeview = gtk_tree_view_new();
gtk_container_add(GTK_CONTAINER (scrolledwindow), treeview);
infobar = gtk_info_bar_new();
infolabel = gtk_widget_new(GTK_TYPE_LABEL,"label", "", NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), infobar, TRUE, TRUE, 0);
GtkWidget *content_area = gtk_info_bar_get_content_area(GTK_INFO_BAR(infobar));
gtk_box_pack_start(GTK_BOX(content_area), infolabel, TRUE, TRUE, 0);
GtkWidget *opensavebox = gtk_widget_new(GTK_TYPE_BOX, "halign", GTK_ALIGN_END, NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), opensavebox, FALSE, FALSE, 0);
GtkWidget *cheatopen = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", GTK_STOCK_OPEN,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_button_set_use_stock(GTK_BUTTON(cheatopen), TRUE);
gtk_box_pack_start(GTK_BOX(opensavebox), cheatopen, FALSE, FALSE, 0);
GtkWidget *cheatclear = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", GTK_STOCK_CLEAR,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_button_set_use_stock(GTK_BUTTON(cheatclear), TRUE);
gtk_box_pack_start(GTK_BOX(opensavebox), cheatclear, FALSE, FALSE, 0);
GtkWidget *cheatremove = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", GTK_STOCK_REMOVE,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_button_set_use_stock(GTK_BUTTON(cheatremove), TRUE);
gtk_box_pack_start(GTK_BOX(opensavebox), cheatremove, FALSE, FALSE, 0);
GtkWidget *descbox = gtk_widget_new(
GTK_TYPE_BOX,
"halign", GTK_ALIGN_END,
NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), descbox, FALSE, FALSE, 0);
GtkWidget *desclabel = gtk_widget_new(
GTK_TYPE_LABEL,
"label", "Description:",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-left", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(descbox), desclabel, FALSE, FALSE, 0);
descedit = gtk_widget_new(
GTK_TYPE_ENTRY,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(descbox), descedit, TRUE, TRUE, 0);
GtkWidget *ggbox = gtk_widget_new(
GTK_TYPE_BOX,
"halign", GTK_ALIGN_END,
NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), ggbox, FALSE, FALSE, 0);
GtkWidget *gglabel = gtk_widget_new(
GTK_TYPE_LABEL,
"label", "Game Genie:",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-left", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(ggbox), gglabel, FALSE, FALSE, 0);
ggedit = gtk_widget_new(
GTK_TYPE_ENTRY,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(ggbox), ggedit, TRUE, TRUE, 0);
GtkWidget *genieadd = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", GTK_STOCK_ADD,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_button_set_use_stock(GTK_BUTTON(genieadd), TRUE);
gtk_box_pack_start(GTK_BOX(ggbox), genieadd, FALSE, FALSE, 0);
GtkWidget *parbox = gtk_widget_new(
GTK_TYPE_BOX,
"halign", GTK_ALIGN_END,
NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), parbox, FALSE, FALSE, 0);
GtkWidget *parlabel = gtk_widget_new(
GTK_TYPE_LABEL,
"label", "Pro Action Rocky:",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-left", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(parbox), parlabel, FALSE, FALSE, 0);
paredit = gtk_widget_new(
GTK_TYPE_ENTRY,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(parbox), paredit, FALSE, FALSE, 0);
GtkWidget *paradd = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", GTK_STOCK_ADD,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_button_set_use_stock(GTK_BUTTON(paradd), TRUE);
gtk_box_pack_start(GTK_BOX(parbox), paradd, FALSE, FALSE, 0);
GtkWidget *cheatok = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", GTK_STOCK_OK,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_button_set_use_stock(GTK_BUTTON(cheatok), TRUE);
gtk_box_pack_start(GTK_BOX(cheatbox), cheatok, FALSE, FALSE, 0);
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(treeview), FALSE);
treestore = gtk_tree_store_new(5, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(treestore));
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
GtkCellRenderer *checkbox = gtk_cell_renderer_toggle_new();
GtkTreeViewColumn *column[5];
// create the display columns
column[0] = gtk_tree_view_column_new_with_attributes("Enable", checkbox, "active", 0, NULL);
column[1] = gtk_tree_view_column_new_with_attributes("Game Genie", renderer, "text", 1, NULL);
column[2] = gtk_tree_view_column_new_with_attributes("PAR", renderer, "text", 2, NULL);
column[3] = gtk_tree_view_column_new_with_attributes("Raw", renderer, "text", 3, NULL);
column[4] = gtk_tree_view_column_new_with_attributes("Description", renderer, "text", 4, NULL);
// add the display column and renderer to the tree view
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[0]);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[1]);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[2]);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[3]);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[4]);
gtkui_cheats_fill_tree(nstpaths.cheatpath);
/*g_signal_connect(G_OBJECT(checkbox), "toggled",
G_CALLBACK(gtkui_cheats_check), NULL);*/
g_signal_connect(G_OBJECT(treeview), "row-activated",
G_CALLBACK(gtkui_cheats_toggle), NULL);
g_signal_connect(G_OBJECT(cheatopen), "clicked",
G_CALLBACK(gtkui_cheats_load), NULL);
g_signal_connect(G_OBJECT(cheatclear), "clicked",
G_CALLBACK(gtkui_cheats_clear), NULL);
g_signal_connect(G_OBJECT(cheatremove), "clicked",
G_CALLBACK(gtkui_cheats_remove), NULL);
g_signal_connect(G_OBJECT(genieadd), "clicked",
G_CALLBACK(gtkui_cheats_gg_add), NULL);
g_signal_connect(G_OBJECT(paradd), "clicked",
G_CALLBACK(gtkui_cheats_par_add), NULL);
g_signal_connect(G_OBJECT(cheatok), "clicked",
G_CALLBACK(gtkui_cheats_ok), NULL);
g_signal_connect(G_OBJECT(cheatwindow), "destroy",
G_CALLBACK(gtkui_cheats_ok), NULL);
gtk_widget_show_all(cheatwindow);
gtk_widget_hide(infobar);
return cheatwindow;
}
/*
create_application_window - Creates the main application window
The window consists of a button bar ( containing a video format selector,
a pause button, a save still image button and the preferences button ).
Below the toolbar, place the video display widget
*/
GtkWidget *create_application_window( )
{
GtkWidget *_window;
GtkWidget *menu_bar;
GtkWidget *ugtk_display;
GtkWidget *ugtk_format_selection;
GtkWidget *widget;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *button_box;
GtkWidget *device_selection;
GtkWidget *scrolled_window;
GtkItemFactory *factory;
GtkAccelGroup *accel_group;
_window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
g_signal_connect( G_OBJECT( _window ), "destroy", G_CALLBACK( gtk_main_quit ), NULL);
gtk_window_set_default_size( GTK_WINDOW( _window ), 680, 560 );
vbox = gtk_vbox_new( 0,0 );
gtk_container_add( GTK_CONTAINER( _window ), vbox );
ugtk_display = unicapgtk_video_display_new( );
/* g_object_set( G_OBJECT( ugtk_display ), "scale-to-fit", TRUE, "backend", "xv", "backend_fourcc", UCIL_FOURCC( 'U', 'Y', 'V', 'Y' ), NULL ); */
g_object_set( G_OBJECT( ugtk_display ), "backend", "gtk", NULL );
g_object_set_data( G_OBJECT( _window ), "ugtk_display", ugtk_display );
g_object_set_data( G_OBJECT( ugtk_display ), "app-window", _window );
accel_group = gtk_accel_group_new();
factory = gtk_item_factory_new( GTK_TYPE_MENU_BAR, "<UnicapgtkSmallappMain>", accel_group );
gtk_item_factory_create_items( factory, nmenu_entries, menu_entries, ugtk_display );
gtk_window_add_accel_group( GTK_WINDOW( _window ), accel_group );
menu_bar = gtk_item_factory_get_widget( factory, "<UnicapgtkSmallappMain>" );
gtk_box_pack_start( GTK_BOX( vbox ), menu_bar, FALSE, TRUE, 0 );
hbox = gtk_hbox_new( 0, 0 );
gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 2 );
device_selection = unicapgtk_device_selection_new(FALSE);
g_signal_connect( G_OBJECT( device_selection ), "unicapgtk_device_selection_changed",
(GCallback)device_change_cb, ugtk_display );
gtk_box_pack_start_defaults( GTK_BOX( hbox ), device_selection );
ugtk_format_selection = unicapgtk_video_format_selection_new( );
gtk_box_pack_start_defaults( GTK_BOX( hbox ), ugtk_format_selection );
g_signal_connect( G_OBJECT( ugtk_format_selection ), "unicapgtk_video_format_changed",
G_CALLBACK( format_change_cb ), ugtk_display );
button_box = gtk_hbutton_box_new();
gtk_box_pack_start( GTK_BOX( hbox ), button_box, 0, 0, 0 );
widget = gtk_toggle_button_new_with_label( GTK_STOCK_MEDIA_PAUSE );
gtk_button_set_use_stock( GTK_BUTTON( widget ), TRUE );
gtk_container_add( GTK_CONTAINER( button_box ), widget );
g_signal_connect( G_OBJECT( widget ), "toggled", G_CALLBACK( pause_toggle_cb ), ugtk_display );
scrolled_window = gtk_scrolled_window_new( NULL, NULL );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolled_window ),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC );
gtk_box_pack_start( GTK_BOX( vbox ), scrolled_window, TRUE, TRUE, 2 );
gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW( scrolled_window ), ugtk_display );
gtk_widget_show_all( _window );
g_object_set_data( G_OBJECT( ugtk_display ), "format_selection", ugtk_format_selection );
g_object_set_data( G_OBJECT( ugtk_display ), "device_selection", device_selection );
return _window;
}
/****************************************************************
* qif_account_picker_dialog
*
* Select an account from the ones that the engine knows about,
* plus those that will be created by the QIF import. If the
* user clicks OK, map_entry is changed and TRUE is returned.
* If the clicks Cancel instead, FALSE is returned. Modal.
****************************************************************/
gboolean
qif_account_picker_dialog(QIFImportWindow * qif_wind, SCM map_entry)
{
QIFAccountPickerDialog * wind;
SCM gnc_name = scm_c_eval_string("qif-map-entry:gnc-name");
SCM set_gnc_name = scm_c_eval_string("qif-map-entry:set-gnc-name!");
SCM orig_acct = scm_call_1(gnc_name, map_entry);
int response;
GtkBuilder *builder;
GtkWidget *button;
wind = g_new0(QIFAccountPickerDialog, 1);
/* Save the map entry. */
wind->map_entry = map_entry;
scm_gc_protect_object(wind->map_entry);
/* Set the initial account to be selected. */
if (scm_is_string(orig_acct))
wind->selected_name = gnc_scm_to_utf8_string (orig_acct);
builder = gtk_builder_new();
gnc_builder_add_from_file (builder, "dialog-account-picker.glade", "QIF Import Account Picker");
/* Connect all the signals */
gtk_builder_connect_signals (builder, wind);
wind->dialog = GTK_WIDGET(gtk_builder_get_object (builder, "QIF Import Account Picker"));
wind->treeview = GTK_TREE_VIEW(gtk_builder_get_object (builder, "account_tree"));
wind->qif_wind = qif_wind;
{
GtkTreeStore *store;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
store = gtk_tree_store_new(NUM_ACCOUNT_COLS, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_BOOLEAN);
gtk_tree_view_set_model(wind->treeview, GTK_TREE_MODEL(store));
g_object_unref(store);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Account"),
renderer,
"text",
ACCOUNT_COL_NAME,
NULL);
g_object_set(column, "expand", TRUE, NULL);
gtk_tree_view_append_column(wind->treeview, column);
renderer = gtk_cell_renderer_toggle_new();
g_object_set(renderer, "activatable", FALSE, NULL);
column = gtk_tree_view_column_new_with_attributes(_("New?"),
renderer,
"active",
ACCOUNT_COL_CHECK,
NULL);
gtk_tree_view_append_column(wind->treeview, column);
selection = gtk_tree_view_get_selection(wind->treeview);
g_signal_connect(selection, "changed",
G_CALLBACK(gnc_ui_qif_account_picker_changed_cb), wind);
g_signal_connect(wind->treeview, "row-activated",
G_CALLBACK(gnc_ui_qif_account_picker_row_activated_cb),
wind);
}
g_signal_connect_after(wind->dialog, "map",
G_CALLBACK(gnc_ui_qif_account_picker_map_cb),
wind);
button = GTK_WIDGET(gtk_builder_get_object (builder, "newbutton"));
gtk_button_set_use_stock(GTK_BUTTON(button), TRUE);
/* this is to get the checkmarks set up right.. it will get called
* again after the window is mapped. */
build_acct_tree(wind, wind->qif_wind);
do
{
response = gtk_dialog_run(GTK_DIALOG(wind->dialog));
}
while (response == GNC_RESPONSE_NEW);
gtk_widget_destroy(wind->dialog);
g_object_unref(G_OBJECT(builder));
scm_gc_unprotect_object(wind->map_entry);
g_free(wind->selected_name);
g_free(wind);
if (response == GTK_RESPONSE_OK)
return TRUE;
/* Restore the original mapping. */
scm_call_2(set_gnc_name, map_entry, orig_acct);
return FALSE;
}
static void
panel_addto_selection_changed (GtkTreeSelection *selection,
PanelAddtoDialog *dialog)
{
GtkTreeModel *filter_model;
GtkTreeModel *child_model;
GtkTreeIter iter;
GtkTreeIter filter_iter;
PanelAddtoItemInfo *data;
char *iid;
if (!gtk_tree_selection_get_selected (selection,
&filter_model,
&filter_iter)) {
gtk_widget_set_sensitive (GTK_WIDGET (dialog->add_button),
FALSE);
return;
}
gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (filter_model),
&iter, &filter_iter);
child_model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (filter_model));
gtk_tree_model_get (child_model, &iter, COLUMN_DATA, &data, -1);
if (!data) {
gtk_widget_set_sensitive (GTK_WIDGET (dialog->add_button),
FALSE);
return;
}
gtk_widget_set_sensitive (GTK_WIDGET (dialog->add_button), TRUE);
if (data->type == PANEL_ADDTO_LAUNCHER_MENU) {
gtk_button_set_label (GTK_BUTTON (dialog->add_button),
GTK_STOCK_GO_FORWARD);
} else {
gtk_button_set_label (GTK_BUTTON (dialog->add_button),
GTK_STOCK_ADD);
}
gtk_button_set_use_stock (GTK_BUTTON (dialog->add_button),
TRUE);
/* only allow dragging applets if we can add applets */
if (panel_profile_id_lists_are_writable ()) {
switch (data->type) {
case PANEL_ADDTO_LAUNCHER:
panel_addto_setup_launcher_drag (GTK_TREE_VIEW (dialog->tree_view),
data->launcher_path);
break;
case PANEL_ADDTO_APPLET:
panel_addto_setup_applet_drag (GTK_TREE_VIEW (dialog->tree_view),
data->iid);
break;
case PANEL_ADDTO_LAUNCHER_MENU:
gtk_tree_view_unset_rows_drag_source (GTK_TREE_VIEW (dialog->tree_view));
break;
case PANEL_ADDTO_MENU:
/* build the iid for menus other than the main menu */
if (data->iid == NULL) {
iid = g_strdup_printf ("MENU:%s/%s",
data->menu_filename,
data->menu_path);
} else {
iid = g_strdup (data->iid);
}
panel_addto_setup_internal_applet_drag (GTK_TREE_VIEW (dialog->tree_view),
iid);
g_free (iid);
break;
default:
panel_addto_setup_internal_applet_drag (GTK_TREE_VIEW (dialog->tree_view),
data->iid);
break;
}
}
}
static gboolean _on_show_dlg(gpointer user_data)
{
FmProgressDisplay* data = (FmProgressDisplay*)user_data;
GtkBuilder* builder;
GtkLabel* to;
GtkWidget *to_label;
FmPath* dest;
const char* title = NULL;
GtkTextTagTable* tag_table;
builder = gtk_builder_new();
tag_table = gtk_text_tag_table_new();
gtk_builder_set_translation_domain(builder, GETTEXT_PACKAGE);
gtk_builder_add_from_file(builder, PACKAGE_UI_DIR "/progress.ui", NULL);
data->dlg = GTK_DIALOG(gtk_builder_get_object(builder, "dlg"));
g_object_weak_ref(G_OBJECT(data->dlg), on_progress_dialog_destroy, data);
g_signal_connect(data->dlg, "response", G_CALLBACK(on_response), data);
/* FIXME: connect to "close" signal */
to_label = (GtkWidget*)gtk_builder_get_object(builder, "to_label");
to = GTK_LABEL(gtk_builder_get_object(builder, "dest"));
data->icon = GTK_IMAGE(gtk_builder_get_object(builder, "icon"));
data->msg = GTK_LABEL(gtk_builder_get_object(builder, "msg"));
data->act = GTK_LABEL(gtk_builder_get_object(builder, "action"));
data->src = GTK_LABEL(gtk_builder_get_object(builder, "src"));
data->dest = (GtkWidget*)gtk_builder_get_object(builder, "dest");
data->current = GTK_LABEL(gtk_builder_get_object(builder, "current"));
data->progress = GTK_PROGRESS_BAR(gtk_builder_get_object(builder, "progress"));
data->error_pane = (GtkWidget*)gtk_builder_get_object(builder, "error_pane");
data->error_msg = GTK_TEXT_VIEW(gtk_builder_get_object(builder, "error_msg"));
data->data_transferred = GTK_LABEL(gtk_builder_get_object(builder, "data_transferred"));
data->data_transferred_label = GTK_LABEL(gtk_builder_get_object(builder, "data_transferred_label"));
data->remaining_time = GTK_LABEL(gtk_builder_get_object(builder, "remaining_time"));
data->remaining_time_label = GTK_LABEL(gtk_builder_get_object(builder, "remaining_time_label"));
data->cancel = GTK_BUTTON(gtk_builder_get_object(builder, "cancel"));
data->suspend = GTK_BUTTON(gtk_dialog_add_button(data->dlg, _("_Pause"), 1));
gtk_button_set_use_stock(data->suspend, FALSE);
gtk_button_set_use_underline(data->suspend, TRUE);
gtk_button_set_image(data->suspend,
gtk_image_new_from_stock(GTK_STOCK_MEDIA_PAUSE,
GTK_ICON_SIZE_BUTTON));
gtk_dialog_set_alternative_button_order(data->dlg, 1, GTK_RESPONSE_CANCEL, -1);
data->bold_tag = gtk_text_tag_new("bold");
g_object_set(data->bold_tag, "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_text_tag_table_add(tag_table, data->bold_tag);
data->error_buf = gtk_text_buffer_new(tag_table);
g_object_unref(tag_table);
gtk_text_view_set_buffer(data->error_msg, data->error_buf);
gtk_widget_hide(GTK_WIDGET(data->icon));
g_object_unref(builder);
/* set the src label */
/* FIXME: direct access to job struct! */
if(data->job->srcs)
{
GList* l = fm_path_list_peek_head_link(data->job->srcs);
int i;
char* disp;
FmPath* path;
GString* str = g_string_sized_new(512);
path = FM_PATH(l->data);
disp = fm_path_display_basename(path);
g_string_assign(str, disp);
g_free(disp);
for( i =1, l=l->next; i < 10 && l; l=l->next, ++i)
{
path = FM_PATH(l->data);
g_string_append(str, _(", "));
disp = fm_path_display_basename(path);
g_string_append(str, disp);
g_free(disp);
}
if(l)
g_string_append(str, "...");
gtk_label_set_text(data->src, str->str);
gtk_widget_set_tooltip_text(GTK_WIDGET(data->src), str->str);
g_string_free(str, TRUE);
}
/* FIXME: use accessor functions instead */
/* FIXME: direct access to job struct! */
switch(data->job->type)
{
/* we set title here if text is complex so may be different from
the op_text when is translated to other languages */
case FM_FILE_OP_MOVE:
/* translators: it is part of "Moving files:" or "Moving xxx.txt" */
data->op_text = _("Moving");
break;
case FM_FILE_OP_COPY:
/* translators: it is part of "Copying files:" or "Copying xxx.txt" */
data->op_text = _("Copying");
break;
case FM_FILE_OP_TRASH:
/* translators: it is part of "Trashing files:" or "Trashing xxx.txt" */
data->op_text = _("Trashing");
break;
case FM_FILE_OP_DELETE:
/* translators: it is part of "Deleting files:" or "Deleting xxx.txt" */
data->op_text = _("Deleting");
break;
case FM_FILE_OP_LINK:
/* translators: it is part of "Creating link /path/xxx.txt" */
data->op_text = _("Creating link");
/* translators: 'In:' string is followed by destination folder path */
gtk_label_set_markup(GTK_LABEL(to_label), _("<b>In:</b>"));
title = _("Creating links to files");
/* NOTE: on creating single symlink or shortcut all operation
is done in single I/O therefore it should fit into 0.5s
timeout and progress window will never be shown */
break;
case FM_FILE_OP_CHANGE_ATTR:
/* translators: it is part of "Changing attributes of xxx.txt" */
data->op_text = _("Changing attributes of");
title = _("Changing attributes of files");
/* NOTE: the same about single symlink is appliable here so
there is no need to add never used string for translation */
break;
case FM_FILE_OP_UNTRASH:
/* translators: it is part of "Restoring files:" or "Restoring xxx.txt" */
data->op_text = _("Restoring");
break;
case FM_FILE_OP_NONE: ;
}
data->str = g_string_sized_new(64);
if (title)
gtk_window_set_title(GTK_WINDOW(data->dlg), title);
else
{
/* note to translators: resulting string is such as "Deleting files" */
g_string_printf(data->str, _("%s files"), data->op_text);
gtk_window_set_title(GTK_WINDOW(data->dlg), data->str->str);
}
gtk_label_set_markup(data->msg, _("<b>File operation is in progress...</b>"));
gtk_widget_show(GTK_WIDGET(data->msg));
if (title) /* we already know the exact string */
g_string_printf(data->str, "<b>%s:</b>", title);
else if (fm_path_list_get_length(data->job->srcs) == 1)
/* note to translators: resulting string is such as "Deleting file" */
g_string_printf(data->str, _("<b>%s file:</b>"), data->op_text);
else
/* note to translators: resulting string is such as "Deleting files" */
g_string_printf(data->str, _("<b>%s files:</b>"), data->op_text);
gtk_label_set_markup(data->act, data->str->str);
dest = fm_file_ops_job_get_dest(data->job);
if(dest)
{
char* dest_str = fm_path_display_name(dest, TRUE);
gtk_label_set_text(to, dest_str);
gtk_widget_set_tooltip_text(GTK_WIDGET(data->dest), dest_str);
g_free(dest_str);
}
else
{
gtk_widget_destroy(data->dest);
gtk_widget_destroy(to_label);
}
gtk_window_set_transient_for(GTK_WINDOW(data->dlg), data->parent);
gtk_window_present(GTK_WINDOW(data->dlg));
data->delay_timeout = 0;
return FALSE;
}
