mirror of
https://github.com/RGBCube/serenity
synced 2025-10-28 00:42:34 +00:00
c1345bda3e
The Piano application used to perform very poorly due to unnecessary draw calls. This is solved with two optimziations: 1. Don't draw the widgets as often as possible. The widgets are instead at least updated every 150ms, except for other events. 2. Don't re-draw the entire piano roll sheet. The piano roll background, excluding in-motion objects (notes, the play cursor), is only re-drawn when its "viewport" changes. A minor drawback of this change is that notes will appear on top of the pitch labels if placed at the left edge of the roll. This is IMO acceptable or may be changed by moving the text to the "foreground".
276 lines
11 KiB
C++
276 lines
11 KiB
C++
/*
|
|
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
|
* Copyright (c) 2019-2020, William McPherson <willmcpherson2@gmail.com>
|
|
* Copyright (c) 2021, kleines Filmröllchen <malu.bertsch@gmail.com>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include "RollWidget.h"
|
|
#include "TrackManager.h"
|
|
#include <LibGUI/Painter.h>
|
|
#include <LibGUI/Scrollbar.h>
|
|
#include <LibGfx/Font.h>
|
|
#include <LibGfx/FontDatabase.h>
|
|
#include <math.h>
|
|
|
|
constexpr int note_height = 20;
|
|
constexpr int max_note_width = note_height * 2;
|
|
constexpr int roll_height = note_count * note_height;
|
|
constexpr int horizontal_scroll_sensitivity = 20;
|
|
constexpr int max_zoom = 1 << 8;
|
|
|
|
RollWidget::RollWidget(TrackManager& track_manager)
|
|
: m_track_manager(track_manager)
|
|
{
|
|
set_should_hide_unnecessary_scrollbars(true);
|
|
set_content_size({ 0, roll_height });
|
|
vertical_scrollbar().set_value(roll_height / 2);
|
|
}
|
|
|
|
RollWidget::~RollWidget()
|
|
{
|
|
}
|
|
|
|
void RollWidget::paint_event(GUI::PaintEvent& event)
|
|
{
|
|
m_roll_width = widget_inner_rect().width() * m_zoom_level;
|
|
set_content_size({ m_roll_width, roll_height });
|
|
|
|
// Divide the roll by the maximum note width. If we get fewer notes than
|
|
// our time signature requires, round up. Otherwise, round down to the
|
|
// nearest x*(2^y), where x is the base number of notes of our time
|
|
// signature. In other words, find a number that is a double of our time
|
|
// signature. For 4/4 that would be 16, 32, 64, 128 ...
|
|
m_num_notes = m_roll_width / max_note_width;
|
|
int time_signature_notes = beats_per_bar * notes_per_beat;
|
|
if (m_num_notes < time_signature_notes)
|
|
m_num_notes = time_signature_notes;
|
|
else
|
|
m_num_notes = time_signature_notes * pow(2, static_cast<int>(log2(m_num_notes / time_signature_notes)));
|
|
m_note_width = static_cast<double>(m_roll_width) / m_num_notes;
|
|
|
|
// This calculates the minimum number of rows needed. We account for a
|
|
// partial row at the top and/or bottom.
|
|
int y_offset = vertical_scrollbar().value();
|
|
int note_offset = y_offset / note_height;
|
|
int note_offset_remainder = y_offset % note_height;
|
|
int paint_area = widget_inner_rect().height() + note_offset_remainder;
|
|
if (paint_area % note_height != 0)
|
|
paint_area += note_height;
|
|
int notes_to_paint = paint_area / note_height;
|
|
int key_pattern_index = (notes_per_octave - 1) - (note_offset % notes_per_octave);
|
|
|
|
int x_offset = horizontal_scrollbar().value();
|
|
int horizontal_note_offset_remainder = fmod(x_offset, m_note_width);
|
|
int horizontal_paint_area = widget_inner_rect().width() + horizontal_note_offset_remainder;
|
|
if (fmod(horizontal_paint_area, m_note_width) != 0)
|
|
horizontal_paint_area += m_note_width;
|
|
int horizontal_notes_to_paint = horizontal_paint_area / m_note_width;
|
|
|
|
GUI::Painter painter(*this);
|
|
|
|
// Draw the background, if necessary.
|
|
if (viewport_changed() || paint_area != m_background->height()) {
|
|
m_background = Gfx::Bitmap::create(Gfx::BitmapFormat::BGRx8888, Gfx::IntSize(m_roll_width, paint_area));
|
|
Gfx::Painter background_painter(*m_background);
|
|
|
|
background_painter.translate(frame_thickness(), frame_thickness());
|
|
background_painter.translate(-horizontal_note_offset_remainder, -note_offset_remainder);
|
|
|
|
for (int y = 0; y < notes_to_paint; ++y) {
|
|
int y_pos = y * note_height;
|
|
|
|
for (int x = 0; x < horizontal_notes_to_paint; ++x) {
|
|
// This is needed to avoid rounding errors. You can't just use
|
|
// m_note_width as the width.
|
|
int x_pos = x * m_note_width;
|
|
int next_x_pos = (x + 1) * m_note_width;
|
|
int distance_to_next_x = next_x_pos - x_pos;
|
|
Gfx::IntRect rect(x_pos, y_pos, distance_to_next_x, note_height);
|
|
|
|
if (key_pattern[key_pattern_index] == Black)
|
|
background_painter.fill_rect(rect, Color::LightGray);
|
|
else
|
|
background_painter.fill_rect(rect, Color::White);
|
|
|
|
background_painter.draw_line(rect.top_right(), rect.bottom_right(), Color::Black);
|
|
background_painter.draw_line(rect.bottom_left(), rect.bottom_right(), Color::Black);
|
|
}
|
|
|
|
if (--key_pattern_index == -1)
|
|
key_pattern_index = notes_per_octave - 1;
|
|
}
|
|
|
|
background_painter.translate(-x_offset, -y_offset);
|
|
background_painter.translate(horizontal_note_offset_remainder, note_offset_remainder);
|
|
|
|
for (int note = note_count - (note_offset + notes_to_paint); note <= (note_count - 1) - note_offset; ++note) {
|
|
int y = ((note_count - 1) - note) * note_height;
|
|
|
|
Gfx::IntRect note_name_rect(3, y, 1, note_height);
|
|
const char* note_name = note_names[note % notes_per_octave];
|
|
|
|
background_painter.draw_text(note_name_rect, note_name, Gfx::TextAlignment::CenterLeft);
|
|
note_name_rect.move_by(Gfx::FontDatabase::default_font().width(note_name) + 2, 0);
|
|
if (note % notes_per_octave == 0)
|
|
background_painter.draw_text(note_name_rect, String::formatted("{}", note / notes_per_octave + 1), Gfx::TextAlignment::CenterLeft);
|
|
}
|
|
|
|
m_prev_zoom_level = m_zoom_level;
|
|
m_prev_scroll_x = horizontal_scrollbar().value();
|
|
m_prev_scroll_y = vertical_scrollbar().value();
|
|
}
|
|
|
|
painter.blit(Gfx::IntPoint(0, 0), *m_background, m_background->rect());
|
|
|
|
// Draw the notes, mouse interaction, and time position.
|
|
painter.translate(frame_thickness(), frame_thickness());
|
|
painter.add_clip_rect(event.rect());
|
|
painter.translate(-horizontal_note_offset_remainder, -note_offset_remainder);
|
|
|
|
for (int y = 0; y < notes_to_paint; ++y) {
|
|
int y_pos = y * note_height;
|
|
|
|
int note = (note_count - note_offset - 1) - y;
|
|
for (int x = 0; x < horizontal_notes_to_paint; ++x) {
|
|
// This is needed to avoid rounding errors. You can't just use
|
|
// m_note_width as the width.
|
|
int x_pos = x * m_note_width;
|
|
int next_x_pos = (x + 1) * m_note_width;
|
|
int distance_to_next_x = next_x_pos - x_pos;
|
|
Gfx::IntRect rect(x_pos, y_pos, distance_to_next_x, note_height);
|
|
|
|
if (keys_widget() && keys_widget()->note_is_set(note))
|
|
painter.fill_rect(rect, note_pressed_color.with_alpha(128));
|
|
}
|
|
}
|
|
|
|
painter.translate(-x_offset, -y_offset);
|
|
painter.translate(horizontal_note_offset_remainder, note_offset_remainder);
|
|
|
|
for (int note = note_count - (note_offset + notes_to_paint); note <= (note_count - 1) - note_offset; ++note) {
|
|
int y = ((note_count - 1) - note) * note_height;
|
|
for (auto roll_note : m_track_manager.current_track().roll_notes(note)) {
|
|
int x = m_roll_width * (static_cast<double>(roll_note.on_sample) / roll_length);
|
|
int width = m_roll_width * (static_cast<double>(roll_note.length()) / roll_length);
|
|
if (x + width < x_offset || x > x_offset + widget_inner_rect().width())
|
|
continue;
|
|
if (width < 2)
|
|
width = 2;
|
|
|
|
int height = note_height;
|
|
|
|
Gfx::IntRect rect(x, y, width, height);
|
|
painter.fill_rect(rect, note_pressed_color);
|
|
painter.draw_rect(rect, Color::Black);
|
|
}
|
|
}
|
|
|
|
int x = m_roll_width * (static_cast<double>(m_track_manager.time()) / roll_length);
|
|
if (x > x_offset && x <= x_offset + widget_inner_rect().width())
|
|
painter.draw_line({ x, 0 }, { x, roll_height }, Gfx::Color::Black);
|
|
|
|
GUI::Frame::paint_event(event);
|
|
}
|
|
|
|
bool RollWidget::viewport_changed() const
|
|
{
|
|
// height is complicated to check, will be done in paint_event
|
|
return m_background.is_null()
|
|
|| m_roll_width != m_background->width()
|
|
|| m_prev_scroll_x != horizontal_scrollbar().value() || m_prev_scroll_y != vertical_scrollbar().value()
|
|
|| m_prev_zoom_level != m_zoom_level;
|
|
}
|
|
|
|
void RollWidget::mousedown_event(GUI::MouseEvent& event)
|
|
{
|
|
if (!widget_inner_rect().contains(event.x(), event.y()))
|
|
return;
|
|
|
|
m_note_drag_start = event.position();
|
|
|
|
int y = (m_note_drag_start.value().y() + vertical_scrollbar().value()) - frame_thickness();
|
|
y /= note_height;
|
|
m_drag_note = (note_count - 1) - y;
|
|
|
|
mousemove_event(event);
|
|
}
|
|
|
|
void RollWidget::mousemove_event(GUI::MouseEvent& event)
|
|
{
|
|
if (!m_note_drag_start.has_value())
|
|
return;
|
|
|
|
if (m_note_drag_location.has_value()) {
|
|
// Clear previous note
|
|
m_track_manager.current_track().set_roll_note(m_drag_note, m_note_drag_location.value().on_sample, m_note_drag_location.value().off_sample);
|
|
}
|
|
|
|
auto get_note_x = [&](int x0) {
|
|
// There's a case where we can't just use x / m_note_width. For example, if
|
|
// your m_note_width is 3.1 you will have a rect starting at 3. When that
|
|
// leftmost pixel of the rect is clicked you will do 3 / 3.1 which is 0
|
|
// and not 1. We can avoid that case by shifting x by 1 if m_note_width is
|
|
// fractional, being careful not to shift out of bounds.
|
|
int x = (x0 + horizontal_scrollbar().value()) - frame_thickness();
|
|
bool note_width_is_fractional = m_note_width - static_cast<int>(m_note_width) != 0;
|
|
bool x_is_not_last = x != widget_inner_rect().width() - 1;
|
|
if (note_width_is_fractional && x_is_not_last)
|
|
++x;
|
|
x /= m_note_width;
|
|
return clamp(x, 0, m_num_notes - 1);
|
|
};
|
|
|
|
int x0 = get_note_x(m_note_drag_start.value().x());
|
|
int x1 = get_note_x(event.x());
|
|
|
|
u32 on_sample = roll_length * (static_cast<double>(min(x0, x1)) / m_num_notes);
|
|
u32 off_sample = (roll_length * (static_cast<double>(max(x0, x1) + 1) / m_num_notes)) - 1;
|
|
m_track_manager.current_track().set_roll_note(m_drag_note, on_sample, off_sample);
|
|
m_note_drag_location = RollNote({ on_sample, off_sample });
|
|
|
|
update();
|
|
}
|
|
|
|
void RollWidget::mouseup_event([[maybe_unused]] GUI::MouseEvent& event)
|
|
{
|
|
m_note_drag_start = {};
|
|
m_note_drag_location = {};
|
|
}
|
|
|
|
// FIXME: Implement zoom and horizontal scroll events in LibGUI, not here.
|
|
void RollWidget::mousewheel_event(GUI::MouseEvent& event)
|
|
{
|
|
if (event.modifiers() & KeyModifier::Mod_Shift) {
|
|
horizontal_scrollbar().set_value(horizontal_scrollbar().value() + (event.wheel_delta() * horizontal_scroll_sensitivity));
|
|
return;
|
|
}
|
|
|
|
if (!(event.modifiers() & KeyModifier::Mod_Ctrl)) {
|
|
GUI::ScrollableWidget::mousewheel_event(event);
|
|
return;
|
|
}
|
|
|
|
double multiplier = event.wheel_delta() >= 0 ? 0.5 : 2;
|
|
|
|
if (m_zoom_level * multiplier > max_zoom)
|
|
return;
|
|
|
|
if (m_zoom_level * multiplier < 1) {
|
|
if (m_zoom_level == 1)
|
|
return;
|
|
m_zoom_level = 1;
|
|
} else {
|
|
m_zoom_level *= multiplier;
|
|
}
|
|
|
|
int absolute_x_of_pixel_at_cursor = horizontal_scrollbar().value() + event.position().x();
|
|
int absolute_x_of_pixel_at_cursor_after_resize = absolute_x_of_pixel_at_cursor * multiplier;
|
|
int new_scrollbar = absolute_x_of_pixel_at_cursor_after_resize - event.position().x();
|
|
|
|
m_roll_width = widget_inner_rect().width() * m_zoom_level;
|
|
set_content_size({ m_roll_width, roll_height });
|
|
|
|
horizontal_scrollbar().set_value(new_scrollbar);
|
|
}
|