ronald1985
/
notepad_squared
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: ronald1985:master
Branches Tags
ronald1985:master
ronald1985:open-files
ronald1985:logging
ronald1985:add-themes
..
compare: ronald1985:add-themes
Branches Tags
ronald1985:master
ronald1985:open-files
ronald1985:logging
ronald1985:add-themes

No commits in common. 'master' and 'add-themes' have entirely different histories.
master ... add-themes

9 changed files with 281 additions and 792 deletions
Show Stats

8
README.md
Unescape Escape View File

@ -15,21 +15,21 @@ Show whether a file has been saved or not - Done
Line wrapping that wraps on words when possible
Ensure that Home, End, Delete keys work - Done
Ensure that Home, End, Delete keys work
Add shortcuts
Add menu bar - should contain, file, edit and settings
Add menu bar (Right click menu)
Need to add a right click menu
Add support for opening files from the editor - drag and drop support and file dialog
Add support for opening files from the editor - drag and drop support?
Syntax highlighting
## Bugs
Holding a key (backspace or arrow keys) doesn't work as expected - Done
Holding a key (backspace or arrow keys) doesn't work as expected
## Screenshots

2
constants.odin
Unescape Escape View File

@ -8,7 +8,7 @@ DEFAULT_WINDOW_MINIMUM_WINDOW_HEIGHT :: 200
// FONT
DEFAULT_FONT :: "/usr/share/fonts/TTF/FiraCode-Regular.ttf"
DEFAULT_FONT_SIZE :: 18
DEFAULT_FONT_SIZE :: 11
// DELAYS
DEFAULT_DELAY :: 100 * time.Millisecond

55
file_dialog/file_dialog.odin
Unescape Escape View File

@ -1,55 +0,0 @@
package file_dialog
// Save file dialog function
show_save_file_dialog :: proc(
title: string = "Save File",
filters: []File_Filter = {},
default_filename: string = "",
default_directory: string = ""
) -> Result {
when ODIN_OS == .Windows {
return show_save_file_dialog_windows(title, filters, default_filename, default_directory)
} else when ODIN_OS == .Linux {
return show_save_file_dialog_linux(title, filters, default_filename, default_directory)
} else {
return {
success = false,
error_message = "Unsupported platform",
}
}
}
// Main cross-platform function
show_open_file_dialog :: proc(
title: string = "Open File",
filters: []File_Filter = {},
allow_multiple: bool = false
) -> Result {
when ODIN_OS == .Windows {
return show_open_file_dialog_windows(title, filters, allow_multiple)
} else when ODIN_OS == .Linux {
return show_open_file_dialog_linux(title, filters, allow_multiple)
} else {
return {
success = false,
error_message = "Unsupported platform",
}
}
}
// Convenience function to clean up results
destroy_result :: proc(result: ^Result) {
if result.file_path != "" {
delete(result.file_path)
}
if len(result.file_paths) > 0 {
for path in result.file_paths {
delete(path)
}
delete(result.file_paths)
}
if result.error_message != "" {
delete(result.error_message)
}
}

77
file_dialog/linux.odin
Unescape Escape View File

@ -1,77 +0,0 @@
#+build linux
#+feature dynamic-literals
package file_dialog
import "core:log"
import "core:strings"
import os2 "core:os/os2"
SAVE_FILE_COMMANDS :: [][]string{
{"yad", "--file", "--save"}
}
OPEN_SINGLE_FILE_COMMANDS :: [][]string{
{"yad", "--file"}
}
show_save_file_dialog_linux :: proc(title: string, filters: []File_Filter, default_filename: string = "", default_directory: string = "") -> (result: Result) {
result.success = false
process_desc: os2.Process_Desc
for command in SAVE_FILE_COMMANDS {
log.debug("attempting to use", command[0], "to get file path")
process_desc.command = command
state, stdout_bytes, stderr_bytes, err := os2.process_exec(process_desc, context.allocator)
if err == .Not_Exist {
log.debug("couldn't find", command[0])
continue
} else if err != nil {
log.error("error whilst getting filename: ", err)
return
}
stdout := string(stdout_bytes)
if len(stdout) == 0 do result.file_path = strings.clone("")
else if stdout[len(stdout)-1] == '\n' do result.file_path = strings.clone(stdout[:len(stdout)-1])
else do result.file_path = strings.clone(string(stdout))
result.success = true
}
return result
}
show_open_file_dialog_linux :: proc(
title: string,
filters: []File_Filter = {},
allow_multiple: bool = false
) -> (result: Result) {
result.success = false
process_desc: os2.Process_Desc
for command in OPEN_SINGLE_FILE_COMMANDS {
log.debug("attempting to use", command[0], "to get file path")
process_desc.command = command
state, stdout_bytes, stderr_bytes, err := os2.process_exec(process_desc, context.allocator)
if err == .Not_Exist {
log.debug("couldn't find", command[0])
continue
} else if err != nil {
log.error("error whilst getting filename: ", err)
return
}
stdout := string(stdout_bytes)
if len(stdout) == 0 do result.file_path = strings.clone("")
else if stdout[len(stdout)-1] == '\n' do result.file_path = strings.clone(stdout[:len(stdout)-1])
else do result.file_path = strings.clone(string(stdout))
result.success = true
}
return result
}

