oak-team/oak-editor
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

style: unify identifier naming per updated conventions

Browse Source 
Automated with clang-tidy readability-identifier-naming (config added to
.clang-tidy) plus scripted passes, per the updated rules now documented
in CONTRIBUTING.md:

- types (class/struct/enum/alias/template params): PascalCase
- functions, variables, members: snake_case (incl. rational -> Rational)
- private/protected members: trailing underscore; static member
  variables likewise (instance_, available_themes_)
- constants and enum values: snake_case (kLinear -> k_linear,
  F32P -> f32p); ALL_CAPS reserved for macros
- macros: OAK_ prefix (OLIVE_ADD_TEST/OLIVE_ASSERT/OLIVE_CONFIG ->
  OAK_ADD_TEST/OAK_ASSERT/OAK_CONFIG, GL_PREAMBLE -> OAK_GL_PREAMBLE,
  include guards -> OAK_*)
- file names: all lowercase (Current/Plugin/OliveHost/OliveClip/
  OlivePluginInstance -> current/plugin/olivehost/oliveclip/
  oliveplugininstance)
- getters share the member name sans underscore, setters set_foo()
- Qt and third-party (OpenFX) virtual overrides and framework callbacks
  keep their original names (exempt in .clang-tidy)

Manual follow-ups required where automation could not reach:
- string-based QMetaObject/SIGNAL/SLOT references updated to renamed
  methods (AddTask, CreatedFile, DeleteSpecificFile, moveSelectionUp, ...)
- macro bodies referencing renamed methods (OLIVE_CONFIG,
  NODE_DEFAULT_DESTRUCTOR, MANAGEDDISPLAYWIDGET_*)
- self-shadowing locals renamed where signals/methods became same-named
  (size_changed, worker_count, selected_items, import param, filters)
- third_party OFX member/namespace usages restored (OFX::Host::*,
  _created, _clipPrefsDirty, createInstance, clearPersistentMessage)
- STL protocol aliases restored (const_iterator) with .clang-tidy
  ignore rules; qHash overloads restored

