krzosa/text_editor
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rewrite to IMGUI

Browse Source
This commit is contained in:
Krzosa Karol
2024-07-05 15:24:58 +02:00
parent e23a7b9c02
commit 0dd6289509
16 changed files with 969 additions and 3277 deletions
Download Patch File Download Diff File Expand all files Collapse all files

384
src/transcript_browser/_main.cpp Normal file
View File

@@ -0,0 +1,384 @@
#define BASIC_IMPL
#include "../basic/basic.h"
#include "../basic/filesystem.h"
#include "tests.h"
#include <thread>
#include <semaphore>
#include <mutex>
Arena Perm;
/*
TODO:
- New threading model idea: I could just spin up a bunch of threads and then don't kill them. Just use them for searching! Each one would have it's own xarena and so on.
- Improve scrolling
- Highlight selected line
- Improve the looks of the application
*/
struct TimeString {
uint16_t hour;
uint16_t minute;
uint16_t second;
String string;
};
Array<TimeString> ParseSrtFile(Arena *arena, String filename) {
String content = ReadFile(*arena, filename);
Array<String> lines = Split(*arena, content, "\n");
IterRemove(lines) {
IterRemovePrepare(lines);
it = Trim(it);
if (it.len == 0) remove_item = true;
}
long section_number = 1;
Array<TimeString> time_strings = {*arena};
for (int i = 0; i < lines.len;) {
String it0 = lines[i++];
long num = strtol(it0.data, NULL, 10);
Assert(section_number == num);
section_number += 1;
TimeString item = {};
String it1 = lines[i++];
item.hour = (uint16_t)strtol(it1.data, NULL, 10);
item.minute = (uint16_t)strtol(it1.data + 3, NULL, 10);
item.second = (uint16_t)strtol(it1.data + 6, NULL, 10);
String next_section_number = Format(*arena, "%d", section_number);
while (i < lines.len && lines[i] != next_section_number) {
String it = lines[i];
item.string = lines[i];
time_strings.add(item);
i += 1;
}
}
IterRemove(time_strings) {
IterRemovePrepare(time_strings);
if (i > 0 && AreEqual(time_strings[i - 1].string, time_strings[i].string, true)) {
remove_item = true;
}
}
return time_strings;
}
struct TimeFile {
Array<TimeString> time_strings;
String file;
};
struct ParseThreadIO {
Array<String> input_files;
// output
Arena *arena;
Array<TimeFile> time_files;
};
void ParseThreadEntry(ParseThreadIO *io) {
io->arena = AllocArena();
io->time_files.allocator = *io->arena;
For(io->input_files) {
Array<TimeString> time_strings = ParseSrtFile(io->arena, it);
io->time_files.add({time_strings, it});
}
}
struct XToTimeString {
String string; // String inside transcript arena
uint16_t hour;
uint16_t minute;
uint16_t second;
String filepath;
};
Arena XArena;
void AddFolder(String folder, Array<String> *filenames, Array<XToTimeString> *x_to_time_string) {
Scratch scratch;
Array<String> srt_files = {scratch};
for (FileIter iter = IterateFiles(scratch, folder); IsValid(iter); Advance(&iter)) {
String file = Copy(Perm, iter.absolute_path);
filenames->add(file);
if (EndsWith(iter.filename, ".srt")) {
srt_files.add(file);
}
}
int64_t thread_count = 16;
Array<std::thread *> threads = {scratch};
int64_t files_per_thread = srt_files.len / thread_count;
int64_t remainder = srt_files.len % thread_count;
int64_t fi = 0;
Array<ParseThreadIO> io = {scratch};
io.reserve(thread_count);
for (int ti = 0; ti < thread_count; ti += 1) {
Array<String> files = {scratch};
for (int i = 0; fi < srt_files.len && i < files_per_thread + remainder; fi += 1, i += 1) {
files.add(srt_files[fi]);
}
if (remainder) remainder = 0;
ParseThreadIO *i = io.alloc();
i->input_files = files;
threads.add(new std::thread(ParseThreadEntry, i));
}
For(threads) {
it->join();
delete it;
}
ForItem(it_io, io) {
ForItem(it_time_file, it_io.time_files) {
For(it_time_file.time_strings) {
String s = Copy(XArena, it.string);
s.data[s.len] = ' ';
x_to_time_string->add({s, it.hour, it.minute, it.second, it_time_file.file});
}
}
Release(it_io.arena);
}
}
//
// Searching thread
//
Arena MatchesArena;
Array<String> Matches = {MatchesArena};
XToTimeString *ItemFound;
Array<char> Prompt; // system allocated
std::mutex SearchThreadArrayMutex;
std::binary_semaphore SearchThreadSemaphore{0};
bool SearchThreadStopSearching = false;
bool SearchThreadRunning = true;
void SearchThreadEntry() {
InitArena(&MatchesArena);
for (;;) {
SearchThreadSemaphore.acquire();
if (!SearchThreadRunning) break;
SearchThreadStopSearching = false;
if (Prompt.len) {
SearchThreadArrayMutex.lock();
{
Matches.clear();
}
SearchThreadArrayMutex.unlock();
String buffer = {(char *)XArena.data, (int64_t)XArena.len};
String find = {Prompt.data, Prompt.len};
int64_t index = 0;
while (Seek(buffer, find, &index, SeekFlag_IgnoreCase)) {
String found = {buffer.data + index, find.len};
SearchThreadArrayMutex.lock();
{
Matches.add(found);
}
SearchThreadArrayMutex.unlock();
if (SearchThreadStopSearching) break;
buffer = buffer.skip(index + find.len);
}
}
}
}
void SearchThreadClose(std::thread &thread) {
SearchThreadRunning = false;
SearchThreadSemaphore.release();
thread.join();
}
int main() {
InitOS();
InitScratch();
InitArena(&Perm);
InitArena(&XArena);
Arena *frame_arena = AllocArena();
XArena.align = 0;
String start_string = "read=D:/zizek";
For(start_string) Prompt.add(it);
std::thread search_thread(SearchThreadEntry);
int64_t chosen_text = 0;
int64_t match_search_offset = 0;
Array<String> filenames = {};
Array<XToTimeString> x_to_time_string = {};
InitWindow(1920, 1080, "Transcript Browser");
SetWindowState(FLAG_WINDOW_RESIZABLE);
SetTargetFPS(60);
Font font = LoadFontEx("C:/Windows/Fonts/consola.ttf", 20, 0, 250);
while (!WindowShouldClose()) {
Clear(frame_arena);
for (int key = GetCharPressed(); key; key = GetCharPressed()) {
UTF8Result utf8 = UTF32ToUTF8(key);
if (utf8.error) {
Prompt.add('?');
continue;
}
for (int i = 0; i < utf8.len; i += 1) {
Prompt.add(utf8.out_str[i]);
match_search_offset = 0;
SearchThreadStopSearching = true;
SearchThreadSemaphore.release();
}
}
if (IsKeyPressed(KEY_BACKSPACE) || IsKeyPressedRepeat(KEY_BACKSPACE)) {
if (ItemFound) {
ItemFound = NULL;
} else if (Prompt.len > 0) {
Prompt.pop();
match_search_offset = 0;
SearchThreadStopSearching = true;
SearchThreadSemaphore.release();
}
}
int64_t offset_size = 1;
if (IsKeyDown(KEY_LEFT_CONTROL)) {
offset_size = 10;
}
if (IsKeyPressed(KEY_DOWN) || IsKeyPressedRepeat(KEY_DOWN)) {
chosen_text += offset_size;
if (chosen_text > 10) match_search_offset += offset_size;
}
if (IsKeyPressed(KEY_UP) || IsKeyPressedRepeat(KEY_UP)) {
chosen_text -= offset_size;
match_search_offset -= offset_size;
}
chosen_text = Clamp(chosen_text, (int64_t)0, Max(Matches.len - 1, (int64_t)0));
match_search_offset = Clamp(match_search_offset, (int64_t)0, Max(Matches.len - 1 - 10, (int64_t)0));
if (IsKeyPressed(KEY_ENTER)) {
String prompt = {Prompt.data, Prompt.len};
if (StartsWith(prompt, "read=")) {
Prompt.add('\0');
AddFolder(prompt.skip(5), &filenames, &x_to_time_string);
Prompt.clear();
} else if (ItemFound) {
String base = ChopLastPeriod(ItemFound->filepath); // .srt
base = ChopLastPeriod(base); // .en
For(filenames) {
if (StartsWith(it, base)) {
if (EndsWith(it, ".mkv") || EndsWith(it, ".webm") || EndsWith(it, ".mp4")) {
int seconds = ItemFound->hour * 60 * 60 + ItemFound->minute * 60 + ItemFound->second;
String copy = Copy(*frame_arena, it);
for (int i = 0; i < copy.len; i += 1)
if (copy.data[i] == '/') copy.data[i] = '\\';
String args = Format(*frame_arena, "C:\\Program Files\\VideoLAN\\VLC\\vlc.exe --start-time %d \"%.*s\"", seconds, FmtString(copy));
printf("%.*s\n", FmtString(args));
RunEx(args);
}
}
}
} else if (Matches.len) {
String string = Matches[chosen_text];
For(x_to_time_string) {
uintptr_t begin = (uintptr_t)(it.string.data);
uintptr_t end = (uintptr_t)(it.string.data + it.string.len);
uintptr_t needle = (uintptr_t)string.data;
if (needle >= begin && needle < end) {
ItemFound = &it;
break;
}
}
}
}
BeginDrawing();
ClearBackground(RAYWHITE);
float font_size = 20;
float y = 0;
int xwidth = (int)MeasureTextEx(font, "_", font_size, 1).x;
if (ItemFound) {
uintptr_t begin_region = (uintptr_t)XArena.data;
uintptr_t end_region = (uintptr_t)XArena.data + XArena.len;
uintptr_t begin = (uintptr_t)(ItemFound->string.data - 1000);
uintptr_t end = (uintptr_t)(ItemFound->string.data + 1000);
begin = Clamp(begin, begin_region, end_region);
end = Clamp(end, begin_region, end_region);
String string = {(char *)begin, (int64_t)(end - begin)};
String filename = SkipToLastSlash(ItemFound->filepath);
DrawTextEx(font, filename.data, {0, y}, font_size, 1, BLACK);
y += font_size;
int per_line = (GetRenderWidth() / xwidth) - 20;
for (String it = string; it.len;) {
String line = it.get_prefix(per_line);
if (ItemFound->string.data >= line.data && ItemFound->string.data < line.data + line.len) {
DrawRectangleLines(0, (int)(y + font_size), GetRenderWidth(), 2, SKYBLUE);
}
String line_terminated = Copy(*frame_arena, line);
DrawTextEx(font, line_terminated.data, {0, y}, font_size, 1, DARKGRAY);
y += font_size;
it = it.skip(per_line);
}
} else {
Prompt.add('\0');
DrawTextEx(font, "> ", {0, y}, font_size, 1, BLACK);
DrawTextEx(font, Prompt.data, {(float)xwidth * 3, y}, font_size, 1, BLACK);
Prompt.pop();
y += font_size;
int64_t chars_per_line = GetRenderWidth() / xwidth - Prompt.len;
SearchThreadArrayMutex.lock();
for (int64_t i = match_search_offset; i < Matches.len; i += 1) {
String it = Matches[i];
uintptr_t begin_region = (uintptr_t)XArena.data;
uintptr_t end_region = (uintptr_t)XArena.data + XArena.len;
uintptr_t begin = (uintptr_t)(it.data - chars_per_line / 2);
uintptr_t end = (uintptr_t)(it.data + chars_per_line / 2);
begin = Clamp(begin, begin_region, end_region);
end = Clamp(end, begin_region, end_region);
String string = Copy(*frame_arena, {(char *)begin, (int64_t)(end - begin)});
String string_first = Copy(*frame_arena, {(char *)begin, (int64_t)(it.data - begin)});
String string_middle = Copy(*frame_arena, it);
int width = (int)MeasureTextEx(font, string_first.data, font_size, 1).x;
if (chosen_text == i) DrawRectangleLines(0, (int)(y + font_size), GetRenderWidth(), 2, SKYBLUE);
String num = Format(*frame_arena, "%d", i);
DrawTextEx(font, num.data, {0, y}, font_size, 1, DARKGRAY);
DrawTextEx(font, string.data, {(float)xwidth * 4, y}, font_size, 1, DARKGRAY);
DrawTextEx(font, string_middle.data, {(float)xwidth * 4 + (float)width, y}, font_size, 1, SKYBLUE);
y += font_size;
if (y > GetRenderHeight()) break;
}
SearchThreadArrayMutex.unlock();
}
if (IsKeyDown(KEY_F1)) DrawFPS(0, 0);
EndDrawing();
}
CloseWindow();
SearchThreadClose(search_thread);
}

