iqbalrifai
/
Aegisub
mirror of https://github.com/odrling/Aegisub
1
0
Fork 0
Code Issues Releases Wiki Activity

De-wxify AssOverride

This commit is contained in:
Thomas Goyne 2012-12-29 15:53:56 -08:00
parent 134fe60517
commit d49758edbf
21 changed files with 233 additions and 242 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

94
aegisub/src/ass_dialogue.cpp
View File

@ -33,13 +33,6 @@
#include "config.h" #include "config.h"
#include <boost/algorithm/string/join.hpp>
#include <fstream>
#include <list>
#include <wx/regex.h>
#include <wx/tokenzr.h>
#include "ass_dialogue.h" #include "ass_dialogue.h"
#include "compat.h" #include "compat.h"
#include "subtitle_format.h" #include "subtitle_format.h"
@ -47,6 +40,13 @@
#include <libaegisub/of_type_adaptor.h> #include <libaegisub/of_type_adaptor.h>
#include <boost/algorithm/string/join.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/tokenizer.hpp>
#include <wx/regex.h>
#include <wx/tokenzr.h>
using namespace boost::adaptors; using namespace boost::adaptors;
std::size_t hash_value(wxString const& s) { std::size_t hash_value(wxString const& s) {
@ -196,23 +196,24 @@ std::auto_ptr<boost::ptr_vector<AssDialogueBlock>> AssDialogue::ParseTags() cons
} }
int drawingLevel = 0; int drawingLevel = 0;
std::string text(from_wx(Text.get()));
for (size_t len = Text.get().size(), cur = 0; cur < len; ) { for (size_t len = text.size(), cur = 0; cur < len; ) {
// Overrides block // Overrides block
if (Text.get()[cur] == '{') { if (text[cur] == '{') {
size_t end = Text.get().find('}', cur); size_t end = text.find('}', cur);
// VSFilter requires that override blocks be closed, while libass // VSFilter requires that override blocks be closed, while libass
// does not. We match VSFilter here. // does not. We match VSFilter here.
if (end == wxString::npos) if (end == std::string::npos)
goto plain; goto plain;
++cur; ++cur;
// Get contents of block // Get contents of block
wxString work = Text.get().substr(cur, end - cur); std::string work = text.substr(cur, end - cur);
cur = end + 1; cur = end + 1;
if (work.size() && work.find('\\') == wxString::npos) { if (work.size() && work.find('\\') == std::string::npos) {
//We've found an override block with no backslashes //We've found an override block with no backslashes
//We're going to assume it's a comment and not consider it an override block //We're going to assume it's a comment and not consider it an override block
//Currently we'll treat this as a plain text block, but feel free to create a new class //Currently we'll treat this as a plain text block, but feel free to create a new class
@ -236,14 +237,14 @@ std::auto_ptr<boost::ptr_vector<AssDialogueBlock>> AssDialogue::ParseTags() cons
// Plain-text/drawing block // Plain-text/drawing block
plain: plain:
wxString work; std::string work;
size_t end = Text.get().find('{', cur + 1); size_t end = text.find('{', cur + 1);
if (end == wxString::npos) { if (end == std::string::npos) {
work = Text.get().substr(cur); work = text.substr(cur);
cur = len; cur = len;
} }
else { else {
work = Text.get().substr(cur, end - cur); work = text.substr(cur, end - cur);
cur = end; cur = end;
} }
@ -260,10 +261,10 @@ void AssDialogue::StripTags() {
Text = GetStrippedText(); Text = GetStrippedText();
} }
static wxString get_text(AssDialogueBlock &d) { return d.GetText(); } static std::string get_text(AssDialogueBlock &d) { return d.GetText(); }
void AssDialogue::UpdateText(boost::ptr_vector<AssDialogueBlock>& blocks) { void AssDialogue::UpdateText(boost::ptr_vector<AssDialogueBlock>& blocks) {
if (blocks.empty()) return; if (blocks.empty()) return;
Text = join(blocks | transformed(get_text), wxS("")); Text = to_wx(join(blocks | transformed(get_text), ""));
} }
void AssDialogue::SetMarginString(wxString const& origvalue, int which) { void AssDialogue::SetMarginString(wxString const& origvalue, int which) {
@ -296,52 +297,45 @@ bool AssDialogue::CollidesWith(const AssDialogue *target) const {
return ((Start < target->Start) ? (target->Start < End) : (Start < target->End)); return ((Start < target->Start) ? (target->Start < End) : (Start < target->End));
} }
static wxString get_text_p(AssDialogueBlock *d) { return d->GetText(); } static std::string get_text_p(AssDialogueBlock *d) { return d->GetText(); }
wxString AssDialogue::GetStrippedText() const { wxString AssDialogue::GetStrippedText() const {
wxString ret; wxString ret;
boost::ptr_vector<AssDialogueBlock> blocks(ParseTags()); boost::ptr_vector<AssDialogueBlock> blocks(ParseTags());
return join(blocks | agi::of_type<AssDialogueBlockPlain>() | transformed(get_text_p), wxS("")); return to_wx(join(blocks | agi::of_type<AssDialogueBlockPlain>() | transformed(get_text_p), ""));
} }
AssEntry *AssDialogue::Clone() const { AssEntry *AssDialogue::Clone() const {
return new AssDialogue(*this); return new AssDialogue(*this);
} }
void AssDialogueBlockDrawing::TransformCoords(int mx,int my,double x,double y) { void AssDialogueBlockDrawing::TransformCoords(int mx, int my, double x, double y) {
// HACK: Implement a proper parser ffs!! // HACK: Implement a proper parser ffs!!
// Could use Spline but it'd be slower and this seems to work fine // Could use Spline but it'd be slower and this seems to work fine
wxStringTokenizer tkn(GetText()," ",wxTOKEN_DEFAULT); bool is_x = true;
wxString cur; std::string final;
wxString final;
bool isX = true;
long temp;
// Process tokens boost::char_separator<char> sep(" ");
while (tkn.HasMoreTokens()) { for (auto const& cur : boost::tokenizer<boost::char_separator<char>>(text, sep)) {
cur = tkn.GetNextToken().Lower(); if (std::all_of(begin(cur), end(cur), isdigit)) {
int val = boost::lexical_cast<int>(cur);
// Number, process it if (is_x)
if (cur.IsNumber()) { val = (int)((val + mx) * x + .5);
// Transform it else
cur.ToLong(&temp); val = (int)((val + my) * y + .5);
if (isX) temp = (long int)((temp+mx)*x + 0.5); final += std::to_string(val);
else temp = (long int)((temp+my)*y + 0.5); final += ' ';
// Write back to list
final += wxString::Format("%i ",temp);
// Toggle X/Y
isX = !isX;
} }
else if (cur.size() == 1) {
// Text char c = tolower(cur[0]);
else { if (c == 'm' || c == 'n' || c == 'l' || c == 'b' || c == 's' || c == 'p' || c == 'c') {
if (cur == "m" || cur == "n" || cur == "l" || cur == "b" || cur == "s" || cur == "p" || cur == "c") isX = true; is_x = true;
final += cur + " "; final += c;
final += ' ';
}
} }
} }
// Write back final // Write back final
final = final.Left(final.Length()-1); final.pop_back();
text = final; text = final;
} }

18
aegisub/src/ass_dialogue.h
View File

@ -74,19 +74,19 @@ std::size_t hash_value(wxString const& s);
class AssDialogueBlock { class AssDialogueBlock {
protected: protected:
/// Text of this block /// Text of this block
wxString text; std::string text;
public: public:
AssDialogueBlock(wxString const& text) : text(text) { } AssDialogueBlock(std::string const& text) : text(text) { }
virtual ~AssDialogueBlock() { } virtual ~AssDialogueBlock() { }
virtual AssBlockType GetType() const = 0; virtual AssBlockType GetType() const = 0;
virtual wxString GetText() { return text; } virtual std::string GetText() { return text; }
}; };
class AssDialogueBlockPlain : public AssDialogueBlock { class AssDialogueBlockPlain : public AssDialogueBlock {
public: public:
AssBlockType GetType() const override { return BLOCK_PLAIN; } AssBlockType GetType() const override { return BLOCK_PLAIN; }
AssDialogueBlockPlain(wxString const& text = wxString()) : AssDialogueBlock(text) { } AssDialogueBlockPlain(std::string const& text = std::string()) : AssDialogueBlock(text) { }
}; };
class AssDialogueBlockDrawing : public AssDialogueBlock { class AssDialogueBlockDrawing : public AssDialogueBlock {
@ -94,23 +94,23 @@ public:
int Scale; int Scale;
AssBlockType GetType() const override { return BLOCK_DRAWING; } AssBlockType GetType() const override { return BLOCK_DRAWING; }
AssDialogueBlockDrawing(wxString const& text, int scale) : AssDialogueBlock(text), Scale(scale) { } AssDialogueBlockDrawing(std::string const& text, int scale) : AssDialogueBlock(text), Scale(scale) { }
void TransformCoords(int trans_x,int trans_y,double mult_x,double mult_y); void TransformCoords(int trans_x,int trans_y,double mult_x,double mult_y);
}; };
class AssDialogueBlockOverride : public AssDialogueBlock { class AssDialogueBlockOverride : public AssDialogueBlock {
public: public:
AssDialogueBlockOverride(wxString const& text = wxString()) : AssDialogueBlock(text) { } AssDialogueBlockOverride(std::string const& text = std::string()) : AssDialogueBlock(text) { }
std::vector<AssOverrideTag> Tags; std::vector<AssOverrideTag> Tags;
AssBlockType GetType() const override { return BLOCK_OVERRIDE; } AssBlockType GetType() const override { return BLOCK_OVERRIDE; }
wxString GetText() override; std::string GetText() override;
void ParseTags(); void ParseTags();
void AddTag(wxString const& tag); void AddTag(std::string const& tag);
/// Type of callback function passed to ProcessParameters /// Type of callback function passed to ProcessParameters
typedef void (*ProcessParametersCallback)(wxString const&, AssOverrideParameter *, void *); typedef void (*ProcessParametersCallback)(std::string const&, AssOverrideParameter *, void *);
/// @brief Process parameters via callback /// @brief Process parameters via callback
/// @param callback The callback function to call per tag parameter /// @param callback The callback function to call per tag parameter
/// @param userData User data to pass to callback function /// @param userData User data to pass to callback function

41
aegisub/src/ass_karaoke.cpp
View File

@ -25,24 +25,28 @@
#include "ass_dialogue.h" #include "ass_dialogue.h"
#include "ass_file.h" #include "ass_file.h"
#include "compat.h"
#include "include/aegisub/context.h" #include "include/aegisub/context.h"
#include "selection_controller.h" #include "selection_controller.h"
#include <boost/format.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/algorithm/string/trim.hpp>
#include <wx/intl.h> #include <wx/intl.h>
wxString AssKaraoke::Syllable::GetText(bool k_tag) const { std::string AssKaraoke::Syllable::GetText(bool k_tag) const {
wxString ret; std::string ret;
if (k_tag) if (k_tag)
ret = wxString::Format("{%s%d}", tag_type, (duration + 5) / 10); ret = str(boost::format("{%s%d}") % tag_type % ((duration + 5) / 10));
size_t idx = 0; size_t idx = 0;
for (auto const& ovr : ovr_tags) { for (auto const& ovr : ovr_tags) {
ret += text.Mid(idx, ovr.first - idx); ret += text.substr(idx, ovr.first - idx);
ret += ovr.second; ret += ovr.second;
idx = ovr.first; idx = ovr.first;
} }
ret += text.Mid(idx); ret += text.substr(idx);
return ret; return ret;
} }
@ -91,7 +95,7 @@ void AssKaraoke::SetLine(AssDialogue *line, bool auto_split, bool normalize) {
if (auto_split && syls.size() == 1) { if (auto_split && syls.size() == 1) {
size_t pos; size_t pos;
no_announce = true; no_announce = true;
while ((pos = syls.back().text.find(' ')) != wxString::npos) while ((pos = syls.back().text.find(' ')) != std::string::npos)
AddSplit(syls.size() - 1, pos + 1); AddSplit(syls.size() - 1, pos + 1);
no_announce = false; no_announce = false;
} }
@ -103,11 +107,11 @@ void AssKaraoke::ParseSyllables(AssDialogue *line, Syllable &syl) {
boost::ptr_vector<AssDialogueBlock> blocks(line->ParseTags()); boost::ptr_vector<AssDialogueBlock> blocks(line->ParseTags());
for (auto& block : blocks) { for (auto& block : blocks) {
wxString text = block.GetText(); std::string text = block.GetText();
if (dynamic_cast<AssDialogueBlockPlain*>(&block)) { if (dynamic_cast<AssDialogueBlockPlain*>(&block)) {
// treat comments as overrides rather than dialogue // treat comments as overrides rather than dialogue
if (text.size() && text[0] == '{') if (boost::starts_with(text, "{"))
syl.ovr_tags[syl.text.size()] += text; syl.ovr_tags[syl.text.size()] += text;
else else
syl.text += text; syl.text += text;
@ -120,7 +124,7 @@ void AssKaraoke::ParseSyllables(AssDialogue *line, Syllable &syl) {
else if (AssDialogueBlockOverride *ovr = dynamic_cast<AssDialogueBlockOverride*>(&block)) { else if (AssDialogueBlockOverride *ovr = dynamic_cast<AssDialogueBlockOverride*>(&block)) {
bool in_tag = false; bool in_tag = false;
for (auto& tag : ovr->Tags) { for (auto& tag : ovr->Tags) {
if (tag.IsValid() && tag.Name.Left(2).Lower() == "\\k") { if (tag.IsValid() && boost::istarts_with(tag.Name, "\\k")) {
if (in_tag) { if (in_tag) {
syl.ovr_tags[syl.text.size()] += "}"; syl.ovr_tags[syl.text.size()] += "}";
in_tag = false; in_tag = false;
@ -142,11 +146,10 @@ void AssKaraoke::ParseSyllables(AssDialogue *line, Syllable &syl) {
syl.duration = tag.Params[0].Get(0) * 10; syl.duration = tag.Params[0].Get(0) * 10;
} }
else { else {
wxString& otext = syl.ovr_tags[syl.text.size()]; std::string& otext = syl.ovr_tags[syl.text.size()];
// Merge adjacent override tags // Merge adjacent override tags
if (otext.size() && otext.Last() == '}') boost::trim_right_if(text, boost::is_any_of("}"));
otext.RemoveLast(); if (!in_tag)
else if (!in_tag)
otext += "{"; otext += "{";
in_tag = true; in_tag = true;
@ -167,16 +170,16 @@ wxString AssKaraoke::GetText() const {
text.reserve(size() * 10); text.reserve(size() * 10);
for (auto const& syl : syls) for (auto const& syl : syls)
text += syl.GetText(true); text += to_wx(syl.GetText(true));
return text; return text;
} }
wxString AssKaraoke::GetTagType() const { std::string AssKaraoke::GetTagType() const {
return begin()->tag_type; return begin()->tag_type;
} }
void AssKaraoke::SetTagType(wxString const& new_type) { void AssKaraoke::SetTagType(std::string const& new_type) {
for (auto& syl : syls) for (auto& syl : syls)
syl.tag_type = new_type; syl.tag_type = new_type;
} }
@ -190,8 +193,8 @@ void AssKaraoke::AddSplit(size_t syl_idx, size_t pos) {
// character then pos will be out of bounds. Doing this is a bit goofy, // character then pos will be out of bounds. Doing this is a bit goofy,
// but it's sometimes required for complex karaoke scripts // but it's sometimes required for complex karaoke scripts
if (pos < syl.text.size()) { if (pos < syl.text.size()) {
new_syl.text = syl.text.Mid(pos); new_syl.text = syl.text.substr(pos);
syl.text = syl.text.Left(pos); syl.text = syl.text.substr(0, pos);
} }
if (new_syl.text.empty()) if (new_syl.text.empty())
@ -302,7 +305,7 @@ void AssKaraoke::SplitLines(std::set<AssDialogue*> const& lines, agi::Context *c
new_line->Start = syl.start_time; new_line->Start = syl.start_time;
new_line->End = syl.start_time + syl.duration; new_line->End = syl.start_time + syl.duration;
new_line->Text = syl.GetText(false); new_line->Text = to_wx(syl.GetText(false));
c->ass->Line.insert(it, *new_line); c->ass->Line.insert(it, *new_line);

13
aegisub/src/ass_karaoke.h
View File

@ -22,6 +22,7 @@
#include <map> #include <map>
#include <set> #include <set>
#include <string>
#include <vector> #include <vector>
#include <wx/string.h> #include <wx/string.h>
@ -39,14 +40,14 @@ public:
struct Syllable { struct Syllable {
int start_time; ///< Start time relative to time zero (not line start) in milliseconds int start_time; ///< Start time relative to time zero (not line start) in milliseconds
int duration; ///< Duration in milliseconds int duration; ///< Duration in milliseconds
wxString text; ///< Stripped syllable text std::string text; ///< Stripped syllable text
wxString tag_type; ///< \k, \kf or \ko std::string tag_type; ///< \k, \kf or \ko
/// Non-karaoke override tags in this syllable. Key is an index in text /// Non-karaoke override tags in this syllable. Key is an index in text
/// before which the value should be inserted /// before which the value should be inserted
std::map<size_t, wxString> ovr_tags; std::map<size_t, std::string> ovr_tags;
/// Get the text of this line with override tags and optionally the karaoke tag /// Get the text of this line with override tags and optionally the karaoke tag
wxString GetText(bool k_tag) const; std::string GetText(bool k_tag) const;
}; };
private: private:
std::vector<Syllable> syls; std::vector<Syllable> syls;
@ -87,9 +88,9 @@ public:
/// Get the karaoke tag type used, with leading slash /// Get the karaoke tag type used, with leading slash
/// @returns "\k", "\kf", or "\ko" /// @returns "\k", "\kf", or "\ko"
wxString GetTagType() const; std::string GetTagType() const;
/// Set the tag type for all karaoke tags in this line /// Set the tag type for all karaoke tags in this line
void SetTagType(wxString const& new_type); void SetTagType(std::string const& new_type);
/// Split lines so that each syllable is its own line /// Split lines so that each syllable is its own line
/// @param lines Lines to split /// @param lines Lines to split

157
aegisub/src/ass_override.cpp
View File

@ -37,17 +37,15 @@
#include "ass_dialogue.h" #include "ass_dialogue.h"
#include <libaegisub/log.h> #include <libaegisub/color.h>
#include "compat.h"
#include "utils.h"
#include <boost/algorithm/string/join.hpp> #include <boost/algorithm/string/join.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/algorithm/string/trim.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/range/adaptor/filtered.hpp> #include <boost/range/adaptor/filtered.hpp>
#include <boost/range/adaptor/transformed.hpp> #include <boost/range/adaptor/transformed.hpp>
#include <functional> #include <functional>
#include <wx/log.h>
#include <wx/tokenzr.h>
using namespace boost::adaptors; using namespace boost::adaptors;
@ -78,31 +76,27 @@ AssOverrideParameter& AssOverrideParameter::operator=(AssOverrideParameter&& rhs
AssOverrideParameter::~AssOverrideParameter() { AssOverrideParameter::~AssOverrideParameter() {
} }
template<> wxString AssOverrideParameter::Get<wxString>() const { template<> std::string AssOverrideParameter::Get<std::string>() const {
if (omitted) throw agi::InternalError("AssOverrideParameter::Get() called on omitted parameter", 0); if (omitted) throw agi::InternalError("AssOverrideParameter::Get() called on omitted parameter", 0);
if (block.get()) { if (block.get()) {
wxString str(block->GetText()); std::string str(block->GetText());
str.Replace("{", ""); if (boost::starts_with(str, "{")) str.erase(0);
str.Replace("}", ""); if (boost::ends_with(str, "}")) str.erase(str.size() - 1);
return str; return str;
} }
return value; return value;
} }
template<> int AssOverrideParameter::Get<int>() const { template<> int AssOverrideParameter::Get<int>() const {
long v = 0; return boost::lexical_cast<int>(Get<std::string>());
Get<wxString>().ToLong(&v);
return v;
} }
template<> double AssOverrideParameter::Get<double>() const { template<> double AssOverrideParameter::Get<double>() const {
double v = 0; return boost::lexical_cast<double>(Get<std::string>());
Get<wxString>().ToDouble(&v);
return v;
} }
template<> float AssOverrideParameter::Get<float>() const { template<> float AssOverrideParameter::Get<float>() const {
return Get<double>(); return boost::lexical_cast<float>(Get<std::string>());
} }
template<> bool AssOverrideParameter::Get<bool>() const { template<> bool AssOverrideParameter::Get<bool>() const {
@ -110,29 +104,29 @@ template<> bool AssOverrideParameter::Get<bool>() const {
} }
template<> agi::Color AssOverrideParameter::Get<agi::Color>() const { template<> agi::Color AssOverrideParameter::Get<agi::Color>() const {
return from_wx(Get<wxString>()); return Get<std::string>();
} }
template<> AssDialogueBlockOverride *AssOverrideParameter::Get<AssDialogueBlockOverride*>() const { template<> AssDialogueBlockOverride *AssOverrideParameter::Get<AssDialogueBlockOverride*>() const {
if (!block.get()) { if (!block.get()) {
block.reset(new AssDialogueBlockOverride(Get<wxString>())); block.reset(new AssDialogueBlockOverride(Get<std::string>()));
block->ParseTags(); block->ParseTags();
} }
return block.get(); return block.get();
} }
template<> void AssOverrideParameter::Set<wxString>(wxString new_value) { template<> void AssOverrideParameter::Set<std::string>(std::string new_value) {
omitted = false; omitted = false;
value = new_value; value = new_value;
block.reset(); block.reset();
} }
template<> void AssOverrideParameter::Set<int>(int new_value) { template<> void AssOverrideParameter::Set<int>(int new_value) {
Set(wxString::Format("%d", new_value)); Set(std::to_string(new_value));
} }
template<> void AssOverrideParameter::Set<double>(double new_value) { template<> void AssOverrideParameter::Set<double>(double new_value) {
Set(wxString::Format("%g", new_value)); Set(std::to_string(new_value));
} }
template<> void AssOverrideParameter::Set<bool>(bool new_value) { template<> void AssOverrideParameter::Set<bool>(bool new_value) {
@ -166,45 +160,42 @@ struct AssOverrideParamProto {
/// Semantic type of this parameter /// Semantic type of this parameter
AssParameterClass classification; AssParameterClass classification;
AssOverrideParamProto (VariableDataType type, int opt=NOT_OPTIONAL, AssParameterClass classi=PARCLASS_NORMAL); AssOverrideParamProto(VariableDataType type, int opt, AssParameterClass classi)
: optional(opt)
, type(type)
, classification(classi)
{
}
}; };
struct AssOverrideTagProto { struct AssOverrideTagProto {
/// Name of the tag, with slash /// Name of the tag, with slash
wxString name; std::string name;
/// Parameters to this tag /// Parameters to this tag
std::vector<AssOverrideParamProto> params; std::vector<AssOverrideParamProto> params;
typedef std::vector<AssOverrideTagProto>::iterator iterator; typedef std::vector<AssOverrideTagProto>::iterator iterator;
/// @brief Add a parameter to this tag prototype /// @brief Add a parameter to this tag prototype
/// @param type Data type of the parameter /// @param type Data type of the parameter
/// @param classi Semantic type of the parameter /// @param classi Semantic type of the parameter
/// @param opt Situations in which this parameter is present /// @param opt Situations in which this parameter is present
void AddParam(VariableDataType type, AssParameterClass classi = PARCLASS_NORMAL, int opt = NOT_OPTIONAL); void AddParam(VariableDataType type, AssParameterClass classi = PARCLASS_NORMAL, int opt = NOT_OPTIONAL) {
params.emplace_back(type, opt, classi);
}
/// @brief Convenience function for single-argument tags /// @brief Convenience function for single-argument tags
/// @param name Name of the tag, with slash /// @param name Name of the tag, with slash
/// @param type Data type of the parameter /// @param type Data type of the parameter
/// @param classi Semantic type of the parameter /// @param classi Semantic type of the parameter
/// @param opt Situations in which this parameter is present /// @param opt Situations in which this parameter is present
void Set(wxString name, VariableDataType type, AssParameterClass classi = PARCLASS_NORMAL, int opt = NOT_OPTIONAL); void Set(const char *name, VariableDataType type, AssParameterClass classi = PARCLASS_NORMAL, int opt = NOT_OPTIONAL) {
this->name = name;
params.emplace_back(type, opt, classi);
}
}; };
AssOverrideParamProto::AssOverrideParamProto(VariableDataType type, int opt, AssParameterClass classi)
: optional(opt)
, type(type)
, classification(classi)
{
}
void AssOverrideTagProto::AddParam(VariableDataType type, AssParameterClass classi, int opt) {
params.emplace_back(type, opt, classi);
}
void AssOverrideTagProto::Set(wxString newName, VariableDataType type, AssParameterClass classi, int opt) {
name = newName;
params.emplace_back(type, opt, classi);
}
static std::vector<AssOverrideTagProto> proto; static std::vector<AssOverrideTagProto> proto;
static void load_protos() { static void load_protos() {
static bool loaded = false; static bool loaded = false;
@ -341,8 +332,8 @@ static void load_protos() {
proto[i].AddParam(VARDATA_BLOCK); proto[i].AddParam(VARDATA_BLOCK);
} }
std::vector<wxString> tokenize(const wxString &text) { std::vector<std::string> tokenize(const std::string &text) {
std::vector<wxString> paramList; std::vector<std::string> paramList;
paramList.reserve(6); paramList.reserve(6);
if (text.empty()) if (text.empty())
@ -351,32 +342,25 @@ std::vector<wxString> tokenize(const wxString &text) {
if (text[0] != '(') { if (text[0] != '(') {
// There's just one parameter (because there's no parentheses) // There's just one parameter (because there's no parentheses)
// This means text is all our parameters // This means text is all our parameters
wxString param(text); paramList.emplace_back(boost::trim_copy(text));
paramList.push_back(param.Trim(true).Trim(false));
return paramList; return paramList;
} }
// Ok, so there are parentheses used here, so there may be more than one parameter // Ok, so there are parentheses used here, so there may be more than one parameter
// Enter fullscale parsing! // Enter fullscale parsing!
size_t i = 0, textlen = text.size(); size_t i = 0, textlen = text.size();
size_t start = 0;
int parDepth = 1; int parDepth = 1;
while (i < textlen && parDepth > 0) { while (i < textlen && parDepth > 0) {
// Just skip until next ',' or ')', whichever comes first // Just skip until next ',' or ')', whichever comes first
// (Next ')' is achieved when parDepth == 0) // (Next ')' is achieved when parDepth == 0)
start = ++i; size_t start = ++i;
while (i < textlen && parDepth > 0) { while (i < textlen && parDepth > 0) {
wxChar c = text[i]; char c = text[i];
// parDepth 1 is where we start, and the tag-level we're interested in parsing on // parDepth 1 is where we start, and the tag-level we're interested in parsing on
if (c == ',' && parDepth == 1) break; if (c == ',' && parDepth == 1) break;
if (c == '(') parDepth++; if (c == '(') parDepth++;
else if (c == ')') { else if (c == ')') {
parDepth--; if (--parDepth == 0) {
if (parDepth < 0) {
wxLogWarning("Unmatched parenthesis near '%s'!\nTag-parsing incomplete.", text.SubString(i, 10));
return paramList;
}
else if (parDepth == 0) {
// We just ate the parenthesis ending this parameter block // We just ate the parenthesis ending this parameter block
// Make sure it doesn't get included in the parameter text // Make sure it doesn't get included in the parameter text
break; break;
@ -385,22 +369,22 @@ std::vector<wxString> tokenize(const wxString &text) {
i++; i++;
} }
// i now points to the first character not member of this parameter // i now points to the first character not member of this parameter
paramList.push_back(text.SubString(start, i-1).Trim(true).Trim(false)); paramList.emplace_back(boost::trim_copy(text.substr(start, i - start)));
} }
if (i+1 < textlen) { if (i+1 < textlen) {
// There's some additional garbage after the parentheses // There's some additional garbage after the parentheses
// Just add it in for completeness // Just add it in for completeness
paramList.push_back(text.Mid(i+1)); paramList.emplace_back(text.begin() + i + 1, text.end());
} }
return paramList; return paramList;
} }
void parse_parameters(AssOverrideTag *tag, const wxString &text, AssOverrideTagProto::iterator proto_it) { void parse_parameters(AssOverrideTag *tag, const std::string &text, AssOverrideTagProto::iterator proto_it) {
tag->Clear(); tag->Clear();
// Tokenize text, attempting to find all parameters // Tokenize text, attempting to find all parameters
std::vector<wxString> paramList = tokenize(text); std::vector<std::string> paramList = tokenize(text);
size_t totalPars = paramList.size(); size_t totalPars = paramList.size();
int parsFlag = 1 << (totalPars - 1); // Get optional parameters flag int parsFlag = 1 << (totalPars - 1); // Get optional parameters flag
@ -428,30 +412,32 @@ void parse_parameters(AssOverrideTag *tag, const wxString &text, AssOverrideTagP
void AssDialogueBlockOverride::ParseTags() { void AssDialogueBlockOverride::ParseTags() {
Tags.clear(); Tags.clear();
wxStringTokenizer tkn(text, "\\", wxTOKEN_STRTOK); int depth = 0;
wxString curTag; size_t start = 0;
if (text.StartsWith("\\")) curTag = "\\"; for (size_t i = 1; i < text.size(); ++i) {
if (depth > 0) {
while (tkn.HasMoreTokens()) { if (text[i] == ')')
curTag += tkn.GetNextToken(); --depth;
}
// Check for parenthesis matching for \t else if (text[i] == '\\') {
while (curTag.Freq('(') > curTag.Freq(')') && tkn.HasMoreTokens()) Tags.emplace_back(text.substr(start, i - start));
curTag << "\\" << tkn.GetNextToken(); start = i;
}
Tags.emplace_back(curTag); else if (text[i] == '(')
++depth;
curTag = "\\";
} }
if (!text.empty())
Tags.emplace_back(text.substr(start));
} }
void AssDialogueBlockOverride::AddTag(wxString const& tag) { void AssDialogueBlockOverride::AddTag(std::string const& tag) {
Tags.emplace_back(tag); Tags.emplace_back(tag);
} }
static wxString tag_str(AssOverrideTag const& t) { return t; } static std::string tag_str(AssOverrideTag const& t) { return t; }
wxString AssDialogueBlockOverride::GetText() { std::string AssDialogueBlockOverride::GetText() {
text = "{" + join(Tags | transformed(tag_str), wxString()) + "}"; text = "{" + join(Tags | transformed(tag_str), std::string()) + "}";
return text; return text;
} }
@ -470,7 +456,7 @@ void AssDialogueBlockOverride::ProcessParameters(ProcessParametersCallback callb
} }
AssOverrideTag::AssOverrideTag() : valid(false) { } AssOverrideTag::AssOverrideTag() : valid(false) { }
AssOverrideTag::AssOverrideTag(wxString const& text) { AssOverrideTag::AssOverrideTag(std::string const& text) {
SetText(text); SetText(text);
} }
AssOverrideTag::AssOverrideTag(AssOverrideTag&& rhs) AssOverrideTag::AssOverrideTag(AssOverrideTag&& rhs)
@ -493,24 +479,25 @@ void AssOverrideTag::Clear() {
valid = false; valid = false;
} }
void AssOverrideTag::SetText(const wxString &text) { void AssOverrideTag::SetText(const std::string &text) {
load_protos(); load_protos();
for (auto cur = proto.begin(); cur != proto.end(); ++cur) { for (auto cur = proto.begin(); cur != proto.end(); ++cur) {
if (text.StartsWith(cur->name)) { if (boost::starts_with(text, cur->name)) {
Name = cur->name; Name = cur->name;
parse_parameters(this, text.Mid(Name.length()), cur); parse_parameters(this, text.substr(Name.size()), cur);
valid = true; valid = true;
return; return;
} }
} }
// Junk tag // Junk tag
Name = text; Name = text;
valid = false; valid = false;
} }
static wxString param_str(AssOverrideParameter const& p) { return p.Get<wxString>(); } static std::string param_str(AssOverrideParameter const& p) { return p.Get<std::string>(); }
AssOverrideTag::operator wxString() const { AssOverrideTag::operator std::string() const {
wxString result = Name; std::string result = Name;
// Determine if it needs parentheses // Determine if it needs parentheses
bool parentheses = Params.size() > 1; bool parentheses = Params.size() > 1;
@ -520,7 +507,7 @@ AssOverrideTag::operator wxString() const {
result += join(Params result += join(Params
| filtered([](AssOverrideParameter const& p) { return !p.omitted; } ) | filtered([](AssOverrideParameter const& p) { return !p.omitted; } )
| transformed(param_str), | transformed(param_str),
wxS(",")); ",");
if (parentheses) result += ")"; if (parentheses) result += ")";
return result; return result;

11
aegisub/src/ass_override.h
View File

@ -37,7 +37,6 @@
#include <vector> #include <vector>
class AssDialogueBlockOverride; class AssDialogueBlockOverride;
class wxString;
/// Type of parameter; probably only used by the resample tool /// Type of parameter; probably only used by the resample tool
enum AssParameterClass { enum AssParameterClass {
@ -63,7 +62,7 @@ enum VariableDataType {
/// A single parameter to an override tag /// A single parameter to an override tag
class AssOverrideParameter : boost::noncopyable { class AssOverrideParameter : boost::noncopyable {
wxString value; std::string value;
mutable std::unique_ptr<AssDialogueBlockOverride> block; mutable std::unique_ptr<AssDialogueBlockOverride> block;
VariableDataType type; VariableDataType type;
@ -93,14 +92,14 @@ class AssOverrideTag : boost::noncopyable {
public: public:
AssOverrideTag(); AssOverrideTag();
AssOverrideTag(AssOverrideTag&&); AssOverrideTag(AssOverrideTag&&);
AssOverrideTag(wxString const& text); AssOverrideTag(std::string const& text);
AssOverrideTag& operator=(AssOverrideTag&&); AssOverrideTag& operator=(AssOverrideTag&&);
wxString Name; std::string Name;
std::vector<AssOverrideParameter> Params; std::vector<AssOverrideParameter> Params;
bool IsValid() const { return valid; } bool IsValid() const { return valid; }
void Clear(); void Clear();
void SetText(const wxString &text); void SetText(const std::string &text);
operator wxString() const; operator std::string() const;
}; };

30
aegisub/src/audio_karaoke.cpp
View File

@ -26,16 +26,6 @@
#include <algorithm> #include <algorithm>
#include <numeric> #include <numeric>
#include <wx/bmpbuttn.h>
#include <wx/button.h>
#include <wx/dcclient.h>
#include <wx/dcmemory.h>
#include <wx/menu.h>
#include <wx/panel.h>
#include <wx/settings.h>
#include <wx/sizer.h>
#include <wx/tokenzr.h>
#include "include/aegisub/context.h" #include "include/aegisub/context.h"
#include "ass_dialogue.h" #include "ass_dialogue.h"
@ -44,11 +34,21 @@
#include "audio_box.h" #include "audio_box.h"
#include "audio_controller.h" #include "audio_controller.h"
#include "audio_timing.h" #include "audio_timing.h"
#include "compat.h"
#include "libresrc/libresrc.h" #include "libresrc/libresrc.h"
#include "main.h" #include "main.h"
#include "selection_controller.h" #include "selection_controller.h"
#include "utils.h" #include "utils.h"
#include <wx/bmpbuttn.h>
#include <wx/button.h>
#include <wx/dcclient.h>
#include <wx/dcmemory.h>
#include <wx/menu.h>
#include <wx/panel.h>
#include <wx/settings.h>
#include <wx/sizer.h>
template<class Container, class Value> template<class Container, class Value>
static inline size_t last_lt_or_eq(Container const& c, Value const& v) { static inline size_t last_lt_or_eq(Container const& c, Value const& v) {
typename Container::const_iterator it = lower_bound(c.begin(), c.end(), v); typename Container::const_iterator it = lower_bound(c.begin(), c.end(), v);
@ -236,8 +236,8 @@ void AudioKaraoke::RenderText() {
} }
} }
void AudioKaraoke::AddMenuItem(wxMenu &menu, wxString const& tag, wxString const& help, wxString const& selected) { void AudioKaraoke::AddMenuItem(wxMenu &menu, std::string const& tag, wxString const& help, std::string const& selected) {
wxMenuItem *item = menu.AppendCheckItem(-1, tag, help); wxMenuItem *item = menu.AppendCheckItem(-1, to_wx(tag), help);
menu.Bind(wxEVT_COMMAND_MENU_SELECTED, std::bind(&AudioKaraoke::SetTagType, this, tag), item->GetId()); menu.Bind(wxEVT_COMMAND_MENU_SELECTED, std::bind(&AudioKaraoke::SetTagType, this, tag), item->GetId());
item->Check(tag == selected); item->Check(tag == selected);
} }
@ -246,7 +246,7 @@ void AudioKaraoke::OnContextMenu(wxContextMenuEvent&) {
if (!enabled) return; if (!enabled) return;
wxMenu context_menu(_("Karaoke tag")); wxMenu context_menu(_("Karaoke tag"));
wxString type = kara->GetTagType(); std::string type = kara->GetTagType();
AddMenuItem(context_menu, "\\k", _("Change karaoke tag to \\k"), type); AddMenuItem(context_menu, "\\k", _("Change karaoke tag to \\k"), type);
AddMenuItem(context_menu, "\\kf", _("Change karaoke tag to \\kf"), type); AddMenuItem(context_menu, "\\kf", _("Change karaoke tag to \\kf"), type);
@ -359,7 +359,7 @@ void AudioKaraoke::SetDisplayText() {
syl_start_points.reserve(kara->size()); syl_start_points.reserve(kara->size());
for (auto const& syl : *kara) { for (auto const& syl : *kara) {
syl_start_points.push_back(spaced_text.size()); syl_start_points.push_back(spaced_text.size());
spaced_text += " " + syl.text; spaced_text += to_wx(" " + syl.text);
} }
// Get the x-coordinates of the right edge of each character // Get the x-coordinates of the right edge of each character
@ -408,7 +408,7 @@ void AudioKaraoke::AcceptSplit() {
cancel_button->Enable(false); cancel_button->Enable(false);
} }
void AudioKaraoke::SetTagType(wxString new_tag) { void AudioKaraoke::SetTagType(std::string const& new_tag) {
kara->SetTagType(new_tag); kara->SetTagType(new_tag);
AcceptSplit(); AcceptSplit();
} }

4
aegisub/src/audio_karaoke.h
View File

@ -118,9 +118,9 @@ class AudioKaraoke : public wxWindow {
void SetDisplayText(); void SetDisplayText();
/// Helper function for context menu creation /// Helper function for context menu creation
void AddMenuItem(wxMenu &menu, wxString const& tag, wxString const& help, wxString const& selected); void AddMenuItem(wxMenu &menu, std::string const& tag, wxString const& help, std::string const& selected);
/// Set the karaoke tags for the selected syllables to the indicated one /// Set the karaoke tags for the selected syllables to the indicated one
void SetTagType(wxString new_type); void SetTagType(std::string const& new_type);
/// Prerender the current line along with syllable split lines /// Prerender the current line along with syllable split lines
void RenderText(); void RenderText();

1
aegisub/src/audio_timing_karaoke.cpp
View File

@ -29,6 +29,7 @@
#include "audio_controller.h" #include "audio_controller.h"
#include "audio_renderer.h" #include "audio_renderer.h"
#include "audio_timing.h" #include "audio_timing.h"
#include "compat.h"
#include "include/aegisub/context.h" #include "include/aegisub/context.h"
#include "main.h" #include "main.h"
#include "pen.h" #include "pen.h"

30
aegisub/src/command/edit.cpp
View File

@ -48,6 +48,7 @@
#include "../ass_file.h" #include "../ass_file.h"
#include "../ass_karaoke.h" #include "../ass_karaoke.h"
#include "../ass_style.h" #include "../ass_style.h"
#include "../compat.h"
#include "../dialog_colorpicker.h" #include "../dialog_colorpicker.h"
#include "../dialog_paste_over.h" #include "../dialog_paste_over.h"
#include "../dialog_search_replace.h" #include "../dialog_search_replace.h"
@ -59,6 +60,7 @@
#include "../utils.h" #include "../utils.h"
#include "../video_context.h" #include "../video_context.h"
#include <boost/algorithm/string/predicate.hpp>
#include <boost/algorithm/string/join.hpp> #include <boost/algorithm/string/join.hpp>
#include <boost/range/adaptor/reversed.hpp> #include <boost/range/adaptor/reversed.hpp>
#include <boost/range/adaptor/sliced.hpp> #include <boost/range/adaptor/sliced.hpp>
@ -166,7 +168,7 @@ void paste_lines(agi::Context *c, bool paste_over) {
} }
template<class T> template<class T>
T get_value(boost::ptr_vector<AssDialogueBlock> const& blocks, int blockn, T initial, wxString const& tag_name, wxString alt = wxString()) { T get_value(boost::ptr_vector<AssDialogueBlock> const& blocks, int blockn, T initial, std::string const& tag_name, std::string alt = "") {
for (auto ovr : blocks | sliced(0, blockn + 1) | reversed | agi::of_type<AssDialogueBlockOverride>()) { for (auto ovr : blocks | sliced(0, blockn + 1) | reversed | agi::of_type<AssDialogueBlockOverride>()) {
for (auto const& tag : ovr->Tags | reversed) { for (auto const& tag : ovr->Tags | reversed) {
if (tag.Name == tag_name || tag.Name == alt) if (tag.Name == tag_name || tag.Name == alt)
@ -190,7 +192,7 @@ int block_at_pos(wxString const& text, int pos) {
return n; return n;
} }
void set_tag(AssDialogue *line, boost::ptr_vector<AssDialogueBlock> &blocks, wxString const& tag, wxString const& value, int &sel_start, int &sel_end, bool at_end = false) { void set_tag(AssDialogue *line, boost::ptr_vector<AssDialogueBlock> &blocks, std::string const& tag, std::string const& value, int &sel_start, int &sel_end, bool at_end = false) {
if (blocks.empty()) if (blocks.empty())
blocks = line->ParseTags(); blocks = line->ParseTags();
@ -205,7 +207,7 @@ void set_tag(AssDialogue *line, boost::ptr_vector<AssDialogueBlock> &blocks, wxS
--blockn; --blockn;
else if ((plain = dynamic_cast<AssDialogueBlockPlain*>(block))) { else if ((plain = dynamic_cast<AssDialogueBlockPlain*>(block))) {
// Cursor is in a comment block, so try the previous block instead // Cursor is in a comment block, so try the previous block instead
if (plain->GetText().StartsWith("{")) { if (boost::starts_with(plain->GetText(), "{")) {
--blockn; --blockn;
start = line->Text.get().rfind('{', start); start = line->Text.get().rfind('{', start);
} }
@ -224,22 +226,22 @@ void set_tag(AssDialogue *line, boost::ptr_vector<AssDialogueBlock> &blocks, wxS
if (blockn < 0) if (blockn < 0)
start = 0; start = 0;
wxString insert = tag + value; std::string insert(tag + value);
int shift = insert.size(); int shift = insert.size();
if (plain || blockn < 0) { if (plain || blockn < 0) {
line->Text = line->Text.get().Left(start) + "{" + insert + "}" + line->Text.get().Mid(start); line->Text = line->Text.get().Left(start) + "{" + to_wx(insert) + "}" + line->Text.get().Mid(start);
shift += 2; shift += 2;
blocks = line->ParseTags(); blocks = line->ParseTags();
} }
else if (ovr) { else if (ovr) {
wxString alt; std::string alt;
if (tag == "\\c") alt = "\\1c"; if (tag == "\\c") alt = "\\1c";
// Remove old of same // Remove old of same
bool found = false; bool found = false;
for (size_t i = 0; i < ovr->Tags.size(); i++) { for (size_t i = 0; i < ovr->Tags.size(); i++) {
wxString name = ovr->Tags[i].Name; std::string const& name = ovr->Tags[i].Name;
if (tag == name || alt == name) { if (tag == name || alt == name) {
shift -= ((wxString)ovr->Tags[i]).size(); shift -= ((std::string)ovr->Tags[i]).size();
if (found) { if (found) {
ovr->Tags.erase(ovr->Tags.begin() + i); ovr->Tags.erase(ovr->Tags.begin() + i);
i--; i--;
@ -433,21 +435,21 @@ struct edit_font : public Command {
get_value(blocks, blockn, style->italic, "\\i") ? wxFONTSTYLE_ITALIC : wxFONTSTYLE_NORMAL, get_value(blocks, blockn, style->italic, "\\i") ? wxFONTSTYLE_ITALIC : wxFONTSTYLE_NORMAL,
get_value(blocks, blockn, style->bold, "\\b") ? wxFONTWEIGHT_BOLD : wxFONTWEIGHT_NORMAL, get_value(blocks, blockn, style->bold, "\\b") ? wxFONTWEIGHT_BOLD : wxFONTWEIGHT_NORMAL,
get_value(blocks, blockn, style->underline, "\\u"), get_value(blocks, blockn, style->underline, "\\u"),
get_value(blocks, blockn, style->font, "\\fn")); to_wx(get_value(blocks, blockn, from_wx(style->font), "\\fn")));
const wxFont font = wxGetFontFromUser(c->parent, startfont); const wxFont font = wxGetFontFromUser(c->parent, startfont);
if (!font.Ok() || font == startfont) return; if (!font.Ok() || font == startfont) return;
if (font.GetFaceName() != startfont.GetFaceName()) if (font.GetFaceName() != startfont.GetFaceName())
set_tag(line, blocks, "\\fn", font.GetFaceName(), sel_start, sel_end); set_tag(line, blocks, "\\fn", from_wx(font.GetFaceName()), sel_start, sel_end);
if (font.GetPointSize() != startfont.GetPointSize()) if (font.GetPointSize() != startfont.GetPointSize())
set_tag(line, blocks, "\\fs", wxString::Format("%d", font.GetPointSize()), sel_start, sel_end); set_tag(line, blocks, "\\fs", std::to_string(font.GetPointSize()), sel_start, sel_end);
if (font.GetWeight() != startfont.GetWeight()) if (font.GetWeight() != startfont.GetWeight())
set_tag(line, blocks, "\\b", wxString::Format("%d", font.GetWeight() == wxFONTWEIGHT_BOLD), sel_start, sel_end); set_tag(line, blocks, "\\b", std::to_string(font.GetWeight() == wxFONTWEIGHT_BOLD), sel_start, sel_end);
if (font.GetStyle() != startfont.GetStyle()) if (font.GetStyle() != startfont.GetStyle())
set_tag(line, blocks, "\\i", wxString::Format("%d", font.GetStyle() == wxFONTSTYLE_ITALIC), sel_start, sel_end); set_tag(line, blocks, "\\i", std::to_string(font.GetStyle() == wxFONTSTYLE_ITALIC), sel_start, sel_end);
if (font.GetUnderlined() != startfont.GetUnderlined()) if (font.GetUnderlined() != startfont.GetUnderlined())
set_tag(line, blocks, "\\i", wxString::Format("%d", font.GetUnderlined()), sel_start, sel_end); set_tag(line, blocks, "\\i", std::to_string(font.GetUnderlined()), sel_start, sel_end);
commit_text(c, _("set font"), sel_start, sel_end); commit_text(c, _("set font"), sel_start, sel_end);
} }

11
aegisub/src/dialog_kara_timing_copy.cpp
View File

@ -53,6 +53,7 @@
#include "ass_dialogue.h" #include "ass_dialogue.h"
#include "ass_file.h" #include "ass_file.h"
#include "ass_karaoke.h" #include "ass_karaoke.h"
#include "compat.h"
#include "help_button.h" #include "help_button.h"
#include "include/aegisub/context.h" #include "include/aegisub/context.h"
#include "kana_table.h" #include "kana_table.h"
@ -266,7 +267,7 @@ void KaraokeLineMatchDisplay::OnPaint(wxPaintEvent &)
// Matched source syllables // Matched source syllables
int syl_x = next_x; int syl_x = next_x;
for (auto const& syl : grp.src) for (auto const& syl : grp.src)
syl_x += DrawBoxedText(dc, syl.text, syl_x, y_line1); syl_x += DrawBoxedText(dc, to_wx(syl.text), syl_x, y_line1);
// Matched destination text // Matched destination text
{ {
@ -305,7 +306,7 @@ void KaraokeLineMatchDisplay::OnPaint(wxPaintEvent &)
dc.SetBrush(wxBrush(inner_back)); dc.SetBrush(wxBrush(inner_back));
} }
syl_x += DrawBoxedText(dc, unmatched_source[j].text, syl_x, y_line1); syl_x += DrawBoxedText(dc, to_wx(unmatched_source[j].text), syl_x, y_line1);
} }
// Remaining destination // Remaining destination
@ -413,7 +414,7 @@ void KaraokeLineMatchDisplay::AutoMatchJapanese()
} }
// We'll first see if we can do something with the first unmatched source syllable // We'll first see if we can do something with the first unmatched source syllable
wxString src(unmatched_source[0].text.Lower()); wxString src(to_wx(unmatched_source[0].text).Lower());
wxString dst(unmatched_destination); wxString dst(unmatched_destination);
source_sel_length = 1; // we're working on the first, assume it was matched source_sel_length = 1; // we're working on the first, assume it was matched
destination_sel_length = 0; destination_sel_length = 0;
@ -531,12 +532,12 @@ void KaraokeLineMatchDisplay::AutoMatchJapanese()
// Check if we've gone too far ahead in the source // Check if we've gone too far ahead in the source
if (src_lookahead_pos++ >= src_lookahead_max) break; if (src_lookahead_pos++ >= src_lookahead_max) break;
// Otherwise look for a match // Otherwise look for a match
if (syl.text.StartsWith(matched_roma)) if (to_wx(syl.text).StartsWith(matched_roma))
{ {
// Yay! Time to interpolate. // Yay! Time to interpolate.
// Special case: If the last source syllable before the matching one is // Special case: If the last source syllable before the matching one is
// empty or contains just whitespace, don't include that one. // empty or contains just whitespace, don't include that one.
if (src_lookahead_pos > 1 && StringEmptyOrWhitespace(unmatched_source[src_lookahead_pos-2].text)) if (src_lookahead_pos > 1 && StringEmptyOrWhitespace(to_wx(unmatched_source[src_lookahead_pos-2].text)))
src_lookahead_pos -= 1; src_lookahead_pos -= 1;
// Special case: Just one source syllable matching, pick all destination found // Special case: Just one source syllable matching, pick all destination found
if (src_lookahead_pos == 2) if (src_lookahead_pos == 2)

4
aegisub/src/dialog_resample.cpp
View File

@ -152,7 +152,7 @@ namespace {
double ar; double ar;
}; };
void resample_tags(wxString const& name, AssOverrideParameter *cur, void *ud) { void resample_tags(std::string const& name, AssOverrideParameter *cur, void *ud) {
resample_state *state = static_cast<resample_state *>(ud); resample_state *state = static_cast<resample_state *>(ud);
double resizer = 1.0; double resizer = 1.0;
@ -182,7 +182,7 @@ namespace {
break; break;
case PARCLASS_DRAWING: { case PARCLASS_DRAWING: {
AssDialogueBlockDrawing block(cur->Get<wxString>(), 1); AssDialogueBlockDrawing block(cur->Get<std::string>(), 1);
block.TransformCoords(state->margin[LEFT], state->margin[TOP], state->rx, state->ry); block.TransformCoords(state->margin[LEFT], state->margin[TOP], state->rx, state->ry);
cur->Set(block.GetText()); cur->Set(block.GetText());
return; return;

6
aegisub/src/dialog_style_editor.cpp
View File

@ -73,11 +73,11 @@ class StyleRenamer {
wxString new_name; wxString new_name;
/// Process a single override parameter to check if it's \r with this style name /// Process a single override parameter to check if it's \r with this style name
static void ProcessTag(wxString const& tag, AssOverrideParameter* param, void *userData) { static void ProcessTag(std::string const& tag, AssOverrideParameter* param, void *userData) {
StyleRenamer *self = static_cast<StyleRenamer*>(userData); StyleRenamer *self = static_cast<StyleRenamer*>(userData);
if (tag == "\\r" && param->GetType() == VARDATA_TEXT && param->Get<wxString>() == self->source_name) { if (tag == "\\r" && param->GetType() == VARDATA_TEXT && to_wx(param->Get<std::string>()) == self->source_name) {
if (self->do_replace) if (self->do_replace)
param->Set(self->new_name); param->Set(from_wx(self->new_name));
else else
self->found_any = true; self->found_any = true;
} }

17
aegisub/src/dialog_translation.cpp
View File

@ -39,6 +39,9 @@
#include "utils.h" #include "utils.h"
#include "video_context.h" #include "video_context.h"
#include <boost/algorithm/string/classification.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <wx/checkbox.h> #include <wx/checkbox.h>
#include <wx/msgdlg.h> #include <wx/msgdlg.h>
#include <wx/sizer.h> #include <wx/sizer.h>
@ -53,9 +56,9 @@ static void add_hotkey(wxSizer *sizer, wxWindow *parent, const char *command, wx
// Skip over override blocks, comments, and whitespace between blocks // Skip over override blocks, comments, and whitespace between blocks
static bool bad_block(AssDialogueBlock &block) { static bool bad_block(AssDialogueBlock &block) {
if (block.GetType() != BLOCK_PLAIN) return true; if (block.GetType() != BLOCK_PLAIN) return true;
wxString text = block.GetText(); std::string text = block.GetText();
if (text.Trim().Trim(false).empty()) return true; if (boost::all(text, boost::is_space())) return true;
if (text[0] == '{' && text.Last() == '}') return true; if (boost::starts_with(text, "{") && boost::ends_with(text, "}")) return true;
return false; return false;
} }
@ -247,14 +250,14 @@ void DialogTranslation::UpdateDisplay() {
for (auto& block : blocks) { for (auto& block : blocks) {
if (block.GetType() == BLOCK_PLAIN) { if (block.GetType() == BLOCK_PLAIN) {
int cur_size = original_text->GetReverseUnicodePosition(original_text->GetLength()); int cur_size = original_text->GetReverseUnicodePosition(original_text->GetLength());
original_text->AppendText(block.GetText()); original_text->AppendTextRaw(block.GetText().c_str());
if (i == cur_block) { if (i == cur_block) {
original_text->StartUnicodeStyling(cur_size); original_text->StartUnicodeStyling(cur_size);
original_text->SetUnicodeStyling(cur_size, block.GetText().size(), 1); original_text->SetUnicodeStyling(cur_size, block.GetText().size(), 1);
} }
} }
else if (block.GetType() == BLOCK_OVERRIDE) else if (block.GetType() == BLOCK_OVERRIDE)
original_text->AppendText(block.GetText()); original_text->AppendTextRaw(block.GetText().c_str());
++i; ++i;
} }
@ -271,7 +274,7 @@ void DialogTranslation::Commit(bool next) {
new_value.Replace("\r\n", "\\N"); new_value.Replace("\r\n", "\\N");
new_value.Replace("\r", "\\N"); new_value.Replace("\r", "\\N");
new_value.Replace("\n", "\\N"); new_value.Replace("\n", "\\N");
blocks[cur_block] = AssDialogueBlockPlain(new_value); blocks[cur_block] = AssDialogueBlockPlain(from_wx(new_value));
active_line->UpdateText(blocks); active_line->UpdateText(blocks);
file_change_connection.Block(); file_change_connection.Block();
@ -290,7 +293,7 @@ void DialogTranslation::Commit(bool next) {
} }
void DialogTranslation::InsertOriginal() { void DialogTranslation::InsertOriginal() {
translated_text->AddText(blocks[cur_block].GetText()); translated_text->AddText(to_wx(blocks[cur_block].GetText()));
} }

2
aegisub/src/export_framerate.cpp
View File

@ -167,7 +167,7 @@ int FORCEINLINE trunc_cs(int time) {
return (time / 10) * 10; return (time / 10) * 10;
} }
void AssTransformFramerateFilter::TransformTimeTags(wxString const& name, AssOverrideParameter *curParam, void *curData) { void AssTransformFramerateFilter::TransformTimeTags(std::string const& name, AssOverrideParameter *curParam, void *curData) {
VariableDataType type = curParam->GetType(); VariableDataType type = curParam->GetType();
if (type != VARDATA_INT && type != VARDATA_FLOAT) return; if (type != VARDATA_INT && type != VARDATA_FLOAT) return;

2
aegisub/src/export_framerate.h
View File

@ -72,7 +72,7 @@ class AssTransformFramerateFilter : public AssExportFilter {
/// @param name Name of the tag /// @param name Name of the tag
/// @param curParam Current parameter being processed /// @param curParam Current parameter being processed
/// @param userdata Filter instance /// @param userdata Filter instance
static void TransformTimeTags(wxString const& name, AssOverrideParameter *curParam, void *userdata); static void TransformTimeTags(std::string const& name, AssOverrideParameter *curParam, void *userdata);
/// @brief Convert a time from the input frame rate to the output frame rate /// @brief Convert a time from the input frame rate to the output frame rate
/// @param time Time in ms to convert /// @param time Time in ms to convert

5
aegisub/src/font_file_lister.cpp
View File

@ -26,6 +26,7 @@
#include "ass_dialogue.h" #include "ass_dialogue.h"
#include "ass_file.h" #include "ass_file.h"
#include "ass_style.h" #include "ass_style.h"
#include "compat.h"
#include "utils.h" #include "utils.h"
#include <libaegisub/of_type_adaptor.h> #include <libaegisub/of_type_adaptor.h>
@ -59,7 +60,7 @@ void FontCollector::ProcessDialogueLine(const AssDialogue *line, int index) {
std::string const& name = tag.Name; std::string const& name = tag.Name;
if (name == "\\r") { if (name == "\\r") {
style = styles[tag.Params[0].Get<wxString>(line->Style)]; style = styles[to_wx(tag.Params[0].Get(from_wx(line->Style)))];
overriden = false; overriden = false;
} }
else if (name == "\\b") { else if (name == "\\b") {
@ -71,7 +72,7 @@ void FontCollector::ProcessDialogueLine(const AssDialogue *line, int index) {
overriden = true; overriden = true;
} }
else if (name == "\\fn") { else if (name == "\\fn") {
style.facename = tag.Params[0].Get(initial.facename); style.facename = to_wx(tag.Params[0].Get(from_wx(initial.facename)));
overriden = true; overriden = true;
} }
} }

2
aegisub/src/subtitle_format_ebu3264.cpp
View File

@ -285,7 +285,7 @@ namespace
case BLOCK_PLAIN: case BLOCK_PLAIN:
// find special characters and convert them // find special characters and convert them
{ {
wxString text = b.GetText(); wxString text = to_wx(b.GetText());
// Skip comments // Skip comments
if (text.size() > 1 && text[0] =='{' && text.Last() == '}') if (text.size() > 1 && text[0] =='{' && text.Last() == '}')

4
aegisub/src/subtitle_format_srt.cpp
View File

@ -516,7 +516,7 @@ void SRTSubtitleFormat::WriteFile(const AssFile *src, wxString const& filename,
} }
bool SRTSubtitleFormat::CanSave(const AssFile *file) const { bool SRTSubtitleFormat::CanSave(const AssFile *file) const {
wxString supported_tags[] = { "\\b", "\\i", "\\s", "\\u" }; std::string supported_tags[] = { "\\b", "\\i", "\\s", "\\u" };
AssStyle defstyle; AssStyle defstyle;
for (auto const& line : file->Line) { for (auto const& line : file->Line) {
@ -574,7 +574,7 @@ wxString SRTSubtitleFormat::ConvertTags(const AssDialogue *diag) const {
} }
// Plain text // Plain text
else if (AssDialogueBlockPlain *plain = dynamic_cast<AssDialogueBlockPlain*>(&block)) { else if (AssDialogueBlockPlain *plain = dynamic_cast<AssDialogueBlockPlain*>(&block)) {
final += plain->GetText(); final += to_wx(plain->GetText());
} }
} }

19
aegisub/src/visual_tool.cpp
View File

@ -28,6 +28,7 @@
#include "ass_file.h" #include "ass_file.h"
#include "ass_style.h" #include "ass_style.h"
#include "ass_time.h" #include "ass_time.h"
#include "compat.h"
#include "include/aegisub/context.h" #include "include/aegisub/context.h"
#include "main.h" #include "main.h"
#include "utils.h" #include "utils.h"
@ -354,7 +355,7 @@ void VisualTool<FeatureType>::RemoveSelection(feature_iterator feat) {
typedef const std::vector<AssOverrideParameter> * param_vec; typedef const std::vector<AssOverrideParameter> * param_vec;
// Find a tag's parameters in a line or return nullptr if it's not found // Find a tag's parameters in a line or return nullptr if it's not found
static param_vec find_tag(boost::ptr_vector<AssDialogueBlock>& blocks, wxString tag_name) { static param_vec find_tag(boost::ptr_vector<AssDialogueBlock>& blocks, std::string const& tag_name) {
for (auto ovr : blocks | agi::of_type<AssDialogueBlockOverride>()) { for (auto ovr : blocks | agi::of_type<AssDialogueBlockOverride>()) {
for (auto const& tag : ovr->Tags) { for (auto const& tag : ovr->Tags) {
if (tag.Name == tag_name) if (tag.Name == tag_name)
@ -526,21 +527,21 @@ wxString VisualToolBase::GetLineVectorClip(AssDialogue *diag, int &scale, bool &
} }
if (tag) { if (tag) {
scale = std::max((*tag)[0].Get(scale), 1); scale = std::max((*tag)[0].Get(scale), 1);
return (*tag)[1].Get<wxString>(""); return to_wx((*tag)[1].Get<std::string>(""));
} }
return ""; return "";
} }
void VisualToolBase::SetSelectedOverride(wxString const& tag, wxString const& value) { void VisualToolBase::SetSelectedOverride(std::string const& tag, wxString const& value) {
for (auto line : c->selectionController->GetSelectedSet()) for (auto line : c->selectionController->GetSelectedSet())
SetOverride(line, tag, value); SetOverride(line, tag, value);
} }
void VisualToolBase::SetOverride(AssDialogue* line, wxString const& tag, wxString const& value) { void VisualToolBase::SetOverride(AssDialogue* line, std::string const& tag, wxString const& value) {
if (!line) return; if (!line) return;
wxString removeTag; std::string removeTag;
if (tag == "\\1c") removeTag = "\\c"; if (tag == "\\1c") removeTag = "\\c";
else if (tag == "\\frz") removeTag = "\\fr"; else if (tag == "\\frz") removeTag = "\\fr";
else if (tag == "\\pos") removeTag = "\\move"; else if (tag == "\\pos") removeTag = "\\move";
@ -548,8 +549,6 @@ void VisualToolBase::SetOverride(AssDialogue* line, wxString const& tag, wxStrin
else if (tag == "\\clip") removeTag = "\\iclip"; else if (tag == "\\clip") removeTag = "\\iclip";
else if (tag == "\\iclip") removeTag = "\\clip"; else if (tag == "\\iclip") removeTag = "\\clip";
wxString insert = tag + value;
// Get block at start // Get block at start
boost::ptr_vector<AssDialogueBlock> blocks(line->ParseTags()); boost::ptr_vector<AssDialogueBlock> blocks(line->ParseTags());
AssDialogueBlock *block = &blocks.front(); AssDialogueBlock *block = &blocks.front();
@ -558,17 +557,17 @@ void VisualToolBase::SetOverride(AssDialogue* line, wxString const& tag, wxStrin
assert(dynamic_cast<AssDialogueBlockDrawing*>(block) == nullptr); assert(dynamic_cast<AssDialogueBlockDrawing*>(block) == nullptr);
if (dynamic_cast<AssDialogueBlockPlain*>(block)) if (dynamic_cast<AssDialogueBlockPlain*>(block))
line->Text = "{" + insert + "}" + line->Text; line->Text = "{" + to_wx(tag) + value + "}" + line->Text;
else if (AssDialogueBlockOverride *ovr = dynamic_cast<AssDialogueBlockOverride*>(block)) { else if (AssDialogueBlockOverride *ovr = dynamic_cast<AssDialogueBlockOverride*>(block)) {
// Remove old of same // Remove old of same
for (size_t i = 0; i < ovr->Tags.size(); i++) { for (size_t i = 0; i < ovr->Tags.size(); i++) {
wxString const& name = ovr->Tags[i].Name; std::string const& name = ovr->Tags[i].Name;
if (tag == name || removeTag == name) { if (tag == name || removeTag == name) {
ovr->Tags.erase(ovr->Tags.begin() + i); ovr->Tags.erase(ovr->Tags.begin() + i);
i--; i--;
} }
} }
ovr->AddTag(insert); ovr->AddTag(tag + from_wx(value));
line->UpdateText(blocks); line->UpdateText(blocks);
} }

4
aegisub/src/visual_tool.h
View File

@ -135,8 +135,8 @@ protected:
void GetLineClip(AssDialogue *diag, Vector2D &p1, Vector2D &p2, bool &inverse); void GetLineClip(AssDialogue *diag, Vector2D &p1, Vector2D &p2, bool &inverse);
wxString GetLineVectorClip(AssDialogue *diag, int &scale, bool &inverse); wxString GetLineVectorClip(AssDialogue *diag, int &scale, bool &inverse);
void SetOverride(AssDialogue* line, wxString const& tag, wxString const& value); void SetOverride(AssDialogue* line, std::string const& tag, wxString const& value);
void SetSelectedOverride(wxString const& tag, wxString const& value); void SetSelectedOverride(std::string const& tag, wxString const& value);
VisualToolBase(VideoDisplay *parent, agi::Context *context); VisualToolBase(VideoDisplay *parent, agi::Context *context);