int bank_ops_open_recent(GtkWidget* parent_window, char* filename)
{
int val;
assert(!session_is_active());
patch_destroy_all();
val = dish_file_read(filename);
if (val < 0)
{
GtkWidget* msg = gtk_message_dialog_new(GTK_WINDOW(parent_window),
GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"Failed to read bank %s\n.", filename);
g_signal_connect_swapped(G_OBJECT(msg), "response",
G_CALLBACK(gtk_widget_destroy), msg);
gtk_widget_show (msg);
gtk_recent_manager_remove_item(recent_manager, filename, NULL);
}
else
{
if (recent_manager)
gtk_recent_manager_add_item (recent_manager,
g_filename_to_uri(filename, NULL, NULL));
}
return val;
}
static void _load_file(EDITOR *e, const gchar *filename)
{
char *text = NULL;
GtkRecentManager *rm = NULL;
rm = gtk_recent_manager_get_default();
gtk_recent_manager_add_item(rm, filename);
if (e->filename)
g_free(e->filename);
e->filename = g_strdup(filename);
XI_message(("_load_file filename: %s", filename));
xml_set_value("Xiphos", "studypad", "lastfile", e->filename);
settings.studypadfilename = xml_get_value("studypad", "lastfile");
change_window_title(e->window, e->filename);
text = inhale_text_from_file(!strncmp(filename, "file:", 5)
? filename + 5
: filename);
XI_message(("web view load string [%s]", text));
webkit_web_view_load_string(WEBKIT_WEB_VIEW(e->html_widget),
text, "text/html", "utf_8", "file://");
g_free(text);
e->is_changed = FALSE;
}
void
libre_impuesto_file_add_recent_item (const char *uri,
const char *mime_type)
{
GtkRecentManager *manager = gtk_recent_manager_get_default ();
g_return_if_fail (mime_type != NULL && uri != NULL);
gtk_recent_manager_add_item (manager, uri);
}
static void
pt_window_ready_to_play (PtWindow *win,
gboolean state)
{
/* Set up widget sensitivity/visibility, actions, labels, window title
and timer according to the state of PtPlayer (ready to play or not).
Reset tooltips for insensitive widgets. */
gchar *display_name = NULL;
enable_win_actions (win, state);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (win->priv->button_play), FALSE);
gtk_widget_set_visible (win->priv->button_play, state);
gtk_widget_set_visible (win->priv->button_open, !state);
gtk_widget_set_sensitive (win->priv->button_play, state);
gtk_widget_set_sensitive (win->priv->button_fast_back, state);
gtk_widget_set_sensitive (win->priv->button_fast_forward, state);
gtk_widget_set_sensitive (win->priv->button_jump_back, state);
gtk_widget_set_sensitive (win->priv->button_jump_forward, state);
gtk_widget_set_sensitive (win->priv->speed_scale, state);
if (state) {
destroy_progress_dlg (win);
display_name = pt_player_get_filename (win->priv->player);
if (display_name) {
gtk_window_set_title (GTK_WINDOW (win), display_name);
g_free (display_name);
}
gtk_recent_manager_add_item (
win->priv->recent,
pt_player_get_uri (win->priv->player));
change_play_button_tooltip (win);
change_jump_back_tooltip (win);
change_jump_forward_tooltip (win);
pt_waveslider_set_follow_cursor (PT_WAVESLIDER (win->priv->waveslider), TRUE);
win->priv->wavedata = pt_player_get_data (win->priv->player);
pt_waveslider_set_wave (PT_WAVESLIDER (win->priv->waveslider),
win->priv->wavedata);
/* add timer after waveslider, didn't update cursor otherwise sometimes */
add_timer (win);
} else {
gtk_label_set_text (GTK_LABEL (win->priv->pos_label), "00:00.0");
gtk_window_set_title (GTK_WINDOW (win), "Parlatype");
gtk_widget_set_tooltip_text (win->priv->button_jump_back, NULL);
gtk_widget_set_tooltip_text (win->priv->button_jump_forward, NULL);
remove_timer (win);
pt_wavedata_free (win->priv->wavedata);
win->priv->wavedata = NULL;
pt_waveslider_set_wave (PT_WAVESLIDER (win->priv->waveslider),
win->priv->wavedata);
}
}
void ui_add_recent_file ( const gchar *filename )
{
if ( filename ) {
GtkRecentManager *manager = gtk_recent_manager_get_default();
GFile *file = g_file_new_for_commandline_arg ( filename );
gchar *uri = g_file_get_uri ( file );
if ( uri && manager )
gtk_recent_manager_add_item ( manager, uri );
g_object_unref( file );
g_free (uri);
}
}
static void
do_real_transfer_done (EmpathyFTManager *manager,
EmpathyFTHandler *handler)
{
const char *contact_name;
const char *filename;
char *first_line, *second_line, *message;
char *uri;
gboolean incoming;
GtkTreeRowReference *row_ref;
GtkRecentManager *recent_manager;
GFile *file;
row_ref = ft_manager_get_row_from_handler (manager, handler);
g_return_if_fail (row_ref != NULL);
incoming = empathy_ft_handler_is_incoming (handler);
contact_name = empathy_contact_get_alias
(empathy_ft_handler_get_contact (handler));
filename = empathy_ft_handler_get_filename (handler);
if (incoming)
/* translators: first %s is filename, second %s
* is the contact name */
first_line = g_strdup_printf (_("“%s” received from %s"), filename,
contact_name);
else
/* translators: first %s is filename, second %s
* is the contact name */
first_line = g_strdup_printf (_("“%s” sent to %s"), filename,
contact_name);
second_line = g_strdup (_("File transfer completed"));
message = g_strdup_printf ("%s\n%s", first_line, second_line);
ft_manager_update_handler_message (manager, row_ref, message);
ft_manager_clear_handler_time (manager, row_ref);
/* update buttons */
ft_manager_update_buttons (manager);
g_free (message);
g_free (first_line);
g_free (second_line);
recent_manager = gtk_recent_manager_get_default ();
file = empathy_ft_handler_get_gfile (handler);
uri = g_file_get_uri (file);
gtk_recent_manager_add_item (recent_manager, uri);
g_free (uri);
}
void
recently_used_add (char *filename)
{
#if GTK_CHECK_VERSION (2,10,0)
static GtkRecentManager *recent = NULL;
if (! recent)
recent = gtk_recent_manager_get_default ();
char buf[1024];
snprintf (buf, sizeof (buf), "file://%s", filename);
gtk_recent_manager_add_item (recent, buf);
#endif
}
static void _save_file(EDITOR *e)
{
GtkRecentManager *rm = NULL;
GString *data = g_string_new("");
editor_get_document_content(data, e);
XI_message(("%s", data->str));
if (!e->filename || (0 == g_strcmp0("Untitled document", e->filename)) || g_strrstr(e->filename, ".spt")) {
GtkWidget *dialog = gtk_file_chooser_dialog_new("Save as", //const gchar *title,
NULL, //GtkWindow *parent,
GTK_FILE_CHOOSER_ACTION_SAVE, //GtkFileChooserAction action,
#ifdef HAVE_GTK_310
"_OK",
GTK_RESPONSE_OK,
"_Cancel",
GTK_RESPONSE_CANCEL,
#else
GTK_STOCK_OK,
GTK_RESPONSE_OK,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
#endif
NULL);
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
settings.studypaddir);
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) {
gchar *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
e->filename = g_strdup(filename);
GFile *gfile = g_file_parse_name(filename);
g_file_replace_contents(gfile, data->str, data->len, NULL, TRUE, G_FILE_CREATE_NONE, NULL, NULL, NULL); //GError **error
}
change_window_title(e->window, e->filename);
gtk_widget_destroy(dialog);
} else {
GFile *gfile = g_file_parse_name(e->filename);
g_file_replace_contents(gfile, data->str, data->len, NULL, TRUE, G_FILE_CREATE_NONE, NULL, NULL, NULL); //GError **error
}
rm = gtk_recent_manager_get_default();
gtk_recent_manager_add_item(rm, e->filename);
e->is_changed = FALSE;
g_string_free(data, TRUE);
}
void wxFileHistory::AddFileToHistory(const wxString& file)
{
wxFileHistoryBase::AddFileToHistory(file);
#ifdef __WXGTK210__
const wxString fullPath = wxFileName(file).GetFullPath();
if ( !gtk_check_version(2,10,0) )
{
wxGtkString uri(g_filename_to_uri(fullPath.fn_str(), NULL, NULL));
if ( uri )
gtk_recent_manager_add_item(gtk_recent_manager_get_default(), uri);
}
#endif
}
static VALUE
rg_add_item(int argc, VALUE *argv, VALUE self)
{
VALUE uri, data;
gboolean ret;
rb_scan_args(argc, argv, "11", &uri, &data);
if (NIL_P(data)){
ret = gtk_recent_manager_add_item(_SELF(self), RVAL2CSTR(uri));
if (! ret) rb_raise(rb_eRuntimeError, "Can't add the uri");
} else {
ret = gtk_recent_manager_add_full(_SELF(self),
RVAL2CSTR(uri),
RVAL2BOXED(data, GTK_TYPE_RECENT_DATA));
if (! ret) rb_raise(rb_eRuntimeError, "Can't add the uri or data");
}
return self;
}
/* Clean up when the pipeline is finished
*/
static void
recorder_pipeline_closed (RecorderPipeline *pipeline)
{
g_signal_handlers_disconnect_by_func (pipeline->src,
(gpointer) recorder_pipeline_on_memory_used_changed,
pipeline);
recorder_disconnect_stage_callbacks (pipeline->recorder);
gst_element_set_state (pipeline->pipeline, GST_STATE_NULL);
if (pipeline->recorder)
{
GtkRecentManager *recent_manager;
GFile *file;
char *uri;
ShellRecorder *recorder = pipeline->recorder;
if (pipeline == recorder->current_pipeline)
{
/* Error case; force a close */
recorder->current_pipeline = NULL;
shell_recorder_close (recorder);
}
recent_manager = gtk_recent_manager_get_default ();
file = g_file_new_for_path (pipeline->filename);
uri = g_file_get_uri (file);
gtk_recent_manager_add_item (recent_manager,
uri);
g_free (uri);
g_object_unref (file);
recorder->pipelines = g_slist_remove (recorder->pipelines, pipeline);
}
recorder_pipeline_free (pipeline);
}
void
empathy_send_file (EmpathyContact *contact,
GFile *file)
{
EmpathyFTFactory *factory;
GtkRecentManager *manager;
gchar *uri;
g_return_if_fail (EMPATHY_IS_CONTACT (contact));
g_return_if_fail (G_IS_FILE (file));
factory = empathy_ft_factory_dup_singleton ();
empathy_ft_factory_new_transfer_outgoing (factory, contact, file,
empathy_get_current_action_time ());
uri = g_file_get_uri (file);
manager = gtk_recent_manager_get_default ();
gtk_recent_manager_add_item (manager, uri);
g_free (uri);
g_object_unref (factory);
}
static gboolean
photos_item_manager_set_active_object (PhotosBaseManager *manager, GObject *object)
{
PhotosItemManager *self = PHOTOS_ITEM_MANAGER (manager);
PhotosItemManagerPrivate *priv = self->priv;
GtkRecentManager *recent;
gboolean ret_val;
const gchar *uri;
g_return_val_if_fail (PHOTOS_IS_BASE_ITEM (object) || object == NULL, FALSE);
ret_val = PHOTOS_BASE_MANAGER_CLASS (photos_item_manager_parent_class)->set_active_object (manager, object);
if (!ret_val)
goto out;
if (object == NULL)
goto out;
if (photos_base_item_is_collection (PHOTOS_BASE_ITEM (object)))
{
GObject *collection;
collection = photos_base_manager_get_active_object (priv->col_mngr);
g_queue_push_head (priv->collection_path, (collection != NULL) ? g_object_ref (collection) : NULL);
photos_base_manager_set_active_object (priv->col_mngr, object);
goto out;
}
recent = gtk_recent_manager_get_default ();
uri = photos_base_item_get_uri (PHOTOS_BASE_ITEM (object));
gtk_recent_manager_add_item (recent, uri);
out:
return ret_val;
}
static int full_save_as(GtkWidget* parent_window, gboolean not_export)
{
GtkWidget* dialog = 0;
GtkWidget* content_area = 0;
GtkWidget* alignment = 0;
GtkWidget* vbox = 0;
GtkWidget* table = 0;
GtkTable* t = 0;
GtkWidget* name_entry = 0;
GtkWidget* folder_button = 0;
enum { TABLE_WIDTH = 4, TABLE_HEIGHT = 2 };
int a1 = 0, a2 = 1;
int b1 = 1, b2 = TABLE_WIDTH;
int y = 0;
const char* title = 0;
char* folder = 0;
if (not_export)
title = "Full Save bank as";
else
title = "Full Export bank from session as";
dialog = gtk_dialog_new_with_buttons(title, GTK_WINDOW(parent_window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
alignment = gtk_alignment_new(0, 0, 1, 1);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), GUI_BORDERSPACE,
GUI_BORDERSPACE,
GUI_BORDERSPACE,
GUI_BORDERSPACE);
gtk_container_add(GTK_CONTAINER(content_area), alignment);
vbox = gtk_vbox_new(FALSE, GUI_SPACING);
gtk_container_add(GTK_CONTAINER(alignment), vbox);
table = gtk_table_new(TABLE_HEIGHT, TABLE_WIDTH, TRUE);
gui_pack(GTK_BOX(vbox), table);
t = GTK_TABLE(table);
gtk_table_set_col_spacing(t, 0, GUI_TEXTSPACE);
gui_label_attach("Name:", t, a1, a2, y, y + 1);
name_entry = gtk_entry_new();
gui_attach(t, name_entry, b1, b2, y, y + 1);
if (dish_file_has_state())
gtk_entry_set_text(GTK_ENTRY(name_entry),
dish_file_state_bank_name());
else
gtk_entry_set_text(GTK_ENTRY(name_entry), untitled_name);
g_signal_connect(G_OBJECT(gtk_entry_get_buffer(GTK_ENTRY(name_entry))),
"inserted-text", G_CALLBACK(name_buf_txt_ins_cb), NULL);
++y;
gui_label_attach("Create Folder in:", t, a1, a2, y, y + 1);
folder_button = gtk_file_chooser_button_new("Select folder",
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
gui_attach(t, folder_button, b1, b2, y, y + 1);
gtk_widget_show_all(dialog);
while(1)
{
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
char* uri = 0;
const char* name = 0;
uri = gtk_file_chooser_get_uri(GTK_FILE_CHOOSER(folder_button));
if (uri && strncmp(uri, "file://", 7) == 0)
{
folder = strdup(uri + 7);
free(uri);
}
else
folder = uri;
name = gtk_entry_get_text(GTK_ENTRY(name_entry));
debug("folder:'%s'\tname (name_entry):'%s'\n", folder,name);
if (folder && name)
{
dish_file_write_full(folder, name);
if (recent_manager)
gtk_recent_manager_add_item(recent_manager,
g_filename_to_uri(dish_file_state_path(),
NULL, NULL));
break;
}
}
else
break;
}
gtk_widget_destroy(dialog);
return 0;
}
/*! \brief Saves a page to a file.
* \par Function Description
* This function saves the page <B>page</B> to a file named
* <B>filename</B>.
*
* It returns the value returned by function <B>f_save()</B> trying
* to save page <B>page</B> to file <B>filename</B> (1 on success, 0
* on failure).
*
* <B>page</B> may not be the current page of <B>toplevel</B>. The
* current page of <B>toplevel</B> is not affected by this function.
*
* \param [in] w_current The toplevel environment.
* \param [in] page The page to save.
* \param [in] filename The name of the file in which to save page.
* \returns 1 on success, 0 otherwise.
*/
gint
x_window_save_page (GschemToplevel *w_current, PAGE *page, const gchar *filename)
{
TOPLEVEL *toplevel = gschem_toplevel_get_toplevel (w_current);
const gchar *log_msg, *state_msg;
gint ret;
GError *err = NULL;
g_return_val_if_fail (toplevel != NULL, 0);
g_return_val_if_fail (page != NULL, 0);
g_return_val_if_fail (filename != NULL, 0);
/* try saving page to filename */
ret = (gint)f_save (toplevel, page, filename, &err);
if (ret != 1) {
log_msg = _("Could NOT save page [%s]\n");
state_msg = _("Error while trying to save");
GtkWidget *dialog;
dialog = gtk_message_dialog_new (GTK_WINDOW (w_current->main_window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"%s",
err->message);
gtk_window_set_title (GTK_WINDOW (dialog), _("Failed to save file"));
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
g_clear_error (&err);
} else {
/* successful save of page to file, update page... */
/* change page name if necessary and prepare log message */
if (g_ascii_strcasecmp (page->page_filename, filename) != 0) {
g_free (page->page_filename);
page->page_filename = g_strdup (filename);
log_msg = _("Saved as [%s]\n");
} else {
log_msg = _("Saved [%s]\n");
}
state_msg = _("Saved");
/* reset page CHANGED flag */
page->CHANGED = 0;
/* add to recent file list */
gtk_recent_manager_add_item (recent_manager, g_filename_to_uri(filename, NULL, NULL));
i_set_filename (w_current, page->page_filename);
x_pagesel_update (w_current);
}
/* log status of operation */
s_log_message (log_msg, filename);
i_set_state_msg (w_current, SELECT, state_msg);
return ret;
}
/*! \brief Opens a new page from a file.
* \par Function Description
* This function opens the file whose name is <B>filename</B> in a
* new PAGE of <B>toplevel</B>.
*
* If there is no page for <B>filename</B> in <B>toplevel</B>'s list
* of pages, it creates a new PAGE, loads the file in it and returns
* a pointer on the new page. Otherwise it returns a pointer on the
* existing page.
*
* If the filename passed is NULL, this function creates an empty,
* untitled page. The name of the untitled page is build from
* configuration data ('untitled-name') and a counter for uniqueness.
*
* The opened page becomes the current page of <B>toplevel</B>.
*
* \param [in] w_current The toplevel environment.
* \param [in] filename The name of the file to open or NULL for a blank page.
* \returns A pointer on the new page.
*
* \bug This code should check to make sure any untitled filename
* does not conflict with a file on disk.
*/
PAGE*
x_window_open_page (GschemToplevel *w_current, const gchar *filename)
{
TOPLEVEL *toplevel = gschem_toplevel_get_toplevel (w_current);
GschemPageView *page_view = gschem_toplevel_get_current_page_view (w_current);
PAGE *page;
gchar *fn;
g_return_val_if_fail (toplevel != NULL, NULL);
/* Generate untitled filename if none was specified */
if (filename == NULL) {
gchar *cwd, *tmp, *untitled_name;
EdaConfig *cfg;
cwd = g_get_current_dir ();
cfg = eda_config_get_context_for_path (cwd);
untitled_name = eda_config_get_string (cfg, "gschem", "default-filename", NULL);
tmp = g_strdup_printf ("%s_%d.sch",
untitled_name,
++w_current->num_untitled);
fn = g_build_filename (cwd, tmp, NULL);
g_free (untitled_name);
g_free(cwd);
g_free(tmp);
} else {
fn = g_strdup (filename);
}
/* Return existing page if it is already loaded */
page = s_page_search (toplevel, fn);
if ( page != NULL ) {
g_free(fn);
return page;
}
page = s_page_new (toplevel, fn);
s_page_goto (toplevel, page);
gschem_toplevel_page_changed (w_current);
/* Load from file if necessary, otherwise just print a message */
if (filename != NULL) {
GError *err = NULL;
if (!quiet_mode)
s_log_message (_("Loading schematic [%s]\n"), fn);
if (!f_open (toplevel, page, (gchar *) fn, &err)) {
GtkWidget *dialog;
g_warning ("%s\n", err->message);
dialog = gtk_message_dialog_new_with_markup
(GTK_WINDOW (w_current->main_window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
_("<b>An error occurred while loading the requested file.</b>\n\nLoading from '%s' failed: %s. The gschem log may contain more information."),
fn, err->message);
gtk_window_set_title (GTK_WINDOW (dialog), _("Failed to load file"));
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
g_error_free (err);
} else {
gtk_recent_manager_add_item (recent_manager, g_filename_to_uri(fn, NULL, NULL));
}
} else {
if (!quiet_mode)
s_log_message (_("New file [%s]\n"),
toplevel->page_current->page_filename);
g_run_hook_page (w_current, "%new-page-hook", toplevel->page_current);
}
gschem_page_view_set_page (page_view,
toplevel->page_current);
o_undo_savestate (w_current, toplevel->page_current, UNDO_ALL);
/* This line is generally un-needed, however if some code
* wants to open a page, yet not bring it to the front, it is
* needed needed to add it into the page manager. Otherwise,
* it will get done in x_window_set_current_page(...)
*/
x_pagesel_update (w_current); /* ??? */
g_free (fn);
return page;
}
/*! \brief Opens a new page from a file.
* \par Function Description
* This function opens the file whose name is <B>filename</B> in a
* new PAGE of <B>toplevel</B>.
*
* If there is no page for <B>filename</B> in <B>toplevel</B>'s list
* of pages, it creates a new PAGE, loads the file in it and returns
* a pointer on the new page. Otherwise it returns a pointer on the
* existing page.
*
* If the filename passed is NULL, this function creates an empty,
* untitled page. The name of the untitled page is build from
* configuration data ('untitled-name') and a counter for uniqueness.
*
* The opened page becomes the current page of <B>toplevel</B>.
*
* \param [in] w_current The toplevel environment.
* \param [in] filename The name of the file to open or NULL for a blank page.
* \returns A pointer on the new page.
*
* \bug This code should check to make sure any untitled filename
* does not conflict with a file on disk.
*/
PAGE*
x_window_open_page (GSCHEM_TOPLEVEL *w_current, const gchar *filename)
{
TOPLEVEL *toplevel = w_current->toplevel;
PAGE *old_current, *page;
gchar *fn;
g_return_val_if_fail (toplevel != NULL, NULL);
/* Generate untitled filename if none was specified */
if (filename == NULL) {
gchar *cwd, *tmp;
cwd = g_get_current_dir ();
tmp = g_strdup_printf ("%s_%d.sch",
toplevel->untitled_name,
++w_current->num_untitled);
fn = g_build_filename (cwd, tmp, NULL);
g_free(cwd);
g_free(tmp);
} else {
fn = g_strdup (filename);
}
/* Return existing page if it is already loaded */
page = s_page_search (toplevel, fn);
if ( page != NULL ) {
g_free(fn);
return page;
}
old_current = toplevel->page_current;
page = s_page_new (toplevel, fn);
s_page_goto (toplevel, page);
/* Load from file if necessary, otherwise just print a message */
if (filename != NULL) {
GError *err = NULL;
if (!quiet_mode)
s_log_message (_("Loading schematic [%s]\n"), fn);
if (!f_open (toplevel, page, (gchar *) fn, &err)) {
GtkWidget *dialog;
g_warning ("%s\n", err->message);
dialog = gtk_message_dialog_new (GTK_WINDOW (w_current->main_window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"%s",
err->message);
gtk_window_set_title (GTK_WINDOW (dialog), _("Failed to load file"));
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
g_error_free (err);
} else {
gtk_recent_manager_add_item (recent_manager, g_filename_to_uri(fn, NULL, NULL));
}
} else {
if (!quiet_mode)
s_log_message (_("New file [%s]\n"),
toplevel->page_current->page_filename);
}
if (scm_is_false (scm_hook_empty_p (new_page_hook)))
scm_run_hook (new_page_hook,
scm_cons (g_make_page_smob (toplevel, page), SCM_EOL));
a_zoom_extents (w_current,
s_page_objects (toplevel->page_current),
A_PAN_DONT_REDRAW);
o_undo_savestate (w_current, UNDO_ALL);
if ( old_current != NULL )
s_page_goto (toplevel, old_current);
/* This line is generally un-needed, however if some code
* wants to open a page, yet not bring it to the front, it is
* needed needed to add it into the page manager. Otherwise,
* it will get done in x_window_set_current_page(...)
*/
x_pagesel_update (w_current); /* ??? */
g_free (fn);
return page;
}
static int open(GtkWidget* parent_window, gboolean not_import)
{
GtkWidget* dialog;
int val;
const char* title;
char* filter = file_ops_join_ext("*", dish_file_extension());
global_settings* settings = settings_get();
if (not_import)
title = "Open bank";
else
title = "Import bank";
dialog = gtk_file_chooser_dialog_new( title,
GTK_WINDOW(parent_window),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN,
GTK_RESPONSE_ACCEPT, NULL);
if (dish_file_has_state())
{
const char* tmp = 0;
tmp = dish_file_state_is_full() ? dish_file_state_parent_dir()
: dish_file_state_bank_dir();
gtk_file_chooser_select_filename(GTK_FILE_CHOOSER(dialog), tmp);
}
else
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
settings->last_bank_dir);
file_chooser_add_filter(dialog, "Petri-Foo files", filter);
file_chooser_add_filter(dialog, "All files", "*");
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
char* name = (char*) gtk_file_chooser_get_filename(
GTK_FILE_CHOOSER(dialog));
val = (not_import) ? dish_file_read(name)
: dish_file_import(name);
if (val < 0)
{
GtkWidget* msg = gtk_message_dialog_new(GTK_WINDOW(dialog),
GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"Failed to read bank %s\n.", name);
g_signal_connect_swapped(G_OBJECT(msg), "response",
G_CALLBACK(gtk_widget_destroy), msg);
gtk_widget_show (msg);
}
else
{
if (recent_manager && not_import)
gtk_recent_manager_add_item(recent_manager,
g_filename_to_uri(name, NULL, NULL));
if (settings->last_bank_dir)
free(settings->last_bank_dir);
settings->last_bank_dir = g_path_get_dirname(name);
}
}
else
{
val = -1;
}
gtk_widget_destroy(dialog);
free(filter);
return val;
}
static gboolean
photos_item_manager_set_active_object (PhotosBaseManager *manager, GObject *object)
{
PhotosItemManager *self = PHOTOS_ITEM_MANAGER (manager);
GObject *active_item;
PhotosWindowMode old_mode;
gboolean active_collection_changed = FALSE;
gboolean ret_val = FALSE;
gboolean start_loading = FALSE;
gboolean window_mode_changed = FALSE;
g_return_val_if_fail (object != NULL, FALSE);
g_return_val_if_fail (PHOTOS_IS_BASE_ITEM (object), FALSE);
active_item = photos_base_manager_get_active_object (manager);
if (object == active_item)
goto out;
photos_item_manager_clear_active_item_load (self);
if (photos_base_item_is_collection (PHOTOS_BASE_ITEM (object)))
{
g_queue_push_head (self->collection_path,
(self->active_collection != NULL) ? g_object_ref (self->active_collection) : NULL);
g_clear_object (&self->active_collection);
self->active_collection = g_object_ref (object);
self->load_state = PHOTOS_LOAD_STATE_NONE;
active_collection_changed = TRUE;
}
else
{
window_mode_changed = photos_item_manager_set_window_mode_internal (self,
PHOTOS_WINDOW_MODE_PREVIEW,
&old_mode);
photos_item_manager_update_fullscreen (self);
self->load_state = PHOTOS_LOAD_STATE_STARTED;
start_loading = TRUE;
}
ret_val = PHOTOS_BASE_MANAGER_CLASS (photos_item_manager_parent_class)->set_active_object (manager, object);
/* We have already eliminated the possibility of failure. */
g_assert (ret_val == TRUE);
active_item = photos_base_manager_get_active_object (manager);
g_assert (active_item == object);
if (active_collection_changed)
{
g_signal_emit (self, signals[ACTIVE_COLLECTION_CHANGED], 0, self->active_collection);
g_assert (active_item == (GObject *) self->active_collection);
}
if (start_loading)
{
GtkRecentManager *recent;
const gchar *uri;
recent = gtk_recent_manager_get_default ();
uri = photos_base_item_get_uri (PHOTOS_BASE_ITEM (object));
gtk_recent_manager_add_item (recent, uri);
self->loader_cancellable = g_cancellable_new ();
photos_base_item_load_async (PHOTOS_BASE_ITEM (object),
self->loader_cancellable,
photos_item_manager_item_load,
g_object_ref (self));
g_signal_emit (self, signals[LOAD_STARTED], 0, PHOTOS_BASE_ITEM (object));
if (window_mode_changed)
g_signal_emit (self, signals[WINDOW_MODE_CHANGED], 0, PHOTOS_WINDOW_MODE_PREVIEW, old_mode);
g_assert (active_item != (GObject *) self->active_collection);
}
out:
return ret_val;
}
static int basic_save_as(GtkWidget* parent_window, gboolean not_export)
{
GtkWidget *dialog;
int val;
const char* title;
char* filter = file_ops_join_ext("*", dish_file_extension());
char* untitled_dish = file_ops_join_ext(untitled_name,
dish_file_extension());
global_settings* settings = settings_get();
if (not_export)
title = "Basic Save bank as";
else
title = "Basic Export as";
dialog = gtk_file_chooser_dialog_new(title,
GTK_WINDOW(parent_window),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE_AS, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_do_overwrite_confirmation(
GTK_FILE_CHOOSER(dialog), TRUE);
if (!dish_file_has_state())
{
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
settings->last_bank_dir);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog),
untitled_dish);
}
else
{
const char* tmp = 0;
char* fn = 0;
char* pdir = 0; /* parent of session dir */
if (dish_file_state_is_full())
{
tmp = dish_file_state_parent_dir();
if (session_is_active()
&& (pdir = file_ops_parent_dir(tmp)) != 0)
{
tmp = pdir;
}
}
else
tmp = dish_file_state_bank_dir();
debug("tmp: '%s'\n", tmp);
debug("parent: '%s'\n", dish_file_state_parent_dir());
debug("bank: '%s'\n", dish_file_state_bank_dir());
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), tmp);
fn = file_ops_join_ext( dish_file_state_bank_name(),
dish_file_extension());
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), fn);
free(fn);
free(pdir);
}
file_chooser_add_filter(dialog, "Petri-Foo files", filter);
file_chooser_add_filter(dialog, "All files", "*");
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
{
char *name = (char *)
gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
if ((val = dish_file_write_basic(name)) < 0)
{
GtkWidget* msg = gtk_message_dialog_new(GTK_WINDOW(dialog),
GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"Failed to write file %s\n.", name);
g_signal_connect_swapped(G_OBJECT(msg), "response",
G_CALLBACK(gtk_widget_destroy), msg);
gtk_widget_show (msg);
}
else
{
if (recent_manager && not_export)
gtk_recent_manager_add_item (recent_manager,
g_filename_to_uri(name, NULL, NULL));
}
}
else
{
val = -1;
}
gtk_widget_destroy(dialog);
free(filter);
return val;
}