886
src/transcript_browser/main.cpp
View File

@@ -1,385 +1,501 @@
#define BASIC_IMPL
#include "../pdf_browser/basic.h"
#include "filesystem.h"
#include "tests.h"
#include "raylib.h"
#include <thread>
#include <semaphore>
#include <mutex>
Arena Perm;
/*
TODO:
- New threading model idea: I could just spin up a bunch of threads and then don't kill them. Just use them for searching! Each one would have it's own xarena and so on.
- Improve scrolling
- Highlight selected line
- Improve the looks of the application
*/
struct TimeString {
uint16_t hour;
uint16_t minute;
uint16_t second;
String string;
};
Array<TimeString> ParseSrtFile(Arena *arena, String filename) {
String content = ReadFile(*arena, filename);
Array<String> lines = Split(*arena, content, "\n");
IterRemove(lines) {
IterRemovePrepare(lines);
it = Trim(it);
if (it.len == 0) remove_item = true;
}
long section_number = 1;
Array<TimeString> time_strings = {*arena};
for (int i = 0; i < lines.len;) {
String it0 = lines[i++];
long num = strtol(it0.data, NULL, 10);
Assert(section_number == num);
section_number += 1;
TimeString item = {};
String it1 = lines[i++];
item.hour = (uint16_t)strtol(it1.data, NULL, 10);
item.minute = (uint16_t)strtol(it1.data + 3, NULL, 10);
item.second = (uint16_t)strtol(it1.data + 6, NULL, 10);
String next_section_number = Format(*arena, "%d", section_number);
while (i < lines.len && lines[i] != next_section_number) {
String it = lines[i];
item.string = lines[i];
time_strings.add(item);
i += 1;
}
}
IterRemove(time_strings) {
IterRemovePrepare(time_strings);
if (i > 0 && AreEqual(time_strings[i - 1].string, time_strings[i].string, true)) {
remove_item = true;
}
}
return time_strings;
}
struct TimeFile {
Array<TimeString> time_strings;
String file;
};
struct ParseThreadIO {
Array<String> input_files;
// output
Arena *arena;
Array<TimeFile> time_files;
};
void ParseThreadEntry(ParseThreadIO *io) {
io->arena = AllocArena();
io->time_files.allocator = *io->arena;
For(io->input_files) {
Array<TimeString> time_strings = ParseSrtFile(io->arena, it);
io->time_files.add({time_strings, it});
}
}
struct XToTimeString {
String string; // String inside transcript arena
uint16_t hour;
uint16_t minute;
uint16_t second;
String filepath;
};
Arena XArena;
void AddFolder(String folder, Array<String> *filenames, Array<XToTimeString> *x_to_time_string) {
Scratch scratch;
Array<String> srt_files = {scratch};
for (FileIter iter = IterateFiles(scratch, folder); IsValid(iter); Advance(&iter)) {
String file = Copy(Perm, iter.absolute_path);
filenames->add(file);
if (EndsWith(iter.filename, ".srt")) {
srt_files.add(file);
}
}
int64_t thread_count = 16;
Array<std::thread *> threads = {scratch};
int64_t files_per_thread = srt_files.len / thread_count;
int64_t remainder = srt_files.len % thread_count;
int64_t fi = 0;
Array<ParseThreadIO> io = {scratch};
io.reserve(thread_count);
for (int ti = 0; ti < thread_count; ti += 1) {
Array<String> files = {scratch};
for (int i = 0; fi < srt_files.len && i < files_per_thread + remainder; fi += 1, i += 1) {
files.add(srt_files[fi]);
}
if (remainder) remainder = 0;
ParseThreadIO *i = io.alloc();
i->input_files = files;
threads.add(new std::thread(ParseThreadEntry, i));
}
For(threads) {
it->join();
delete it;
}
ForItem(it_io, io) {
ForItem(it_time_file, it_io.time_files) {
For(it_time_file.time_strings) {
String s = Copy(XArena, it.string);
s.data[s.len] = ' ';
x_to_time_string->add({s, it.hour, it.minute, it.second, it_time_file.file});
}
}
Release(it_io.arena);
}
}
//
// Searching thread
//
Arena MatchesArena;
Array<String> Matches = {MatchesArena};
XToTimeString *ItemFound;
Array<char> Prompt; // system allocated
std::mutex SearchThreadArrayMutex;
std::binary_semaphore SearchThreadSemaphore{0};
bool SearchThreadStopSearching = false;
bool SearchThreadRunning = true;
void SearchThreadEntry() {
InitArena(&MatchesArena);
for (;;) {
SearchThreadSemaphore.acquire();
if (!SearchThreadRunning) break;
SearchThreadStopSearching = false;
if (Prompt.len) {
SearchThreadArrayMutex.lock();
{
Matches.clear();
}
SearchThreadArrayMutex.unlock();
String buffer = {(char *)XArena.data, (int64_t)XArena.len};
String find = {Prompt.data, Prompt.len};
int64_t index = 0;
while (Seek(buffer, find, &index, SeekFlag_IgnoreCase)) {
String found = {buffer.data + index, find.len};
SearchThreadArrayMutex.lock();
{
Matches.add(found);
}
SearchThreadArrayMutex.unlock();
if (SearchThreadStopSearching) break;
buffer = buffer.skip(index + find.len);
}
}
}
}
void SearchThreadClose(std::thread &thread) {
SearchThreadRunning = false;
SearchThreadSemaphore.release();
thread.join();
}
int main() {
InitOS();
InitScratch();
InitArena(&Perm);
InitArena(&XArena);
Arena *frame_arena = AllocArena();
XArena.align = 0;
String start_string = "read=D:/zizek";
For(start_string) Prompt.add(it);
std::thread search_thread(SearchThreadEntry);
int64_t chosen_text = 0;
int64_t match_search_offset = 0;
Array<String> filenames = {};
Array<XToTimeString> x_to_time_string = {};
InitWindow(1920, 1080, "Transcript Browser");
SetWindowState(FLAG_WINDOW_RESIZABLE);
SetTargetFPS(60);
Font font = LoadFontEx("C:/Windows/Fonts/consola.ttf", 20, 0, 250);
while (!WindowShouldClose()) {
Clear(frame_arena);
for (int key = GetCharPressed(); key; key = GetCharPressed()) {
UTF8Result utf8 = UTF32ToUTF8(key);
if (utf8.error) {
Prompt.add('?');
continue;
}
for (int i = 0; i < utf8.len; i += 1) {
Prompt.add(utf8.out_str[i]);
match_search_offset = 0;
SearchThreadStopSearching = true;
SearchThreadSemaphore.release();
}
}
if (IsKeyPressed(KEY_BACKSPACE) || IsKeyPressedRepeat(KEY_BACKSPACE)) {
if (ItemFound) {
ItemFound = NULL;
} else if (Prompt.len > 0) {
Prompt.pop();
match_search_offset = 0;
SearchThreadStopSearching = true;
SearchThreadSemaphore.release();
}
}
int64_t offset_size = 1;
if (IsKeyDown(KEY_LEFT_CONTROL)) {
offset_size = 10;
}
if (IsKeyPressed(KEY_DOWN) || IsKeyPressedRepeat(KEY_DOWN)) {
chosen_text += offset_size;
if (chosen_text > 10) match_search_offset += offset_size;
}
if (IsKeyPressed(KEY_UP) || IsKeyPressedRepeat(KEY_UP)) {
chosen_text -= offset_size;
match_search_offset -= offset_size;
}
chosen_text = Clamp(chosen_text, (int64_t)0, Max(Matches.len - 1, (int64_t)0));
match_search_offset = Clamp(match_search_offset, (int64_t)0, Max(Matches.len - 1 - 10, (int64_t)0));
if (IsKeyPressed(KEY_ENTER)) {
String prompt = {Prompt.data, Prompt.len};
if (StartsWith(prompt, "read=")) {
Prompt.add('\0');
AddFolder(prompt.skip(5), &filenames, &x_to_time_string);
Prompt.clear();
} else if (ItemFound) {
String base = ChopLastPeriod(ItemFound->filepath); // .srt
base = ChopLastPeriod(base); // .en
For(filenames) {
if (StartsWith(it, base)) {
if (EndsWith(it, ".mkv") || EndsWith(it, ".webm") || EndsWith(it, ".mp4")) {
int seconds = ItemFound->hour * 60 * 60 + ItemFound->minute * 60 + ItemFound->second;
String copy = Copy(*frame_arena, it);
for (int i = 0; i < copy.len; i += 1)
if (copy.data[i] == '/') copy.data[i] = '\\';
String args = Format(*frame_arena, "C:\\Program Files\\VideoLAN\\VLC\\vlc.exe --start-time %d \"%.*s\"", seconds, FmtString(copy));
printf("%.*s\n", FmtString(args));
RunEx(args);
}
}
}
} else if (Matches.len) {
String string = Matches[chosen_text];
For(x_to_time_string) {
uintptr_t begin = (uintptr_t)(it.string.data);
uintptr_t end = (uintptr_t)(it.string.data + it.string.len);
uintptr_t needle = (uintptr_t)string.data;
if (needle >= begin && needle < end) {
ItemFound = &it;
break;
}
}
}
}
BeginDrawing();
ClearBackground(RAYWHITE);
float font_size = 20;
float y = 0;
int xwidth = (int)MeasureTextEx(font, "_", font_size, 1).x;
if (ItemFound) {
uintptr_t begin_region = (uintptr_t)XArena.data;
uintptr_t end_region = (uintptr_t)XArena.data + XArena.len;
uintptr_t begin = (uintptr_t)(ItemFound->string.data - 1000);
uintptr_t end = (uintptr_t)(ItemFound->string.data + 1000);
begin = Clamp(begin, begin_region, end_region);
end = Clamp(end, begin_region, end_region);
String string = {(char *)begin, (int64_t)(end - begin)};
String filename = SkipToLastSlash(ItemFound->filepath);
DrawTextEx(font, filename.data, {0, y}, font_size, 1, BLACK);
y += font_size;
int per_line = (GetRenderWidth() / xwidth) - 20;
for (String it = string; it.len;) {
String line = it.get_prefix(per_line);
if (ItemFound->string.data >= line.data && ItemFound->string.data < line.data + line.len) {
DrawRectangleLines(0, (int)(y + font_size), GetRenderWidth(), 2, SKYBLUE);
}
String line_terminated = Copy(*frame_arena, line);
DrawTextEx(font, line_terminated.data, {0, y}, font_size, 1, DARKGRAY);
y += font_size;
it = it.skip(per_line);
}
} else {
Prompt.add('\0');
DrawTextEx(font, "> ", {0, y}, font_size, 1, BLACK);
DrawTextEx(font, Prompt.data, {(float)xwidth * 3, y}, font_size, 1, BLACK);
Prompt.pop();
y += font_size;
int64_t chars_per_line = GetRenderWidth() / xwidth - Prompt.len;
SearchThreadArrayMutex.lock();
for (int64_t i = match_search_offset; i < Matches.len; i += 1) {
String it = Matches[i];
uintptr_t begin_region = (uintptr_t)XArena.data;
uintptr_t end_region = (uintptr_t)XArena.data + XArena.len;
uintptr_t begin = (uintptr_t)(it.data - chars_per_line / 2);
uintptr_t end = (uintptr_t)(it.data + chars_per_line / 2);
begin = Clamp(begin, begin_region, end_region);
end = Clamp(end, begin_region, end_region);
String string = Copy(*frame_arena, {(char *)begin, (int64_t)(end - begin)});
String string_first = Copy(*frame_arena, {(char *)begin, (int64_t)(it.data - begin)});
String string_middle = Copy(*frame_arena, it);
int width = (int)MeasureTextEx(font, string_first.data, font_size, 1).x;
if (chosen_text == i) DrawRectangleLines(0, (int)(y + font_size), GetRenderWidth(), 2, SKYBLUE);
String num = Format(*frame_arena, "%d", i);
DrawTextEx(font, num.data, {0, y}, font_size, 1, DARKGRAY);
DrawTextEx(font, string.data, {(float)xwidth * 4, y}, font_size, 1, DARKGRAY);
DrawTextEx(font, string_middle.data, {(float)xwidth * 4 + (float)width, y}, font_size, 1, SKYBLUE);
y += font_size;
if (y > GetRenderHeight()) break;
}
SearchThreadArrayMutex.unlock();
}
if (IsKeyDown(KEY_F1)) DrawFPS(0, 0);
EndDrawing();
}
CloseWindow();
SearchThreadClose(search_thread);
}
#define BASIC_IMPL
#include "../basic/basic.h"
#include "../basic/filesystem.h"
#include <thread>
#include <semaphore>
#include <mutex>
#include <stdio.h>
#include "imgui.h"
#include "imgui_impl_sdl2.h"
#include "imgui_impl_opengl3.h"
#include <SDL.h>
#include <SDL_opengl.h>
Arena Perm;
/*
TODO:
- New threading model idea: I could just spin up a bunch of threads and then don't kill them. Just use them for searching! Each one would have it's own xarena and so on.
- Improve scrolling
- Highlight selected line
- Improve the looks of the application
*/
struct TimeString {
uint16_t hour;
uint16_t minute;
uint16_t second;
String string;
};
Array<TimeString> ParseSrtFile(Arena *arena, String filename) {
String content = ReadFile(*arena, filename);
Array<String> lines = Split(*arena, content, "\n");
IterRemove(lines) {
IterRemovePrepare(lines);
it = Trim(it);
if (it.len == 0) remove_item = true;
}
long section_number = 1;
Array<TimeString> time_strings = {*arena};
for (int i = 0; i < lines.len;) {
String it0 = lines[i++];
long num = strtol(it0.data, NULL, 10);
Assert(section_number == num);
section_number += 1;
TimeString item = {};
String it1 = lines[i++];
item.hour = (uint16_t)strtol(it1.data, NULL, 10);
item.minute = (uint16_t)strtol(it1.data + 3, NULL, 10);
item.second = (uint16_t)strtol(it1.data + 6, NULL, 10);
String next_section_number = Format(*arena, "%d", section_number);
while (i < lines.len && lines[i] != next_section_number) {
String it = lines[i];
item.string = lines[i];
time_strings.add(item);
i += 1;
}
}
IterRemove(time_strings) {
IterRemovePrepare(time_strings);
if (i > 0 && AreEqual(time_strings[i - 1].string, time_strings[i].string, true)) {
remove_item = true;
}
}
return time_strings;
}
struct TimeFile {
Array<TimeString> time_strings;
String file;
};
struct ParseThreadIO {
Array<String> input_files;
// output
Arena *arena;
Array<TimeFile> time_files;
};
void ParseThreadEntry(ParseThreadIO *io) {
io->arena = AllocArena();
io->time_files.allocator = *io->arena;
For(io->input_files) {
Array<TimeString> time_strings = ParseSrtFile(io->arena, it);
io->time_files.add({time_strings, it});
}
}
struct XToTimeString {
String string; // String inside transcript arena
uint16_t hour;
uint16_t minute;
uint16_t second;
String filepath;
};
Arena XArena;
void AddFolder(String folder, Array<String> *filenames, Array<XToTimeString> *x_to_time_string) {
Scratch scratch;
Array<String> srt_files = {scratch};
for (FileIter iter = IterateFiles(scratch, folder); IsValid(iter); Advance(&iter)) {
String file = Copy(Perm, iter.absolute_path);
filenames->add(file);
if (EndsWith(iter.filename, ".srt")) {
srt_files.add(file);
}
}
int64_t thread_count = 16;
Array<std::thread *> threads = {scratch};
int64_t files_per_thread = srt_files.len / thread_count;
int64_t remainder = srt_files.len % thread_count;
int64_t fi = 0;
Array<ParseThreadIO> io = {scratch};
io.reserve(thread_count);
for (int ti = 0; ti < thread_count; ti += 1) {
Array<String> files = {scratch};
for (int i = 0; fi < srt_files.len && i < files_per_thread + remainder; fi += 1, i += 1) {
files.add(srt_files[fi]);
}
if (remainder) remainder = 0;
ParseThreadIO *i = io.alloc();
i->input_files = files;
threads.add(new std::thread(ParseThreadEntry, i));
}
For(threads) {
it->join();
delete it;
}
ForItem(it_io, io) {
ForItem(it_time_file, it_io.time_files) {
For(it_time_file.time_strings) {
String s = Copy(XArena, it.string);
s.data[s.len] = ' ';
x_to_time_string->add({s, it.hour, it.minute, it.second, it_time_file.file});
}
}
Release(it_io.arena);
}
}
//
// Searching thread
//
Arena MatchesArena;
Array<String> Matches = {MatchesArena};
XToTimeString *ItemFound;
char Prompt[256];
std::mutex SearchThreadArrayMutex;
std::binary_semaphore SearchThreadSemaphore{0};
bool SearchThreadStopSearching = false;
bool SearchThreadRunning = true;
void SearchThreadEntry() {
InitArena(&MatchesArena);
for (;;) {
SearchThreadSemaphore.acquire();
if (!SearchThreadRunning) break;
SearchThreadStopSearching = false;
if (Prompt[0]) {
SearchThreadArrayMutex.lock();
{
Matches.clear();
}
SearchThreadArrayMutex.unlock();
String buffer = {(char *)XArena.data, (int64_t)XArena.len};
String find = Prompt;
int64_t index = 0;
while (Seek(buffer, find, &index, SeekFlag_IgnoreCase)) {
String found = {buffer.data + index, find.len};
SearchThreadArrayMutex.lock();
{
Matches.add(found);
}
SearchThreadArrayMutex.unlock();
if (SearchThreadStopSearching) break;
buffer = buffer.skip(index + find.len);
}
}
}
}
void SearchThreadClose(std::thread &thread) {
SearchThreadRunning = false;
SearchThreadSemaphore.release();
thread.join();
}
XToTimeString *FindItem(Array<XToTimeString> &x_to_time_string, String string) {
For(x_to_time_string) {
uintptr_t begin = (uintptr_t)(it.string.data);
uintptr_t end = (uintptr_t)(it.string.data + it.string.len);
uintptr_t needle = (uintptr_t)string.data;
if (needle >= begin && needle < end) {
return &it;
}
}
return NULL;
}
int main(int, char **) {
InitOS();
InitScratch();
InitArena(&Perm);
InitArena(&XArena);
XArena.align = 0;
memcpy(Prompt, "read=D:/zizek", sizeof("read=D:/zizek"));
std::thread search_thread(SearchThreadEntry);
int64_t chosen_text = 0;
int64_t match_search_offset = 0;
Array<String> filenames = {};
Array<XToTimeString> x_to_time_string = {};
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_GAMECONTROLLER) != 0) {
printf("Error: %s\n", SDL_GetError());
return -1;
}
const char *glsl_version = "#version 150";
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, 0);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
SDL_SetHint(SDL_HINT_IME_SHOW_UI, "1");
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
SDL_WindowFlags window_flags = (SDL_WindowFlags)(SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);
SDL_Window *window = SDL_CreateWindow("Dear ImGui SDL2+OpenGL3 example", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1280, 720, window_flags);
if (window == nullptr) {
printf("Error: SDL_CreateWindow(): %s\n", SDL_GetError());
return -1;
}
SDL_GLContext gl_context = SDL_GL_CreateContext(window);
SDL_GL_MakeCurrent(window, gl_context);
SDL_GL_SetSwapInterval(1); // Enable vsync
// Setup Dear ImGui context
IMGUI_CHECKVERSION();
ImGui::CreateContext();
ImGuiIO &io = ImGui::GetIO();
(void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
// Setup Dear ImGui style
// ImGui::StyleColorsDark();
ImGui::StyleColorsLight();
// Setup Platform/Renderer backends
ImGui_ImplSDL2_InitForOpenGL(window, gl_context);
ImGui_ImplOpenGL3_Init(glsl_version);
io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\segoeui.ttf", 18.0f);
// Our state
bool show_demo_window = true;
bool show_another_window = false;
ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);
bool enter_down = false;
int64_t frame = -1;
// Main loop
bool done = false;
while (!done) {
Scratch frame_arena;
frame += 1;
bool enter_press = false;
SDL_Event event;
while (SDL_PollEvent(&event)) {
ImGui_ImplSDL2_ProcessEvent(&event);
if (event.type == SDL_KEYDOWN) {
if (event.key.keysym.sym == SDLK_RETURN) {
if (enter_down == false) enter_press = true;
enter_down = true;
}
} else if (event.type == SDL_KEYUP) {
if (event.key.keysym.sym == SDLK_RETURN) {
enter_down = false;
}
}
if (event.type == SDL_QUIT)
done = true;
if (event.type == SDL_WINDOWEVENT && event.window.event == SDL_WINDOWEVENT_CLOSE && event.window.windowID == SDL_GetWindowID(window))
done = true;
}
// Start the Dear ImGui frame
ImGui_ImplOpenGL3_NewFrame();
ImGui_ImplSDL2_NewFrame();
ImGui::NewFrame();
#if 1
{
ImGuiWindowFlags window_flags = 0;
window_flags |= ImGuiWindowFlags_NoTitleBar;
window_flags |= ImGuiWindowFlags_NoScrollbar;
window_flags |= ImGuiWindowFlags_NoMove;
window_flags |= ImGuiWindowFlags_NoResize;
window_flags |= ImGuiWindowFlags_NoCollapse;
const ImGuiViewport *main_viewport = ImGui::GetMainViewport();
ImGui::SetNextWindowPos(ImVec2(0, 0), ImGuiCond_Always);
ImGui::SetNextWindowSize(ImVec2(main_viewport->Size.x, 20), ImGuiCond_Always);
ImGui::Begin("input", NULL, window_flags);
if (frame < 4) ImGui::SetKeyboardFocusHere(0);
if (ImGui::InputText("Input your query", Prompt, sizeof(Prompt))) {
match_search_offset = 0;
SearchThreadStopSearching = true;
SearchThreadSemaphore.release();
}
ImGui::End();
if (enter_press) {
String prompt = Prompt;
if (StartsWith(prompt, "read=")) {
AddFolder(prompt.skip(5), &filenames, &x_to_time_string);
memset(Prompt, 0, sizeof(Prompt));
}
}
}
{
ImGuiWindowFlags window_flags = 0;
window_flags |= ImGuiWindowFlags_NoTitleBar;
window_flags |= ImGuiWindowFlags_NoMove;
window_flags |= ImGuiWindowFlags_NoResize;
window_flags |= ImGuiWindowFlags_NoCollapse;
const ImGuiViewport *main_viewport = ImGui::GetMainViewport();
ImGui::SetNextWindowPos(ImVec2(0, 30), ImGuiCond_Always);
ImGui::SetNextWindowSize(ImVec2(main_viewport->Size.x, main_viewport->Size.y - 30), ImGuiCond_Always);
ImGui::Begin("result", NULL, window_flags);
SearchThreadArrayMutex.lock();
float font_size = ImGui::GetFontSize();
ImFont *font = ImGui::GetFont();
int64_t chars_per_line = (int64_t)main_viewport->WorkSize.x / (int64_t)font->GetCharAdvance('_') - strlen(Prompt) * 2;
// int64_t chars_per_line = 200;
ImGuiListClipper clipper;
clipper.Begin((int)Matches.len);
while (clipper.Step()) {
for (int i = clipper.DisplayStart; i < clipper.DisplayEnd; i++) {
// for (int64_t i = 0; i < Matches.len; i += 1) {
auto &it = Matches[i];
uintptr_t begin_region = (uintptr_t)XArena.data;
uintptr_t end_region = (uintptr_t)XArena.data + XArena.len;
uint64_t begin = (uintptr_t)(it.data - chars_per_line / 2);
uint64_t end = (uintptr_t)(it.data + it.len + chars_per_line / 2);
uint64_t a = Clamp(begin, begin_region, end_region);
uint64_t b = Clamp((uintptr_t)it.data, begin_region, end_region);
String left = {(char *)a, (int64_t)(b - a)};
uint64_t c = Clamp((uintptr_t)(it.data + it.len), begin_region, end_region);
uint64_t d = Clamp(end, begin_region, end_region);
String right = {(char *)c, (int64_t)(d - c)};
String middle = it;
String string = Format(frame_arena, "%.*s**%.*s**%.*s##%d",
FmtString(left), FmtString(middle), FmtString(right), (int)i);
if (ImGui::CollapsingHeader(string.data)) {
uintptr_t begin_region = (uintptr_t)XArena.data;
uintptr_t end_region = (uintptr_t)XArena.data + XArena.len;
uintptr_t begin = (uintptr_t)(it.data - 1000);
uintptr_t end = (uintptr_t)(it.data + 1000);
uint64_t a = Clamp(begin, begin_region, end_region);
uint64_t b = Clamp((uintptr_t)it.data, begin_region, end_region);
String left = {(char *)a, (int64_t)(b - a)};
uint64_t c = Clamp((uintptr_t)(it.data + it.len), begin_region, end_region);
uint64_t d = Clamp(end, begin_region, end_region);
String right = {(char *)c, (int64_t)(d - c)};
String middle = it;
String string = Format(frame_arena, "%.*s***************%.*s***************%.*s",
FmtString(left), FmtString(middle), FmtString(right));
XToTimeString *item = FindItem(x_to_time_string, middle);
if (ImGui::Button("Open")) {
String base = ChopLastPeriod(item->filepath); // .srt
base = ChopLastPeriod(base); // .en
For(filenames) {
if (StartsWith(it, base)) {
if (EndsWith(it, ".mkv") || EndsWith(it, ".webm") || EndsWith(it, ".mp4")) {
int seconds = item->hour * 60 * 60 + item->minute * 60 + item->second;
String copy = Copy(*frame_arena, it);
for (int i = 0; i < copy.len; i += 1)
if (copy.data[i] == '/') copy.data[i] = '\\';
String args = Format(*frame_arena, "C:\\Program Files\\VideoLAN\\VLC\\vlc.exe --start-time %d \"%.*s\"", seconds, FmtString(copy));
RunEx(args);
}
}
}
}
ImGui::SameLine();
ImGui::Text(item->filepath.data);
ImGui::TextWrapped(string.data);
}
}
}
SearchThreadArrayMutex.unlock();
ImGui::End();
}
#else
// 1. Show the big demo window (Most of the sample code is in ImGui::ShowDemoWindow()! You can browse its code to learn more about Dear ImGui!).
if (show_demo_window)
ImGui::ShowDemoWindow(&show_demo_window);
// 2. Show a simple window that we create ourselves. We use a Begin/End pair to create a named window.
{
static float f = 0.0f;
static int counter = 0;
ImGui::Begin("Hello, world!"); // Create a window called "Hello, world!" and append into it.
ImGui::Text("This is some useful text."); // Display some text (you can use a format strings too)
ImGui::Checkbox("Demo Window", &show_demo_window); // Edit bools storing our window open/close state
ImGui::Checkbox("Another Window", &show_another_window);
ImGui::SliderFloat("float", &f, 0.0f, 1.0f); // Edit 1 float using a slider from 0.0f to 1.0f
ImGui::ColorEdit3("clear color", (float *)&clear_color); // Edit 3 floats representing a color
if (ImGui::Button("Button")) // Buttons return true when clicked (most widgets return true when edited/activated)
counter++;
ImGui::SameLine();
ImGui::Text("counter = %d", counter);
ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / io.Framerate, io.Framerate);
ImGui::End();
}
// 3. Show another simple window.
if (show_another_window) {
ImGui::Begin("Another Window", &show_another_window); // Pass a pointer to our bool variable (the window will have a closing button that will clear the bool when clicked)
ImGui::Text("Hello from another window!");
if (ImGui::Button("Close Me"))
show_another_window = false;
ImGui::End();
}
#endif
// Rendering
ImGui::Render();
glViewport(0, 0, (int)io.DisplaySize.x, (int)io.DisplaySize.y);
glClearColor(clear_color.x * clear_color.w, clear_color.y * clear_color.w, clear_color.z * clear_color.w, clear_color.w);
glClear(GL_COLOR_BUFFER_BIT);
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
SDL_GL_SwapWindow(window);
}
SearchThreadClose(search_thread);
// Cleanup
ImGui_ImplOpenGL3_Shutdown();
ImGui_ImplSDL2_Shutdown();
ImGui::DestroyContext();
SDL_GL_DeleteContext(gl_context);
SDL_DestroyWindow(window);
SDL_Quit();
return 0;
}