Full build and test suite pass: ctest 4/4, ~1960 gtest cases green.
This commit is contained in:
Mike-Solar
2026-07-19 16:10:54 +08:00
parent cb1718a103
commit bb40b4923e
1014 changed files with 44257 additions and 44220 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/widget/curvewidget/curveview.cpp
+126 -126
View File
@@ -43,17 +43,17 @@ CurveView::CurveView(QWidget *parent)
, dragging_bezier_pt_(nullptr)
{
setAlignment(Qt::AlignLeft | Qt::AlignVCenter);
SetYAxisEnabled(true);
SetAutoSelectSiblings(false);
set_y_axis_enabled(true);
set_auto_select_siblings(false);
text_padding_ =
QtUtils::QFontMetricsWidth(fontMetrics(), QStringLiteral("i"));
QtUtils::q_font_metrics_width(fontMetrics(), QStringLiteral("i"));
minimum_grid_space_ =
QtUtils::QFontMetricsWidth(fontMetrics(), QStringLiteral("00000"));
QtUtils::q_font_metrics_width(fontMetrics(), QStringLiteral("00000"));
}
void CurveView::ConnectInput(const NodeKeyframeTrackReference &ref)
void CurveView::connect_input(const NodeKeyframeTrackReference &ref)
{
if (connected_inputs_.contains(ref)) {
// Input wasn't connected, do nothing
@@ -61,19 +61,19 @@ void CurveView::ConnectInput(const NodeKeyframeTrackReference &ref)
}
// Add keyframes from track
KeyframeViewInputConnection *track_con = AddKeyframesOfTrack(ref);
track_con->SetBrush(keyframe_colors_.value(ref));
KeyframeViewInputConnection *track_con = add_keyframes_of_track(ref);
track_con->set_brush(keyframe_colors_.value(ref));
track_connections_.insert(ref, track_con);
// Signal to CurveWidget to update its bezier/linear/hold buttons if a key type changes
connect(track_con, &KeyframeViewInputConnection::TypeChanged, this,
&CurveView::SelectionChanged);
connect(track_con, &KeyframeViewInputConnection::type_changed, this,
&CurveView::selection_changed);
// Append to the list
connected_inputs_.append(ref);
}
void CurveView::DisconnectInput(const NodeKeyframeTrackReference &ref)
void CurveView::disconnect_input(const NodeKeyframeTrackReference &ref)
{
if (!connected_inputs_.contains(ref)) {
// Input wasn't connected, do nothing
@@ -81,24 +81,24 @@ void CurveView::DisconnectInput(const NodeKeyframeTrackReference &ref)
}
// Remove keyframes belonging to this element and track
RemoveKeyframesOfTrack(track_connections_.take(ref));
remove_keyframes_of_track(track_connections_.take(ref));
// Remove from the list
connected_inputs_.removeOne(ref);
}
void CurveView::SelectKeyframesOfInput(const NodeKeyframeTrackReference &ref)
void CurveView::select_keyframes_of_input(const NodeKeyframeTrackReference &ref)
{
DeselectAll();
deselect_all();
if (KeyframeViewInputConnection *con = track_connections_.value(ref)) {
foreach (NodeKeyframe *key, con->GetKeyframes()) {
SelectKeyframe(key);
foreach (NodeKeyframe *key, con->get_keyframes()) {
select_keyframe(key);
}
}
}
void CurveView::SetKeyframeTrackColor(const NodeKeyframeTrackReference &ref,
void CurveView::set_keyframe_track_color(const NodeKeyframeTrackReference &ref,
const QColor &color)
{
// Insert color into hashmap
@@ -106,7 +106,7 @@ void CurveView::SetKeyframeTrackColor(const NodeKeyframeTrackReference &ref,
if (KeyframeViewInputConnection *con = track_connections_.value(ref)) {
// Update all keyframes
con->SetBrush(color);
con->set_brush(color);
}
}
@@ -120,7 +120,7 @@ void CurveView::drawBackground(QPainter *painter, const QRectF &rect)
QVector<QLine> lines;
double x_interval = timebase().flipped().toDouble();
double x_interval = timebase().flipped().to_double();
double y_interval = 100.0;
int x_grid_interval, y_grid_interval;
@@ -128,12 +128,12 @@ void CurveView::drawBackground(QPainter *painter, const QRectF &rect)
painter->setPen(QPen(palette().window().color(), 1));
do {
x_grid_interval = qRound(x_interval * GetScale() * timebase_dbl());
x_grid_interval = qRound(x_interval * get_scale() * timebase_dbl());
x_interval *= 2.0;
} while (x_grid_interval < minimum_grid_space_);
do {
y_grid_interval = qRound(y_interval * GetYScale());
y_grid_interval = qRound(y_interval * get_y_scale());
y_interval *= 2.0;
} while (y_grid_interval < minimum_grid_space_);
@@ -146,7 +146,7 @@ void CurveView::drawBackground(QPainter *painter, const QRectF &rect)
// Add vertical lines
for (int i = x_start; i < rect.right(); i += x_grid_interval) {
int value =
qRound(static_cast<double>(i) / GetScale() / timebase_dbl());
qRound(static_cast<double>(i) / get_scale() / timebase_dbl());
painter->drawText(i + text_padding_,
qRound(scene_bottom_left.y()) - text_padding_,
QString::number(value));
@@ -155,7 +155,7 @@ void CurveView::drawBackground(QPainter *painter, const QRectF &rect)
// Add horizontal lines
for (int i = y_start; i < rect.bottom(); i += y_grid_interval) {
int value = qRound(static_cast<double>(i) / GetYScale());
int value = qRound(static_cast<double>(i) / get_y_scale());
painter->drawText(qRound(scene_bottom_left.x()) + text_padding_,
i - text_padding_, QString::number(-value));
lines.append(QLine(qRound(rect.left()), i, qRound(rect.right()), i));
@@ -169,9 +169,9 @@ void CurveView::drawBackground(QPainter *painter, const QRectF &rect)
Node *node = ref.input().node();
const QString &input = ref.input().input();
if (node->IsInputKeyframing(input, ref.input().element())) {
if (node->is_input_keyframing(input, ref.input().element())) {
const QVector<NodeKeyframeTrack> &tracks =
node->GetKeyframeTracks(ref.input());
node->get_keyframe_tracks(ref.input());
const NodeKeyframeTrack &track = tracks.at(ref.track());
@@ -183,7 +183,7 @@ void CurveView::drawBackground(QPainter *painter, const QRectF &rect)
QPainterPath path;
// Draw straight line leading to first keyframe
QPointF first_key_pos = GetKeyframePosition(track.first());
QPointF first_key_pos = get_keyframe_position(track.first());
path.moveTo(QPointF(scene_bottom_left.x(), first_key_pos.y()));
path.lineTo(first_key_pos);
@@ -192,16 +192,16 @@ void CurveView::drawBackground(QPainter *painter, const QRectF &rect)
NodeKeyframe *before = track.at(i - 1);
NodeKeyframe *after = track.at(i);
QPointF before_pos = GetKeyframePosition(before);
QPointF after_pos = GetKeyframePosition(after);
QPointF before_pos = get_keyframe_position(before);
QPointF after_pos = get_keyframe_position(after);
if (before->type() == NodeKeyframe::kHold) {
if (before->type() == NodeKeyframe::k_hold) {
// Draw a hold keyframe (basically a right angle)
path.lineTo(after_pos.x(), before_pos.y());
path.lineTo(after_pos.x(), after_pos.y());
} else if (before->type() == NodeKeyframe::kBezier &&
after->type() == NodeKeyframe::kBezier) {
} else if (before->type() == NodeKeyframe::k_bezier &&
after->type() == NodeKeyframe::k_bezier) {
// Draw a cubic bezier
// Cubic beziers have two control points, so we can just use both
@@ -215,15 +215,15 @@ void CurveView::drawBackground(QPainter *painter, const QRectF &rect)
path.cubicTo(before_control_point, after_control_point,
after_pos);
} else if (before->type() == NodeKeyframe::kBezier ||
after->type() == NodeKeyframe::kBezier) {
} else if (before->type() == NodeKeyframe::k_bezier ||
after->type() == NodeKeyframe::k_bezier) {
// Draw a quadratic bezier
// Quadratic beziers have a single control point, we just have to determine which it is
QPointF key_anchor;
QPointF control_point;
if (before->type() == NodeKeyframe::kBezier) {
if (before->type() == NodeKeyframe::k_bezier) {
key_anchor = before_pos;
control_point = before->valid_bezier_control_out();
} else {
@@ -244,7 +244,7 @@ void CurveView::drawBackground(QPainter *painter, const QRectF &rect)
}
// Draw straight line leading from end keyframe
QPointF last_key_pos = GetKeyframePosition(track.last());
QPointF last_key_pos = get_keyframe_position(track.last());
path.lineTo(QPointF(scene_top_right.x(), last_key_pos.y()));
painter->drawPath(path);
@@ -264,15 +264,15 @@ void CurveView::ContextMenuEvent(Menu &m)
{
// View settings
QAction *zoom_fit_action = m.addAction(tr("Zoom to Fit"));
connect(zoom_fit_action, &QAction::triggered, this, &CurveView::ZoomToFit);
connect(zoom_fit_action, &QAction::triggered, this, &CurveView::zoom_to_fit);
QAction *zoom_fit_selected_action = m.addAction(tr("Zoom to Fit Selected"));
connect(zoom_fit_selected_action, &QAction::triggered, this,
&CurveView::ZoomToFitSelected);
&CurveView::zoom_to_fit_selected);
QAction *reset_zoom_action = m.addAction(tr("Reset Zoom"));
connect(reset_zoom_action, &QAction::triggered, this,
&CurveView::ResetZoom);
&CurveView::reset_zoom);
}
void CurveView::SceneRectUpdateEvent(QRectF &r)
@@ -281,8 +281,8 @@ void CurveView::SceneRectUpdateEvent(QRectF &r)
bool got_val = false;
foreach (KeyframeViewInputConnection *con, track_connections_) {
foreach (NodeKeyframe *key, con->GetKeyframes()) {
qreal key_y = GetItemYFromKeyframeValue(key);
foreach (NodeKeyframe *key, con->get_keyframes()) {
qreal key_y = get_item_y_from_keyframe_value(key);
if (got_val) {
min_val = qMin(key_y, min_val);
@@ -301,19 +301,19 @@ void CurveView::SceneRectUpdateEvent(QRectF &r)
}
}
qreal CurveView::GetKeyframeSceneY(KeyframeViewInputConnection *track,
qreal CurveView::get_keyframe_scene_y(KeyframeViewInputConnection *track,
NodeKeyframe *key)
{
return GetItemYFromKeyframeValue(key);
return get_item_y_from_keyframe_value(key);
}
void CurveView::DrawKeyframe(QPainter *painter, NodeKeyframe *key,
void CurveView::draw_keyframe(QPainter *painter, NodeKeyframe *key,
KeyframeViewInputConnection *track,
const QRectF &key_rect)
{
if (IsKeyframeSelected(key) && key->type() == NodeKeyframe::kBezier) {
if (is_keyframe_selected(key) && key->type() == NodeKeyframe::k_bezier) {
// Draw bezier control points if keyframe is selected
int control_point_size = QtUtils::QFontMetricsWidth(fontMetrics(), "o");
int control_point_size = QtUtils::q_font_metrics_width(fontMetrics(), "o");
int half_sz = control_point_size / 2;
QRectF control_point_rect(-half_sz, -half_sz, control_point_size,
control_point_size);
@@ -332,14 +332,14 @@ void CurveView::DrawKeyframe(QPainter *painter, NodeKeyframe *key,
painter->drawEllipse(cp_in);
painter->drawEllipse(cp_out);
bezier_pts_.append({ cp_in, key, NodeKeyframe::kInHandle });
bezier_pts_.append({ cp_out, key, NodeKeyframe::kOutHandle });
bezier_pts_.append({ cp_in, key, NodeKeyframe::k_in_handle });
bezier_pts_.append({ cp_out, key, NodeKeyframe::k_out_handle });
}
super::DrawKeyframe(painter, key, track, key_rect);
super::draw_keyframe(painter, key, track, key_rect);
}
bool CurveView::FirstChanceMousePress(QMouseEvent *event)
bool CurveView::first_chance_mouse_press(QMouseEvent *event)
{
dragging_bezier_pt_ = nullptr;
QPointF scene_pt = mapToScene(event->pos());
@@ -353,11 +353,11 @@ bool CurveView::FirstChanceMousePress(QMouseEvent *event)
if (dragging_bezier_pt_) {
NodeKeyframe *key = dragging_bezier_pt_->keyframe;
dragging_bezier_point_start_ =
(dragging_bezier_pt_->type == NodeKeyframe::kInHandle) ?
(dragging_bezier_pt_->type == NodeKeyframe::k_in_handle) ?
key->bezier_control_in() :
key->bezier_control_out();
dragging_bezier_point_opposing_start_ =
(dragging_bezier_pt_->type == NodeKeyframe::kInHandle) ?
(dragging_bezier_pt_->type == NodeKeyframe::k_in_handle) ?
key->bezier_control_out() :
key->bezier_control_in();
@@ -368,11 +368,11 @@ bool CurveView::FirstChanceMousePress(QMouseEvent *event)
}
}
void CurveView::FirstChanceMouseMove(QMouseEvent *event)
void CurveView::first_chance_mouse_move(QMouseEvent *event)
{
// Calculate cursor difference and scale it
QPointF scene_pos = mapToScene(event->pos());
QPointF mouse_diff_scaled = GetScaledCursorPos(scene_pos - drag_start_);
QPointF mouse_diff_scaled = get_scaled_cursor_pos(scene_pos - drag_start_);
if (event->modifiers() & Qt::ShiftModifier) {
// If holding shift, only move one axis
@@ -382,7 +382,7 @@ void CurveView::FirstChanceMouseMove(QMouseEvent *event)
// Flip the mouse Y because bezier control points are drawn bottom to top, not top to bottom
mouse_diff_scaled.setY(-mouse_diff_scaled.y());
QPointF new_bezier_pos = GenerateBezierControlPosition(
QPointF new_bezier_pos = generate_bezier_control_position(
dragging_bezier_pt_->type, dragging_bezier_point_start_,
mouse_diff_scaled);
@@ -392,7 +392,7 @@ void CurveView::FirstChanceMouseMove(QMouseEvent *event)
NodeKeyframe::get_opposing_bezier_type(dragging_bezier_pt_->type);
if (!(event->modifiers() & Qt::ControlModifier)) {
new_opposing_pos = GenerateBezierControlPosition(
new_opposing_pos = generate_bezier_control_position(
opposing_type, dragging_bezier_point_opposing_start_,
-mouse_diff_scaled);
} else {
@@ -405,10 +405,10 @@ void CurveView::FirstChanceMouseMove(QMouseEvent *event)
dragging_bezier_pt_->keyframe->set_bezier_control(opposing_type,
new_opposing_pos);
Redraw();
redraw();
}
void CurveView::FirstChanceMouseRelease(QMouseEvent *event)
void CurveView::first_chance_mouse_release(QMouseEvent *event)
{
MultiUndoCommand *command = new MultiUndoCommand();
@@ -434,23 +434,23 @@ void CurveView::FirstChanceMouseRelease(QMouseEvent *event)
command, tr("Moved Keyframe Bezier Control Point"));
}
void CurveView::KeyframeDragStart(QMouseEvent *event)
void CurveView::keyframe_drag_start(QMouseEvent *event)
{
drag_keyframe_values_.resize(GetSelectedKeyframes().size());
for (size_t i = 0; i < GetSelectedKeyframes().size(); i++) {
NodeKeyframe *key = GetSelectedKeyframes().at(i);
drag_keyframe_values_.resize(get_selected_keyframes().size());
for (size_t i = 0; i < get_selected_keyframes().size(); i++) {
NodeKeyframe *key = get_selected_keyframes().at(i);
drag_keyframe_values_[i] = key->value();
}
drag_start_ = mapToScene(event->pos());
}
void CurveView::KeyframeDragMove(QMouseEvent *event, QString &tip)
void CurveView::keyframe_drag_move(QMouseEvent *event, QString &tip)
{
if (event->modifiers() & Qt::ShiftModifier) {
// Lock to X axis only and set original values on all keys
for (size_t i = 0; i < GetSelectedKeyframes().size(); i++) {
NodeKeyframe *key = GetSelectedKeyframes().at(i);
for (size_t i = 0; i < get_selected_keyframes().size(); i++) {
NodeKeyframe *key = get_selected_keyframes().at(i);
key->set_value(drag_keyframe_values_.at(i));
}
return;
@@ -458,31 +458,31 @@ void CurveView::KeyframeDragMove(QMouseEvent *event, QString &tip)
// Calculate cursor difference
double scaled_diff =
(mapToScene(event->pos()).y() - drag_start_.y()) / GetYScale();
(mapToScene(event->pos()).y() - drag_start_.y()) / get_y_scale();
// Validate movement - ensure no keyframe goes above its max point or below its min point
for (size_t i = 0; i < GetSelectedKeyframes().size(); i++) {
NodeKeyframe *key = GetSelectedKeyframes().at(i);
for (size_t i = 0; i < get_selected_keyframes().size(); i++) {
NodeKeyframe *key = get_selected_keyframes().at(i);
FloatSlider::DisplayType display = GetFloatDisplayTypeFromKeyframe(key);
FloatSlider::DisplayType display = get_float_display_type_from_keyframe(key);
Node *node = key->parent();
double original_val = FloatSlider::TransformValueToDisplay(
double original_val = FloatSlider::transform_value_to_display(
drag_keyframe_values_.at(i).toDouble(), display);
const QString &input = key->input();
double new_val = FloatSlider::TransformDisplayToValue(
double new_val = FloatSlider::transform_display_to_value(
original_val - scaled_diff, display);
double limited = new_val;
if (node->HasInputProperty(input, QStringLiteral("min"))) {
if (node->has_input_property(input, QStringLiteral("min"))) {
limited = qMax(
limited,
node->GetInputProperty(input, QStringLiteral("min")).toDouble());
node->get_input_property(input, QStringLiteral("min")).toDouble());
}
if (node->HasInputProperty(input, QStringLiteral("max"))) {
if (node->has_input_property(input, QStringLiteral("max"))) {
limited = qMin(
limited,
node->GetInputProperty(input, QStringLiteral("max")).toDouble());
node->get_input_property(input, QStringLiteral("max")).toDouble());
}
if (limited != new_val) {
@@ -491,34 +491,34 @@ void CurveView::KeyframeDragMove(QMouseEvent *event, QString &tip)
}
// Set values
for (size_t i = 0; i < GetSelectedKeyframes().size(); i++) {
NodeKeyframe *key = GetSelectedKeyframes().at(i);
FloatSlider::DisplayType display = GetFloatDisplayTypeFromKeyframe(key);
key->set_value(FloatSlider::TransformDisplayToValue(
FloatSlider::TransformValueToDisplay(
for (size_t i = 0; i < get_selected_keyframes().size(); i++) {
NodeKeyframe *key = get_selected_keyframes().at(i);
FloatSlider::DisplayType display = get_float_display_type_from_keyframe(key);
key->set_value(FloatSlider::transform_display_to_value(
FloatSlider::transform_value_to_display(
drag_keyframe_values_.at(i).toDouble(), display) -
scaled_diff,
display));
}
NodeKeyframe *tip_item = GetSelectedKeyframes().front();
NodeKeyframe *tip_item = get_selected_keyframes().front();
bool ok;
double num_value = tip_item->value().toDouble(&ok);
if (ok) {
tip = QStringLiteral("%1\n");
tip.append(FloatSlider::ValueToString(
num_value + GetOffsetFromKeyframe(tip_item),
GetFloatDisplayTypeFromKeyframe(tip_item), 2, true));
tip.append(FloatSlider::value_to_string(
num_value + get_offset_from_keyframe(tip_item),
get_float_display_type_from_keyframe(tip_item), 2, true));
}
}
void CurveView::KeyframeDragRelease(QMouseEvent *event,
void CurveView::keyframe_drag_release(QMouseEvent *event,
MultiUndoCommand *command)
{
for (size_t i = 0; i < GetSelectedKeyframes().size(); i++) {
NodeKeyframe *k = GetSelectedKeyframes().at(i);
for (size_t i = 0; i < get_selected_keyframes().size(); i++) {
NodeKeyframe *k = get_selected_keyframes().at(i);
if (!qFuzzyCompare(k->value().toDouble(),
drag_keyframe_values_.at(i).toDouble())) {
command->add_child(new NodeParamSetKeyframeValueCommand(
@@ -528,7 +528,7 @@ void CurveView::KeyframeDragRelease(QMouseEvent *event,
}
QPointF
CurveView::GenerateBezierControlPosition(const NodeKeyframe::BezierType mode,
CurveView::generate_bezier_control_position(const NodeKeyframe::BezierType mode,
const QPointF &start_point,
const QPointF &scaled_cursor_diff)
{
@@ -537,7 +537,7 @@ CurveView::GenerateBezierControlPosition(const NodeKeyframe::BezierType mode,
new_bezier_pos += scaled_cursor_diff;
// LIMIT bezier handles from overlapping each other
if (mode == NodeKeyframe::kInHandle) {
if (mode == NodeKeyframe::k_in_handle) {
if (new_bezier_pos.x() > 0) {
new_bezier_pos.setX(0);
}
@@ -550,26 +550,26 @@ CurveView::GenerateBezierControlPosition(const NodeKeyframe::BezierType mode,
return new_bezier_pos;
}
QPointF CurveView::GetScaledCursorPos(const QPointF &cursor_pos)
QPointF CurveView::get_scaled_cursor_pos(const QPointF &cursor_pos)
{
return QPointF(cursor_pos.x() / GetScale(), cursor_pos.y() / GetYScale());
return QPointF(cursor_pos.x() / get_scale(), cursor_pos.y() / get_y_scale());
}
void CurveView::ZoomToFitInternal(bool selected_only)
void CurveView::zoom_to_fit_internal(bool selected_only)
{
bool got_val = false;
rational min_time, max_time;
Rational min_time, max_time;
double min_val, max_val;
foreach (KeyframeViewInputConnection *con, track_connections_) {
foreach (NodeKeyframe *key, con->GetKeyframes()) {
if (!selected_only || IsKeyframeSelected(key)) {
rational transformed_time =
GetAdjustedTime(key->parent(), GetTimeTarget(), key->time(),
Node::kTransformTowardsOutput);
foreach (NodeKeyframe *key, con->get_keyframes()) {
if (!selected_only || is_keyframe_selected(key)) {
Rational transformed_time =
get_adjusted_time(key->parent(), get_time_target(), key->time(),
Node::k_transform_towards_output);
qreal key_y = GetUnscaledItemYFromKeyframeValue(key);
qreal key_y = get_unscaled_item_y_from_keyframe_value(key);
if (got_val) {
min_time = qMin(transformed_time, min_time);
@@ -592,8 +592,8 @@ void CurveView::ZoomToFitInternal(bool selected_only)
// Prevent scaling if no keyframes were found
if (got_val) {
QRectF desired(QPointF(min_time.toDouble(), min_val),
QPointF(max_time.toDouble(), max_val));
QRectF desired(QPointF(min_time.to_double(), min_val),
QPointF(max_time.to_double(), max_val));
const double scale_divider = 0.5;
double scale_half_divider = scale_divider * 0.5;
@@ -612,10 +612,10 @@ void CurveView::ZoomToFitInternal(bool selected_only)
viewport()->height() / desired.height() * scale_divider;
}
emit ScaleChanged(new_x_scale);
SetYScale(new_y_scale);
emit scale_changed(new_x_scale);
set_y_scale(new_y_scale);
UpdateSceneRect();
update_scene_rect();
int sb_x = desired.left() * new_x_scale -
viewport()->width() * scale_half_divider;
@@ -629,19 +629,19 @@ void CurveView::ZoomToFitInternal(bool selected_only)
}
}
qreal CurveView::GetItemYFromKeyframeValue(NodeKeyframe *key)
qreal CurveView::get_item_y_from_keyframe_value(NodeKeyframe *key)
{
return GetUnscaledItemYFromKeyframeValue(key) * GetYScale();
return get_unscaled_item_y_from_keyframe_value(key) * get_y_scale();
}
qreal CurveView::GetUnscaledItemYFromKeyframeValue(NodeKeyframe *key)
qreal CurveView::get_unscaled_item_y_from_keyframe_value(NodeKeyframe *key)
{
double val = key->value().toDouble();
val = FloatSlider::TransformValueToDisplay(
val, GetFloatDisplayTypeFromKeyframe(key));
val = FloatSlider::transform_value_to_display(
val, get_float_display_type_from_keyframe(key));
val += GetOffsetFromKeyframe(key);
val += get_offset_from_keyframe(key);
return -val;
}
@@ -649,35 +649,35 @@ qreal CurveView::GetUnscaledItemYFromKeyframeValue(NodeKeyframe *key)
QPointF CurveView::ScalePoint(const QPointF &point)
{
// Flips Y coordinate because curves are drawn bottom to top
return QPointF(point.x() * GetScale(), -point.y() * GetYScale());
return QPointF(point.x() * get_scale(), -point.y() * get_y_scale());
}
FloatSlider::DisplayType
CurveView::GetFloatDisplayTypeFromKeyframe(NodeKeyframe *key)
CurveView::get_float_display_type_from_keyframe(NodeKeyframe *key)
{
Node *node = key->parent();
const QString &input = key->input();
if (node->HasInputProperty(input, QStringLiteral("view"))) {
if (node->has_input_property(input, QStringLiteral("view"))) {
// Try to get view from input (which will be normal if unset)
return static_cast<FloatSlider::DisplayType>(
node->GetInputProperty(input, QStringLiteral("view")).toInt());
node->get_input_property(input, QStringLiteral("view")).toInt());
}
// Fallback to normal
return FloatSlider::kNormal;
return FloatSlider::k_normal;
}
double CurveView::GetOffsetFromKeyframe(NodeKeyframe *key)
double CurveView::get_offset_from_keyframe(NodeKeyframe *key)
{
Node *node = key->parent();
const QString &input = key->input();
if (node->HasInputProperty(input, QStringLiteral("offset"))) {
QVariant v = node->GetInputProperty(input, QStringLiteral("offset"));
if (node->has_input_property(input, QStringLiteral("offset"))) {
QVariant v = node->get_input_property(input, QStringLiteral("offset"));
// NOTE: Implement getting correct offset for the track based on the data type
QVector<QVariant> track_vals =
NodeValue::split_normal_value_into_track_values(
node->GetInputDataType(input), v);
node->get_input_data_type(input), v);
return track_vals.at(key->track()).toDouble();
}
@@ -685,25 +685,25 @@ double CurveView::GetOffsetFromKeyframe(NodeKeyframe *key)
return 0;
}
QPointF CurveView::GetKeyframePosition(NodeKeyframe *key)
QPointF CurveView::get_keyframe_position(NodeKeyframe *key)
{
return QPointF(GetKeyframeSceneX(key), GetItemYFromKeyframeValue(key));
return QPointF(get_keyframe_scene_x(key), get_item_y_from_keyframe_value(key));
}
void CurveView::ZoomToFit()
void CurveView::zoom_to_fit()
{
ZoomToFitInternal(false);
zoom_to_fit_internal(false);
}
void CurveView::ZoomToFitSelected()
void CurveView::zoom_to_fit_selected()
{
ZoomToFitInternal(true);
zoom_to_fit_internal(true);
}
void CurveView::ResetZoom()
void CurveView::reset_zoom()
{
emit ScaleChanged(1.0);
SetYScale(1.0);
emit scale_changed(1.0);
set_y_scale(1.0);
}
}
app/widget/curvewidget/curveview.h
+28 -28
View File
@@ -19,8 +19,8 @@
***/
#ifndef CURVEVIEW_H
#define CURVEVIEW_H
#ifndef OAK_CURVEVIEW_H
#define OAK_CURVEVIEW_H
#include "node/keyframe.h"
#include "widget/keyframeview/keyframeview.h"
@@ -34,27 +34,27 @@ class CurveView : public KeyframeView {
public:
CurveView(QWidget *parent = nullptr);
void ConnectInput(const NodeKeyframeTrackReference &ref);
void connect_input(const NodeKeyframeTrackReference &ref);
void DisconnectInput(const NodeKeyframeTrackReference &ref);
void disconnect_input(const NodeKeyframeTrackReference &ref);
void SelectKeyframesOfInput(const NodeKeyframeTrackReference &ref);
void select_keyframes_of_input(const NodeKeyframeTrackReference &ref);
void SetKeyframeTrackColor(const NodeKeyframeTrackReference &ref,
void set_keyframe_track_color(const NodeKeyframeTrackReference &ref,
const QColor &color);
const QHash<NodeKeyframeTrackReference, KeyframeViewInputConnection *> &
GetConnections() const
get_connections() const
{
return track_connections_;
}
public slots:
void ZoomToFit();
void zoom_to_fit();
void ZoomToFitSelected();
void zoom_to_fit_selected();
void ResetZoom();
void reset_zoom();
protected:
virtual void drawBackground(QPainter *painter, const QRectF &rect) override;
@@ -64,45 +64,45 @@ protected:
virtual void SceneRectUpdateEvent(QRectF &r) override;
virtual qreal GetKeyframeSceneY(KeyframeViewInputConnection *track,
virtual qreal get_keyframe_scene_y(KeyframeViewInputConnection *track,
NodeKeyframe *key) override;
virtual void DrawKeyframe(QPainter *painter, NodeKeyframe *key,
virtual void draw_keyframe(QPainter *painter, NodeKeyframe *key,
KeyframeViewInputConnection *track,
const QRectF &key_rect) override;
virtual bool FirstChanceMousePress(QMouseEvent *event) override;
virtual void FirstChanceMouseMove(QMouseEvent *event) override;
virtual void FirstChanceMouseRelease(QMouseEvent *event) override;
virtual bool first_chance_mouse_press(QMouseEvent *event) override;
virtual void first_chance_mouse_move(QMouseEvent *event) override;
virtual void first_chance_mouse_release(QMouseEvent *event) override;
virtual void KeyframeDragStart(QMouseEvent *event) override;
virtual void KeyframeDragMove(QMouseEvent *event, QString &tip) override;
virtual void KeyframeDragRelease(QMouseEvent *event,
virtual void keyframe_drag_start(QMouseEvent *event) override;
virtual void keyframe_drag_move(QMouseEvent *event, QString &tip) override;
virtual void keyframe_drag_release(QMouseEvent *event,
MultiUndoCommand *command) override;
private:
void ZoomToFitInternal(bool selected_only);
void zoom_to_fit_internal(bool selected_only);
qreal GetItemYFromKeyframeValue(NodeKeyframe *key);
qreal GetUnscaledItemYFromKeyframeValue(NodeKeyframe *key);
qreal get_item_y_from_keyframe_value(NodeKeyframe *key);
qreal get_unscaled_item_y_from_keyframe_value(NodeKeyframe *key);
QPointF ScalePoint(const QPointF &point);
static FloatSlider::DisplayType
GetFloatDisplayTypeFromKeyframe(NodeKeyframe *key);
get_float_display_type_from_keyframe(NodeKeyframe *key);
static double GetOffsetFromKeyframe(NodeKeyframe *key);
static double get_offset_from_keyframe(NodeKeyframe *key);
void AdjustLines();
void adjust_lines();
QPointF GetKeyframePosition(NodeKeyframe *key);
QPointF get_keyframe_position(NodeKeyframe *key);
static QPointF
GenerateBezierControlPosition(const NodeKeyframe::BezierType mode,
generate_bezier_control_position(const NodeKeyframe::BezierType mode,
const QPointF &start_point,
const QPointF &scaled_cursor_diff);
QPointF GetScaledCursorPos(const QPointF &cursor_pos);
QPointF get_scaled_cursor_pos(const QPointF &cursor_pos);
QHash<NodeKeyframeTrackReference, QColor> keyframe_colors_;
QHash<NodeKeyframeTrackReference, KeyframeViewInputConnection *>
@@ -132,4 +132,4 @@ private:
}
#endif // CURVEVIEW_H
#endif // OAK_CURVEVIEW_H
app/widget/curvewidget/curvewidget.cpp
+86 -86
View File
@@ -47,10 +47,10 @@ CurveWidget::CurveWidget(QWidget *parent)
outer_layout->addWidget(splitter);
tree_view_ = new NodeTreeView();
tree_view_->SetOnlyShowKeyframable(true);
tree_view_->SetShowKeyframeTracksAsRows(true);
connect(tree_view_, &NodeTreeView::InputSelectionChanged, this,
&CurveWidget::InputSelectionChanged);
tree_view_->set_only_show_keyframable(true);
tree_view_->set_show_keyframe_tracks_as_rows(true);
connect(tree_view_, &NodeTreeView::input_selection_changed, this,
&CurveWidget::input_selection_changed);
splitter->addWidget(tree_view_);
QWidget *workarea = new QWidget();
@@ -70,21 +70,21 @@ CurveWidget::CurveWidget(QWidget *parent)
linear_button_->setEnabled(false);
top_controls->addWidget(linear_button_);
connect(linear_button_, &QPushButton::clicked, this,
&CurveWidget::KeyframeTypeButtonTriggered);
&CurveWidget::keyframe_type_button_triggered);
bezier_button_ = new QPushButton(tr("Bezier"));
bezier_button_->setCheckable(true);
bezier_button_->setEnabled(false);
top_controls->addWidget(bezier_button_);
connect(bezier_button_, &QPushButton::clicked, this,
&CurveWidget::KeyframeTypeButtonTriggered);
&CurveWidget::keyframe_type_button_triggered);
hold_button_ = new QPushButton(tr("Hold"));
hold_button_->setCheckable(true);
hold_button_->setEnabled(false);
top_controls->addWidget(hold_button_);
connect(hold_button_, &QPushButton::clicked, this,
&CurveWidget::KeyframeTypeButtonTriggered);
&CurveWidget::keyframe_type_button_triggered);
layout->addLayout(top_controls);
@@ -96,19 +96,19 @@ CurveWidget::CurveWidget(QWidget *parent)
ruler_view_layout->addWidget(ruler());
view_ = new CurveView();
ConnectTimelineView(view_);
view_->SetSnapService(this);
connect_timeline_view(view_);
view_->set_snap_service(this);
ruler_view_layout->addWidget(view_);
layout->addLayout(ruler_view_layout);
// Connect ruler and view together
connect(view_, &CurveView::SelectionChanged, this,
&CurveWidget::SelectionChanged);
connect(view_, &CurveView::Dragged, this,
&CurveWidget::KeyframeViewDragged);
connect(view_, &CurveView::Released, this,
&CurveWidget::KeyframeViewReleased);
connect(view_, &CurveView::selection_changed, this,
&CurveWidget::selection_changed);
connect(view_, &CurveView::dragged, this,
&CurveWidget::keyframe_view_dragged);
connect(view_, &CurveView::released, this,
&CurveWidget::keyframe_view_released);
// TimeBasedWidget's scrollbar has extra functionality that we can take advantage of
view_->setHorizontalScrollBar(scrollbar());
@@ -119,25 +119,25 @@ CurveWidget::CurveWidget(QWidget *parent)
SetScale(120.0);
}
const double &CurveWidget::GetVerticalScale()
const double &CurveWidget::get_vertical_scale()
{
return view_->GetYScale();
return view_->get_y_scale();
}
void CurveWidget::SetVerticalScale(const double &vscale)
void CurveWidget::set_vertical_scale(const double &vscale)
{
view_->SetYScale(vscale);
view_->set_y_scale(vscale);
}
void CurveWidget::DeleteSelected()
{
view_->DeleteSelected();
view_->delete_selected();
}
Node *CurveWidget::GetSelectedNodeWithID(const QString &id)
Node *CurveWidget::get_selected_node_with_id(const QString &id)
{
for (auto it = view_->GetConnections().cbegin();
it != view_->GetConnections().cend(); it++) {
for (auto it = view_->get_connections().cbegin();
it != view_->get_connections().cend(); it++) {
Node *n = it.key().input().node();
if (n->id() == id) {
return n;
@@ -147,28 +147,28 @@ Node *CurveWidget::GetSelectedNodeWithID(const QString &id)
return nullptr;
}
bool CurveWidget::CopySelected(bool cut)
bool CurveWidget::copy_selected(bool cut)
{
if (super::CopySelected(cut)) {
if (super::copy_selected(cut)) {
return true;
}
return view_->CopySelected(cut);
return view_->copy_selected(cut);
}
bool CurveWidget::Paste()
bool CurveWidget::paste()
{
if (super::Paste()) {
if (super::paste()) {
return true;
}
return view_->Paste(std::bind(&CurveWidget::GetSelectedNodeWithID, this,
return view_->paste(std::bind(&CurveWidget::get_selected_node_with_id, this,
std::placeholders::_1));
}
void CurveWidget::SetNodes(const QVector<Node *> &nodes)
void CurveWidget::set_nodes(const QVector<Node *> &nodes)
{
tree_view_->SetNodes(nodes);
tree_view_->set_nodes(nodes);
// Save new node list
nodes_ = nodes;
@@ -176,13 +176,13 @@ void CurveWidget::SetNodes(const QVector<Node *> &nodes)
// Generate colors
foreach (Node *node, nodes_) {
foreach (const QString &input, node->inputs()) {
if (node->IsInputKeyframable(input) &&
!node->IsInputHidden(input)) {
int arr_sz = node->InputArraySize(input);
if (node->is_input_keyframable(input) &&
!node->is_input_hidden(input)) {
int arr_sz = node->input_array_size(input);
for (int i = -1; i < arr_sz; i++) {
// Generate a random color for this input
const QVector<NodeKeyframeTrack> &tracks =
node->GetKeyframeTracks(input, i);
node->get_keyframe_tracks(input, i);
for (int j = 0; j < tracks.size(); j++) {
NodeKeyframeTrackReference ref(
@@ -193,8 +193,8 @@ void CurveWidget::SetNodes(const QVector<Node *> &nodes)
QColor::fromHsl(std::rand() % 360, 255, 160);
keyframe_colors_.insert(ref, c);
tree_view_->SetKeyframeTrackColor(ref, c);
view_->SetKeyframeTrackColor(ref, c);
tree_view_->set_keyframe_track_color(ref, c);
view_->set_keyframe_track_color(ref, c);
}
}
}
@@ -203,92 +203,92 @@ void CurveWidget::SetNodes(const QVector<Node *> &nodes)
}
}
void CurveWidget::TimebaseChangedEvent(const rational &timebase)
void CurveWidget::TimebaseChangedEvent(const Rational &timebase)
{
super::TimebaseChangedEvent(timebase);
view_->SetTimebase(timebase);
view_->set_timebase(timebase);
}
void CurveWidget::ScaleChangedEvent(const double &scale)
{
super::ScaleChangedEvent(scale);
view_->SetScale(scale);
view_->set_scale(scale);
}
void CurveWidget::TimeTargetChangedEvent(ViewerOutput *target)
{
TimeTargetObject::TimeTargetChangedEvent(target);
key_control_->SetTimeTarget(target);
key_control_->set_time_target(target);
view_->SetTimeTarget(target);
view_->set_time_target(target);
}
void CurveWidget::ConnectedNodeChangeEvent(ViewerOutput *n)
{
super::ConnectedNodeChangeEvent(n);
key_control_->SetTimeTarget(n);
key_control_->set_time_target(n);
SetTimeTarget(n);
set_time_target(n);
}
void CurveWidget::SetKeyframeButtonEnabled(bool enable)
void CurveWidget::set_keyframe_button_enabled(bool enable)
{
linear_button_->setEnabled(enable);
bezier_button_->setEnabled(enable);
hold_button_->setEnabled(enable);
}
void CurveWidget::SetKeyframeButtonChecked(bool checked)
void CurveWidget::set_keyframe_button_checked(bool checked)
{
linear_button_->setChecked(checked);
bezier_button_->setChecked(checked);
hold_button_->setChecked(checked);
}
void CurveWidget::SetKeyframeButtonCheckedFromType(NodeKeyframe::Type type)
void CurveWidget::set_keyframe_button_checked_from_type(NodeKeyframe::Type type)
{
linear_button_->setChecked(type == NodeKeyframe::kLinear);
bezier_button_->setChecked(type == NodeKeyframe::kBezier);
hold_button_->setChecked(type == NodeKeyframe::kHold);
linear_button_->setChecked(type == NodeKeyframe::k_linear);
bezier_button_->setChecked(type == NodeKeyframe::k_bezier);
hold_button_->setChecked(type == NodeKeyframe::k_hold);
}
void CurveWidget::ConnectInput(Node *node, const QString &input, int element)
void CurveWidget::connect_input(Node *node, const QString &input, int element)
{
if (element == -1 && node->InputIsArray(input)) {
if (element == -1 && node->input_is_array(input)) {
// This is the root element, connect all elements (if applicable)
int arr_sz = node->InputArraySize(input);
int arr_sz = node->input_array_size(input);
for (int i = -1; i < arr_sz; i++) {
ConnectInputInternal(node, input, i);
connect_input_internal(node, input, i);
}
} else {
// This is a single element, just connect it as-is
ConnectInputInternal(node, input, element);
connect_input_internal(node, input, element);
}
}
void CurveWidget::ConnectInputInternal(Node *node, const QString &input,
void CurveWidget::connect_input_internal(Node *node, const QString &input,
int element)
{
NodeInput input_ref(node, input, element);
int track_count =
NodeValue::get_number_of_keyframe_tracks(input_ref.GetDataType());
NodeValue::get_number_of_keyframe_tracks(input_ref.get_data_type());
for (int i = 0; i < track_count; i++) {
NodeKeyframeTrackReference track_ref(input_ref, i);
view_->ConnectInput(track_ref);
view_->connect_input(track_ref);
selected_tracks_.append(track_ref);
}
}
void CurveWidget::SelectionChanged()
void CurveWidget::selection_changed()
{
const std::vector<NodeKeyframe *> &selected = view_->GetSelectedKeyframes();
const std::vector<NodeKeyframe *> &selected = view_->get_selected_keyframes();
SetKeyframeButtonChecked(false);
SetKeyframeButtonEnabled(!selected.empty());
set_keyframe_button_checked(false);
set_keyframe_button_enabled(!selected.empty());
if (!selected.empty()) {
bool all_same_type = true;
@@ -305,12 +305,12 @@ void CurveWidget::SelectionChanged()
}
if (all_same_type) {
SetKeyframeButtonCheckedFromType(type);
set_keyframe_button_checked_from_type(type);
}
}
}
void CurveWidget::KeyframeTypeButtonTriggered(bool checked)
void CurveWidget::keyframe_type_button_triggered(bool checked)
{
QPushButton *key_btn = static_cast<QPushButton *>(sender());
@@ -321,7 +321,7 @@ void CurveWidget::KeyframeTypeButtonTriggered(bool checked)
}
// Get selected items and do nothing if there are none
const std::vector<NodeKeyframe *> &selected = view_->GetSelectedKeyframes();
const std::vector<NodeKeyframe *> &selected = view_->get_selected_keyframes();
if (selected.empty()) {
return;
}
@@ -331,15 +331,15 @@ void CurveWidget::KeyframeTypeButtonTriggered(bool checked)
// Determine which type to set
if (key_btn == bezier_button_) {
new_type = NodeKeyframe::kBezier;
new_type = NodeKeyframe::k_bezier;
} else if (key_btn == hold_button_) {
new_type = NodeKeyframe::kHold;
new_type = NodeKeyframe::k_hold;
} else {
new_type = NodeKeyframe::kLinear;
new_type = NodeKeyframe::k_linear;
}
// Ensure only the appropriate button is checked
SetKeyframeButtonCheckedFromType(new_type);
set_keyframe_button_checked_from_type(new_type);
MultiUndoCommand *command = new MultiUndoCommand();
@@ -351,47 +351,47 @@ void CurveWidget::KeyframeTypeButtonTriggered(bool checked)
command, tr("Changed Type of %1 Keyframe(s) to %2"));
}
void CurveWidget::InputSelectionChanged(const NodeKeyframeTrackReference &ref)
void CurveWidget::input_selection_changed(const NodeKeyframeTrackReference &ref)
{
key_control_->SetInput(ref.input());
key_control_->set_input(ref.input());
foreach (const NodeKeyframeTrackReference &c, selected_tracks_) {
view_->DisconnectInput(c);
view_->disconnect_input(c);
}
selected_tracks_.clear();
if (ref.IsValid() && !ref.input().IsArray()) {
if (ref.is_valid() && !ref.input().is_array()) {
// This reference is a track, connect it only
view_->ConnectInput(ref);
view_->connect_input(ref);
selected_tracks_.append(ref);
} else if (ref.input().IsValid()) {
} else if (ref.input().is_valid()) {
// This reference is a input, connect all tracks
ConnectInput(ref.input().node(), ref.input().input(),
connect_input(ref.input().node(), ref.input().input(),
ref.input().element());
} else if (Node *node = ref.input().node()) {
// This is a node, add all inputs
foreach (const QString &input, node->inputs()) {
if (node->IsInputKeyframable(input) &&
!node->IsInputHidden(input)) {
ConnectInput(node, input, -1);
if (node->is_input_keyframable(input) &&
!node->is_input_hidden(input)) {
connect_input(node, input, -1);
}
}
}
view_->ZoomToFit();
view_->zoom_to_fit();
}
void CurveWidget::KeyframeViewDragged(int x, int y)
void CurveWidget::keyframe_view_dragged(int x, int y)
{
SetCatchUpScrollValue(x);
SetCatchUpScrollValue(view_->verticalScrollBar(), y, view_->height());
set_catch_up_scroll_value(x);
set_catch_up_scroll_value(view_->verticalScrollBar(), y, view_->height());
}
void CurveWidget::KeyframeViewReleased()
void CurveWidget::keyframe_view_released()
{
StopCatchUpScrollTimer();
StopCatchUpScrollTimer(view_->verticalScrollBar());
stop_catch_up_scroll_timer();
stop_catch_up_scroll_timer(view_->verticalScrollBar());
}
}
app/widget/curvewidget/curvewidget.h
+29 -29
View File
@@ -19,8 +19,8 @@
***/
#ifndef CURVEWIDGET_H
#define CURVEWIDGET_H
#ifndef OAK_CURVEWIDGET_H
#define OAK_CURVEWIDGET_H
#include <QCheckBox>
#include <QHBoxLayout>
@@ -41,32 +41,32 @@ class CurveWidget : public TimeBasedWidget, public TimeTargetObject {
public:
CurveWidget(QWidget *parent = nullptr);
const double &GetVerticalScale();
void SetVerticalScale(const double &vscale);
const double &get_vertical_scale();
void set_vertical_scale(const double &vscale);
void DeleteSelected();
void SelectAll()
void select_all()
{
view_->SelectAll();
view_->select_all();
}
void DeselectAll()
void deselect_all()
{
view_->DeselectAll();
view_->deselect_all();
}
Node *GetSelectedNodeWithID(const QString &id);
Node *get_selected_node_with_id(const QString &id);
virtual bool CopySelected(bool cut) override;
virtual bool copy_selected(bool cut) override;
virtual bool Paste() override;
virtual bool paste() override;
public slots:
void SetNodes(const QVector<Node *> &nodes);
void set_nodes(const QVector<Node *> &nodes);
protected:
virtual void TimebaseChangedEvent(const rational &) override;
virtual void TimebaseChangedEvent(const Rational &) override;
virtual void ScaleChangedEvent(const double &) override;
virtual void TimeTargetChangedEvent(ViewerOutput *target) override;
@@ -74,32 +74,32 @@ protected:
virtual void ConnectedNodeChangeEvent(ViewerOutput *n) override;
virtual const QVector<KeyframeViewInputConnection *> *
GetSnapKeyframes() const override
get_snap_keyframes() const override
{
return &view_->GetKeyframeTracks();
return &view_->get_keyframe_tracks();
}
virtual const TimeTargetObject *GetKeyframeTimeTarget() const override
virtual const TimeTargetObject *get_keyframe_time_target() const override
{
return view_;
}
virtual const std::vector<NodeKeyframe *> *
GetSnapIgnoreKeyframes() const override
get_snap_ignore_keyframes() const override
{
return &view_->GetSelectedKeyframes();
return &view_->get_selected_keyframes();
}
private:
void SetKeyframeButtonEnabled(bool enable);
void set_keyframe_button_enabled(bool enable);
void SetKeyframeButtonChecked(bool checked);
void set_keyframe_button_checked(bool checked);
void SetKeyframeButtonCheckedFromType(NodeKeyframe::Type type);
void set_keyframe_button_checked_from_type(NodeKeyframe::Type type);
void ConnectInput(Node *node, const QString &input, int element);
void connect_input(Node *node, const QString &input, int element);
void ConnectInputInternal(Node *node, const QString &input, int element);
void connect_input_internal(Node *node, const QString &input, int element);
QHash<NodeKeyframeTrackReference, QColor> keyframe_colors_;
@@ -120,16 +120,16 @@ private:
QVector<NodeKeyframeTrackReference> selected_tracks_;
private slots:
void SelectionChanged();
void selection_changed();
void KeyframeTypeButtonTriggered(bool checked);
void keyframe_type_button_triggered(bool checked);
void InputSelectionChanged(const NodeKeyframeTrackReference &ref);
void input_selection_changed(const NodeKeyframeTrackReference &ref);
void KeyframeViewDragged(int x, int y);
void KeyframeViewReleased();
void keyframe_view_dragged(int x, int y);
void keyframe_view_released();
};
}
#endif // CURVEWIDGET_H
#endif // OAK_CURVEWIDGET_H