src/ui/dialog/ocaldialogs.cpp

   1 /**\r
   2  * Implementation of the OCAL import/export dialogs\r
   3  *\r
   4  * Authors:\r
   5  *   Joel Holdsworth\r
   6  *   Bruno Dilly\r
   7  *   Other dudes from The Inkscape Organization\r
   8  *\r
   9  * Copyright (C) 2007 Bruno Dilly\r
  10  *\r
  11  * Released under GNU GPL, read the file 'COPYING' for more information\r
  12  */\r
  13 \r
  14 #ifdef HAVE_CONFIG_H\r
  15 # include <config.h>\r
  16 #endif\r
  17 \r
  18 #include "ocaldialogs.h"\r
  19 #include "dialogs/dialog-events.h"\r
  20 #include "interface.h"\r
  21 \r
  22 #ifdef WITH_GNOME_VFS\r
  23 # include <libgnomevfs/gnome-vfs.h>\r
  24 #endif\r
  25 \r
  26 namespace Inkscape\r
  27 {\r
  28 namespace UI\r
  29 {\r
  30 namespace Dialog\r
  31 {
  32
  33 //########################################################################\r
  34 //# F I L E    E X P O R T   T O   O C A L\r
  35 //########################################################################\r
  36 \r
  37 \r
  38 \r
  39 /**\r
  40  * Callback for fileNameEntry widget\r
  41  */\r
  42 void FileExportToOCALDialog::fileNameEntryChangedCallback()\r
  43 {\r
  44     if (!fileNameEntry)\r
  45         return;\r
  46 \r
  47     Glib::ustring fileName = fileNameEntry->get_text();\r
  48     if (!Glib::get_charset()) //If we are not utf8\r
  49         fileName = Glib::filename_to_utf8(fileName);\r
  50 \r
  51     myFilename = fileName;\r
  52     response(Gtk::RESPONSE_OK);\r
  53 }\r
  54 \r
  55 \r
  56 \r
  57 /**\r
  58  * Callback for fileNameEntry widget\r
  59  */\r
  60 void FileExportToOCALDialog::fileTypeChangedCallback()\r
  61 {\r
  62     int sel = fileTypeComboBox.get_active_row_number();\r
  63     if (sel<0 || sel >= (int)fileTypes.size())\r
  64         return;\r
  65     FileType type = fileTypes[sel];\r
  66 \r
  67     extension = type.extension;\r
  68     updateNameAndExtension();\r
  69 }\r
  70 \r
  71 \r
  72 \r
  73 void FileExportToOCALDialog::createFileTypeMenu()\r
  74 {\r
  75     Inkscape::Extension::DB::OutputList extension_list;\r
  76     Inkscape::Extension::db.get_output_list(extension_list);\r
  77     knownExtensions.clear();\r
  78 \r
  79     for (Inkscape::Extension::DB::OutputList::iterator current_item = extension_list.begin();\r
  80          current_item != extension_list.end(); current_item++)\r
  81     {\r
  82         Inkscape::Extension::Output * omod = *current_item;\r
  83 \r
  84         // FIXME: would be nice to grey them out instead of not listing them\r
  85         if (omod->deactivated()) continue;\r
  86 \r
  87         FileType type;\r
  88         type.name     = (_(omod->get_filetypename()));\r
  89         type.pattern  = "*";\r
  90         Glib::ustring extension = omod->get_extension();\r
  91         knownExtensions.insert( extension.casefold() );\r
  92         fileDialogExtensionToPattern (type.pattern, extension);\r
  93         type.extension= omod;\r
  94         fileTypeComboBox.append_text(type.name);\r
  95         fileTypes.push_back(type);\r
  96     }\r
  97 \r
  98     //#Let user choose\r
  99     FileType guessType;\r
 100     guessType.name = _("Guess from extension");\r
 101     guessType.pattern = "*";\r
 102     guessType.extension = NULL;\r
 103     fileTypeComboBox.append_text(guessType.name);\r
 104     fileTypes.push_back(guessType);\r
 105 \r
 106 \r
 107     fileTypeComboBox.set_active(0);\r
 108     fileTypeChangedCallback(); //call at least once to set the filter\r
 109 }\r
 110 \r
 111 \r
 112 \r
 113 /**\r
 114  * Constructor\r
 115  */\r
 116 FileExportToOCALDialog::FileExportToOCALDialog(Gtk::Window &parentWindow,\r
 117             const Glib::ustring &title,\r
 118             const Glib::ustring &default_key) :\r
 119     FileDialogOCALBase(title)\r
 120 {\r
 121     /*\r
 122      * Start Taking the vertical Box and putting a Label\r
 123      * and a Entry to take the filename\r
 124      * Later put the extension selection and checkbox (?)\r
 125      */\r
 126     /* Initalize to Autodetect */\r
 127     extension = NULL;\r
 128     /* No filename to start out with */\r
 129     myFilename = "";\r
 130 \r
 131     Gtk::VBox *vbox = get_vbox();\r
 132 \r
 133     Gtk::Label *fileLabel = new Gtk::Label(_("File"));\r
 134 \r
 135     fileNameEntry = new Gtk::Entry();\r
 136     fileNameEntry->set_text(myFilename);\r
 137     fileNameEntry->set_max_length(252); // I am giving the extension approach.\r
 138     fileBox.pack_start(*fileLabel);\r
 139     fileBox.pack_start(*fileNameEntry, Gtk::PACK_EXPAND_WIDGET, 3);\r
 140     vbox->pack_start(fileBox);\r
 141 \r
 142     //###### Do we want the .xxx extension automatically added?\r
 143     fileTypeCheckbox.set_label(Glib::ustring(_("Append filename extension automatically")));\r
 144     fileTypeCheckbox.set_active( (bool)prefs_get_int_attribute("dialogs.export",\r
 145                                                                "append_extension", 1) );\r
 146 \r
 147     createFileTypeMenu();\r
 148 \r
 149     fileTypeComboBox.set_size_request(200,40);\r
 150     fileTypeComboBox.signal_changed().connect(\r
 151         sigc::mem_fun(*this, &FileExportToOCALDialog::fileTypeChangedCallback) );\r
 152 \r
 153     checksBox.pack_start( fileTypeCheckbox );\r
 154     vbox->pack_start( checksBox );\r
 155 \r
 156     vbox->pack_end( fileTypeComboBox );\r
 157 \r
 158     //Let's do some customization\r
 159     fileNameEntry = NULL;\r
 160     Gtk::Container *cont = get_toplevel();\r
 161     std::vector<Gtk::Entry *> entries;\r
 162     findEntryWidgets(cont, entries);\r
 163     //g_message("Found %d entry widgets\n", entries.size());\r
 164     if (entries.size() >=1 )\r
 165         {\r
 166         //Catch when user hits [return] on the text field\r
 167         fileNameEntry = entries[0];\r
 168         fileNameEntry->signal_activate().connect(\r
 169              sigc::mem_fun(*this, &FileExportToOCALDialog::fileNameEntryChangedCallback) );\r
 170         }\r
 171 \r
 172     //Let's do more customization\r
 173     std::vector<Gtk::Expander *> expanders;\r
 174     findExpanderWidgets(cont, expanders);\r
 175     //g_message("Found %d expander widgets\n", expanders.size());\r
 176     if (expanders.size() >=1 )\r
 177         {\r
 178         //Always show the file list\r
 179         Gtk::Expander *expander = expanders[0];\r
 180         expander->set_expanded(true);\r
 181         }\r
 182 \r
 183 \r
 184     add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);\r
 185     set_default(*add_button(Gtk::Stock::SAVE,   Gtk::RESPONSE_OK));\r
 186 \r
 187     show_all_children();\r
 188 }\r
 189 \r
 190 \r
 191 \r
 192 /**\r
 193  * Destructor\r
 194  */\r
 195 FileExportToOCALDialog::~FileExportToOCALDialog()\r
 196 {\r
 197 }\r
 198 \r
 199 \r
 200 \r
 201 /**\r
 202  * Show this dialog modally.  Return true if user hits [OK]\r
 203  */\r
 204 bool\r
 205 FileExportToOCALDialog::show()\r
 206 {\r
 207     set_modal (TRUE);                      //Window\r
 208     sp_transientize((GtkWidget *)gobj());  //Make transient\r
 209     gint b = run();                        //Dialog\r
 210     hide();\r
 211 \r
 212     if (b == Gtk::RESPONSE_OK)\r
 213     {\r
 214         updateNameAndExtension();\r
 215 \r
 216         return TRUE;\r
 217         }\r
 218     else\r
 219         {\r
 220         return FALSE;\r
 221         }\r
 222 }\r
 223 \r
 224 \r
 225 /**\r
 226  * Get the file extension type that was selected by the user. Valid after an [OK]\r
 227  */\r
 228 Inkscape::Extension::Extension *\r
 229 FileExportToOCALDialog::getSelectionType()\r
 230 {\r
 231     return extension;\r
 232 }\r
 233 \r
 234 void FileExportToOCALDialog::setSelectionType( Inkscape::Extension::Extension * key )\r
 235 {\r
 236     // If no pointer to extension is passed in, look up based on filename extension.\r
 237     if ( !key ) {\r
 238         // Not quite UTF-8 here.\r
 239         gchar *filenameLower = g_ascii_strdown(myFilename.c_str(), -1);\r
 240         for ( int i = 0; !key && (i < (int)fileTypes.size()); i++ ) {\r
 241             Inkscape::Extension::Output *ext = dynamic_cast<Inkscape::Extension::Output*>(fileTypes[i].extension);\r
 242             if ( ext && ext->get_extension() ) {\r
 243                 gchar *extensionLower = g_ascii_strdown( ext->get_extension(), -1 );\r
 244                 if ( g_str_has_suffix(filenameLower, extensionLower) ) {\r
 245                     key = fileTypes[i].extension;\r
 246                 }\r
 247                 g_free(extensionLower);\r
 248             }\r
 249         }\r
 250         g_free(filenameLower);\r
 251     }\r
 252 \r
 253     // Ensure the proper entry in the combo box is selected.\r
 254     if ( key ) {\r
 255         extension = key;\r
 256         gchar const * extensionID = extension->get_id();\r
 257         if ( extensionID ) {\r
 258             for ( int i = 0; i < (int)fileTypes.size(); i++ ) {\r
 259                 Inkscape::Extension::Extension *ext = fileTypes[i].extension;\r
 260                 if ( ext ) {\r
 261                     gchar const * id = ext->get_id();\r
 262                     if ( id && ( strcmp(extensionID, id) == 0) ) {\r
 263                         int oldSel = fileTypeComboBox.get_active_row_number();\r
 264                         if ( i != oldSel ) {\r
 265                             fileTypeComboBox.set_active(i);\r
 266                         }\r
 267                         break;\r
 268                     }\r
 269                 }\r
 270             }\r
 271         }\r
 272     }\r
 273 }\r
 274 \r
 275 \r
 276 /**\r
 277  * Get the file name chosen by the user.   Valid after an [OK]\r
 278  */\r
 279 Glib::ustring\r
 280 FileExportToOCALDialog::getFilename()\r
 281 {\r
 282     myFilename = fileNameEntry->get_text();\r
 283     updateNameAndExtension();\r
 284     return myFilename;\r
 285 }\r
 286 \r
 287 \r
 288 void\r
 289 FileExportToOCALDialog::change_title(const Glib::ustring& title)\r
 290 {\r
 291     this->set_title(title);\r
 292 }\r
 293 \r
 294 void FileExportToOCALDialog::updateNameAndExtension()\r
 295 {\r
 296     // Pick up any changes the user has typed in.\r
 297     Glib::ustring tmp = myFilename;   // get_filename();\r
 298 \r
 299     Inkscape::Extension::Output* newOut = extension ? dynamic_cast<Inkscape::Extension::Output*>(extension) : 0;\r
 300     if ( fileTypeCheckbox.get_active() && newOut ) {\r
 301         try {\r
 302             bool appendExtension = true;\r
 303             Glib::ustring utf8Name = Glib::filename_to_utf8( myFilename );\r
 304             Glib::ustring::size_type pos = utf8Name.rfind('.');\r
 305             if ( pos != Glib::ustring::npos ) {\r
 306                 Glib::ustring trail = utf8Name.substr( pos );\r
 307                 Glib::ustring foldedTrail = trail.casefold();\r
 308                 if ( (trail == ".")\r
 309                      | (foldedTrail != Glib::ustring( newOut->get_extension() ).casefold()\r
 310                         && ( knownExtensions.find(foldedTrail) != knownExtensions.end() ) ) ) {\r
 311                     utf8Name = utf8Name.erase( pos );\r
 312                 } else {\r
 313                     appendExtension = false;\r
 314                 }\r
 315             }\r
 316 \r
 317             if (appendExtension) {\r
 318                 utf8Name = utf8Name + newOut->get_extension();\r
 319                 myFilename = Glib::filename_from_utf8( utf8Name );\r
 320 \r
 321             }\r
 322         } catch ( Glib::ConvertError& e ) {\r
 323             // ignore\r
 324         }\r
 325     }\r
 326 }\r
 327 \r
 328 //#########################################################################\r
 329 //### F I L E   I M P O R T   F R O M   O C A L\r
 330 //#########################################################################\r
 331 \r
 332 /*\r
 333  * Callback for row activated\r
 334  */\r
 335 void FileListViewText::on_row_activated(const Gtk::TreeModel::Path& path, Gtk::TreeViewColumn* column)\r
 336 {\r
 337     // create file path\r
 338     myFilename = Glib::get_tmp_dir();\r
 339     myFilename.append(G_DIR_SEPARATOR_S);\r
 340     std::vector<int> posArray(1);\r
 341     posArray = path.get_indices();\r
 342     myFilename.append(get_text(posArray[0], 2));\r
 343     \r
 344 #ifdef WITH_GNOME_VFS\r
 345     gnome_vfs_init();\r
 346     GnomeVFSHandle    *from_handle = NULL;\r
 347     GnomeVFSHandle    *to_handle = NULL;\r
 348     GnomeVFSFileSize  bytes_read;\r
 349     GnomeVFSFileSize  bytes_written;\r
 350     GnomeVFSResult    result;\r
 351     guint8 buffer[8192];\r
 352 \r
 353     //get file url\r
 354     Glib::ustring fileUrl = get_text(posArray[0], 1); //http url\r
 355 \r
 356     //Glib::ustring fileUrl = "dav://"; //dav url\r
 357     //fileUrl.append(prefs_get_string_attribute("options.ocalurl", "str"));\r
 358     //fileUrl.append("/dav/");\r
 359     //fileUrl.append(get_text(posArray[0], 3)); //author dir\r
 360     //fileUrl.append("/");\r
 361     //fileUrl.append(get_text(posArray[0], 2)); //filename\r
 362 \r
 363     if (!Glib::get_charset()) //If we are not utf8\r
 364         fileUrl = Glib::filename_to_utf8(fileUrl);\r
 365 \r
 366     // verifies if the file wasn't previously downloaded\r
 367     if(gnome_vfs_open(&to_handle, myFilename.c_str(), GNOME_VFS_OPEN_READ) == GNOME_VFS_ERROR_NOT_FOUND)\r
 368     {\r
 369         // open the temp file to receive\r
 370         result = gnome_vfs_open (&to_handle, myFilename.c_str(), GNOME_VFS_OPEN_WRITE);\r
 371         if (result == GNOME_VFS_ERROR_NOT_FOUND){\r
 372             result = gnome_vfs_create (&to_handle, myFilename.c_str(), GNOME_VFS_OPEN_WRITE, FALSE, GNOME_VFS_PERM_USER_ALL);\r
 373         }\r
 374         if (result != GNOME_VFS_OK) {\r
 375             g_warning("Error creating temp file: %s", gnome_vfs_result_to_string(result));\r
 376             return;\r
 377         }\r
 378         result = gnome_vfs_open (&from_handle, fileUrl.c_str(), GNOME_VFS_OPEN_READ);\r
 379         if (result != GNOME_VFS_OK) {\r
 380             g_warning("Could not find the file in Open Clip Art Library.");\r
 381             return;\r
 382         }\r
 383         // copy the file\r
 384         while (1) {\r
 385             result = gnome_vfs_read (from_handle, buffer, 8192, &bytes_read);\r
 386             if ((result == GNOME_VFS_ERROR_EOF) &&(!bytes_read)){\r
 387                 result = gnome_vfs_close (from_handle);\r
 388                 result = gnome_vfs_close (to_handle);\r
 389                 break;\r
 390             }\r
 391             if (result != GNOME_VFS_OK) {\r
 392                 g_warning("%s", gnome_vfs_result_to_string(result));\r
 393                 return;\r
 394             }\r
 395             result = gnome_vfs_write (to_handle, buffer, bytes_read, &bytes_written);\r
 396             if (result != GNOME_VFS_OK) {\r
 397                 g_warning("%s", gnome_vfs_result_to_string(result));\r
 398                 return;\r
 399             }\r
 400             if (bytes_read != bytes_written){\r
 401                 g_warning("Bytes read not equal to bytes written");\r
 402                 return;\r
 403             }\r
 404         }\r
 405     }\r
 406     else\r
 407     {\r
 408         gnome_vfs_close(to_handle);\r
 409     }\r
 410     myPreview->showImage(myFilename);\r
 411 #endif\r
 412 }\r
 413 \r
 414 \r
 415 /*\r
 416  * Returns the selected filename\r
 417  */\r
 418 Glib::ustring FileListViewText::getFilename()\r
 419 {\r
 420     return myFilename;\r
 421 }\r
 422 \r
 423 /**\r
 424  * Callback for user input into searchTagEntry\r
 425  */\r
 426 void FileImportFromOCALDialog::searchTagEntryChangedCallback()\r
 427 {\r
 428     if (!searchTagEntry)\r
 429         return;\r
 430 \r
 431     notFoundLabel->hide();\r
 432 \r
 433     Glib::ustring searchTag = searchTagEntry->get_text();\r
 434     // create the ocal uri to get rss feed\r
 435     Glib::ustring uri = "http://www.";\r
 436     uri.append(prefs_get_string_attribute("options.ocalurl", "str"));\r
 437     uri.append("/media/feed/rss/");\r
 438     uri.append(searchTag);\r
 439     if (!Glib::get_charset()) //If we are not utf8\r
 440         uri = Glib::filename_to_utf8(uri);\r
 441 \r
 442 #ifdef WITH_GNOME_VFS\r
 443 \r
 444     // get the rss feed\r
 445     gnome_vfs_init();\r
 446     GnomeVFSHandle    *from_handle = NULL;\r
 447     GnomeVFSHandle    *to_handle = NULL;\r
 448     GnomeVFSFileSize  bytes_read;\r
 449     GnomeVFSFileSize  bytes_written;\r
 450     GnomeVFSResult    result;\r
 451     guint8 buffer[8192];\r
 452 \r
 453     // create the temp file name\r
 454     Glib::ustring fileName = Glib::get_tmp_dir ();\r
 455     fileName.append(G_DIR_SEPARATOR_S);\r
 456     fileName.append("ocalfeed.xml");\r
 457 \r
 458     // open the temp file to receive\r
 459     result = gnome_vfs_open (&to_handle, fileName.c_str(), GNOME_VFS_OPEN_WRITE);\r
 460     if (result == GNOME_VFS_ERROR_NOT_FOUND){\r
 461         result = gnome_vfs_create (&to_handle, fileName.c_str(), GNOME_VFS_OPEN_WRITE, FALSE, GNOME_VFS_PERM_USER_ALL);\r
 462     }\r
 463     if (result != GNOME_VFS_OK) {\r
 464         g_warning("Error creating temp file: %s", gnome_vfs_result_to_string(result));\r
 465         return;\r
 466     }\r
 467 \r
 468     // open the rss feed\r
 469     result = gnome_vfs_open (&from_handle, uri.c_str(), GNOME_VFS_OPEN_READ);\r
 470     if (result != GNOME_VFS_OK) {\r
 471         sp_ui_error_dialog(_("Failed to receive the Open Clip Art Library RSS feed. Verify if the URL is correct in Configuration->Misc (e.g.: openclipart.org)"));\r
 472         //g_warning("Could not find the Open Clip Art Library rss feed. Verify if the OCAL url is correct in Configuration");\r
 473         return;\r
 474     }\r
 475 \r
 476     // copy the file\r
 477     while (1) {\r
 478 \r
 479         result = gnome_vfs_read (from_handle, buffer, 8192, &bytes_read);\r
 480 \r
 481         if ((result == GNOME_VFS_ERROR_EOF) &&(!bytes_read)){\r
 482             result = gnome_vfs_close (from_handle);\r
 483             result = gnome_vfs_close (to_handle);\r
 484             break;\r
 485         }\r
 486 \r
 487         if (result != GNOME_VFS_OK) {\r
 488             g_warning("%s", gnome_vfs_result_to_string(result));\r
 489             return;\r
 490         }\r
 491         result = gnome_vfs_write (to_handle, buffer, bytes_read, &bytes_written);\r
 492         if (result != GNOME_VFS_OK) {\r
 493             g_warning("%s", gnome_vfs_result_to_string(result));\r
 494             return;\r
 495         }\r
 496 \r
 497         if (bytes_read != bytes_written){\r
 498             g_warning("Bytes read not equal to bytes written");\r
 499             return;\r
 500         }\r
 501 \r
 502     }\r
 503 \r
 504     // create the resulting xml document tree\r
 505     // this initialize the library and test mistakes between compiled and shared library used\r
 506     LIBXML_TEST_VERSION \r
 507     xmlDoc *doc = NULL;\r
 508     xmlNode *root_element = NULL;\r
 509     doc = xmlReadFile(fileName.c_str(), NULL, 0);\r
 510     if (doc == NULL) {\r
 511         g_warning("Failed to parse %s\n", fileName.c_str());\r
 512     return;\r
 513     }\r
 514     \r
 515     // get the root element node\r
 516     root_element = xmlDocGetRootElement(doc);\r
 517 \r
 518     // clear the fileslist\r
 519     filesList->clear_items();\r
 520     filesList->set_sensitive(false);\r
 521 \r
 522     // print all xml the element names\r
 523     print_xml_element_names(root_element);\r
 524 \r
 525     if (filesList->size() == 0)\r
 526     {\r
 527         notFoundLabel->show();\r
 528         filesList->set_sensitive(false);\r
 529     }\r
 530     else\r
 531         filesList->set_sensitive(true);\r
 532 \r
 533     // free the document\r
 534     xmlFreeDoc(doc);\r
 535     // free the global variables that may have been allocated by the parser\r
 536     xmlCleanupParser();\r
 537     return;\r
 538 #endif    \r
 539 }\r
 540 \r
 541 /**\r
 542  * Prints the names of the all the xml elements \r
 543  * that are siblings or children of a given xml node\r
 544  */\r
 545 void FileImportFromOCALDialog::print_xml_element_names(xmlNode * a_node)\r
 546 {\r
 547     xmlNode *cur_node = NULL;\r
 548     guint row_num = 0;\r
 549     for (cur_node = a_node; cur_node; cur_node = cur_node->next) {\r
 550         // get itens information\r
 551         if (strcmp((const char*)cur_node->name, "rss")) //avoid the root\r
 552             if (cur_node->type == XML_ELEMENT_NODE && !strcmp((const char*)cur_node->parent->name, "item"))\r
 553             {\r
 554                 if (!strcmp((const char*)cur_node->name, "title"))\r
 555                 {\r
 556                     xmlChar *title = xmlNodeGetContent(cur_node);\r
 557                     row_num = filesList->append_text((const char*)title);\r
 558                     xmlFree(title);\r
 559                 }\r
 560 #ifdef WITH_GNOME_VFS\r
 561                 else if (!strcmp((const char*)cur_node->name, "enclosure"))\r
 562                 {\r
 563                     xmlChar *urlattribute = xmlGetProp(cur_node, (xmlChar*)"url");\r
 564                     filesList->set_text(row_num, 1, (const char*)urlattribute);\r
 565                     gchar *tmp_file;\r
 566                     tmp_file = gnome_vfs_uri_extract_short_path_name(gnome_vfs_uri_new((const char*)urlattribute));\r
 567                     filesList->set_text(row_num, 2, (const char*)tmp_file);\r
 568                     xmlFree(urlattribute);\r
 569                 }\r
 570                 else if (!strcmp((const char*)cur_node->name, "creator"))\r
 571                 {\r
 572                     filesList->set_text(row_num, 3, (const char*)xmlNodeGetContent(cur_node));\r
 573                 }\r
 574 #endif\r
 575             }\r
 576         print_xml_element_names(cur_node->children);\r
 577     }\r
 578 }\r
 579 \r
 580 /**\r
 581  * Constructor.  Not called directly.  Use the factory.\r
 582  */\r
 583 FileImportFromOCALDialog::FileImportFromOCALDialog(Gtk::Window& parentWindow, \r
 584                                        const Glib::ustring &dir,\r
 585                                        const Glib::ustring &title) :\r
 586      FileDialogOCALBase(title)\r
 587 {\r
 588 \r
 589     // Initalize to Autodetect\r
 590     extension = NULL;\r
 591     // No filename to start out with\r
 592     Glib::ustring searchTag = "";\r
 593 \r
 594     Gtk::VBox *vbox = get_vbox();\r
 595     Gtk::Label *tagLabel = new Gtk::Label(_("Search Tag"));\r
 596     notFoundLabel = new Gtk::Label(_("No files matched your search"));\r
 597     messageBox.pack_start(*notFoundLabel);\r
 598     searchTagEntry = new Gtk::Entry();\r
 599     searchTagEntry->set_text(searchTag);\r
 600     searchTagEntry->set_max_length(252); // I am giving the extension approach.\r
 601     tagBox.pack_start(*tagLabel);\r
 602     tagBox.pack_start(*searchTagEntry, Gtk::PACK_EXPAND_WIDGET, 3);\r
 603     filesPreview = new SVGPreview();\r
 604     filesPreview->showNoPreview();\r
 605     filesList = new FileListViewText(4, *filesPreview);\r
 606     filesList->set_sensitive(false);\r
 607     // add the listview inside a ScrolledWindow\r
 608     listScrolledWindow.add(*filesList);\r
 609     // only show the scrollbars when they are necessary:\r
 610     listScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);\r
 611     filesList->set_column_title(0, _("Files Found"));\r
 612     listScrolledWindow.set_size_request(200, 180);\r
 613     filesList->get_column(1)->set_visible(false); // file url\r
 614     filesList->get_column(2)->set_visible(false); // tmp file path\r
 615     filesList->get_column(3)->set_visible(false); // author dir\r
 616     filesBox.pack_start(listScrolledWindow);\r
 617     filesBox.pack_start(*filesPreview);\r
 618     vbox->pack_start(tagBox);\r
 619     vbox->pack_start(messageBox);\r
 620     vbox->pack_start(filesBox);\r
 621 \r
 622     //Let's do some customization\r
 623     searchTagEntry = NULL;\r
 624     Gtk::Container *cont = get_toplevel();\r
 625     std::vector<Gtk::Entry *> entries;\r
 626     findEntryWidgets(cont, entries);\r
 627     if (entries.size() >=1 )\r
 628     {\r
 629     //Catch when user hits [return] on the text field\r
 630         searchTagEntry = entries[0];\r
 631         searchTagEntry->signal_activate().connect(\r
 632               sigc::mem_fun(*this, &FileImportFromOCALDialog::searchTagEntryChangedCallback));\r
 633     }\r
 634 \r
 635     add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);\r
 636     set_default(*add_button(Gtk::Stock::OPEN,   Gtk::RESPONSE_OK));\r
 637 \r
 638     show_all_children();\r
 639     notFoundLabel->hide();\r
 640 }\r
 641 \r
 642 /**\r
 643  * Destructor\r
 644  */\r
 645 FileImportFromOCALDialog::~FileImportFromOCALDialog()\r
 646 {\r
 647 \r
 648 }\r
 649 \r
 650 /**\r
 651  * Show this dialog modally.  Return true if user hits [OK]\r
 652  */\r
 653 bool\r
 654 FileImportFromOCALDialog::show()\r
 655 {\r
 656     set_modal (TRUE);                      //Window\r
 657     sp_transientize((GtkWidget *)gobj());  //Make transient\r
 658     gint b = run();                        //Dialog\r
 659     hide();\r
 660 \r
 661     if (b == Gtk::RESPONSE_OK)\r
 662     {\r
 663         return TRUE;\r
 664     }\r
 665     else\r
 666     {\r
 667         return FALSE;\r
 668     }\r
 669 }\r
 670 \r
 671 \r
 672 /**\r
 673  * Get the file extension type that was selected by the user. Valid after an [OK]\r
 674  */\r
 675 Inkscape::Extension::Extension *\r
 676 FileImportFromOCALDialog::getSelectionType()\r
 677 {\r
 678     return extension;\r
 679 }\r
 680 \r
 681 \r
 682 /**\r
 683  * Get the file name chosen by the user.   Valid after an [OK]\r
 684  */\r
 685 Glib::ustring\r
 686 FileImportFromOCALDialog::getFilename (void)\r
 687 {\r
 688     return filesList->getFilename();\r
 689 }\r
 690 \r
 691 } //namespace Dialog\r
 692 } //namespace UI\r
 693 } //namespace Inkscape\r
 694 \r
 695 /*\r
 696   Local Variables:\r
 697   mode:c++\r
 698   c-file-style:"stroustrup"\r
 699   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))\r
 700   indent-tabs-mode:nil\r
 701   fill-column:99\r
 702   End:\r
 703 */\r
 704 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :