282 lines
8.1 KiB
C++
282 lines
8.1 KiB
C++
/***
|
|
|
|
Olive - Non-Linear Video Editor
|
|
Copyright (C) 2022 Olive Team
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
***/
|
|
|
|
#include "textv3.h"
|
|
|
|
#include <QAbstractTextDocumentLayout>
|
|
#include <QDateTime>
|
|
#include <QTextDocument>
|
|
|
|
#include "common/html.h"
|
|
#include "core.h"
|
|
#include "node/project.h"
|
|
#include "node/nodeundo.h"
|
|
|
|
namespace olive {
|
|
|
|
#define super ShapeNodeBase
|
|
|
|
enum TextVerticalAlign {
|
|
kVerticalAlignTop,
|
|
kVerticalAlignCenter,
|
|
kVerticalAlignBottom,
|
|
};
|
|
|
|
const QString TextGeneratorV3::kTextInput = QStringLiteral("text_in");
|
|
const QString TextGeneratorV3::kVerticalAlignmentInput = QStringLiteral("valign_in");
|
|
const QString TextGeneratorV3::kUseArgsInput = QStringLiteral("use_args_in");
|
|
const QString TextGeneratorV3::kArgsInput = QStringLiteral("args_in");
|
|
|
|
TextGeneratorV3::TextGeneratorV3() :
|
|
ShapeNodeBase(false),
|
|
dont_emit_valign_(false)
|
|
{
|
|
AddInput(kTextInput, NodeValue::kText, QStringLiteral("<p style='font-size: 72pt; color: white;'>%1</p>").arg(tr("Sample Text")));
|
|
SetInputProperty(kTextInput, QStringLiteral("vieweronly"), true);
|
|
|
|
SetStandardValue(kSizeInput, QVector2D(400, 300));
|
|
|
|
AddInput(kVerticalAlignmentInput, NodeValue::kCombo, InputFlags(kInputFlagHidden | kInputFlagStatic));
|
|
|
|
AddInput(kUseArgsInput, NodeValue::kBoolean, true, InputFlags(kInputFlagHidden | kInputFlagStatic));
|
|
|
|
AddInput(kArgsInput, NodeValue::kText, InputFlags(kInputFlagArray));
|
|
SetInputProperty(kArgsInput, QStringLiteral("arraystart"), 1);
|
|
|
|
text_gizmo_ = new TextGizmo(this);
|
|
text_gizmo_->SetInput(NodeInput(this, kTextInput));
|
|
connect(text_gizmo_, &TextGizmo::Activated, this, &TextGeneratorV3::GizmoActivated);
|
|
connect(text_gizmo_, &TextGizmo::Deactivated, this, &TextGeneratorV3::GizmoDeactivated);
|
|
}
|
|
|
|
QString TextGeneratorV3::Name() const
|
|
{
|
|
return tr("Text");
|
|
}
|
|
|
|
QString TextGeneratorV3::id() const
|
|
{
|
|
return QStringLiteral("org.olivevideoeditor.Olive.text3");
|
|
}
|
|
|
|
QVector<Node::CategoryID> TextGeneratorV3::Category() const
|
|
{
|
|
return {kCategoryGenerator};
|
|
}
|
|
|
|
QString TextGeneratorV3::Description() const
|
|
{
|
|
return tr("Generate rich text.");
|
|
}
|
|
|
|
void TextGeneratorV3::Retranslate()
|
|
{
|
|
super::Retranslate();
|
|
|
|
SetInputName(kTextInput, tr("Text"));
|
|
SetInputName(kVerticalAlignmentInput, tr("Vertical Alignment"));
|
|
SetComboBoxStrings(kVerticalAlignmentInput, {tr("Top"), tr("Middle"), tr("Bottom")});
|
|
SetInputName(kArgsInput, tr("Arguments"));
|
|
}
|
|
|
|
void TextGeneratorV3::Value(const NodeValueRow &value, const NodeGlobals &globals, NodeValueTable *table) const
|
|
{
|
|
QString text = value[kTextInput].toString();
|
|
|
|
if (value[kUseArgsInput].toBool()) {
|
|
auto args = value[kArgsInput].toArray();
|
|
if (!args.empty()) {
|
|
QStringList list;
|
|
list.reserve(args.size());
|
|
for (size_t i=0; i<args.size(); i++) {
|
|
list.append(args[i].toString());
|
|
}
|
|
|
|
text = FormatString(text, list);
|
|
}
|
|
}
|
|
|
|
if (!text.isEmpty()) {
|
|
TexturePtr base = value[kTextInput].toTexture();
|
|
|
|
VideoParams text_params = base ? base->params() : globals.vparams();
|
|
text_params.set_format(PixelFormat::U8);
|
|
text_params.set_colorspace(project()->color_manager()->GetDefaultInputColorSpace());
|
|
|
|
GenerateJob job(value);
|
|
job.Insert(kTextInput, NodeValue(NodeValue::kText, text));
|
|
|
|
PushMergableJob(value, Texture::Job(text_params, job), table);
|
|
} else if (value[kBaseInput].toTexture()) {
|
|
table->Push(value[kBaseInput]);
|
|
}
|
|
}
|
|
|
|
void TextGeneratorV3::GenerateFrame(FramePtr frame, const GenerateJob& job) const
|
|
{
|
|
QImage img(reinterpret_cast<uchar*>(frame->data()), frame->width(), frame->height(), frame->linesize_bytes(), QImage::Format_RGBA8888_Premultiplied);
|
|
img.fill(Qt::transparent);
|
|
|
|
// 96 DPI in DPM (96 / 2.54 * 100)
|
|
const int dpm = 3780;
|
|
img.setDotsPerMeterX(dpm);
|
|
img.setDotsPerMeterY(dpm);
|
|
|
|
QTextDocument text_doc;
|
|
text_doc.documentLayout()->setPaintDevice(&img);
|
|
|
|
QString html = job.Get(kTextInput).toString();
|
|
Html::HtmlToDoc(&text_doc, html);
|
|
|
|
QVector2D size = job.Get(kSizeInput).toVec2();
|
|
text_doc.setTextWidth(size.x());
|
|
|
|
// Draw rich text onto image
|
|
QPainter p(&img);
|
|
p.scale(1.0 / frame->video_params().divider(), 1.0 / frame->video_params().divider());
|
|
|
|
QVector2D pos = job.Get(kPositionInput).toVec2();
|
|
p.translate(pos.x() - size.x()/2, pos.y() - size.y()/2);
|
|
p.translate(frame->video_params().width()/2, frame->video_params().height()/2);
|
|
p.setClipRect(0, 0, size.x(), size.y());
|
|
|
|
switch (static_cast<VerticalAlignment>(job.Get(kVerticalAlignmentInput).toInt())) {
|
|
case kVAlignTop:
|
|
// Do nothing
|
|
break;
|
|
case kVAlignMiddle:
|
|
p.translate(0, size.y()/2-text_doc.size().height()/2);
|
|
break;
|
|
case kVAlignBottom:
|
|
p.translate(0, size.y()-text_doc.size().height());
|
|
break;
|
|
}
|
|
|
|
// Ensure default text color is white
|
|
QAbstractTextDocumentLayout::PaintContext ctx;
|
|
ctx.palette.setColor(QPalette::Text, Qt::white);
|
|
|
|
text_doc.documentLayout()->draw(&p, ctx);
|
|
}
|
|
|
|
void TextGeneratorV3::UpdateGizmoPositions(const NodeValueRow &row, const NodeGlobals &globals)
|
|
{
|
|
super::UpdateGizmoPositions(row, globals);
|
|
|
|
QRectF rect = poly_gizmo()->GetPolygon().boundingRect();
|
|
text_gizmo_->SetRect(rect);
|
|
text_gizmo_->SetHtml(row[kTextInput].toString());
|
|
}
|
|
|
|
Qt::Alignment TextGeneratorV3::GetQtAlignmentFromOurs(VerticalAlignment v)
|
|
{
|
|
switch (v) {
|
|
case kVAlignTop:
|
|
return Qt::AlignTop;
|
|
case kVAlignMiddle:
|
|
return Qt::AlignVCenter;
|
|
case kVAlignBottom:
|
|
return Qt::AlignBottom;
|
|
}
|
|
return Qt::Alignment();
|
|
}
|
|
|
|
TextGeneratorV3::VerticalAlignment TextGeneratorV3::GetOurAlignmentFromQts(Qt::Alignment v)
|
|
{
|
|
switch (v) {
|
|
case Qt::AlignTop:
|
|
return kVAlignTop;
|
|
case Qt::AlignVCenter:
|
|
return kVAlignMiddle;
|
|
case Qt::AlignBottom:
|
|
return kVAlignBottom;
|
|
}
|
|
|
|
return kVAlignTop;
|
|
}
|
|
|
|
QString TextGeneratorV3::FormatString(const QString &input, const QStringList &args)
|
|
{
|
|
QString output;
|
|
output.reserve(input.size());
|
|
|
|
for (int i=0; i<input.size(); i++) {
|
|
const QChar &this_char = input.at(i);
|
|
|
|
if (i < input.size()-1 && this_char == '%') {
|
|
const QChar &next_char = input.at(i+1);
|
|
if (next_char == '%') {
|
|
// Double percent, append a single percent
|
|
output.append('%');
|
|
i++;
|
|
} else if (next_char.isDigit()) {
|
|
// Find length of number
|
|
QString num;
|
|
i++;
|
|
while (i < input.size() && input.at(i).isDigit()) {
|
|
num.append(input.at(i));
|
|
i++;
|
|
}
|
|
i--;
|
|
int index = num.toInt()-1;
|
|
if (index >= 0 && index < args.size()) {
|
|
output.append(args.at(index));
|
|
}
|
|
} else {
|
|
output.append(this_char);
|
|
}
|
|
} else {
|
|
output.append(this_char);
|
|
}
|
|
}
|
|
|
|
return output;
|
|
}
|
|
|
|
void TextGeneratorV3::InputValueChangedEvent(const QString &input, int element)
|
|
{
|
|
if (input == kVerticalAlignmentInput && !dont_emit_valign_) {
|
|
text_gizmo_->SetVerticalAlignment(GetQtAlignmentFromOurs(GetVerticalAlignment()));
|
|
}
|
|
|
|
super::InputValueChangedEvent(input, element);
|
|
}
|
|
|
|
void TextGeneratorV3::GizmoActivated()
|
|
{
|
|
SetStandardValue(kUseArgsInput, false);
|
|
connect(text_gizmo_, &TextGizmo::VerticalAlignmentChanged, this, &TextGeneratorV3::SetVerticalAlignmentUndoable);
|
|
dont_emit_valign_ = true;
|
|
}
|
|
|
|
void TextGeneratorV3::GizmoDeactivated()
|
|
{
|
|
SetStandardValue(kUseArgsInput, true);
|
|
disconnect(text_gizmo_, &TextGizmo::VerticalAlignmentChanged, this, &TextGeneratorV3::SetVerticalAlignmentUndoable);
|
|
dont_emit_valign_ = true;
|
|
}
|
|
|
|
void TextGeneratorV3::SetVerticalAlignmentUndoable(Qt::Alignment a)
|
|
{
|
|
Core::instance()->undo_stack()->push(new NodeParamSetStandardValueCommand(NodeInput(this, kVerticalAlignmentInput), GetOurAlignmentFromQts(a)));
|
|
}
|
|
|
|
}
|