liz/rawTherapee
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merged master into gtk3

Browse Source
This commit is contained in:
Beep6581
2016-01-30 16:00:53 +01:00
parent 2880cfbbda b5aa2dcffc
commit fc339a2fea
40 changed files with 1455 additions and 1463 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
rtgui/batchqueue.cc
View File

@@ -38,43 +38,42 @@
using namespace std;
using namespace rtengine;
BatchQueue::BatchQueue (FileCatalog* aFileCatalog) : processing(NULL), fileCatalog(aFileCatalog), sequence(0), listener(NULL),
pmenu (new Gtk::Menu ())
BatchQueue::BatchQueue (FileCatalog* aFileCatalog) : processing(NULL), fileCatalog(aFileCatalog), sequence(0), listener(NULL)
{
location = THLOC_BATCHQUEUE;
int p = 0;
pmenu->attach (*Gtk::manage(open = new Gtk::MenuItem (M("FILEBROWSER_POPUPOPENINEDITOR"))), 0, 1, p, p + 1);
pmenu.attach (*Gtk::manage(open = new Gtk::MenuItem (M("FILEBROWSER_POPUPOPENINEDITOR"))), 0, 1, p, p + 1);
p++;
pmenu->attach (*Gtk::manage(selall = new Gtk::MenuItem (M("FILEBROWSER_POPUPSELECTALL"))), 0, 1, p, p + 1);
pmenu.attach (*Gtk::manage(selall = new Gtk::MenuItem (M("FILEBROWSER_POPUPSELECTALL"))), 0, 1, p, p + 1);
p++;
pmenu->attach (*Gtk::manage(new Gtk::SeparatorMenuItem ()), 0, 1, p, p + 1);
pmenu.attach (*Gtk::manage(new Gtk::SeparatorMenuItem ()), 0, 1, p, p + 1);
p++;
pmenu->attach (*Gtk::manage(head = new MyImageMenuItem (M("FILEBROWSER_POPUPMOVEHEAD"), "toleftend.png")), 0, 1, p, p + 1);
pmenu.attach (*Gtk::manage(head = new MyImageMenuItem (M("FILEBROWSER_POPUPMOVEHEAD"), "toleftend.png")), 0, 1, p, p + 1);
p++;
pmenu->attach (*Gtk::manage(tail = new MyImageMenuItem (M("FILEBROWSER_POPUPMOVEEND"), "torightend.png")), 0, 1, p, p + 1);
pmenu.attach (*Gtk::manage(tail = new MyImageMenuItem (M("FILEBROWSER_POPUPMOVEEND"), "torightend.png")), 0, 1, p, p + 1);
p++;
pmenu->attach (*Gtk::manage(new Gtk::SeparatorMenuItem ()), 0, 1, p, p + 1);
pmenu.attach (*Gtk::manage(new Gtk::SeparatorMenuItem ()), 0, 1, p, p + 1);
p++;
pmenu->attach (*Gtk::manage(cancel = new MyImageMenuItem (M("FILEBROWSER_POPUPCANCELJOB"), "gtk-close.png")), 0, 1, p, p + 1);
pmenu.attach (*Gtk::manage(cancel = new MyImageMenuItem (M("FILEBROWSER_POPUPCANCELJOB"), "gtk-close.png")), 0, 1, p, p + 1);
p++;
pmenu->show_all ();
pmenu.show_all ();
// Accelerators
pmaccelgroup = Gtk::AccelGroup::create ();
pmenu->set_accel_group (pmaccelgroup);
open->add_accelerator ("activate", pmenu->get_accel_group(), GDK_KEY_e, Gdk::CONTROL_MASK, Gtk::ACCEL_VISIBLE);
selall->add_accelerator ("activate", pmenu->get_accel_group(), GDK_KEY_a, Gdk::CONTROL_MASK, Gtk::ACCEL_VISIBLE);
head->add_accelerator ("activate", pmenu->get_accel_group(), GDK_KEY_Home, (Gdk::ModifierType)0, Gtk::ACCEL_VISIBLE);
tail->add_accelerator ("activate", pmenu->get_accel_group(), GDK_KEY_End, (Gdk::ModifierType)0, Gtk::ACCEL_VISIBLE);
cancel->add_accelerator ("activate", pmenu->get_accel_group(), GDK_KEY_Delete, (Gdk::ModifierType)0, Gtk::ACCEL_VISIBLE);
pmenu.set_accel_group (pmaccelgroup);
open->add_accelerator ("activate", pmaccelgroup, GDK_KEY_e, Gdk::CONTROL_MASK, Gtk::ACCEL_VISIBLE);
selall->add_accelerator ("activate", pmaccelgroup, GDK_KEY_a, Gdk::CONTROL_MASK, Gtk::ACCEL_VISIBLE);
head->add_accelerator ("activate", pmaccelgroup, GDK_KEY_Home, (Gdk::ModifierType)0, Gtk::ACCEL_VISIBLE);
tail->add_accelerator ("activate", pmaccelgroup, GDK_KEY_End, (Gdk::ModifierType)0, Gtk::ACCEL_VISIBLE);
cancel->add_accelerator ("activate", pmaccelgroup, GDK_KEY_Delete, (Gdk::ModifierType)0, Gtk::ACCEL_VISIBLE);
open->signal_activate().connect(sigc::mem_fun(*this, &BatchQueue::openLastSelectedItemInEditor));
cancel->signal_activate().connect (std::bind (&BatchQueue::cancelItems, this, std::ref (selected)));
@@ -137,8 +136,7 @@ int BatchQueue::getThumbnailHeight ()
void BatchQueue::rightClicked (ThumbBrowserEntryBase* entry)
{
pmenu->popup (3, this->eventTime);
pmenu.popup (3, this->eventTime);
}
void BatchQueue::doubleClicked(ThumbBrowserEntryBase* entry)

3
rtgui/batchqueue.h
View File

@@ -57,9 +57,8 @@ protected:
MyImageMenuItem* tail;
Gtk::MenuItem* selall;
Gtk::MenuItem* open;
std::unique_ptr<Gtk::Menu> pmenu;
Glib::RefPtr<Gtk::AccelGroup> pmaccelgroup;
Gtk::Menu pmenu;
BatchQueueListener* listener;

18
rtgui/cachemanager.cc
View File

@@ -351,7 +351,7 @@ void CacheManager::applyCacheSizeLimitation () const
const auto dirName = Glib::build_filename (baseDir, "data");
const auto dir = Gio::File::create_for_path (dirName);
auto enumerator = dir->enumerate_children ();
auto enumerator = dir->enumerate_children ("standard::*,time::*");
while (auto file = enumerator->next_file ()) {
files.emplace_back (file->get_name (), file->modification_time ());
@@ -370,11 +370,21 @@ void CacheManager::applyCacheSizeLimitation () const
auto cacheEntries = files.size ();
for (auto entry = files.begin(); cacheEntries-- > options.maxCacheEntries; ++entry) {
for (auto entry = files.begin (); cacheEntries-- > options.maxCacheEntries; ++entry) {
const auto& fname = entry->first;
const auto& name = entry->first;
deleteFiles (fname, getMD5 (fname), true, false);
constexpr auto md5_size = 32;
const auto name_size = name.size();
if (name_size < md5_size + 5) {
continue;
}
const auto fname = name.substr (0, name_size - md5_size - 5);
const auto md5 = name.substr (name_size - md5_size - 4, md5_size);
deleteFiles (fname, md5, true, false);
}
}

40
rtgui/filmsimulation.cc
View File

@@ -12,23 +12,35 @@ using namespace rtengine::procparams;
namespace
{
void notifySlowParseDir (const std::chrono::system_clock::time_point& startedAt)
bool notifySlowParseDir (const std::chrono::system_clock::time_point& startedAt)
{
static bool alreadyNotified = false;
static enum
{
Undecided,
Cancel,
Continue
}
decision = Undecided;
if (alreadyNotified) {
return;
if (decision == Cancel) {
return false;
} else if (decision == Continue) {
return true;
}
const auto now = std::chrono::system_clock::now ();
if (now - startedAt < std::chrono::seconds (10)) {
return;
return true;
}
Gtk::MessageDialog dialog (M ("TP_FILMSIMULATION_SLOWPARSEDIR"), false, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_OK, true);
dialog.run ();
alreadyNotified = true;
Gtk::MessageDialog dialog (M ("TP_FILMSIMULATION_SLOWPARSEDIR"), false, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_YES_NO, true);
if (dialog.run () == Gtk::RESPONSE_YES) {
decision = Cancel;
return false;
} else {
decision = Continue;
return true;
}
}
}
@@ -227,7 +239,10 @@ int ClutComboBox::parseDir (const Glib::ustring& path)
dirs.push_back (std::move (dir));
notifySlowParseDir (startedAt);
if (!notifySlowParseDir (startedAt)) {
m_model->clear ();
return 0;
}
}
currDirs.clear ();
@@ -278,7 +293,10 @@ int ClutComboBox::parseDir (const Glib::ustring& path)
++fileCount;
notifySlowParseDir (startedAt);
if (!notifySlowParseDir (startedAt)) {
m_model->clear ();
return 0;
}
}
}

