josh/jes
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
jes/src/gui/Window.cc

408 lines
9.8 KiB
C++
Raw Blame History

#include "gl3w.h"
#include "Window.h"
#include "Runtime.h"
#define INITIAL_WIDTH 500
#define INITIAL_HEIGHT 500
#define FONT_SIZE 16
struct
{
SDL_TimerID timer_id;
Uint16 mod;
bool pressed;
} Key_Statuses[SDL_NUM_SCANCODES];
/**
* Initialize SDL.
*
* @retval true SDL was loaded successfully.
* @retval false Loading SDL failed.
*/
static bool Initialize_SDL()
{
static bool initialized = false;
if (initialized)
{
return true;
}
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) != 0)
{
return false;
}
atexit(SDL_Quit);
initialized = true;
return true;
}
/**
* Initialize OpenGL.
*
* @retval true OpenGL was loaded successfully.
* @retval false Loading OpenGL failed.
*/
static bool Initialize_OpenGL()
{
if (gl3wInit() != 0)
{
/* Failed to gl3wInit() */
return false;
}
if (!gl3wIsSupported(3, 0))
{
/* OpenGL 3.0 is not supported */
return false;
}
glActiveTexture(GL_TEXTURE0);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
return true;
}
/**
* Create a Window.
*
* @retval true The Window was created successfully.
* @retval false There was an error while creating the Window.
*/
bool Window::create(std::shared_ptr<Buffer> buffer)
{
if (!Initialize_SDL())
{
return false;
}
m_window = SDL_CreateWindow(
APPNAME,
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
INITIAL_WIDTH,
INITIAL_HEIGHT,
SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
if (m_window == NULL)
{
return false;
}
(void)SDL_GL_CreateContext(m_window);
if (!Initialize_OpenGL())
{
return false;
}
m_exit_requested = false;
/* TODO: user configurable font, size */
std::string font_path = Runtime::find(Runtime::FONT, "DejaVuSansMono");
if (font_path == "")
{
return false;
}
if (!m_font.load(font_path.c_str(), FONT_SIZE))
{
return false;
}
m_shaders.text = std::make_shared<TextShader>();
m_shaders.text->use();
m_shaders.text->set_texture(0);
m_shaders.text->set_color(1.0, 1.0, 1.0, 1.0);
m_shaders.flat = std::make_shared<FlatShader>();
GLint cursor_bounds[] = {0, 0,
m_font.get_advance(), 0,
m_font.get_advance(), m_font.get_line_height(),
0, m_font.get_line_height()};
m_cursor_array = glcxx::Array::create();
m_cursor_array->bind();
m_cursor_buffer = glcxx::Buffer::create(GL_ARRAY_BUFFER, GL_STATIC_DRAW,
cursor_bounds, sizeof(cursor_bounds));
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_INT, GL_FALSE, 0, 0);
m_buffer = buffer;
m_cursor = m_buffer->piece_table->add_cursor();
m_start_piece = m_buffer->piece_table->start_piece->next;
m_cursor_row = 0;
m_scroll_offset = 5;
resize();
return true;
}
/**
* Run the Window event loop.
*
* TODO: make this a static method to support multiple GUI windows.
*/
void Window::run_event_loop()
{
SDL_Event event;
while ((!m_exit_requested) && SDL_WaitEvent(&event))
{
handle_event(event);
}
}
Uint32 Key_Repeat(Uint32 interval, void * param)
{
if (Key_Statuses[(uintptr_t)param].pressed)
{
SDL_Event event;
event.user.code = 0;
event.user.data1 = param;
event.user.data2 = (void *)(uintptr_t)Key_Statuses[(uintptr_t)param].mod;
event.type = SDL_USEREVENT;
SDL_PushEvent(&event);
return 25u;
}
else
{
return 0u;
}
}
/**
* Handle a SDL event.
*/
void Window::handle_event(SDL_Event & event)
{
switch (event.type)
{
case SDL_QUIT:
m_exit_requested = true;
break;
case SDL_KEYDOWN:
if (event.key.repeat == 0)
{
Key_Statuses[event.key.keysym.scancode].pressed = true;
Key_Statuses[event.key.keysym.scancode].timer_id = SDL_AddTimer(200, Key_Repeat, (void *)event.key.keysym.scancode);
Key_Statuses[event.key.keysym.scancode].mod = event.key.keysym.mod;
handle_key(event.key.keysym.scancode, event.key.keysym.mod);
}
break;
case SDL_KEYUP:
Key_Statuses[event.key.keysym.scancode].pressed = false;
if (Key_Statuses[event.key.keysym.scancode].timer_id != 0)
{
SDL_RemoveTimer(Key_Statuses[event.key.keysym.scancode].timer_id);
Key_Statuses[event.key.keysym.scancode].timer_id = 0;
}
break;
case SDL_WINDOWEVENT:
switch (event.window.event)
{
case SDL_WINDOWEVENT_EXPOSED:
redraw();
break;
case SDL_WINDOWEVENT_RESIZED:
resize();
redraw();
break;
}
break;
case SDL_USEREVENT:
handle_key((uint32_t)(uintptr_t)event.user.data1,
(uint32_t)(uintptr_t)event.user.data2);
break;
}
}
void Window::handle_key(uint32_t scancode, uint32_t mod)
{
switch (scancode)
{
case SDL_SCANCODE_ESCAPE:
m_exit_requested = true;
break;
case SDL_SCANCODE_H:
cursor_move(CURSOR_LEFT);
break;
case SDL_SCANCODE_J:
cursor_move(CURSOR_DOWN);
break;
case SDL_SCANCODE_K:
cursor_move(CURSOR_UP);
break;
case SDL_SCANCODE_L:
cursor_move(CURSOR_RIGHT);
break;
}
}
void Window::cursor_move(int which)
{
bool success = false;
int current_row_offset = m_cursor->column / m_columns;
int row_offset = 0;
switch (which)
{
case CURSOR_LEFT:
success = m_cursor->go_left(1);
break;
case CURSOR_RIGHT:
success = m_cursor->go_right(1);
break;
case CURSOR_UP:
success = m_cursor->go_up(1, m_cursor->column);
break;
case CURSOR_DOWN:
success = m_cursor->go_down(1, m_cursor->column);
break;
}
if (success)
{
switch (which)
{
case CURSOR_LEFT:
case CURSOR_RIGHT:
row_offset = m_cursor->column / m_columns - current_row_offset;
break;
case CURSOR_UP:
{
PieceTable::Cursor c = *m_cursor;
c.go_end_of_line();
row_offset = m_cursor->column / m_columns - c.column / m_columns - 1 - current_row_offset;
}
break;
case CURSOR_DOWN:
{
PieceTable::Cursor c = *m_cursor;
c.go_up(1, 0u);
c.go_end_of_line();
row_offset = c.column / m_columns - current_row_offset + 1 + m_cursor->column / m_columns;
}
break;
}
update_cursor_row(m_cursor_row + row_offset);
redraw();
}
}
void Window::update_cursor_row(int cursor_row)
{
m_cursor_row = std::max(m_scroll_offset, std::min(m_rows - m_scroll_offset - 1, cursor_row));
}
std::pair<int, PieceTable::Cursor> Window::calculate_start_position()
{
m_cursor_row = std::min(m_cursor_row, m_rows - 1);
int row = m_cursor_row - m_cursor->column / m_columns;
PieceTable::Cursor cursor = *m_cursor;
cursor.go_start_of_line();
while (row > 0)
{
if (cursor.go_up(1, 0u))
{
PieceTable::Cursor c = cursor;
c.go_end_of_line();
row -= c.column / m_columns + 1;
}
else
{
m_cursor_row -= row;
row = 0;
}
}
return std::pair<int, PieceTable::Cursor>(row, cursor);
}
void Window::draw_text()
{
auto start_position = calculate_start_position();
int row = start_position.first;
PieceTable::Cursor cursor = start_position.second;
for (;;)
{
int row_offset = cursor.column / m_columns;
int screen_row = row + row_offset;
if (screen_row >= m_rows)
break;
int screen_column = cursor.column % m_columns;
if (cursor == *m_cursor)
draw_cursor(screen_column, screen_row);
if (screen_row >= 0)
{
uint32_t character = *cursor;
if (character != 0xFFFFFFFFu)
draw_character(screen_column, screen_row, character);
}
if (!cursor.go_right(1))
{
if (!cursor.go_down(1, 0))
break;
row = screen_row + 1;
}
}
}
void Window::draw_character(int screen_column, int screen_row, uint32_t character)
{
m_shaders.text->use();
int advance = m_font.get_advance();
int line_height = m_font.get_line_height();
int x = screen_column * advance;
int y = m_height - (screen_row + 1) * line_height;
auto g = m_font.get_glyph(character);
m_shaders.text->set_position(x, y + m_font.get_baseline_offset());
g->render();
}
void Window::resize()
{
SDL_GetWindowSize(m_window, &m_width, &m_height);
glViewport(0, 0, m_width, m_height);
m_shaders.text->use();
m_shaders.text->set_viewport_size(m_width, m_height);
m_shaders.flat->use();
m_shaders.flat->set_viewport_size(m_width, m_height);
m_columns = m_width / m_font.get_advance();
if (m_columns < 1)
m_columns = 1;
m_rows = (m_height + m_font.get_line_height() - 1) / m_font.get_line_height();
}
void Window::redraw()
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
draw_text();
SDL_GL_SwapWindow(m_window);
}
void Window::draw_cursor(int screen_column, int screen_row)
{
int advance = m_font.get_advance();
int line_height = m_font.get_line_height();
int x = screen_column * advance;
int y = m_height - (screen_row + 1) * line_height;
m_cursor_array->bind();
m_shaders.flat->use();
m_shaders.flat->set_color(1.0, 0.2, 1.0, 1.0);
m_shaders.flat->set_position(x, y);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
Reference in New Issue View Git Blame Copy Permalink