void Gobby::OperationNew::start()
{
InfRequest* request;
if(m_directory)
{
request = inf_browser_add_subdirectory(
m_browser, &m_parent, m_name.c_str(), NULL,
on_request_finished_static, this);
}
else
{
request = inf_browser_add_note(
m_browser, &m_parent, m_name.c_str(),
"InfText", NULL, NULL, TRUE,
on_request_finished_static, this);
}
if(request != NULL)
{
m_request = request;
g_object_ref(m_request);
m_message_handle = get_status_bar().add_info_message(
Glib::ustring::compose(
m_directory ?
_("Creating directory \"%1\"...") :
_("Creating document \"%1\"..."),
m_name));
}
}
void layer_new_mouse(void)
{
// Local variables
GdkCursor *selection_cursor; // Holds the new temporary selection cursor
// If no project is loaded then don't run this function
if (NULL == get_current_slide())
{
// Make a beep, then return
gdk_beep();
return;
}
// Change the focus of the window to be this widget
set_delete_focus(FOCUS_LAYER);
// Change the cursor to something suitable
selection_cursor = gdk_cursor_new(GDK_CROSSHAIR);
gdk_window_set_cursor(get_main_drawing_area()->window, selection_cursor);
gdk_cursor_unref(selection_cursor);
// Set a toggle so the release button callback will know to do the rest
set_new_layer_selected(TYPE_MOUSE_CURSOR);
// Update the status bar
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(get_status_bar()), _(" Please click the insertion point"));
gdk_flush();
}
void Gobby::OperationNew::on_request_finished(const InfBrowserIter* iter,
const GError* error)
{
if(error)
{
const Glib::ustring prefix = Glib::ustring::compose(
m_directory ?
_("Failed to create directory \"%1\""):
_("Failed to create document \"%1\""),
m_name);
get_status_bar().add_error_message(prefix, error->message);
fail();
}
else
{
if(!m_directory)
{
InfSessionProxy* proxy =
inf_browser_get_session(m_browser, iter);
g_assert(proxy != NULL);
get_folder_manager().add_document(
m_browser, iter, proxy, NULL);
}
finish();
}
}
Gobby::OperationExportHtml::~OperationExportHtml()
{
if(m_file)
{
// TODO: Cancel outstanding async operations?
get_status_bar().remove_message(m_message_handle);
}
}
void Gobby::OperationExportHtml::error(const Glib::ustring& message)
{
get_status_bar().add_error_message(
Glib::ustring::compose(
_("Failed to export document \"%1\" to HTML"), m_file->get_uri()),
message);
fail();
}
void Gobby::OperationSave::error(const Glib::ustring& message)
{
get_status_bar().add_error_message(
Glib::ustring::compose(_("Failed to save document \"%1\""),
m_file->get_uri()),
message);
fail();
}
void Gobby::OperationExportHtml::start()
{
m_file->replace_async(
sigc::mem_fun(*this, &OperationExportHtml::on_file_replace));
m_message_handle = get_status_bar().add_info_message(
Glib::ustring::compose(
_("Exporting document \"%1\" to \"%2\" in HTML..."),
m_title, m_file->get_uri()));
}
Gobby::OperationOpen::~OperationOpen()
{
// TODO: Cancel outstanding async operations?
if(m_request != NULL)
{
g_signal_handlers_disconnect_by_func(
G_OBJECT(m_request),
(gpointer)G_CALLBACK(on_request_finished_static),
this);
g_object_unref(m_request);
}
if(m_content != NULL)
g_object_unref(m_content);
if(m_message_handle != get_status_bar().invalid_handle())
get_status_bar().remove_message(m_message_handle);
}
void Gobby::OperationSave::start()
{
m_file->replace_async(sigc::mem_fun(*this,
&OperationSave::on_file_replace));
m_message_handle = get_status_bar().add_info_message(
Glib::ustring::compose(
_("Saving document \"%1\" to \"%2\"..."),
m_view->get_title(), m_file->get_uri()));
}
Gobby::OperationSave::~OperationSave()
{
// TODO: Cancel outstanding async operations?
for(std::list<Line>::iterator iter = m_lines.begin();
iter != m_lines.end(); ++ iter)
{
g_free(iter->first);
}
get_status_bar().remove_message(m_message_handle);
}
void layer_copy(void)
{
// Local variables
slide *current_slide_data; // Alias to make things easier
guint selected_layer; // Holds the number of the layer that is selected
layer *this_layer; // Pointer to the presently selected layer
// Initialise some things
current_slide_data = get_current_slide_data();
// Determine which layer the user has selected in the timeline
selected_layer = time_line_get_selected_layer_num(current_slide_data->timeline_widget);
current_slide_data->layers = g_list_first(current_slide_data->layers);
this_layer = g_list_nth_data(current_slide_data->layers, selected_layer);
// If there is already a layer in the copy buffer, then we free it
if (NULL != get_copy_layer())
{
layer_free(get_copy_layer());
}
// Create a new layer
set_copy_layer(layer_duplicate(this_layer));
if (NULL == get_copy_layer())
{
// Something went wrong duplicating the existing layer. Not much we can do
gdk_beep();
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(get_status_bar()), _(" Copy failed"));
gdk_flush();
return;
}
// Update the status bar
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(get_status_bar()), _(" Layer copied to buffer"));
gdk_flush();
return;
}
Gobby::OperationNew::~OperationNew()
{
if(m_request != NULL)
{
g_signal_handlers_disconnect_by_func(
G_OBJECT(m_request),
(gpointer)G_CALLBACK(on_request_finished_static),
this);
g_object_unref(m_request);
get_status_bar().remove_message(m_message_handle);
}
g_object_unref(m_browser);
}
Gobby::OperationOpen::OperationOpen(Operations& operations,
const Preferences& preferences,
InfBrowser* browser,
const InfBrowserIter* parent,
const std::string& name,
const Glib::RefPtr<Gio::File>& file,
const char* encoding):
Operation(operations), m_preferences(preferences),
m_name(name), m_file(file), m_parent(browser, parent),
m_encoding_auto_detect_index(-1),
m_eol_style(DocumentInfoStorage::EOL_CR), m_request(NULL),
m_raw_pos(0), m_content(NULL),
m_message_handle(get_status_bar().invalid_handle())
{
if(encoding != NULL)
{
m_encoding = encoding;
}
else
{
m_encoding_auto_detect_index = 0;
m_encoding = get_autodetect_encoding(0);
}
}
void Gobby::OperationOpen::start()
{
m_iconv.reset(new Glib::IConv("UTF-8", m_encoding));
try
{
m_file->read_async(sigc::mem_fun(
*this, &OperationOpen::on_file_read));
m_message_handle = get_status_bar().add_info_message(
Glib::ustring::compose(
_("Opening document \"%1\"..."), m_file->get_uri()));
m_parent.signal_node_removed().connect(
sigc::mem_fun(
*this, &OperationOpen::on_node_removed));
m_content = GTK_TEXT_BUFFER(gtk_source_buffer_new(NULL));
}
catch(const Gio::Error& err)
{
error(err.what());
}
}
void layer_move_up(void)
{
// Local variables
GList *above_layer; // The layer above the selected one
GList *layer_pointer; // Points to the layers in the selected slide
GList *our_layer; // The selected layer
guint selected_row; // Holds the row that is selected
// If no project is loaded then don't run this function
if (NULL == get_current_slide())
{
// Make a beep, then return
gdk_beep();
return;
}
// Initialise various things
layer_pointer = get_current_slide_layers_pointer();
layer_pointer = g_list_first(layer_pointer);
// Change the focus of the window to be this widget
set_delete_focus(FOCUS_LAYER);
// Determine which layer the user has selected in the timeline
selected_row = time_line_get_selected_layer_num(get_current_slide_timeline_widget());
if (0 == selected_row)
{
// We're already at the top of the list, so return
gdk_beep();
return;
}
// Get details of the layers we're moving around
our_layer = g_list_nth(layer_pointer, selected_row);
above_layer = g_list_nth(layer_pointer, selected_row - 1);
// Check if the user has selected the Background layer, if so we return (ignoring this move request)
if (TRUE == ((layer *) our_layer->data)->background)
{
// We're processing a background layer, so return
gdk_beep();
return;
}
// Move the row up one in the layer list
layer_pointer = g_list_remove_link(layer_pointer, our_layer);
layer_pointer = g_list_insert_before(layer_pointer, above_layer, our_layer->data);
set_current_slide_layers_pointer(layer_pointer);
// Move the row up one in the timeline widget
time_line_set_selected_layer_num(get_current_slide_timeline_widget(), selected_row - 1);
// Redraw the timeline area
draw_timeline();
// Redraw the workspace
draw_workspace();
// Recreate the slide thumbnail
film_strip_create_thumbnail(get_current_slide_data());
// Set the changes made variable
set_changes_made(TRUE);
// Update the status bar
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(get_status_bar()), _(" Layer moved up"));
gdk_flush();
}
void slide_delete(void)
{
// Local variables
GString *message; // Used to construct message strings
GtkTreePath *new_path; // Temporary path
gint num_slides; // Number of slides in the whole slide list
GtkTreePath *old_path = NULL; // The old path, which we'll free
gint slide_position; // Which slide in the slide list we are deleting
GtkTreeSelection *film_strip_selector; //
GtkTreeIter selection_iter; //
undo_history_data *undo_item_data = NULL; // Memory structure undo history items are created in
// Are we trying to delete the only slide in the project (not good)?
set_slides(g_list_first(get_slides()));
num_slides = g_list_length(get_slides());
if (1 == num_slides)
{
// Yes we are, so give a warning message and don't delete the slide
message = g_string_new(NULL);
g_string_printf(message, "%s ED462: %s", _("Error"), _("You must leave at least one slide in a project."));
display_warning(message->str);
g_string_free(message, TRUE);
return;
}
// Determine where the slide is positioned in the project
slide_position = g_list_position(get_slides(), get_current_slide());
// Create and store the undo history item for this slide
undo_item_data = g_new0(undo_history_data, 1);
undo_item_data->layer_data_new = NULL; // NULL means not set
undo_item_data->layer_data_old = NULL; // NULL means not set
undo_item_data->position_new = -1; // -1 means not set
undo_item_data->position_old = slide_position;
undo_item_data->slide_data = get_current_slide_data();
undo_history_add_item(UNDO_DELETE_SLIDE, undo_item_data, TRUE);
// Remove the current slide from the slide list
set_slides(g_list_remove_link(get_slides(), get_current_slide()));
// Remove the current slide from the film strip
film_strip_selector = gtk_tree_view_get_selection(GTK_TREE_VIEW(get_film_strip_view()));
gtk_tree_selection_get_selected(film_strip_selector, NULL, &selection_iter);
gtk_list_store_remove(GTK_LIST_STORE(get_film_strip_store()), &selection_iter);
// * Update the currently selected slide to point to the next slide *
if (num_slides == (slide_position + 1))
{
// If we're deleting the last slide, we'll need to point to the previous one instead
slide_position--;
}
set_current_slide(g_list_nth(get_slides(), slide_position));
// Select the next thumbnail in the film strip and scroll to display it
gtk_tree_view_get_cursor(GTK_TREE_VIEW(get_film_strip_view()), &new_path, NULL);
if (NULL != new_path)
old_path = new_path; // Make a backup of the old path, so we can free it
new_path = gtk_tree_path_new_from_indices(slide_position, -1);
gtk_tree_view_set_cursor(GTK_TREE_VIEW(get_film_strip_view()), new_path, NULL, FALSE);
gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(get_film_strip_view()), new_path, NULL, TRUE, 0.5, 0.0);
if (NULL != old_path)
gtk_tree_path_free(old_path); // Free the old path
// Redraw the timeline
draw_timeline();
// Redraw the workspace
draw_workspace();
// Set the changes made variable
set_changes_made(TRUE);
// Update the status bar
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(get_status_bar()), _(" Slide deleted"));
gdk_flush();
}
void slide_move_down(void)
{
// Local variables
GtkTreeIter from_iter, to_iter;
GtkTreePath *new_path; // Temporary path
GList *next_slide; // Pointer to the slide below
gint num_slides; // The total number of slides
GtkTreePath *old_path = NULL; // The old path, which we'll free
gint slide_position; // Which slide in the slide list we are moving
slide *this_slide_data; // Pointer to the data for this slide
GString *tmp_gstring;
// Initialise some things
tmp_gstring = g_string_new(NULL);
// Safety check
set_slides(g_list_first(get_slides()));
slide_position = g_list_position(get_slides(), get_current_slide());
num_slides = g_list_length(get_slides());
if (num_slides == (slide_position + 1))
{
// We can't move the bottom most slide any further down, so just return
return;
}
// Swap the slides around
this_slide_data = get_current_slide_data();
next_slide = g_list_nth(get_slides(), slide_position + 1);
set_current_slide_data(next_slide->data);
next_slide->data = this_slide_data;
set_current_slide(next_slide);
// Move the thumbnail down one position in the film strip list
g_string_printf(tmp_gstring, "%u", slide_position);
if (TRUE == gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(get_film_strip_store()), &from_iter, tmp_gstring->str))
{
g_string_printf(tmp_gstring, "%u", slide_position + 1);
if (TRUE == gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(get_film_strip_store()), &to_iter, tmp_gstring->str))
{
gtk_list_store_move_after(GTK_LIST_STORE(get_film_strip_store()), &from_iter, &to_iter);
}
}
g_string_free(tmp_gstring, TRUE);
// Scroll the film strip to show the new thumbnail position
gtk_tree_view_get_cursor(GTK_TREE_VIEW(get_film_strip_view()), &new_path, NULL);
if (NULL != new_path)
old_path = new_path; // Make a backup of the old path, so we can free it
new_path = gtk_tree_path_new_from_indices(slide_position + 1, -1);
gtk_tree_view_set_cursor(GTK_TREE_VIEW(get_film_strip_view()), new_path, NULL, FALSE);
gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(get_film_strip_view()), new_path, NULL, TRUE, 0.5, 0.0);
if (NULL != old_path)
gtk_tree_path_free(old_path); // Free the old path
// Set the changes made variable
set_changes_made(TRUE);
// Update the status bar
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(get_status_bar()), _(" Slide moved down"));
gdk_flush();
}