15
file_dialog/types.odin
Unescape Escape View File

@ -1,15 +0,0 @@
package file_dialog
// Cross-platform file dialog result
Result :: struct {
success: bool,
file_path: string, // For single selection (backward compatibility)
file_paths: []string, // For multiple selection
error_message: string,
}
// File filter for dialog
File_Filter :: struct {
name: string,
pattern: string,
}

267
file_dialog/windows.odin
Unescape Escape View File

@ -1,267 +0,0 @@
#+build windows
package file_dialog
import "core:strings"
import "core:c"
import "core:fmt"
foreign import comdlg32 "system:comdlg32.lib"
foreign import ole32 "system:ole32.lib"
foreign import shell32 "system:shell32.lib"
OPENFILENAME :: struct {
lStructSize: c.ulong,
hwndOwner: rawptr,
hInstance: rawptr,
lpstrFilter: cstring,
lpstrCustomFilter: cstring,
nMaxCustFilter: c.ulong,
nFilterIndex: c.ulong,
lpstrFile: cstring,
nMaxFile: c.ulong,
lpstrFileTitle: cstring,
nMaxFileTitle: c.ulong,
lpstrInitialDir: cstring,
lpstrTitle: cstring,
Flags: c.ulong,
nFileOffset: c.ushort,
nFileExtension: c.ushort,
lpstrDefExt: cstring,
lCustData: c.ulong_ptr,
lpfnHook: rawptr,
lpTemplateName: cstring,
pvReserved: rawptr,
dwReserved: c.ulong,
FlagsEx: c.ulong,
}
OFN_PATHMUSTEXIST :: 0x00000800
OFN_FILEMUSTEXIST :: 0x00001000
OFN_HIDEREADONLY :: 0x00000004
OFN_ALLOWMULTISELECT :: 0x00000200
@(default_calling_convention="stdcall")
foreign comdlg32 {
GetOpenFileNameA :: proc(lpofn: ^OPENFILENAME) -> c.int ---
GetSaveFileNameA :: proc(lpofn: ^OPENFILENAME) -> c.int ---
}
show_open_file_dialog_windows :: proc(title: string, filters: []File_Filter, allow_multiple: bool) -> File_Dialog_Result {
MAX_PATH :: 260
BUFFER_SIZE :: 32768 // Larger buffer for multiple files
file_buffer: [BUFFER_SIZE]c.char
// Build filter string (format: "Description\0*.ext\0Description2\0*.ext2\0\0")
filter_str := strings.builder_make()
defer strings.builder_destroy(&filter_str)
if len(filters) > 0 {
for filter in filters {
strings.write_string(&filter_str, filter.name)
strings.write_byte(&filter_str, 0)
strings.write_string(&filter_str, filter.pattern)
strings.write_byte(&filter_str, 0)
}
} else {
strings.write_string(&filter_str, "All Files")
strings.write_byte(&filter_str, 0)
strings.write_string(&filter_str, "*.*")
strings.write_byte(&filter_str, 0)
}
strings.write_byte(&filter_str, 0) // Double null terminator
filter_cstr := strings.clone_to_cstring(strings.to_string(filter_str))
defer delete(filter_cstr)
title_cstr := strings.clone_to_cstring(title)
defer delete(title_cstr)
flags := OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY
if allow_multiple {
flags |= OFN_ALLOWMULTISELECT
}
ofn := OPENFILENAME{
lStructSize = size_of(OPENFILENAME),
lpstrFile = &file_buffer[0],
nMaxFile = BUFFER_SIZE,
lpstrFilter = filter_cstr,
nFilterIndex = 1,
lpstrTitle = title_cstr,
Flags = flags,
}
if GetOpenFileNameA(&ofn) != 0 {
buffer_str := string(cstring(&file_buffer[0]))
if allow_multiple {
// Parse multiple files format: "directory\0file1\0file2\0\0"
parts := strings.split(buffer_str, "\x00")
defer delete(parts)
if len(parts) > 1 && parts[1] != "" {
// Multiple files selected
directory := parts[0]
file_paths := make([]string, len(parts) - 1)
for i := 1; i < len(parts); i+=1 {
if parts[i] != "" {
full_path := strings.concatenate({directory, "\\", parts[i]})
file_paths[i-1] = full_path
}
}
return {
success = true,
file_path = file_paths[0], // First file for compatibility
file_paths = file_paths,
}
} else {
// Single file selected (even with multiple selection enabled)
return {
success = true,
file_path = strings.clone(buffer_str),
file_paths = {strings.clone(buffer_str)},
}
}
} else {
// Single file selection
return {
success = true,
file_path = strings.clone(buffer_str),
file_paths = {strings.clone(buffer_str)},
}
}
}
return {
success = false,
error_message = "User cancelled or dialog failed",
}
}
show_save_file_dialog_macos :: proc(title: string, filters: []File_Filter, default_filename: string = "", default_directory: string = "") -> File_Dialog_Result {
panel := NSSavePanel_savePanel()
title_nsstr := NSStringFromCString(strings.clone_to_cstring(title))
NSSavePanel_setTitle(panel, title_nsstr)
// Set default filename if provided
if default_filename != "" {
filename_nsstr := NSStringFromCString(strings.clone_to_cstring(default_filename))
NSSavePanel_setNameFieldStringValue(panel, filename_nsstr)
}
// Set default directory if provided
if default_directory != "" {
dir_nsstr := NSStringFromCString(strings.clone_to_cstring(default_directory))
dir_url := NSURL_fileURLWithPath(dir_nsstr)
if dir_url != nil {
NSSavePanel_setDirectoryURL(panel, dir_url)
}
}
// Note: File filters in NSSavePanel require more complex setup
// This is a simplified version - full implementation would use UTType
response := NSSavePanel_runModal(panel)
if response == NSModalResponseOK {
url := NSSavePanel_URL(panel)
if url != nil {
path_nsstr := NSURL_path(url)
path_cstr := NSString_UTF8String(path_nsstr)
file_path := strings.clone(string(path_cstr))
return {
success = true,
file_path = file_path,
file_paths = {file_path},
}
}
}
return {
success = false,
error_message = "User cancelled or dialog failed",
}
}
show_save_file_dialog_windows :: proc(
title: string,
filters: []File_Filter,
default_filename: string = "",
default_directory: string = ""
) -> File_Dialog_Result {
MAX_PATH :: 260
file_buffer: [MAX_PATH]c.char
// Set default filename if provided
if default_filename != "" {
filename_cstr := strings.clone_to_cstring(default_filename)
defer delete(filename_cstr)
// Copy to buffer (ensure null termination)
filename_len := min(len(default_filename), MAX_PATH - 1)
for i in 0..<filename_len {
file_buffer[i] = c.char(default_filename[i])
}
file_buffer[filename_len] = 0
}
// Build filter string
filter_str := strings.builder_make()
defer strings.builder_destroy(&filter_str)
if len(filters) > 0 {
for filter in filters {
strings.write_string(&filter_str, filter.name)
strings.write_byte(&filter_str, 0)
strings.write_string(&filter_str, filter.pattern)
strings.write_byte(&filter_str, 0)
}
} else {
strings.write_string(&filter_str, "All Files")
strings.write_byte(&filter_str, 0)
strings.write_string(&filter_str, "*.*")
strings.write_byte(&filter_str, 0)
}
strings.write_byte(&filter_str, 0) // Double null terminator
filter_cstr := strings.clone_to_cstring(strings.to_string(filter_str))
defer delete(filter_cstr)
title_cstr := strings.clone_to_cstring(title)
defer delete(title_cstr)
// Default directory (optional)
dir_cstr: cstring = nil
if default_directory != "" {
dir_cstr = strings.clone_to_cstring(default_directory)
defer delete(dir_cstr)
}
ofn := OPENFILENAME{
lStructSize = size_of(OPENFILENAME),
lpstrFile = &file_buffer[0],
nMaxFile = MAX_PATH,
lpstrFilter = filter_cstr,
nFilterIndex = 1,
lpstrTitle = title_cstr,
lpstrInitialDir = dir_cstr,
Flags = OFN_PATHMUSTEXIST | OFN_HIDEREADONLY,
}
if GetSaveFileNameA(&ofn) != 0 {
return {
success = true,
file_path = strings.clone(string(cstring(&file_buffer[0]))),
file_paths = {strings.clone(string(cstring(&file_buffer[0])))},
}
}
return {
success = false,
error_message = "User cancelled or dialog failed",
}
}

