4a7ebbf91a516d588a7dcc45921c17a896b65f62JazzyNico

4a7ebbf91a516d588a7dcc45921c17a896b65f62JazzyNico#ifdef HAVE_CONFIG_H

4a7ebbf91a516d588a7dcc45921c17a896b65f62JazzyNico# include <config.h>

4a7ebbf91a516d588a7dcc45921c17a896b65f62JazzyNico#endif

4a7ebbf91a516d588a7dcc45921c17a896b65f62JazzyNico

4a7ebbf91a516d588a7dcc45921c17a896b65f62JazzyNico#include <stdio.h> // rename()

4a7ebbf91a516d588a7dcc45921c17a896b65f62JazzyNico#include <unistd.h> // close()

4a7ebbf91a516d588a7dcc45921c17a896b65f62JazzyNico#include <errno.h> // errno

4a7ebbf91a516d588a7dcc45921c17a896b65f62JazzyNico#include <string.h> // strerror()

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner#include "path-prefix.h"

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner#include "ocaldialogs.h"

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner#include "filedialogimpl-gtkmm.h"

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner#include "interface.h"

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner#include "gc-core.h"

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner#include <dialogs/dialog-events.h>

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner#include "io/sys.h"

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner#include "preferences.h"

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapennernamespace Inkscape

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner{

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapennernamespace UI

4a7ebbf91a516d588a7dcc45921c17a896b65f62JazzyNico{

4a7ebbf91a516d588a7dcc45921c17a896b65f62JazzyNiconamespace Dialog

4a7ebbf91a516d588a7dcc45921c17a896b65f62JazzyNico{

4a7ebbf91a516d588a7dcc45921c17a896b65f62JazzyNiconamespace OCAL

4a7ebbf91a516d588a7dcc45921c17a896b65f62JazzyNico{

4a7ebbf91a516d588a7dcc45921c17a896b65f62JazzyNico

4a7ebbf91a516d588a7dcc45921c17a896b65f62JazzyNico

4a7ebbf91a516d588a7dcc45921c17a896b65f62JazzyNico /*

4a7ebbf91a516d588a7dcc45921c17a896b65f62JazzyNico /* Initalize to Autodetect */

4a7ebbf91a516d588a7dcc45921c17a896b65f62JazzyNico /* No filename to start out with */

4a7ebbf91a516d588a7dcc45921c17a896b65f62JazzyNico /* Set our dialog type (save, export, etc...)*/

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner /*

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner /* No username and password to start out with */

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapennerLoadingBox::LoadingBox() : Gtk::EventBox()

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner{

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner set_visible_window(false);

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner draw_spinner = false;

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner spinner_step = 0;

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner signal_expose_event().connect(sigc::mem_fun(*this, &LoadingBox::_on_expose_event), false);

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner}

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapennerbool LoadingBox::_on_expose_event(GdkEventExpose* event)

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner{

ffbd2f8fa3a83d1d4ad8cd672cf738ffaa5cdfeeapenner Cairo::RefPtr<Cairo::Context> cr = get_window()->create_cairo_context();

4a7ebbf91a516d588a7dcc45921c17a896b65f62JazzyNico

4a7ebbf91a516d588a7dcc45921c17a896b65f62JazzyNico // Draw shadow

int x = get_allocation().get_x();

int y = get_allocation().get_y();

int width = get_allocation().get_width();

int height = get_allocation().get_height();

get_style()->paint_shadow(get_window(), get_state(), Gtk::SHADOW_IN,

Gdk::Rectangle(x, y, width, height),

*this, Glib::ustring::ustring("viewport"), x, y, width, height);

if (draw_spinner) {

int spinner_size = 16;

int spinner_x = x + (width - spinner_size) / 2;

int spinner_y = y + (height - spinner_size) / 2;

// FIXME: Gtk::Style::paint_spinner not yet in gtkmm

gtk_paint_spinner(gtk_widget_get_style(GTK_WIDGET(gobj())),

gtk_widget_get_window(GTK_WIDGET(gobj())),

gtk_widget_get_state(GTK_WIDGET(gobj())), NULL, GTK_WIDGET(gobj()),

NULL, spinner_step, spinner_x, spinner_y, spinner_size, spinner_size);

}

return false;

}

void LoadingBox::start()

{

// Timeout hasn't been stopped, so must be disconnected

if ((draw_spinner != false) & (timeout != NULL)) {

timeout.disconnect();

}

draw_spinner = true;

timeout = Glib::signal_timeout().connect(sigc::mem_fun(*this, &LoadingBox::on_timeout), 80);

}

void LoadingBox::stop()

{

draw_spinner = false;

}

bool LoadingBox::on_timeout() {

if (draw_spinner) {

if (spinner_step == 11) {

spinner_step = 0;

} else {

spinner_step ++;

}

queue_draw();

return true;

}

return false;

}

PreviewWidget::PreviewWidget() : Gtk::VBox(false, 12)

{

box_loading = new LoadingBox();

image = new Gtk::Image();

label_title = new Gtk::Label();

label_description = new Gtk::Label();

label_time = new Gtk::Label();

pack_start(*box_loading, false, false);

pack_start(*image, false, false);

pack_start(*label_title, false, false);

pack_start(*label_description, false, false);

pack_start(*label_time, false, false);

label_title->set_line_wrap(true);

label_title->set_line_wrap_mode(Pango::WRAP_WORD_CHAR);

label_description->set_line_wrap(true);

label_description->set_line_wrap_mode(Pango::WRAP_WORD_CHAR);

label_time->set_line_wrap(true);

label_time->set_line_wrap_mode(Pango::WRAP_WORD_CHAR);

box_loading->set_no_show_all(true);

image->set_no_show_all(true);

label_title->set_size_request(90, -1);

label_description->set_size_request(90, -1);

label_time->set_size_request(90, -1);

box_loading->set_size_request(90, 90);

set_border_width(12);

signal_expose_event().connect(sigc::mem_fun(*this, &PreviewWidget::_on_expose_event), false);

clear();

}

void PreviewWidget::set_metadata(Glib::ustring description, Glib::ustring creator,

Glib::ustring time)

{

label_title->set_markup(g_markup_printf_escaped("<b>%s</b>", description.c_str()));

label_description->set_markup(g_markup_printf_escaped("%s", creator.c_str()));

label_time->set_markup(g_markup_printf_escaped("<small>%s</small>", time.c_str()));

show_box_loading();

}

void PreviewWidget::show_box_loading()

{

box_loading->show();

box_loading->start();

}

void PreviewWidget::hide_box_loading()

{

box_loading->hide();

box_loading->stop();

}

void PreviewWidget::set_image(std::string path)

{

image->set(path);

hide_box_loading();

image->show();

}

void PreviewWidget::clear()

{

label_title->set_markup("");

label_description->set_markup("");

label_time->set_markup("");

box_loading->hide();

image->hide();

}

bool PreviewWidget::_on_expose_event(GdkEventExpose* event)

{

Cairo::RefPtr<Cairo::Context> cr = get_window()->create_cairo_context();

// Draw background

int x = get_allocation().get_x();

int y = get_allocation().get_y();

int width = get_allocation().get_width();

int height = get_allocation().get_height();

Gdk::Color background_fill = get_style()->get_base(get_state());

cr->rectangle(x, y, width, height);

Gdk::Cairo::set_source_color(cr, background_fill);

cr->fill();

return false;

}

StatusWidget::StatusWidget() : Gtk::HBox(false, 6)

{

image = new Gtk::Image(Gtk::Stock::DIALOG_ERROR, Gtk::ICON_SIZE_MENU);

spinner = new Gtk::Spinner();

label = new Gtk::Label();

image->set_no_show_all(true);

spinner->set_no_show_all(true);

label->set_no_show_all(true);

pack_start(*image, false, false);

pack_start(*spinner, false, false);

pack_start(*label, false, false);

}

void StatusWidget::clear()

{

spinner->hide();

image->hide();

label->hide();

}

void StatusWidget::set_info(Glib::ustring text)

{

spinner->hide();

image->show();

label->show();

image->set(Gtk::Stock::DIALOG_INFO, Gtk::ICON_SIZE_MENU);

label->set_text(text);

}

void StatusWidget::set_error(Glib::ustring text)

{

spinner->hide();

image->show();

label->show();

image->set(Gtk::Stock::DIALOG_ERROR, Gtk::ICON_SIZE_MENU);

label->set_text(text);

}

void StatusWidget::start_process(Glib::ustring text)

{

image->hide();

spinner->show();

label->show();

label->set_text(text);

spinner->start();

show_all();

}

void StatusWidget::end_process()

{

spinner->stop();

spinner->hide();

label->hide();

clear();

}

SearchEntry::SearchEntry() : Gtk::Entry()

{

signal_changed().connect(sigc::mem_fun(*this, &SearchEntry::_on_changed));

signal_icon_press().connect(sigc::mem_fun(*this, &SearchEntry::_on_icon_pressed));

set_icon_from_stock(Gtk::Stock::FIND, Gtk::ENTRY_ICON_PRIMARY);

gtk_entry_set_icon_from_stock(gobj(), GTK_ENTRY_ICON_SECONDARY, NULL);

}

void SearchEntry::_on_icon_pressed(Gtk::EntryIconPosition icon_position, const GdkEventButton* event)

{

if (icon_position == Gtk::ENTRY_ICON_SECONDARY) {

grab_focus();

set_text("");

} else if (icon_position == Gtk::ENTRY_ICON_PRIMARY) {

select_region(0, -1);

grab_focus();

}

}

void SearchEntry::_on_changed()

{

if (get_text().empty()) {

gtk_entry_set_icon_from_stock(gobj(), GTK_ENTRY_ICON_SECONDARY, NULL);

} else {

set_icon_from_stock(Gtk::Stock::CLEAR, Gtk::ENTRY_ICON_SECONDARY);

}

}

BaseBox::BaseBox() : Gtk::EventBox()

{

signal_expose_event().connect(sigc::mem_fun(*this, &BaseBox::_on_expose_event), false);

set_visible_window(false);

}

bool BaseBox::_on_expose_event(GdkEventExpose* event)

{

Cairo::RefPtr<Cairo::Context> cr = get_window()->create_cairo_context();

// Draw background and shadow

int x = get_allocation().get_x();

int y = get_allocation().get_y();

int width = get_allocation().get_width();

int height = get_allocation().get_height();

Gdk::Color background_fill = get_style()->get_base(get_state());

cr->rectangle(x, y, width, height);

Gdk::Cairo::set_source_color(cr, background_fill);

cr->fill();

get_style()->paint_shadow(get_window(), get_state(), Gtk::SHADOW_IN,

Gdk::Rectangle(x, y, width, height),

*this, Glib::ustring::ustring("viewport"), x, y, width, height);

return false;

}

LogoArea::LogoArea() : Gtk::EventBox()

{

// Try to load the OCAL logo, but if the file is not found, degrade gracefully

try {

std::string logo_path = Glib::build_filename(INKSCAPE_PIXMAPDIR, "OCAL.png");

logo_mask = Cairo::ImageSurface::create_from_png(logo_path);

draw_logo = true;

} catch(Cairo::logic_error) {

logo_mask = Cairo::ImageSurface::create(Cairo::FORMAT_ARGB32, 1,1);

draw_logo = false;

}

signal_expose_event().connect(sigc::mem_fun(*this, &LogoArea::_on_expose_event));

set_visible_window(false);

}

bool LogoArea::_on_expose_event(GdkEventExpose* event)

{

if (draw_logo) {

int x = get_allocation().get_x();

int y = get_allocation().get_y();

int width = get_allocation().get_width();

int height = get_allocation().get_height();

int x_logo = x + (width - 220) / 2;

int y_logo = y + (height - 76) / 2;

Cairo::RefPtr<Cairo::Context> cr = get_window()->create_cairo_context();

// Draw logo, we mask [read fill] it with the mid colour from the

// user's GTK theme

Gdk::Color logo_fill = get_style()->get_mid(get_state());

Gdk::Cairo::set_source_color(cr, logo_fill);

cr->mask(logo_mask, x_logo, y_logo);

}

return false;

}

SearchResultList::SearchResultList(guint columns_count) : ListViewText(columns_count)

{

set_headers_visible(false);

set_column_title(RESULTS_COLUMN_MARKUP, _("Clipart found"));

Gtk::CellRenderer* cr_markup = get_column_cell_renderer(RESULTS_COLUMN_MARKUP);

cr_markup->set_property("ellipsize", Pango::ELLIPSIZE_END);

get_column(RESULTS_COLUMN_MARKUP)->clear_attributes(*cr_markup);

get_column(RESULTS_COLUMN_MARKUP)->add_attribute(*cr_markup,

"markup", RESULTS_COLUMN_MARKUP);

// Hide all columns except for the MARKUP column

for (int i = 0; i < RESULTS_COLUMN_LENGTH; i++) {

if (i != RESULTS_COLUMN_MARKUP) {

get_column(i)->set_visible(false);

}

}

}

void ImportDialog::on_button_import_clicked() {

std::vector<Gtk::TreeModel::Path> pathlist;

pathlist = list_results->get_selection()->get_selected_rows();

std::vector<int> posArray(1);

posArray = pathlist[0].get_indices();

int row = posArray[0];

download_image(row);

widget_status->start_process(_("Downloading image..."));

}

void ImportDialog::on_list_results_cursor_changed()

{

std::vector<Gtk::TreeModel::Path> pathlist;

pathlist = list_results->get_selection()->get_selected_rows();

std::vector<int> posArray(1);

posArray = pathlist[0].get_indices();

int row = posArray[0];

// FIXME: this would be better as a per-user OCAL cache of files

// instead of filling /tmp with downloads.

update_preview(row);

download_thumbnail_image(row);

}

void ImportDialog::update_preview(int row)

{

Glib::ustring description = list_results->get_text(row, RESULTS_COLUMN_DESCRIPTION);

Glib::ustring creator = list_results->get_text(row, RESULTS_COLUMN_CREATOR);

Glib::ustring date = list_results->get_text(row, RESULTS_COLUMN_DATE);

preview_files->clear();

preview_files->set_metadata(description, creator, date);

}

std::string ImportDialog::get_temporary_dir(DownloadType type)

{

std::string ocal_tmp_dir = Glib::build_filename(Glib::get_tmp_dir(),

"openclipart");

if (type == TYPE_THUMBNAIL) {

return Glib::build_filename(ocal_tmp_dir, "thumbnails");

} else {

return Glib::build_filename(ocal_tmp_dir, "images");

}

}

void ImportDialog::create_temporary_dirs()

{

// Make sure the temporary directories exists, if not, create them

std::string ocal_tmp_thumbnail_dir = get_temporary_dir(TYPE_THUMBNAIL);

std::string ocal_tmp_image_dir = get_temporary_dir(TYPE_IMAGE);

if (!Glib::file_test(ocal_tmp_thumbnail_dir, Glib::FILE_TEST_EXISTS)) {

Glib::RefPtr<Gio::File> directory = Gio::File::create_for_path(ocal_tmp_thumbnail_dir);

directory->make_directory_with_parents();

}

if (!Glib::file_test(ocal_tmp_image_dir, Glib::FILE_TEST_EXISTS)) {

Glib::RefPtr<Gio::File> directory = Gio::File::create_for_path(ocal_tmp_image_dir);

directory->make_directory_with_parents();

}

}

void ImportDialog::download_image(int row)

{

// Get Remote File URL

Glib::ustring url = list_results->get_text(row, RESULTS_COLUMN_URL);

Glib::RefPtr<Gio::File> file_remote = Gio::File::create_for_uri(url.c_str());

std::string ocal_tmp_image_dir = get_temporary_dir(TYPE_IMAGE);

// Make a unique filename for the clipart, in the form 'GUID.extension'

Glib::ustring guid = list_results->get_text(row, RESULTS_COLUMN_GUID);

Glib::ustring original_filename = list_results->get_text(row, RESULTS_COLUMN_FILENAME);

Glib::ustring extension = Inkscape::IO::get_file_extension(original_filename);

Glib::ustring filename = Glib::ustring::compose("%1%2", guid, extension);

std::string path = Glib::build_filename(ocal_tmp_image_dir, filename.c_str());

// Download it asynchronously

Glib::RefPtr<Gio::File> file_local = Gio::File::create_for_path(path);

file_remote->copy_async(file_local,

sigc::bind<Glib::RefPtr<Gio::File> , Glib::ustring>(

sigc::mem_fun(*this, &ImportDialog::on_image_downloaded),

file_remote, path),

Gio::FILE_COPY_OVERWRITE);

}

void ImportDialog::on_image_downloaded(const Glib::RefPtr<Gio::AsyncResult>& result,

Glib::RefPtr<Gio::File> file_remote, Glib::ustring path)

{

// Try to show the the thumbnail in the Preview widget

bool success = file_remote->copy_finish(result);

try {

widget_status->clear();

m_signal_response.emit(path);

widget_status->set_info(_("Clipart downloaded successfully"));

} catch(Glib::Error) {

success = false;

}

// If anything went wrong, show an error message

if (!success) {

widget_status->set_error(_("Could not download image"));

path = "";

}

}

void ImportDialog::download_thumbnail_image(int row)

{

// Get Remote File URL

Glib::ustring url = list_results->get_text(row, RESULTS_COLUMN_THUMBNAIL_URL);

Glib::RefPtr<Gio::File> file_thumbnail_remote = Gio::File::create_for_uri(url);

std::string ocal_tmp_thumbnail_dir = get_temporary_dir(TYPE_THUMBNAIL);

// Make a unique filename for the clipart, in the form 'GUID.extension'

Glib::ustring guid = list_results->get_text(row, RESULTS_COLUMN_GUID);

Glib::ustring original_filename = list_results->get_text(row, RESULTS_COLUMN_THUMBNAIL_FILENAME);

Glib::ustring extension = Inkscape::IO::get_file_extension(original_filename);

Glib::ustring filename_thumbnail = Glib::ustring::compose("%1%2", guid, extension);

std::string path_thumbnail = Glib::build_filename(ocal_tmp_thumbnail_dir, filename_thumbnail.c_str());

// Download it asynchronously

Glib::RefPtr<Gio::File> file_thumbnail_local = Gio::File::create_for_path(path_thumbnail);

file_thumbnail_remote->copy_async(file_thumbnail_local,

sigc::bind<Glib::RefPtr<Gio::File> , Glib::ustring>(

sigc::mem_fun(*this, &ImportDialog::on_thumbnail_image_downloaded),

file_thumbnail_remote, path_thumbnail),

Gio::FILE_COPY_OVERWRITE);

}

void ImportDialog::on_thumbnail_image_downloaded(const Glib::RefPtr<Gio::AsyncResult>& result,

Glib::RefPtr<Gio::File> file_thumbnail_remote, Glib::ustring path_thumbnail)

{

// Try to show the the thumbnail in the Preview widget

bool success = file_thumbnail_remote->copy_finish(result);

try {

widget_status->clear();

preview_files->set_image(path_thumbnail);

} catch(Glib::Error) {

success = false;

}

// If anything went wrong, show an error message

if (!success) {

widget_status->set_error(_("Could not download thumbnail file"));

path_thumbnail = "";

}

}

void ImportDialog::on_list_results_row_activated(const Gtk::TreeModel::Path& path,

Gtk::TreeViewColumn* column)

{

on_list_results_cursor_changed();

button_import->signal_clicked();

}

void SearchResultList::populate_from_xml(xmlNode * a_node)

{

xmlNode *cur_node = NULL;

guint row_num = 0;

for (cur_node = a_node; cur_node; cur_node = cur_node->next) {

// Get items information

if (strcmp((const char*)cur_node->name, "rss")) // Avoid the root

if (cur_node->type == XML_ELEMENT_NODE && !strcmp((const char*)cur_node->parent->name, "item"))

{

if (!strcmp((const char*)cur_node->name, "title"))

{

row_num = append_text("");

xmlChar *xml_title = xmlNodeGetContent(cur_node);

char* title = (char*) xml_title;

set_text(row_num, RESULTS_COLUMN_TITLE, title);

xmlFree(title);

}

else if (!strcmp((const char*)cur_node->name, "pubDate"))

{

xmlChar *xml_date = xmlNodeGetContent(cur_node);

char* date = (char*) xml_date;

set_text(row_num, RESULTS_COLUMN_DATE, date);

xmlFree(xml_date);

}

else if (!strcmp((const char*)cur_node->name, "creator"))

{

xmlChar *xml_creator = xmlNodeGetContent(cur_node);

char* creator = (char*) xml_creator;

set_text(row_num, RESULTS_COLUMN_CREATOR, creator);

xmlFree(xml_creator);

}

else if (!strcmp((const char*)cur_node->name, "description"))

{

xmlChar *xml_description = xmlNodeGetContent(cur_node);

//char* final_description;

char* stripped_description = g_strstrip((char*) xml_description);

if (!strcmp(stripped_description, "")) {

stripped_description = _("No description");

}

//GRegex* regex = g_regex_new(g_regex_escape_string(stripped_description, -1));

//final_description = g_regex_replace_literal(regex, "\n", -1, 0, " ");

set_text(row_num, RESULTS_COLUMN_DESCRIPTION, stripped_description);

xmlFree(xml_description);

}

else if (!strcmp((const char*)cur_node->name, "enclosure"))

{

xmlChar *xml_url = xmlGetProp(cur_node, (xmlChar*) "url");

char* url = (char*) xml_url;

char* filename = g_path_get_basename(url);

set_text(row_num, RESULTS_COLUMN_URL, url);

set_text(row_num, RESULTS_COLUMN_FILENAME, filename);

xmlFree(xml_url);

}

else if (!strcmp((const char*)cur_node->name, "thumbnail"))

{

xmlChar *xml_thumbnail_url = xmlGetProp(cur_node, (xmlChar*) "url");

char* thumbnail_url = (char*) xml_thumbnail_url;

char* thumbnail_filename = g_path_get_basename(thumbnail_url);

set_text(row_num, RESULTS_COLUMN_THUMBNAIL_URL, thumbnail_url);

set_text(row_num, RESULTS_COLUMN_THUMBNAIL_FILENAME, thumbnail_filename);

xmlFree(xml_thumbnail_url);

}

else if (!strcmp((const char*)cur_node->name, "guid"))

{

xmlChar *xml_guid = xmlNodeGetContent(cur_node);

char* guid_url = (char*) xml_guid;

char* guid = g_path_get_basename(guid_url);

set_text(row_num, RESULTS_COLUMN_GUID, guid);

xmlFree(xml_guid);

}

}

populate_from_xml(cur_node->children);

}

}

void ImportDialog::on_button_search_clicked()

{

on_entry_search_activated();

}

void ImportDialog::on_button_close_clicked()

{

hide_all();

}

void ImportDialog::on_entry_search_activated()

{

widget_status->start_process(_("Searching clipart..."));

notebook_content->set_current_page(NOTEBOOK_PAGE_LOGO);

Inkscape::Preferences *prefs = Inkscape::Preferences::get();

Glib::ustring search_keywords = entry_search->get_text();

// Create the URI to the OCAL RSS feed

xml_uri = Glib::ustring::compose("http://%1/media/feed/rss/%2",

prefs->getString("/options/ocalurl/str"), search_keywords);

// If we are not UTF8

if (!Glib::get_charset()) {

xml_uri = Glib::filename_to_utf8(xml_uri);

}

// Open the rss feed

xml_file = Gio::File::create_for_uri(xml_uri);

xml_file->load_contents_async(sigc::mem_fun(*this, &ImportDialog::on_xml_file_read));

}

void ImportDialog::on_xml_file_read(const Glib::RefPtr<Gio::AsyncResult>& result)

{

widget_status->end_process();

char* data;

gsize length;

bool sucess = xml_file->load_contents_finish(result, data, length);

if (!sucess) {

widget_status->set_error(_("Could not connect to the Open Clip Art Library"));

return;

}

// Create the resulting xml document tree

// Initialize libxml and test mistakes between compiled and shared library used

LIBXML_TEST_VERSION

xmlDoc *doc = NULL;

xmlNode *root_element = NULL;

doc = xmlReadMemory(data, (int) length, xml_uri.c_str(), NULL,

XML_PARSE_RECOVER + XML_PARSE_NOWARNING + XML_PARSE_NOERROR);

if (doc == NULL) {

// If nothing is returned, no results could be found

if (length == 0) {

notebook_content->set_current_page(NOTEBOOK_PAGE_NOT_FOUND);

update_label_no_search_results();

} else {

widget_status->set_error(_("Could not parse search results"));

}

return;

}

// Get the root element node

root_element = xmlDocGetRootElement(doc);

// Clear and populate the list_results

list_results->clear_items();

list_results->populate_from_xml(root_element);

// Populate the MARKUP column with the title & description of the clipart

for (guint i = 0; i <= list_results->size() - 1; i++) {

Glib::ustring title = list_results->get_text(i, RESULTS_COLUMN_TITLE);

Glib::ustring description = list_results->get_text(i, RESULTS_COLUMN_DESCRIPTION);

char* markup = g_markup_printf_escaped("<b>%s</b>\n<span size=\"small\">%s</span>",

title.c_str(), description.c_str());

list_results->set_text(i, RESULTS_COLUMN_MARKUP, markup);

}

notebook_content->set_current_page(NOTEBOOK_PAGE_RESULTS);

// free the document

xmlFreeDoc(doc);

// free the global variables that may have been allocated by the parser

xmlCleanupParser();

}

void ImportDialog::update_label_no_search_results()

{

Glib::ustring keywords = Glib::Markup::escape_text(entry_search->get_text());

Gdk::Color grey = entry_search->get_style()->get_text_aa(entry_search->get_state());

Glib::ustring markup = Glib::ustring::compose(

"<span size=\"large\">%1 <b>%2</b> %3</span>\n<span color=\"%4\">%5</span>",

_("No clipart named"), keywords, _("was found."), grey.to_string(),

_("Please make sure all keywords are spelled correctly, or try again with different keywords."));

label_not_found->set_markup(markup);

}

ImportDialog::ImportDialog(Gtk::Window& parent_window,

const Glib::ustring &/*dir*/,

FileDialogType file_types,

const Glib::ustring &title) :

FileDialogBase(title, parent_window)

{

// Initalize to Autodetect

extension = NULL;

// No filename to start out with

Glib::ustring search_keywords = "";

dialogType = file_types;

// Creation

Gtk::VBox *vbox = new Gtk::VBox(false, 0);

Gtk::HButtonBox *hbuttonbox_bottom = new Gtk::HButtonBox();

Gtk::HBox *hbox_bottom = new Gtk::HBox(false, 12);

BaseBox *basebox_logo = new BaseBox();

BaseBox *basebox_no_search_results = new BaseBox();

label_not_found = new Gtk::Label();

label_description = new Gtk::Label();

entry_search = new SearchEntry();

button_search = new Gtk::Button(_("Search"));

Gtk::HButtonBox* hbuttonbox_search = new Gtk::HButtonBox();

Gtk::ScrolledWindow* scrolledwindow_preview = new Gtk::ScrolledWindow();

preview_files = new PreviewWidget();

/// Add the buttons in the bottom of the dialog

button_cancel = new Gtk::Button(Gtk::Stock::CANCEL);

button_close = new Gtk::Button(_("Close"));

button_import = new Gtk::Button(_("Import"));

list_results = new SearchResultList(RESULTS_COLUMN_LENGTH);

drawingarea_logo = new LogoArea();

notebook_content = new Gtk::Notebook();

widget_status = new StatusWidget();

// Packing

this->add(*vbox);

vbox->pack_start(hbox_tags, false, false);

vbox->pack_start(hbox_files, true, true);

vbox->pack_start(*hbox_bottom, false, false);

basebox_logo->add(*drawingarea_logo);

basebox_no_search_results->add(*label_not_found);

hbox_bottom->pack_start(*widget_status, true, true);

hbox_bottom->pack_start(*hbuttonbox_bottom, true, true);

hbuttonbox_bottom->pack_start(*button_cancel, false, false);

hbuttonbox_bottom->pack_start(*button_close, false, false);

hbuttonbox_bottom->pack_start(*button_import, false, false);

hbuttonbox_search->pack_start(*button_search, false, false);

hbox_tags.pack_start(*entry_search, true, true);

hbox_tags.pack_start(*hbuttonbox_search, false, false);

hbox_files.pack_start(*notebook_content, true, true);

scrolledwindow_preview->add(*preview_files);

hbox_files.pack_start(*scrolledwindow_preview, true, true);

notebook_content->insert_page(*basebox_logo, NOTEBOOK_PAGE_LOGO);

notebook_content->insert_page(scrolledwindow_list, NOTEBOOK_PAGE_RESULTS);

notebook_content->insert_page(*basebox_no_search_results, NOTEBOOK_PAGE_NOT_FOUND);

// Properties

set_border_width(12);

set_default_size(480, 320);

vbox->set_spacing(12);

hbuttonbox_bottom->set_spacing(6);

hbuttonbox_bottom->set_layout(Gtk::BUTTONBOX_END);

//button_import->set_sensitive(false);

entry_search->set_max_length(255);

hbox_tags.set_spacing(6);

preview_files->clear();

notebook_content->set_current_page(NOTEBOOK_PAGE_LOGO);

/// Add the listview inside a ScrolledWindow

scrolledwindow_list.add(*list_results);

scrolledwindow_list.set_shadow_type(Gtk::SHADOW_IN);

/// Only show the scrollbars when they are necessary

scrolledwindow_list.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

scrolledwindow_list.set_size_request(310, 230);

drawingarea_logo->set_size_request(310, 230);

hbox_files.set_spacing(12);

label_not_found->set_line_wrap(true);

label_not_found->set_line_wrap_mode(Pango::WRAP_WORD);

label_not_found->set_justify(Gtk::JUSTIFY_CENTER);

label_not_found->set_size_request(260, -1);

scrolledwindow_preview->set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);

notebook_content->set_show_tabs(false);

notebook_content->set_show_border(false);

button_cancel->set_no_show_all(true);

button_close->set_no_show_all(true);

button_close->show();

button_cancel->hide();

// Signals

entry_search->signal_activate().connect(

sigc::mem_fun(*this, &ImportDialog::on_entry_search_activated));

button_import->signal_clicked().connect(

sigc::mem_fun(*this, &ImportDialog::on_button_import_clicked));

button_close->signal_clicked().connect(

sigc::mem_fun(*this, &ImportDialog::on_button_close_clicked));

button_search->signal_clicked().connect(

sigc::mem_fun(*this, &ImportDialog::on_button_search_clicked));

list_results->signal_cursor_changed().connect(

sigc::mem_fun(*this, &ImportDialog::on_list_results_cursor_changed));

list_results->signal_row_activated().connect(

sigc::mem_fun(*this, &ImportDialog::on_list_results_row_activated));

show_all_children();

entry_search->grab_focus();

// Make sure the temporary directories needed later exist

create_temporary_dirs();

}

ImportDialog::~ImportDialog()

{

}

Inkscape::Extension::Extension *

ImportDialog::get_selection_type()

{

return extension;

}

ImportDialog::type_signal_response ImportDialog::signal_response()

{

return m_signal_response;

}

} //namespace OCAL

} //namespace Dialog

} //namespace UI

} //namespace Inkscape