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;
}
}
