void AddinManager::erase_note_addin_info(const std::string & id) { { const IdInfoMap::iterator iter = m_note_addin_infos.find(id); if (m_note_addin_infos.end() == iter) { ERR_OUT(_("Note add-in info %s is absent"), id.c_str()); return; } m_note_addin_infos.erase(iter); } { for(NoteAddinMap::iterator iter = m_note_addins.begin(); iter != m_note_addins.end(); ++iter) { IdAddinMap & id_addin_map = iter->second; IdAddinMap::iterator it = id_addin_map.find(id); if (id_addin_map.end() == it) { ERR_OUT(_("Note add-in %s is absent"), id.c_str()); continue; } NoteAddin * const addin = it->second; if (addin) { addin->dispose(true); id_addin_map.erase(it); } } } }
void AddinManager::erase_note_addin_info( const sharp::DynamicModule * dmod) { const char * const id = dmod->id(); { const IdInfoMap::iterator iter = m_note_addin_infos.find(id); if (m_note_addin_infos.end() == iter) { ERR_OUT("NoteAddin info %s absent", id); return; } m_note_addin_infos.erase(iter); } { for(NoteAddinMap::iterator iter = m_note_addins.begin(); iter != m_note_addins.end(); ++iter) { IdAddinMap & id_addin_map = iter->second; IdAddinMap::iterator it = id_addin_map.find(id); if (id_addin_map.end() == it) { ERR_OUT("NoteAddin %s absent", id); continue; } NoteAddin * const addin = it->second; if (addin) { addin->dispose(true); id_addin_map.erase(it); } } } }
static int create_type13(RECORD **anrecord, struct finger_view_minutiae_record *fvmr, FILE *fp, unsigned int idc) { char fn[MAXPATHLEN]; unsigned char *imgdata; int imgsize; /*** 13.999 - Image data ***/ // fp parameter is for the file containing the list of // image files if (fscanf(fp, "%s", fn) < 0) ERR_OUT("reading image list file.\n"); printf("reading image from file %s\n", fn); if (read_binary_image_data(fn, &imgdata, &imgsize) != 0) ERR_OUT("reading image data"); if (image2type_13(anrecord, imgdata, imgsize, fvmr->fmr->x_image_size, fvmr->fmr->y_image_size, 8, (double)(fvmr->fmr->x_resolution / 10.0), "NONE", // Compression String idc, fvmr->impression_type, "NIST 894.03") != 0) ERR_OUT("converting image to Type-13 record"); // Calculate and update the record length field if (update_ANSI_NIST_tagged_record_LEN(*anrecord) != 0) ERR_OUT("updating Type-13 record length"); return 0; err_out: return -1; }
static int StatusRegWaitForBit(int flagBit) // this would be in ISR { int cnt, err, temp; // wait for bit to be set for(cnt=0; cnt<DMA_PENDING_TIMEOUT_COUNT; cnt++) { err = Bar0Read(BAR0_STATUS_REG, 1, &temp); if (err) ERR_OUT("Could not read BAR0_STATUS_REG\n"); if (temp & (1<<flagBit)) break; // printf("."); } // printf("\n"); if (cnt == DMA_PENDING_TIMEOUT_COUNT) ERR_OUT("flagBit was still not done in DMA_PENDING_TIMEOUT_COUNT\n"); // clear bit temp = (1 << flagBit); err = Bar0Write(BAR0_STATUS_REG, 1, &temp); if (err) ERR_OUT("Could not write to BAR0_STATUS_REG to clear flagBit\n"); // err = Bar0Read(BAR0_STATUS_REG, 1, &temp); // if (err) ERR_OUT("Could not read BAR0_STATUS_REG to check flagBit\n"); // if (temp & (1 << flagBit)) // ERR_OUT("flagBit is still set after clearing\n"); return 0; }
static void get_options(int argc, char *argv[]) { int ch; int i_opt; i_opt = v_opt = 0; r_opt = 0; while ((ch = getopt(argc, argv, "i:r:v")) != -1) { switch (ch) { case 'i': if (i_opt == 2) { usage(); goto err_out; } if ((in_fp[i_opt] = fopen(optarg, "rb")) == NULL) OPEN_ERR_EXIT(optarg); i_opt++; break; case 'r': r_opt = strtol(optarg, NULL, 10); if (r_opt == 0 && errno == EINVAL) ERR_OUT("Radius must be numeric"); if (r_opt < 0) ERR_OUT("Radius must be greater than 0"); break; case 'v': v_opt++; break; default: usage(); break; } } if ((i_opt != 2) | (r_opt == 0)) { usage(); goto err_out; } return; err_out: close_files(); exit(EXIT_FAILURE); }
void GnoteSyncClient::parse(const std::string & manifest_path) { // Set defaults before parsing m_last_sync_date = sharp::DateTime::now().add_days(-1); m_last_sync_rev = -1; m_file_revisions.clear(); m_deleted_notes.clear(); m_server_id = ""; if(!sharp::file_exists(manifest_path)) { m_last_sync_date = sharp::DateTime(); write(manifest_path); } sharp::XmlReader reader(manifest_path); while(reader.read()) { if(reader.get_node_type() == XML_READER_TYPE_ELEMENT) { if(reader.get_name() == "last-sync-date") { std::string value = reader.read_string(); try { m_last_sync_date = sharp::DateTime::from_iso8601(value); } catch(...) { /* TRANSLATORS: %s is file */ ERR_OUT(_("Unparsable last-sync-date element in %s"), manifest_path.c_str()); } } else if(reader.get_name() == "last-sync-rev") { std::string value = reader.read_string(); try { m_last_sync_rev = STRING_TO_INT(value); } catch(...) { /* TRANSLATORS: %s is file */ ERR_OUT(_("Unparsable last-sync-rev element in %s"), manifest_path.c_str()); } } else if(reader.get_name() == "server-id") { m_server_id = reader.read_string(); } else if(reader.get_name() == "note-revisions") { read_notes(reader, &GnoteSyncClient::read_updated_note_atts); } else if(reader.get_name() == "note-deletions") { read_notes(reader, &GnoteSyncClient::read_deleted_note_atts); } } } }
void NiepceWindow::on_open_library() { Configuration & cfg = Application::app()->config(); std::string libMoniker; int reopen = 0; try { reopen = std::stoi(cfg.getValue("reopen_last_catalog", "0")); } catch(...) { } if(reopen) { libMoniker = cfg.getValue("last_open_catalog", ""); } if(libMoniker.empty()) { libMoniker = prompt_open_library(); } else { DBG_OUT("last library is %s", libMoniker.c_str()); } if(!libMoniker.empty()) { if(!open_library(libMoniker)) { ERR_OUT("library %s cannot be open. Prompting.", libMoniker.c_str()); libMoniker = prompt_open_library(); open_library(libMoniker); } } }
void AddinManager::load_addins_for_note(const Note::Ptr & note) { if(m_note_addins.find(note) != m_note_addins.end()) { ERR_OUT(_("Trying to load addins when they are already loaded")); return; } IdAddinMap loaded_addins; m_note_addins[note] = loaded_addins; IdAddinMap & loaded(m_note_addins[note]); // avoid copying the whole map for(IdInfoMap::const_iterator iter = m_note_addin_infos.begin(); iter != m_note_addin_infos.end(); ++iter) { const IdInfoMap::value_type & addin_info(*iter); sharp::IInterface* iface = (*addin_info.second)(); NoteAddin * addin = dynamic_cast<NoteAddin *>(iface); if(addin) { addin->initialize(note); loaded.insert(std::make_pair(addin_info.first, addin)); } else { DBG_OUT("wrong type for the interface: %s", typeid(*iface).name()); delete iface; } } }
void game_set_player_count(GameData *gd, unsigned num) { ASSERT_CONFIG(); if(!num || num > gamelib_get_max_players()) { ERR_OUT("Tried to use more players than the platform can support."); exit(1); } gd->data.config.player_count = num; }
void AddinManager::add_note_addin_info( const sharp::DynamicModule * dmod) { const char * const id = dmod->id(); { const IdInfoMap::const_iterator iter = m_note_addin_infos.find(id); if (m_note_addin_infos.end() != iter) { ERR_OUT("NoteAddin info %s already present", id); return; } } sharp::IfaceFactoryBase * const f = dmod->query_interface( NoteAddin::IFACE_NAME); if(!f) { ERR_OUT("does not implement %s", NoteAddin::IFACE_NAME); return; } m_note_addin_infos.insert(std::make_pair(std::string(id), f)); { for(NoteAddinMap::iterator iter = m_note_addins.begin(); iter != m_note_addins.end(); ++iter) { IdAddinMap & id_addin_map = iter->second; IdAddinMap::const_iterator it = id_addin_map.find(id); if (id_addin_map.end() != it) { ERR_OUT("NoteAddin %s already present", id); continue; } const Note::Ptr & note = iter->first; NoteAddin * const addin = dynamic_cast<NoteAddin *>((*f)()); if (addin) { addin->initialize(note); id_addin_map.insert(std::make_pair(id, addin)); } } } }
int DMAReadFromDev(int *size_in_bytes) // data will be in mem_info[1] { int err, temp; unsigned int data[3]; struct timeval t0, t1; // check if there's data to be read err = StatusRegWaitForBit(BITPOS_RX_READY); if (err) ERR_OUT("\nFailed StatusRegWaitForBit(BITPOS_RX_READY)\n"); // check if DMA was pending err = Bar0Read(BAR0_DMA1_ADDR_LO, 1, &temp); if (err) ERR_OUT("Could not read from BAR0_DMA1_ADDR_LO to determine DMA in progress bit\n"); if (temp & 1) ERR_OUT("DMA1 is still in progress\n"); // clear BITPOS_RX_READY temp = 1<<BITPOS_DMA1_DONE; err = Bar0Write(BAR0_STATUS_REG, 1, &temp); if (err) ERR_OUT("Could not write BAR0_STATUS_REG to clear BITPOS_DMA1_DONE\n"); // get length err = Bar0Read(BAR0_DMA1_LENSTAT, 1, size_in_bytes); if (err) ERR_OUT("Could not read BAR0_DMA1_LENSTAT\n"); *size_in_bytes &= 0xFFFF; if (*size_in_bytes > TC_KMEM_LENGTH_BYTES) ERR_OUT("size_in_bytes > TC_KMEM_LENGTH_BYTES\n"); if (sizeof (int) == 4) { data[0] = 0; data[1] = (((unsigned int)mem_info[1]) & 0xFFFFFFFC) | 1; } // else // 64 bit // { // data[0] = ((unsigned int)mem_info[1]) >> 32; // data[1] = (((unsigned int)mem_info[1]) & 0xFFFFFFFC) | 3; // } // set up DMA addr err = Bar0Write(BAR0_DMA1_ADDR_HI, 2, data); if (err) ERR_OUT("Could not write to BAR0_DMA0 registers\n"); // wait for DMA1 done gettimeofday(&t0, NULL); err = StatusRegWaitForBit(BITPOS_DMA1_DONE); gettimeofday(&t1, NULL); if (err) ERR_OUT("\nFailed StatusRegWaitForBit(BITPOS_DMA1_DONE)\n"); RecordTime(&dma1Time, t0, t1); dma1Bytes += *size_in_bytes; return 0; }
int DMAWriteToDev(int size_in_bytes) // data must already be in mem_info[0] { int err, size_in_words, temp, cnt; unsigned int data[3]; struct timeval t0, t1; gettimeofday(&t0, NULL); if (size_in_bytes > TC_KMEM_LENGTH_BYTES) ERR_OUT("size_in_bytes > TC_KMEM_LENGTH_BYTES\n"); // check if DMA was pending err = Bar0Read(BAR0_DMA0_ADDR_LO, 1, &temp); if (err) ERR_OUT("Could not read from BAR0_DMA0_ADDR_LO to determine DMA in progress bit\n"); if (temp & 1) ERR_OUT("DMA0 is still in progress\n"); data[0] = size_in_bytes; if (sizeof (int) == 4) { data[1] = 0; data[2] = (((unsigned int)mem_info[0]) & 0xFFFFFFFC) | 1; } // else // 64 bit // { // data[1] = ((unsigned int)mem_info[0]) >> 32; // data[2] = (((unsigned int)mem_info[0]) & 0xFFFFFFFC) | 3; // } // set up DMA addr/lenstat err = Bar0Write(BAR0_DMA0_LENSTAT, 3, data); if (err) ERR_OUT("Could not write to BAR0_DMA0 registers\n"); // wait for DMA0done; in real use, this should be in ISR gettimeofday(&t0, NULL); err = StatusRegWaitForBit(BITPOS_DMA0_DONE); gettimeofday(&t1, NULL); if (err) ERR_OUT("Failed StatusRegWaitForBit(BITPOS_DMA0_DONE)\n"); RecordTime(&dma0Time, t0, t1); dma0Bytes += size_in_bytes; return 0; }
int CopyFromKmem(int index, int size_in_words, void *buffer) { int err; if (index > TC_KMEM_COUNT) ERR_OUT("index > TC_KMEM_COUNT\n"); if (size_in_words > TC_KMEM_LENGTH_BYTES/4) ERR_OUT("size_in_words > TC_KMEM_LENGTH_BYTES/4\n"); param->index = index; param->offset = 0; param->length = size_in_words; err = ioctl(fd, TC_IOC_KMEM_RD, param); if (err) { printf("TC_IOC_KMEM_RD failed\n"); return -1; } memcpy(buffer, ¶m->data[0], size_in_words*4); return 0; }
bool AddinInfo::validate(const Glib::ustring & release, const Glib::ustring & version_info) const { if(validate_compatibility(release, version_info)) { return true; } ERR_OUT(_("Incompatible plug-in %s: expected %s, got %s"), m_id.c_str(), (release + " " + version_info).c_str(), (m_libgnote_release + " " + m_libgnote_version_info).c_str()); return false; }
void AddinManager::load_addin_infos(const std::string & path) { std::list<std::string> files; sharp::directory_get_files_with_ext(path, ".desktop", files); for(std::list<std::string>::iterator iter = files.begin(); iter != files.end(); ++iter) { try { AddinInfo addin_info(*iter); std::string module = Glib::build_filename(path, addin_info.addin_module()); if(sharp::file_exists(module + "." + G_MODULE_SUFFIX)) { addin_info.addin_module(module); m_addin_infos[addin_info.id()] = addin_info; } else { ERR_OUT(_("Failed to find module %s for addin %s"), addin_info.id().c_str(), module.c_str()); } } catch(std::exception & e) { ERR_OUT(_("Failed to load addin info for %s: %s"), iter->c_str(), e.what()); } } }
void ExportToGTGNoteAddin::export_button_clicked() { try { if (s_gtg_interface == 0) { Glib::RefPtr<Gio::DBus::NodeInfo> node_info = Gio::DBus::NodeInfo::create_for_xml(GTG_INTERFACE); s_gtg_interface = node_info->lookup_interface("org.gnome.GTG"); if(s_gtg_interface == 0) { ERR_OUT(_("GTG XML loaded, but interface not found")); return; } } } catch(Glib::Error & e) { ERR_OUT(_("Failed to create GTG interface from XML: %s"), e.what().c_str()); return; } try { Glib::RefPtr<Gio::DBus::Proxy> proxy = Gio::DBus::Proxy::create_for_bus_sync( Gio::DBus::BUS_TYPE_SESSION, "org.gnome.GTG", "/org/gnome/GTG", "org.gnome.GTG", s_gtg_interface); if(proxy == 0) { ERR_OUT(_("Failed to create D-Bus proxy for GTG")); return; } gnote::Note::Ptr note(get_note()); std::string title = note->get_title(); std::string body = sharp::string_trim(sharp::string_replace_first(note->text_content(), title, "")); std::vector<Glib::VariantBase> parameters; parameters.reserve(2); parameters.push_back(Glib::Variant<Glib::ustring>::create(title)); parameters.push_back(Glib::Variant<Glib::ustring>::create(body)); Glib::VariantContainerBase params = Glib::VariantContainerBase::create_tuple(parameters); proxy->call_sync("OpenNewTask", params); } catch(Glib::Error & e) { ERR_OUT(_("Failed to call GTG: %s"), e.what().c_str()); } }
void NiepceWindow::on_lib_notification(const eng::LibNotification& ln) { switch (engine_library_notification_type(&ln)) { case eng::NotificationType::NEW_LIBRARY_CREATED: create_initial_labels(); break; case eng::NotificationType::ADDED_LABEL: { auto l = engine_library_notification_get_label(&ln); if (l) { m_libClient->getDataProvider()->addLabel(*l); } else { ERR_OUT("Invalid label (nullptr)"); } break; } case eng::NotificationType::LABEL_CHANGED: { auto l = engine_library_notification_get_label(&ln); if (l) { m_libClient->getDataProvider()->updateLabel(*l); } else { ERR_OUT("Invalid label (nullptr)"); } break; } case eng::NotificationType::LABEL_DELETED: { auto id = engine_library_notification_get_id(&ln); if (id) { m_libClient->getDataProvider()->deleteLabel(id); } else { ERR_OUT("Invalid ID"); } break; } default: break; } }
Glib::ustring RemoteControl::CreateNamedNote(const Glib::ustring& linked_title) { NoteBase::Ptr note = m_manager.find(linked_title); if (note) return ""; try { note = m_manager.create (linked_title); return note->uri(); } catch (const std::exception & e) { ERR_OUT(_("Exception thrown when creating note: %s"), e.what()); } return ""; }
/* Ready a game structure for actual use: */ void game_finalize(GameData *gd) { Level *lvl; TankList *tl; DrawBuffer *b; PList *pl; Screen *s; ASSERT_CONFIG(); /* Initialize most of the structures: */ s = screen_new (gd->data.config.is_fullscreen); pl = plist_new (); b = drawbuffer_new(gd->data.config.w, gd->data.config.h); lvl = level_new (b, gd->data.config.w, gd->data.config.h); tl = tanklist_new (lvl, pl); /* Generate our random level: */ generate_level(lvl, gd->data.config.gen); level_decorate(lvl); level_make_bases(lvl); /* Debug the starting data, if we're debugging: */ if(gd->is_debug) level_dump_bmp(lvl, "debug_start.bmp"); /* Start drawing! */ drawbuffer_set_default(b, color_rock); level_draw_all(lvl, b); screen_set_mode_level(s, b); /* Set up the players/GUI: */ if (gd->data.config.player_count == 1) init_single_player(s, tl, lvl); else if(gd->data.config.player_count == 2) init_double_player(s, tl, lvl); else { ERR_OUT("Don't know how to draw more than 2 players at once..."); exit(1); } /* Copy all of our variables into the GameData struct: */ gd->is_active = 1; gd->data.active.s = s; gd->data.active.pl = pl; gd->data.active.b = b; gd->data.active.lvl = lvl; gd->data.active.tl = tl; }
int32_t LibFile::property(fwk::PropertyIndex idx) const { switch(idx) { case NpTiffOrientationProp: return orientation(); case NpXmpRatingProp: return rating(); case NpXmpLabelProp: return label(); case NpNiepceFlagProp: return flag(); default: ERR_OUT("get property %u not handled", idx); break; } return -1; }
std::string RemoteControl::CreateNamedNote(const std::string& linked_title) { Note::Ptr note; note = m_manager.find (linked_title); if (note) return ""; try { note = m_manager.create (linked_title); return note->uri(); } catch (const std::exception & e) { ERR_OUT("create throw: %s", e.what()); } return ""; }
Glib::RefPtr<Gdk::Pixbuf> gdkpixbuf_scale_to_fit(const Glib::RefPtr<Gdk::Pixbuf> & pix, int dim) { int height, width; int orig_h, orig_w; if(!pix) { ERR_OUT("NULL pixbuf"); return pix; } orig_h = pix->get_height(); orig_w = pix->get_width(); int orig_dim = std::max(orig_h, orig_w); double ratio = (double)dim / (double)orig_dim; width = (int)(ratio * orig_w); height = (int)(ratio * orig_h); return pix->scale_simple(width, height, Gdk::INTERP_BILINEAR); }
void LibFile::setProperty(fwk::PropertyIndex idx, int32_t v) { switch(idx) { case NpTiffOrientationProp: setOrientation(v); break; case NpXmpRatingProp: setRating(v); break; case NpXmpLabelProp: setLabel(v); break; case NpNiepceFlagProp: setFlag(v); break; default: ERR_OUT("set property %u not handled", idx); break; } }
void BugzillaPreferences::remove_clicked() { // Remove the icon file and call UpdateIconStore (). Gtk::TreeIter iter; iter = icon_tree->get_selection()->get_selected(); if (!iter) { return; } std::string icon_path = (*iter)[m_columns.file_path]; gnote::utils::HIGMessageDialog dialog(NULL, GTK_DIALOG_DESTROY_WITH_PARENT, Gtk::MESSAGE_QUESTION, Gtk::BUTTONS_NONE, _("Really remove this icon?"), _("If you remove an icon it is permanently lost.")); Gtk::Button *button; button = manage(new Gtk::Button (Gtk::Stock::CANCEL)); button->property_can_default() = true; button->show (); dialog.add_action_widget (*button, Gtk::RESPONSE_CANCEL); dialog.set_default_response(Gtk::RESPONSE_CANCEL); button = manage(new Gtk::Button (Gtk::Stock::DELETE)); button->property_can_default() = true; button->show (); dialog.add_action_widget (*button, 666); int result = dialog.run (); if (result == 666) { try { sharp::file_delete (icon_path); update_icon_store (); } catch (const sharp::Exception & e) { ERR_OUT("Error removing icon %s: %s", icon_path.c_str(), e.what()); } } }
Glib::RefPtr<Gdk::Pixbuf> ImageListStore::get_loading_icon() { Glib::RefPtr<Gdk::Pixbuf> icon; if(!icon) { static std::mutex m; m.lock(); if (!icon) { auto icon_theme(fwk::Application::app()->getIconTheme()); try { icon = icon_theme->load_icon( Glib::ustring("image-loading"), 32, Gtk::ICON_LOOKUP_USE_BUILTIN); } catch(const Gtk::IconThemeError & e) { ERR_OUT("Exception %s.", e.what().c_str()); } } m.unlock(); } return icon; }
gnote::Note::Ptr NoteOfTheDay::create(gnote::NoteManager & manager, const Glib::Date & date) { const std::string title = get_title(date); const std::string xml = get_content(date, manager); gnote::Note::Ptr notd; try { notd = manager.create(title, xml); } catch (const sharp::Exception & e) { ERR_OUT("NoteOfTheDay could not create %s: %s", title.c_str(), e.what()); return gnote::Note::Ptr(); } // Automatically tag all new Note of the Day notes notd->add_tag(gnote::TagManager::obj().get_or_create_system_tag( "NoteOfTheDay")); return notd; }
void NoteOfTheDayPreferences::open_template_button_clicked() const { gnote::NoteBase::Ptr template_note = m_note_manager.find(NoteOfTheDay::s_template_title); if (0 == template_note) { try { template_note = m_note_manager.create( NoteOfTheDay::s_template_title, NoteOfTheDay::get_template_content( NoteOfTheDay::s_template_title)); template_note->queue_save(gnote::CONTENT_CHANGED); } catch (const sharp::Exception & e) { /* TRANSLATORS: first %s is template note title, second is error */ ERR_OUT(_("NoteOfTheDay could not create %s: %s"), NoteOfTheDay::s_template_title.c_str(), e.what()); } } if(0 != template_note) { gnote::IGnote::obj().open_note(static_pointer_cast<gnote::Note>(template_note)); } }
/* Create a default game structure: */ GameData *game_new() { GameData *out = get_object(GameData); /* Copy in all the default values: */ out->is_active = out->is_debug = 0; out->data.config.gen = NULL; /* The hell was I thinking? out->data.config.w = GAME_WIDTH; out->data.config.h = GAME_HEIGHT; */ out->data.config.w = 1000; out->data.config.h = 500; out->data.config.player_count = gamelib_get_max_players(); if(gamelib_get_can_window()) out->data.config.is_fullscreen = 0; else if(gamelib_get_can_fullscreen()) out->data.config.is_fullscreen = 1; else { /* The hell!? */ ERR_OUT("gamelib can't run fullscreen or in a window."); exit(1); } return out; }
void NoteDirectoryWatcherApplicationAddin::add_or_update_note(const Glib::ustring & note_id) { const Glib::ustring & note_path = Glib::build_filename(note_manager().notes_dir(), note_id + ".note"); if (!sharp::file_exists(note_path)) { DBG_OUT("NoteDirectoryWatcher: Not processing update of %s because file does not exist.", note_path.c_str()); return; } Glib::ustring noteXml; try { noteXml = sharp::file_read_all_text(note_path); } catch(sharp::Exception & e) { /* TRANSLATORS: first %s is file name, second is error */ ERR_OUT(_("NoteDirectoryWatcher: Update aborted, error reading %s: %s"), note_path.c_str(), e.what()); return; } if(noteXml == "") { DBG_OUT("NoteDirectoryWatcher: Update aborted, %s had no contents.", note_path.c_str()); return; } Glib::ustring note_uri = make_uri(note_id); gnote::NoteBase::Ptr note = note_manager().find_by_uri(note_uri); bool is_new_note = false; if(note == 0) { is_new_note = true; DBG_OUT("NoteDirectoryWatcher: Adding %s because file changed.", note_id.c_str()); Glib::ustring title; Glib::RefPtr<Glib::Regex> regex = Glib::Regex::create("<title>([^<]+)</title>", Glib::REGEX_MULTILINE); Glib::MatchInfo match_info; if(regex->match(noteXml, match_info)) { title = match_info.fetch(1); } else { /* TRANSLATORS: %s is file */ ERR_OUT(_("NoteDirectoryWatcher: Error reading note title from %s"), note_path.c_str()); return; } try { note = note_manager().create_with_guid(title, note_id); if(note == 0) { /* TRANSLATORS: %s is file */ ERR_OUT(_("NoteDirectoryWatcher: Unknown error creating note from %s"), note_path.c_str()); return; } } catch(std::exception & e) { /* TRANSLATORS: first %s is file, second is error */ ERR_OUT(_("NoteDirectoryWatcher: Error creating note from %s: %s"), note_path.c_str(), e.what()); return; } } if(is_new_note) { DBG_OUT("NoteDirectoryWatcher: Updating %s because file changed.", note_id.c_str()); } try { note->load_foreign_note_xml(noteXml, gnote::CONTENT_CHANGED); } catch(std::exception & e) { /* TRANSLATORS: first %s is file, second is error */ ERR_OUT(_("NoteDirectoryWatcher: Update aborted, error parsing %s: %s"), note_path.c_str(), e.what()); if(is_new_note) { note_manager().delete_note(note); } } }
void ImageListStore::on_lib_notification(const eng::LibNotification &ln) { switch(ln.type) { case eng::Library::NotifyType::FOLDER_CONTENT_QUERIED: case eng::Library::NotifyType::KEYWORD_CONTENT_QUERIED: { eng::LibFile::ListPtr l = boost::any_cast<eng::LibFile::ListPtr>(ln.param); DBG_OUT("received folder content file # %lu", l->size()); // clear the map before the list. m_idmap.clear(); clear(); eng::LibFile::List::const_iterator iter = l->begin(); for_each(l->begin(), l->end(), [this](const eng::LibFile::Ptr & f) { Gtk::TreeModel::iterator riter = append(); Gtk::TreeRow row = *riter; Glib::RefPtr<Gdk::Pixbuf> icon = get_loading_icon(); row[m_columns.m_pix] = icon; row[m_columns.m_libfile] = f; row[m_columns.m_strip_thumb] = fwk::gdkpixbuf_scale_to_fit(icon, 100); m_idmap[f->id()] = riter; }); // at that point clear the cache because the icon view is populated. getLibraryClient()->thumbnailCache().request(l); break; } case eng::Library::NotifyType::METADATA_CHANGED: { eng::metadata_desc_t m = boost::any_cast<eng::metadata_desc_t>(ln.param); fwk::PropertyIndex prop = m.meta; DBG_OUT("metadata changed %s", eng::_propertyName(prop)); // only interested in a few props if(is_property_interesting(prop)) { std::map<eng::library_id_t, Gtk::TreeIter>::const_iterator iter = m_idmap.find(m.id); if(iter != m_idmap.end()) { Gtk::TreeRow row = *(iter->second); // eng::LibFile::Ptr file = row[m_columns.m_libfile]; file->setProperty(prop, boost::get<int>(m.value)); row[m_columns.m_libfile] = file; } } break; } case eng::Library::NotifyType::XMP_NEEDS_UPDATE: { fwk::Configuration & cfg = fwk::Application::app()->config(); int write_xmp = false; Glib::ustring xmp_pref; try { xmp_pref = cfg.getValue("write_xmp_automatically", "0"); write_xmp = std::stoi(xmp_pref); } catch(const std::exception & e) { ERR_OUT("couldn't cast %s: %s", xmp_pref.c_str(), e.what()); } getLibraryClient()->processXmpUpdateQueue(write_xmp); break; } default: break; } }