402
main.odin
Unescape Escape View File

@ -2,16 +2,13 @@ package main
import "core:fmt"
import "core:log"
import "core:math"
import "core:os"
import "core:slice"
import "core:strings"
import "core:thread"
import "core:time"
import "core:math"
import rl "vendor:raylib"
import "file_dialog"
main :: proc() {
context.logger = log.create_console_logger(.Debug)
@ -19,6 +16,11 @@ main :: proc() {
args := os.args[1:]
if len(args) == 0 {
fmt.println("Usage: gui_cat <file1> [file2] [file3] ...")
return
}
config, ok := parse_config("config.ini")
if !ok {
log.fatal("failed to parse config file")
@ -27,7 +29,7 @@ main :: proc() {
// Initialize application
app := App{
files = make([dynamic]File_Buffer),
files = make([dynamic]FileBuffer),
fonts = make([dynamic]FontConfig),
active_tab = 0,
current_font_index = 0,
@ -53,16 +55,12 @@ main :: proc() {
load_fonts(&app)
// Load files from command line arguments
if len(args) > 1 {
for filename in args {
create_file_buffer(&app, filename)
}
} else {
create_file_buffer(&app)
load_file(&app, filename)
}
if len(app.files) == 0 {
log.error("no files could be loaded")
fmt.println("No files could be loaded")
rl.CloseWindow()
return
}
@ -75,15 +73,141 @@ main :: proc() {
// Main loop
for !rl.WindowShouldClose() {
rl.BeginDrawing()
rl.ClearBackground(app.config.colours.background)
update(&app)
draw(&app)
}
}
load_fonts :: proc(app: ^App) {
// TODO: Support loading multiple fonts
// TODO: Allow searching for a font based on it's name and search fc-list database
font := FontConfig{
font = rl.LoadFont(strings.clone_to_cstring(app.config.font)),
size = f32(app.config.font_size),
name = "Default",
}
append(&app.fonts, font)
app.line_height = app.fonts[app.current_font_index].size + 4
}
load_file :: proc(app: ^App, filename: string) {
data, ok := os.read_entire_file(filename)
if !ok {
fmt.printf("Failed to read file: %s\n", filename)
return
}
buffer := FileBuffer{
filename = strings.clone(filename),
content = string(data),
modified = false,
cursor_pos = 0,
scroll_y = 0,
selection = Selection{start = 0, end = 0, active = false},
}
append(&app.files, buffer)
}
get_wrapped_lines :: proc(content: string, font: ^FontConfig, max_width: f32) -> []WrappedLine {
lines := strings.split(content, "\n")
defer delete(lines)
wrapped_lines := make([dynamic]WrappedLine)
character_offset := 0
for line, line_index in lines {
if len(line) == 0 {
// Empty line
append(&wrapped_lines, WrappedLine{
text = "",
original_line = line_index,
character_offset = character_offset,
})
} else {
// Wrap long lines
current_pos := 0
for current_pos < len(line) {
// Find how many characters fit in the width
fit_characters := 0
current_width: f32 = 0
for file in app.files {
if app.thread_finished && thread.is_done(app.thread) {
thread.destroy(app.thread)
for i in current_pos..<len(line) {
character_width := rl.MeasureTextEx(font.font, strings.clone_to_cstring(fmt.tprint(rune(line[i]))), font.size, 1).x
if current_width + character_width > max_width && fit_characters > 0 {
break
}
current_width += character_width
fit_characters += 1
}
// If we couldn't fit even one character, force at least one
if fit_characters == 0 {
fit_characters = 1
}
// Extract the text that fits
end_pos := min(current_pos + fit_characters, len(line))
wrapped_text := line[current_pos:end_pos]
append(&wrapped_lines, WrappedLine{
text = wrapped_text,
original_line = line_index,
character_offset = character_offset + current_pos,
})
current_pos = end_pos
}
}
character_offset += len(line) + 1 // +1 for newline
}
return wrapped_lines[:]
}
get_character_at_position :: proc(app: ^App, mouse_pos: rl.Vector2) -> int {
if len(app.files) == 0 || app.active_tab >= len(app.files) do return 0
file := &app.files[app.active_tab]
font := &app.fonts[app.current_font_index]
content_area_x := 10 + app.line_number_width
content_area_y := app.text_area_y
content_width := f32(app.window_width - 20) - app.line_number_width - 10
if mouse_pos.x < content_area_x || mouse_pos.y < content_area_y do return 0
wrapped_lines := get_wrapped_lines(file.content, font, content_width)
defer delete(wrapped_lines)
y_pos := content_area_y - file.scroll_y + 5
for wrapped_line, i in wrapped_lines {
if mouse_pos.y >= y_pos && mouse_pos.y < y_pos + app.line_height {
// Found the line, now find the character
x_offset := mouse_pos.x - content_area_x - 5
if x_offset <= 0 {
return wrapped_line.character_offset
}
for j in 0..=len(wrapped_line.text) {
text_slice := wrapped_line.text[:j]
text_width := rl.MeasureTextEx(font.font, strings.clone_to_cstring(text_slice), font.size, 1).x
if x_offset <= text_width {
return wrapped_line.character_offset + j
}
}
return wrapped_line.character_offset + len(wrapped_line.text)
}
y_pos += app.line_height
}
return len(file.content)
}
update :: proc(app: ^App) {
// Handle window resize
if rl.IsWindowResized() {
app.window_width = rl.GetScreenWidth()
@ -102,7 +226,6 @@ main :: proc() {
}
}
if !app.file_dialog_open {
// Handle text selection with mouse
if len(app.files) > 0 && app.active_tab < len(app.files) {
current_file := &app.files[app.active_tab]
@ -110,7 +233,7 @@ main :: proc() {
if rl.IsMouseButtonPressed(.LEFT) {
if mouse_pos.y > app.text_area_y {
character_pos := get_character_at_position(&app, mouse_pos)
character_pos := get_character_at_position(app, mouse_pos)
current_file.cursor_pos = character_pos
current_file.selection.start = character_pos
current_file.selection.end = character_pos
@ -122,7 +245,7 @@ main :: proc() {
if app.is_dragging && rl.IsMouseButtonDown(.LEFT) {
if mouse_pos.y > app.text_area_y {
character_pos := get_character_at_position(&app, mouse_pos)
character_pos := get_character_at_position(app, mouse_pos)
current_file.cursor_pos = character_pos
if character_pos != app.mouse_drag_start {
current_file.selection.start = min(app.mouse_drag_start, character_pos)
@ -263,16 +386,13 @@ main :: proc() {
// Handle keyboard shortcuts
if rl.IsKeyDown(.LEFT_CONTROL) || rl.IsKeyDown(.RIGHT_CONTROL) {
if rl.IsKeyPressed(.S) {
app.thread = thread.create_and_start_with_poly_data2(&app, current_file, save_file)
}
if rl.IsKeyPressed(.O) {
app.thread = thread.create_and_start_with_poly_data(&app, open_file)
save_file(current_file)
}
if rl.IsKeyPressed(.A) {
select_all(current_file)
}
if rl.IsKeyPressed(.C) {
copy_selection(&app, current_file)
copy_selection(app, current_file)
}
if rl.IsKeyPressed(.V) {
paste_text(current_file, app.copied_text)
@ -294,193 +414,24 @@ main :: proc() {
}
}
}
}
}
draw :: proc(app: ^App) {
rl.BeginDrawing()
rl.ClearBackground(app.config.colours.background)
// Draw tabs
draw_tabs(&app)
draw_tabs(app)
// Draw active file content
if len(app.files) > 0 && app.active_tab < len(app.files) {
draw_file_content(&app, &app.files[app.active_tab])
draw_file_content(app, &app.files[app.active_tab])
}
// Draw status bar
draw_status_bar(&app)
draw_status_bar(app)
rl.EndDrawing()
}
}
load_fonts :: proc(app: ^App) {
// TODO: Support loading multiple fonts
// TODO: Allow searching for a font based on it's name and search fc-list database
font := FontConfig{
font = rl.LoadFont(strings.clone_to_cstring(app.config.font)),
size = f32(app.config.font_size),
name = "Default",
}
append(&app.fonts, font)
app.line_height = app.fonts[app.current_font_index].size + 4
}
create_file_buffer :: proc(app: ^App, filename: string = "") -> (ok: bool) {
ok = false
buffer: File_Buffer
if len(filename) == 0 {
buffer = File_Buffer{
filename = "",
content = "",
modified = false,
cursor_pos = 0,
scroll_y = 0,
selection = Selection{start = 0, end = 0, active = false},
}
} else {
data, ok := os.read_entire_file(filename)
if !ok {
fmt.printf("Failed to read file: %s\n", filename)
return
}
buffer = File_Buffer{
filename = strings.clone(filename),
content = string(data),
modified = false,
cursor_pos = 0,
scroll_y = 0,
selection = Selection{start = 0, end = 0, active = false},
}
}
append(&app.files, buffer)
ok = true
return
}
open_file :: proc(app: ^App) {
app.file_dialog_open = true
result: file_dialog.Result
result = file_dialog.show_open_file_dialog()
app.file_dialog_open = false
if !result.success {
log.error(result.error_message)
return
}
defer file_dialog.destroy_result(&result)
ok := create_file_buffer(app, result.file_path)
if !ok {
log.error("failed ot create file buffer")
return
}
app.active_tab+=1
return
}
get_wrapped_lines :: proc(content: string, font: ^FontConfig, max_width: f32) -> []WrappedLine {
lines := strings.split(content, "\n")
defer delete(lines)
wrapped_lines := make([dynamic]WrappedLine)
character_offset := 0
for line, line_index in lines {
if len(line) == 0 {
// Empty line
append(&wrapped_lines, WrappedLine{
text = "",
original_line = line_index,
character_offset = character_offset,
})
} else {
// Wrap long lines
current_pos := 0
for current_pos < len(line) {
// Find how many characters fit in the width
fit_characters := 0
current_width: f32 = 0
for i in current_pos..<len(line) {
character_width := rl.MeasureTextEx(font.font, strings.clone_to_cstring(fmt.tprint(rune(line[i]))), font.size, 1).x
if current_width + character_width > max_width && fit_characters > 0 {
break
}
current_width += character_width
fit_characters += 1
}
// If we couldn't fit even one character, force at least one
if fit_characters == 0 {
fit_characters = 1
}
// Extract the text that fits
end_pos := min(current_pos + fit_characters, len(line))
wrapped_text := line[current_pos:end_pos]
append(&wrapped_lines, WrappedLine{
text = wrapped_text,
original_line = line_index,
character_offset = character_offset + current_pos,
})
current_pos = end_pos
}
}
character_offset += len(line) + 1 // +1 for newline
}
return wrapped_lines[:]
}
get_character_at_position :: proc(app: ^App, mouse_pos: rl.Vector2) -> int {
if len(app.files) == 0 || app.active_tab >= len(app.files) do return 0
file := &app.files[app.active_tab]
font := &app.fonts[app.current_font_index]
content_area_x := 10 + app.line_number_width
content_area_y := app.text_area_y
content_width := f32(app.window_width - 20) - app.line_number_width - 10
if mouse_pos.x < content_area_x || mouse_pos.y < content_area_y do return 0
wrapped_lines := get_wrapped_lines(file.content, font, content_width)
defer delete(wrapped_lines)
y_pos := content_area_y - file.scroll_y + 5
for wrapped_line, i in wrapped_lines {
if mouse_pos.y >= y_pos && mouse_pos.y < y_pos + app.line_height {
// Found the line, now find the character
x_offset := mouse_pos.x - content_area_x - 5
if x_offset <= 0 {
return wrapped_line.character_offset
}
for j in 0..=len(wrapped_line.text) {
text_slice := wrapped_line.text[:j]
text_width := rl.MeasureTextEx(font.font, strings.clone_to_cstring(text_slice), font.size, 1).x
if x_offset <= text_width {
return wrapped_line.character_offset + j
}
}
return wrapped_line.character_offset + len(wrapped_line.text)
}
y_pos += app.line_height
}
return len(file.content)
}
draw :: proc(app: ^App) {
}
draw_tabs :: proc(app: ^App) {
@ -528,7 +479,7 @@ draw_tabs :: proc(app: ^App) {
}
}
draw_file_content :: proc(app: ^App, file: ^File_Buffer) {
draw_file_content :: proc(app: ^App, file: ^FileBuffer) {
font := &app.fonts[app.current_font_index]
// Content area (excluding line numbers)
@ -706,7 +657,7 @@ draw_status_bar :: proc(app: ^App) {
}
}
insert_character :: proc(file: ^File_Buffer, character: rune) {
insert_character :: proc(file: ^FileBuffer, character: rune) {
if file.cursor_pos <= len(file.content) {
before := file.content[:file.cursor_pos]
after := file.content[file.cursor_pos:]
@ -717,7 +668,7 @@ insert_character :: proc(file: ^File_Buffer, character: rune) {
}
}
delete_character :: proc(file: ^File_Buffer, delete_backwards: bool = false) {
delete_character :: proc(file: ^FileBuffer, delete_backwards: bool = false) {
if file.cursor_pos > 0 && !delete_backwards {
before := file.content[:file.cursor_pos-1]
after := file.content[file.cursor_pos:]
@ -734,7 +685,7 @@ delete_character :: proc(file: ^File_Buffer, delete_backwards: bool = false) {
}
}
delete_selection :: proc(file: ^File_Buffer) {
delete_selection :: proc(file: ^FileBuffer) {
if !file.selection.active do return
start := min(file.selection.start, file.selection.end)
@ -748,20 +699,20 @@ delete_selection :: proc(file: ^File_Buffer) {
clear_selection(file)
}
clear_selection :: proc(file: ^File_Buffer) {
clear_selection :: proc(file: ^FileBuffer) {
file.selection.active = false
file.selection.start = 0
file.selection.end = 0
}
select_all :: proc(file: ^File_Buffer) {
select_all :: proc(file: ^FileBuffer) {
file.selection.start = 0
file.selection.end = len(file.content)
file.selection.active = true
file.cursor_pos = len(file.content)
}
copy_selection :: proc(app: ^App, file: ^File_Buffer) {
copy_selection :: proc(app: ^App, file: ^FileBuffer) {
if !file.selection.active do return
start := min(file.selection.start, file.selection.end)
@ -772,7 +723,7 @@ copy_selection :: proc(app: ^App, file: ^File_Buffer) {
rl.SetClipboardText(strings.clone_to_cstring(app.copied_text))
}
paste_text :: proc(file: ^File_Buffer, text: string) {
paste_text :: proc(file: ^FileBuffer, text: string) {
if file.selection.active {
delete_selection(file)
}
@ -789,7 +740,7 @@ paste_text :: proc(file: ^File_Buffer, text: string) {
}
}
move_cursor_up :: proc(file: ^File_Buffer) {
move_cursor_up :: proc(file: ^FileBuffer) {
// For wrapped text, we need to handle cursor movement differently
if file.cursor_pos > 0 {
// Find the previous newline
@ -816,7 +767,7 @@ move_cursor_up :: proc(file: ^File_Buffer) {
}
}
move_cursor_down :: proc(file: ^File_Buffer) {
move_cursor_down :: proc(file: ^FileBuffer) {
// For wrapped text, we need to handle cursor movement differently
if file.cursor_pos < len(file.content) {
// Find the current line start
@ -852,7 +803,7 @@ move_cursor_down :: proc(file: ^File_Buffer) {
}
}
move_cursor_to_start_of_line :: proc(file: ^File_Buffer) {
move_cursor_to_start_of_line :: proc(file: ^FileBuffer) {
// For wrapped text, we need to handle cursor movement differently
if file.cursor_pos < len(file.content) {
// Find the current line start
@ -868,7 +819,7 @@ move_cursor_to_start_of_line :: proc(file: ^File_Buffer) {
}
}
move_cursor_to_end_of_line :: proc(file: ^File_Buffer) {
move_cursor_to_end_of_line :: proc(file: ^FileBuffer) {
// For wrapped text, we need to handle cursor movement differently
if file.cursor_pos < len(file.content) {
// Find the next newline
@ -884,26 +835,13 @@ move_cursor_to_end_of_line :: proc(file: ^File_Buffer) {
}
}
save_file :: proc(app: ^App, file: ^File_Buffer) {
app.thread_finished = false
if len(file.filename) == 0 {
app.file_dialog_open = true
result := file_dialog.show_save_file_dialog()
app.file_dialog_open = false
if !result.success {
log.error(result.error_message)
}
defer file_dialog.destroy_result(&result)
file.filename = strings.clone(result.file_path)
}
ok := os.write_entire_file(file.filename, transmute([]u8)file.content)
file.modified = !ok
if !ok {
log.error("failed to save file, \"", file.filename, "\"", sep="") // TODO: Show popup window that displays this to the user
return
save_file :: proc(file: ^FileBuffer) {
success := os.write_entire_file(file.filename, transmute([]u8)file.content)
if success {
file.modified = false
fmt.printf("Saved: %s\n", file.filename)
} else {
fmt.printf("Failed to save: %s\n", file.filename)
}
app.thread_finished = true
}

31
themes.odin
Unescape Escape View File

@ -1,31 +0,0 @@
#+feature dynamic-literals
package main
themes := map[string]Colours {
"gruvbox dark hard" = Colours{
background = Colour{29, 32, 33, 255},
text = Colour{227, 218, 186, 255},
status_bar_text = Colour{133, 153, 0, 255},
line_numbers = Colour{146, 131, 116, 255},
line_numbers_background = Colour{40, 40, 40, 255},
active_tab = Colour{60, 56, 54, 255},
inactive_tab = Colour{50, 48, 47, 255},
tab_border = Colour{0, 218, 0, 255},
cursor = Colour{251, 241, 199, 255},
highlight = Colour{61, 63, 64, 255}
},
"solarized dark" = Colours{
background = Colour{0, 43, 54, 255},
text = Colour{131, 148, 150, 255},
status_bar_text = Colour{133, 153, 0, 255},
line_numbers = Colour{88, 110, 117, 255},
line_numbers_background = Colour{7, 54, 66, 255},
active_tab = Colour{7, 54, 66, 255},
inactive_tab = Colour{0, 43, 54, 255},
tab_border = Colour{88, 110, 117, 255},
cursor = Colour{147, 161, 161, 255},
highlight = Colour{61, 63, 64, 255}
},
}

20
types.odin
Unescape Escape View File

@ -1,7 +1,5 @@
package main
import "core:thread"
import rl "vendor:raylib"
Colour :: rl.Color
@ -10,31 +8,31 @@ Colour :: rl.Color
FontConfig :: struct {
font: rl.Font,
size: f32,
name: string
name: string,
}
// Text selection
Selection :: struct {
start: int,
end: int,
active: bool
active: bool,
}
// Wrapped line information
WrappedLine :: struct {
text: string,
original_line: int,
character_offset: int
character_offset: int,
}
// File buffer structure
File_Buffer :: struct {
FileBuffer :: struct {
filename: string,
content: string,
modified: bool,
cursor_pos: int,
scroll_y: f32,
selection: Selection
selection: Selection,
}
Colours :: struct {
@ -54,11 +52,12 @@ Colours :: struct {
Config :: struct {
font: string,
font_size: int,
colours: Colours
colours: Colours,
}
// Application state
App :: struct {
files: [dynamic]File_Buffer,
files: [dynamic]FileBuffer,
active_tab: int,
fonts: [dynamic]FontConfig,
current_font_index: int,
@ -72,7 +71,4 @@ App :: struct {
is_dragging: bool,
copied_text: string,
config: Config,
thread: ^thread.Thread,
thread_finished: bool,
file_dialog_open: bool
}

Write Preview
Loading…
Cancel
Save