330
rtgui/multilangmgr.cc
View File

@@ -16,127 +16,165 @@
* You should have received a copy of the GNU General Public License
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "multilangmgr.h"
#include <fstream>
#include <regex>
#ifdef WIN32
// Desired auto detect function is Vista+
#if (__GNUC__ == 4 && __GNUC_MINOR__ >= 8) || __GNUC__ > 4
#define WINVER 0x0600 // switching to WINVER for gcc 4.8.1 support on Winx64
#else
#define _WIN32_WINNT 0x0600
#endif
#include <windows.h>
#include <winnls.h>
#if (__GNUC__ == 4 && __GNUC_MINOR__ >= 8) || __GNUC__ > 4
#undef WINVER
#else
#undef _WIN32_WINNT
#endif
#endif
#include <glib/gstdio.h>
#include "multilangmgr.h"
#include <cstring>
#include "../rtengine/safegtk.h"
namespace
{
// Maps standard locales to languages, e.g. "de-DE" to "Deutsch".
struct LocaleToLang : private std::map<std::pair<Glib::ustring, Glib::ustring>, Glib::ustring>
{
static const std::pair<Glib::ustring, Glib::ustring> key (const Glib::ustring& major, const Glib::ustring& minor = Glib::ustring ())
{
return std::make_pair (major, minor);
}
LocaleToLang ()
{
emplace (key ("ca"), "Catala");
emplace (key ("cs"), "Czech");
emplace (key ("da"), "Dansk");
emplace (key ("de"), "Deutsch");
emplace (key ("es"), "Espanol");
emplace (key ("eu"), "Euskara");
emplace (key ("fr"), "Francais");
emplace (key ("el"), "Greek");
emplace (key ("he"), "Hebrew");
emplace (key ("it"), "Italiano");
emplace (key ("ja"), "Japanese");
emplace (key ("lv"), "Latvian");
emplace (key ("hu"), "Magyar");
emplace (key ("nl"), "Nederlands");
emplace (key ("nn"), "Norsk BM");
emplace (key ("nb"), "Norsk BM");
emplace (key ("pl"), "Polish");
emplace (key ("pt"), "Portugues (Brasil)");
emplace (key ("ru"), "Russian");
emplace (key ("sr"), "Serbian (Cyrilic Characters)");
emplace (key ("sk"), "Slovak");
emplace (key ("fi"), "Suomi");
emplace (key ("sv"), "Swedish");
emplace (key ("tr"), "Turkish");
emplace (key ("zh", "CN"), "Chinese (Simplified)");
emplace (key ("zh", "SG"), "Chinese (Traditional)");
}
Glib::ustring operator() (const Glib::ustring& locale) const
{
Glib::ustring major, minor;
if (locale.length () >= 2) {
major = locale.substr (0, 2).lowercase ();
}
if (locale.length () >= 5) {
minor = locale.substr (3, 2).uppercase ();
}
// Look for matching language and country.
auto iterator = find (key (major, minor));
if (iterator != end ()) {
return iterator->second;
}
// Look for matching language only.
iterator = find (key (major));
if (iterator != end ()) {
return iterator->second;
}
return "default";
}
};
const LocaleToLang localeToLang;
}
MultiLangMgr langMgr;
Glib::ustring M (std::string key)
MultiLangMgr::MultiLangMgr ()
{
return langMgr.getStr (key);
}
// fb is fallback manager if the first could not be loaded
bool MultiLangMgr::load (Glib::ustring fname, MultiLangMgr* fb)
MultiLangMgr::MultiLangMgr (const Glib::ustring& fname, MultiLangMgr* fallbackMgr)
{
FILE *f = safe_g_fopen (fname, "rt");
load (fname, fallbackMgr);
}
fallBack = fb;
bool MultiLangMgr::load (const Glib::ustring& fname, MultiLangMgr* fallbackMgr)
{
this->fallbackMgr.reset (fallbackMgr);
if (f == NULL) {
std::ifstream file (fname.c_str ());
if (!file.is_open ()) {
return false;
}
transTable.clear ();
std::map<std::string, Glib::ustring> translations;
std::string entry, key, value;
char* buffer = new char[2048];
while (std::getline (file, entry)) {
while (fgets (buffer, 2048, f) != 0) {
// find separator
int seppos = 0;
while (buffer[seppos] != 0 && buffer[seppos] != ';') {
seppos++;
}
// no separator found
if (buffer[seppos] == 0) {
if (entry.empty () || entry.front () == '#') {
continue;
}
// cut the last \n and \r characters
int endpos = strlen(buffer) - 1;
std::istringstream line (entry);
while (buffer[endpos] == '\n' || buffer[endpos] == '\r') {
endpos--;
if (!std::getline (line, key, ';') || !std::getline (line, value)) {
continue;
}
buffer[endpos + 1] = 0;
// replace "\n" to '\n'
int j = 0;
static const std::regex newline ("\\\\n");
value = std::regex_replace (value, newline, "\n");
for (int i = 0; i < endpos + 1; i++)
if (i < endpos && buffer[i] == '\\' && buffer[i + 1] == 'n') {
buffer[j++] = '\n';
i++;
} else {
buffer[j++] = buffer[i];
}
buffer[j] = 0;
// cut to two parts
buffer[seppos] = 0;
transTable[buffer] = buffer + seppos + 1;
translations.emplace (key, value);
}
fclose (f);
delete [] buffer;
this->translations.swap (translations);
return true;
}
bool MultiLangMgr::save (Glib::ustring fname)
Glib::ustring MultiLangMgr::getStr (const std::string& key) const
{
const auto iterator = translations.find (key);
FILE *f = safe_g_fopen (fname, "wt");
if (f == NULL) {
return false;
if (iterator != translations.end ()) {
return iterator->second;
}
std::map<std::string, Glib::ustring>::iterator r;
for (r = transTable.begin (); r != transTable.end(); r++) {
fprintf (f, "%s;%s\n", r->first.c_str(), safe_locale_from_utf8(r->second).c_str());
if (fallbackMgr) {
return fallbackMgr->getStr (key);
}
fclose (f);
return true;
return key;
}
bool MultiLangMgr::isOSLanguageDetectSupported()
bool MultiLangMgr::isOSLanguageDetectSupported ()
{
#if defined(WIN32) || defined(__linux__) || defined(__APPLE__)
#if defined (WIN32) || defined (__linux__) || defined (__APPLE__)
return true;
#else
return false;
#endif
}
// returns Language name mapped from the currently selected OS language
Glib::ustring MultiLangMgr::getOSUserLanguage()
Glib::ustring MultiLangMgr::getOSUserLanguage ()
{
Glib::ustring langName ("default");
#if defined(WIN32)
#if defined (WIN32)
const LCID localeID = GetUserDefaultLCID ();
TCHAR localeName[18];
@@ -148,153 +186,23 @@ Glib::ustring MultiLangMgr::getOSUserLanguage()
localeName[langLen - 1] = '-';
const int countryLen = GetLocaleInfo (localeID, LOCALE_SISO3166CTRYNAME, localeName + langLen, 9);
const int countryLen = GetLocaleInfo (localeID, LOCALE_SISO3166CTRYNAME, &localeName[langLen], 9);
if (countryLen <= 0) {
return langName;
}
langName = TranslateRFC2Language (localeName);
langName = localeToLang (localeName);
#elif defined(__linux__) || defined(__APPLE__)
#elif defined (__linux__) || defined (__APPLE__)
const char* locale = setlocale(LC_CTYPE, "");
setlocale(LC_NUMERIC, "C"); // to set decimal point to "."
if (locale) {
langName = TranslateRFC2Language (locale);
// Query the current locale and force decimal point to dot.
if (const char* locale = setlocale (LC_CTYPE, "")) {
langName = localeToLang (locale);
}
setlocale (LC_NUMERIC, "C");
#endif
return langName;
}
// Translates RFC standard language code to file name, e.g. "de-DE" to "Deutsch"
Glib::ustring MultiLangMgr::TranslateRFC2Language(Glib::ustring rfcName)
{
if (rfcName.length() < 2) {
return Glib::ustring("default");
}
Glib::ustring major = rfcName.substr(0, 2).lowercase();
Glib::ustring minor;
if (rfcName.length() >= 5) {
minor = rfcName.substr(3, 2).uppercase();
}
//printf("Lang: %s - %s\n",major.c_str(),minor.c_str());
if (major == "ca") {
return "Catala";
}
if (major == "zh") {
return (minor == "CN" || minor == "SG") ? "Chinese (Simplified)" : "Chinese (Traditional)";
}
if (major == "cs") {
return "Czech";
}
if (major == "da") {
return "Dansk";
}
if (major == "de") {
return "Deutsch";
}
if (major == "es") {
return "Espanol";
}
if (major == "eu") {
return "Euskara";
}
if (major == "fr") {
return "Francais";
}
if (major == "el") {
return "Greek";
}
if (major == "he") {
return "Hebrew";
}
if (major == "it") {
return "Italiano";
}
if (major == "ja") {
return "Japanese";
}
if (major == "lv") {
return "Latvian";
}
if (major == "hu") {
return "Magyar";
}
if (major == "nl") {
return "Nederlands";
}
if (major == "nn" || major == "nb") {
return "Norsk BM";
}
if (major == "pl") {
return "Polish";
}
if (major == "pt") {
return "Portugues (Brasil)";
}
if (major == "ru") {
return "Russian";
}
if (major == "sr") {
return "Serbian (Cyrilic Characters)";
}
if (major == "sk") {
return "Slovak";
}
if (major == "fi") {
return "Suomi";
}
if (major == "sv") {
return "Swedish";
}
if (major == "tr") {
return "Turkish";
}
// Don't split en-US, en-GB, etc. since only default english is constantly updated
return "default";
}
Glib::ustring MultiLangMgr::getStr (std::string key)
{
std::map<std::string, Glib::ustring>::iterator r = transTable.find (key);
if (r != transTable.end()) {
return r->second;
} else if (fallBack) {
return fallBack->getStr (key);
} else {
return key;
}
}

42
rtgui/multilangmgr.h
View File

@@ -20,38 +20,38 @@
#define _MULTILANGMGR_
#include <map>
#include <memory>
#include <string>
#include <glibmm.h>
#include <glibmm/ustring.h>
class MultiLangMgr
{
std::map<std::string, Glib::ustring> transTable;
MultiLangMgr* fallBack;
Glib::ustring TranslateRFC2Language(Glib::ustring rfcName);
public:
MultiLangMgr ();
MultiLangMgr (const Glib::ustring& fname, MultiLangMgr* fallbackMgr = nullptr);
public:
MultiLangMgr () : fallBack (NULL) {}
MultiLangMgr (Glib::ustring fname) : fallBack (NULL)
{
load (fname);
}
MultiLangMgr (Glib::ustring fname, MultiLangMgr* fb) : fallBack (NULL)
{
load (fname, fb);
}
bool load (const Glib::ustring& fname, MultiLangMgr* fallbackMgr = nullptr);
bool load (Glib::ustring fname, MultiLangMgr* fb = NULL);
bool save (Glib::ustring fname);
public:
Glib::ustring getStr (const std::string& key) const;
public:
static bool isOSLanguageDetectSupported ();
static Glib::ustring getOSUserLanguage ();
private:
std::map<std::string, Glib::ustring> translations;
std::unique_ptr<MultiLangMgr> fallbackMgr;
bool isOSLanguageDetectSupported();
Glib::ustring getOSUserLanguage();
Glib::ustring getStr (std::string key);
};
extern MultiLangMgr langMgr;
Glib::ustring M (std::string key);
inline Glib::ustring M (const std::string& key)
{
return langMgr.getStr (key);
}
#endif