2006-05-05 20:52:09 +02:00
|
|
|
// Copyright (c) 2005-2006, Rodrigo Braz Monteiro
|
2006-01-16 22:02:54 +01:00
|
|
|
// All rights reserved.
|
|
|
|
//
|
|
|
|
// Redistribution and use in source and binary forms, with or without
|
|
|
|
// modification, are permitted provided that the following conditions are met:
|
|
|
|
//
|
|
|
|
// * Redistributions of source code must retain the above copyright notice,
|
|
|
|
// this list of conditions and the following disclaimer.
|
|
|
|
// * Redistributions in binary form must reproduce the above copyright notice,
|
|
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
|
|
// and/or other materials provided with the distribution.
|
|
|
|
// * Neither the name of the Aegisub Group nor the names of its contributors
|
|
|
|
// may be used to endorse or promote products derived from this software
|
|
|
|
// without specific prior written permission.
|
|
|
|
//
|
|
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
|
|
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
|
|
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
|
|
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
|
|
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
|
|
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
|
|
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
|
|
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
|
|
// POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
//
|
2009-07-29 07:43:02 +02:00
|
|
|
// Aegisub Project http://www.aegisub.org/
|
|
|
|
|
2012-04-04 00:44:40 +02:00
|
|
|
#include "utils.h"
|
|
|
|
|
2013-01-04 16:01:50 +01:00
|
|
|
#include "compat.h"
|
2014-05-29 17:28:37 +02:00
|
|
|
#include "format.h"
|
2013-01-04 16:01:50 +01:00
|
|
|
#include "options.h"
|
2013-12-27 04:23:59 +01:00
|
|
|
#include "retina_helper.h"
|
2013-01-04 16:01:50 +01:00
|
|
|
|
|
|
|
#include <libaegisub/dispatch.h>
|
|
|
|
#include <libaegisub/fs.h>
|
|
|
|
#include <libaegisub/log.h>
|
|
|
|
|
2009-09-10 15:06:40 +02:00
|
|
|
#ifdef __UNIX__
|
|
|
|
#include <unistd.h>
|
|
|
|
#endif
|
2014-05-23 00:40:16 +02:00
|
|
|
#include <boost/filesystem/path.hpp>
|
2012-04-04 00:44:40 +02:00
|
|
|
#include <map>
|
2014-05-06 19:48:22 +02:00
|
|
|
#include <unicode/locid.h>
|
2017-05-09 04:01:47 +02:00
|
|
|
#include <unicode/unistr.h>
|
2012-11-19 06:10:36 +01:00
|
|
|
#include <wx/clipbrd.h>
|
2013-01-22 05:27:56 +01:00
|
|
|
#include <wx/filedlg.h>
|
2009-01-04 12:45:06 +01:00
|
|
|
#include <wx/stdpaths.h>
|
2011-10-28 22:15:10 +02:00
|
|
|
#include <wx/window.h>
|
2009-09-10 15:06:40 +02:00
|
|
|
|
2009-01-04 12:45:06 +01:00
|
|
|
#ifdef __APPLE__
|
2010-08-14 19:42:37 +02:00
|
|
|
#include <libaegisub/util_osx.h>
|
2013-12-10 18:08:30 +01:00
|
|
|
#include <CoreText/CTFont.h>
|
2009-01-04 12:45:06 +01:00
|
|
|
#endif
|
2006-01-16 22:02:54 +01:00
|
|
|
|
2012-03-25 06:05:06 +02:00
|
|
|
/// @brief There shall be no kiB, MiB stuff here Pretty reading of size
|
2006-07-01 04:27:37 +02:00
|
|
|
wxString PrettySize(int bytes) {
|
2012-03-27 02:49:43 +02:00
|
|
|
const char *suffix[] = { "", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB" };
|
2006-07-01 04:27:37 +02:00
|
|
|
|
|
|
|
// Set size
|
2012-10-15 06:37:14 +02:00
|
|
|
size_t i = 0;
|
2006-07-01 04:27:37 +02:00
|
|
|
double size = bytes;
|
2012-10-15 06:37:14 +02:00
|
|
|
while (size > 1024 && i + 1 < sizeof(suffix) / sizeof(suffix[0])) {
|
2012-03-27 02:49:43 +02:00
|
|
|
size /= 1024.0;
|
2006-07-01 04:27:37 +02:00
|
|
|
i++;
|
|
|
|
}
|
2012-03-25 06:05:06 +02:00
|
|
|
|
2006-07-01 04:27:37 +02:00
|
|
|
// Set number of decimal places
|
2012-03-27 02:49:43 +02:00
|
|
|
const char *fmt = "%.0f";
|
|
|
|
if (size < 10)
|
|
|
|
fmt = "%.2f";
|
|
|
|
else if (size < 100)
|
|
|
|
fmt = "%1.f";
|
2014-05-29 17:28:37 +02:00
|
|
|
return agi::wxformat(fmt, size) + " " + suffix[i];
|
2006-07-01 04:27:37 +02:00
|
|
|
}
|
2007-01-11 06:33:36 +01:00
|
|
|
|
2022-07-29 21:50:10 +02:00
|
|
|
std::string float_to_string(double val, int precision) {
|
|
|
|
std::string fmt = "%." + std::to_string(precision) + "f";
|
|
|
|
std::string s = agi::format(fmt, val);
|
2013-07-31 05:31:10 +02:00
|
|
|
size_t pos = s.find_last_not_of("0");
|
|
|
|
if (pos != s.find(".")) ++pos;
|
|
|
|
s.erase(begin(s) + pos, end(s));
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
2007-01-21 07:30:19 +01:00
|
|
|
int SmallestPowerOf2(int x) {
|
|
|
|
x--;
|
|
|
|
x |= (x >> 1);
|
|
|
|
x |= (x >> 2);
|
|
|
|
x |= (x >> 4);
|
|
|
|
x |= (x >> 8);
|
|
|
|
x |= (x >> 16);
|
|
|
|
x++;
|
|
|
|
return x;
|
|
|
|
}
|
2007-04-14 17:26:46 +02:00
|
|
|
|
2014-06-13 18:33:41 +02:00
|
|
|
#ifndef __WXMAC__
|
2009-01-04 12:45:06 +01:00
|
|
|
void RestartAegisub() {
|
2012-06-08 23:20:21 +02:00
|
|
|
config::opt->Flush();
|
|
|
|
|
2009-01-04 12:45:06 +01:00
|
|
|
#if defined(__WXMSW__)
|
2013-08-12 05:20:41 +02:00
|
|
|
wxExecute("\"" + wxStandardPaths::Get().GetExecutablePath() + "\"");
|
2009-01-04 12:45:06 +01:00
|
|
|
#else
|
2013-08-12 05:20:41 +02:00
|
|
|
wxExecute(wxStandardPaths::Get().GetExecutablePath());
|
2009-01-04 12:45:06 +01:00
|
|
|
#endif
|
|
|
|
}
|
2014-06-13 18:33:41 +02:00
|
|
|
#endif
|
2009-07-29 07:43:02 +02:00
|
|
|
|
2011-10-25 21:40:45 +02:00
|
|
|
bool ForwardMouseWheelEvent(wxWindow *source, wxMouseEvent &evt) {
|
|
|
|
wxWindow *target = wxFindWindowAtPoint(wxGetMousePosition());
|
|
|
|
if (!target || target == source) return true;
|
|
|
|
|
|
|
|
// If the mouse is over a parent of the source window just pretend it's
|
|
|
|
// over the source window, so that the mouse wheel works on borders and such
|
|
|
|
wxWindow *parent = source->GetParent();
|
|
|
|
while (parent && parent != target) parent = parent->GetParent();
|
|
|
|
if (parent == target) return true;
|
|
|
|
|
|
|
|
// Otherwise send it to the new target
|
|
|
|
target->GetEventHandler()->ProcessEvent(evt);
|
|
|
|
evt.Skip(false);
|
|
|
|
return false;
|
|
|
|
}
|
2012-04-04 00:44:40 +02:00
|
|
|
|
2013-01-04 16:01:50 +01:00
|
|
|
std::string GetClipboard() {
|
2012-10-25 17:13:13 +02:00
|
|
|
wxString data;
|
|
|
|
wxClipboard *cb = wxClipboard::Get();
|
|
|
|
if (cb->Open()) {
|
2015-03-22 19:46:58 +01:00
|
|
|
if (cb->IsSupported(wxDF_TEXT) || cb->IsSupported(wxDF_UNICODETEXT)) {
|
2012-10-25 17:13:13 +02:00
|
|
|
wxTextDataObject raw_data;
|
|
|
|
cb->GetData(raw_data);
|
|
|
|
data = raw_data.GetText();
|
|
|
|
}
|
|
|
|
cb->Close();
|
|
|
|
}
|
2013-01-04 16:01:50 +01:00
|
|
|
return from_wx(data);
|
2012-10-25 17:13:13 +02:00
|
|
|
}
|
|
|
|
|
2013-01-04 16:01:50 +01:00
|
|
|
void SetClipboard(std::string const& new_data) {
|
2012-10-25 17:13:13 +02:00
|
|
|
wxClipboard *cb = wxClipboard::Get();
|
|
|
|
if (cb->Open()) {
|
2013-01-04 16:01:50 +01:00
|
|
|
cb->SetData(new wxTextDataObject(to_wx(new_data)));
|
2012-10-25 17:13:13 +02:00
|
|
|
cb->Flush();
|
2014-06-01 16:05:18 +02:00
|
|
|
cb->Close();
|
2012-10-25 17:13:13 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void SetClipboard(wxBitmap const& new_data) {
|
|
|
|
wxClipboard *cb = wxClipboard::Get();
|
|
|
|
if (cb->Open()) {
|
|
|
|
cb->SetData(new wxBitmapDataObject(new_data));
|
|
|
|
cb->Flush();
|
2014-06-01 16:05:18 +02:00
|
|
|
cb->Close();
|
2012-10-25 17:13:13 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-04 16:01:50 +01:00
|
|
|
void CleanCache(agi::fs::path const& directory, std::string const& file_type, uint64_t max_size, uint64_t max_files) {
|
|
|
|
static std::unique_ptr<agi::dispatch::Queue> queue;
|
|
|
|
if (!queue)
|
|
|
|
queue = agi::dispatch::Create();
|
|
|
|
|
|
|
|
max_size <<= 20;
|
|
|
|
if (max_files == 0)
|
|
|
|
max_files = std::numeric_limits<uint64_t>::max();
|
|
|
|
queue->Async([=]{
|
|
|
|
LOG_D("utils/clean_cache") << "cleaning " << directory/file_type;
|
|
|
|
uint64_t total_size = 0;
|
2014-07-18 00:46:27 +02:00
|
|
|
using cache_item = std::pair<int64_t, agi::fs::path>;
|
|
|
|
std::vector<cache_item> cachefiles;
|
2013-01-04 16:01:50 +01:00
|
|
|
for (auto const& file : agi::fs::DirectoryIterator(directory, file_type)) {
|
|
|
|
agi::fs::path path = directory/file;
|
2014-07-18 00:46:27 +02:00
|
|
|
cachefiles.push_back({agi::fs::ModifiedTime(path), path});
|
2013-01-04 16:01:50 +01:00
|
|
|
total_size += agi::fs::Size(path);
|
2012-04-04 00:44:40 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (cachefiles.size() <= max_files && total_size <= max_size) {
|
2014-05-29 00:19:05 +02:00
|
|
|
LOG_D("utils/clean_cache") << agi::format("cache does not need cleaning (maxsize=%d, cursize=%d, maxfiles=%d, numfiles=%d), exiting"
|
|
|
|
, max_size, total_size, max_files, cachefiles.size());
|
2013-01-04 16:01:50 +01:00
|
|
|
return;
|
2012-04-04 00:44:40 +02:00
|
|
|
}
|
|
|
|
|
2014-07-18 00:46:27 +02:00
|
|
|
sort(begin(cachefiles), end(cachefiles), [](cache_item const& a, cache_item const& b) {
|
|
|
|
return a.first < b.first;
|
|
|
|
});
|
|
|
|
|
2012-04-04 00:44:40 +02:00
|
|
|
int deleted = 0;
|
2012-11-04 04:53:03 +01:00
|
|
|
for (auto const& i : cachefiles) {
|
2012-04-04 00:44:40 +02:00
|
|
|
// stop cleaning?
|
|
|
|
if ((total_size <= max_size && cachefiles.size() - deleted <= max_files) || cachefiles.size() - deleted < 2)
|
|
|
|
break;
|
|
|
|
|
2013-01-04 16:01:50 +01:00
|
|
|
uint64_t size = agi::fs::Size(i.second);
|
|
|
|
try {
|
|
|
|
agi::fs::Remove(i.second);
|
|
|
|
LOG_D("utils/clean_cache") << "deleted " << i.second;
|
|
|
|
}
|
|
|
|
catch (agi::Exception const& e) {
|
2014-05-29 14:57:27 +02:00
|
|
|
LOG_D("utils/clean_cache") << "failed to delete file " << i.second << ": " << e.GetMessage();
|
2012-04-04 00:44:40 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2013-01-04 16:01:50 +01:00
|
|
|
total_size -= size;
|
2012-04-04 00:44:40 +02:00
|
|
|
++deleted;
|
|
|
|
}
|
|
|
|
|
|
|
|
LOG_D("utils/clean_cache") << "deleted " << deleted << " files, exiting";
|
2013-01-04 16:01:50 +01:00
|
|
|
});
|
2012-04-04 00:44:40 +02:00
|
|
|
}
|
|
|
|
|
2012-05-26 22:16:08 +02:00
|
|
|
#ifndef __WXOSX_COCOA__
|
2013-12-27 04:23:59 +01:00
|
|
|
// OS X implementation in osx_utils.mm
|
2012-06-07 04:48:13 +02:00
|
|
|
void AddFullScreenButton(wxWindow *) { }
|
|
|
|
void SetFloatOnParent(wxWindow *) { }
|
2013-12-27 04:23:59 +01:00
|
|
|
|
|
|
|
// OS X implementation in retina_helper.mm
|
2019-05-17 09:01:31 +02:00
|
|
|
RetinaHelper::RetinaHelper(wxWindow* w) { window = w; }
|
2013-12-27 04:23:59 +01:00
|
|
|
RetinaHelper::~RetinaHelper() { }
|
2019-05-17 09:01:31 +02:00
|
|
|
int RetinaHelper::GetScaleFactor() const {
|
|
|
|
#ifdef __WXGTK__
|
|
|
|
return int(window->GetContentScaleFactor());
|
|
|
|
#else
|
|
|
|
return 1;
|
|
|
|
#endif
|
|
|
|
}
|
2012-05-26 22:16:08 +02:00
|
|
|
#endif
|
2013-01-04 16:01:50 +01:00
|
|
|
|
2013-12-10 18:08:30 +01:00
|
|
|
wxString FontFace(std::string opt_prefix) {
|
|
|
|
opt_prefix += "/Font Face";
|
|
|
|
auto value = OPT_GET(opt_prefix)->GetString();
|
|
|
|
#ifdef __WXOSX_COCOA__
|
|
|
|
if (value.empty()) {
|
|
|
|
auto default_font = CTFontCreateUIFontForLanguage(kCTFontUserFontType, 0, nullptr);
|
|
|
|
auto default_font_name = CTFontCopyPostScriptName(default_font);
|
|
|
|
CFRelease(default_font);
|
|
|
|
|
|
|
|
auto utf8_str = CFStringGetCStringPtr(default_font_name, kCFStringEncodingUTF8);
|
|
|
|
if (utf8_str)
|
|
|
|
value = utf8_str;
|
|
|
|
else {
|
|
|
|
char buffer[1024];
|
|
|
|
CFStringGetCString(default_font_name, buffer, sizeof(buffer), kCFStringEncodingUTF8);
|
|
|
|
buffer[1023] = '\0';
|
|
|
|
value = buffer;
|
|
|
|
}
|
|
|
|
|
|
|
|
CFRelease(default_font_name);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return to_wx(value);
|
|
|
|
}
|
|
|
|
|
2015-01-01 04:41:56 +01:00
|
|
|
static agi::fs::path FileSelector(wxString const& message, std::string const& option_name, std::string const& default_filename, std::string const& default_extension, std::string const& wildcard, int flags, wxWindow *parent) {
|
2013-01-22 05:27:56 +01:00
|
|
|
wxString path;
|
|
|
|
if (!option_name.empty())
|
|
|
|
path = to_wx(OPT_GET(option_name)->GetString());
|
2015-01-01 04:41:56 +01:00
|
|
|
agi::fs::path filename = wxFileSelector(message, path, to_wx(default_filename), to_wx(default_extension), to_wx(wildcard), flags, parent).wx_str();
|
2013-01-22 05:27:56 +01:00
|
|
|
if (!filename.empty() && !option_name.empty())
|
|
|
|
OPT_SET(option_name)->SetString(filename.parent_path().string());
|
|
|
|
return filename;
|
|
|
|
}
|
|
|
|
|
2015-01-01 04:41:56 +01:00
|
|
|
agi::fs::path OpenFileSelector(wxString const& message, std::string const& option_name, std::string const& default_filename, std::string const& default_extension, std::string const& wildcard, wxWindow *parent) {
|
2013-01-22 05:27:56 +01:00
|
|
|
return FileSelector(message, option_name, default_filename, default_extension, wildcard, wxFD_OPEN | wxFD_FILE_MUST_EXIST, parent);
|
|
|
|
}
|
|
|
|
|
2015-01-01 04:41:56 +01:00
|
|
|
agi::fs::path SaveFileSelector(wxString const& message, std::string const& option_name, std::string const& default_filename, std::string const& default_extension, std::string const& wildcard, wxWindow *parent) {
|
2013-01-22 05:27:56 +01:00
|
|
|
return FileSelector(message, option_name, default_filename, default_extension, wildcard, wxFD_SAVE | wxFD_OVERWRITE_PROMPT, parent);
|
|
|
|
}
|
2014-05-06 19:48:22 +02:00
|
|
|
|
|
|
|
wxString LocalizedLanguageName(wxString const& lang) {
|
2018-03-31 02:57:19 +02:00
|
|
|
icu::Locale iculoc(lang.c_str());
|
2014-05-06 19:48:22 +02:00
|
|
|
if (!iculoc.isBogus()) {
|
2018-03-31 02:57:19 +02:00
|
|
|
icu::UnicodeString ustr;
|
2014-05-06 19:48:22 +02:00
|
|
|
iculoc.getDisplayName(iculoc, ustr);
|
2014-05-07 03:31:19 +02:00
|
|
|
#ifdef _MSC_VER
|
2020-04-11 01:14:53 +02:00
|
|
|
return wxString((const wchar_t*)ustr.getBuffer());
|
2014-05-07 03:31:19 +02:00
|
|
|
#else
|
|
|
|
std::string utf8;
|
|
|
|
ustr.toUTF8String(utf8);
|
|
|
|
return to_wx(utf8);
|
|
|
|
#endif
|
2014-05-06 19:48:22 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (auto info = wxLocale::FindLanguageInfo(lang))
|
|
|
|
return info->Description;
|
|
|
|
return lang;
|
|
|
|
}
|