add selector to timetable. --CONTAINS BUGS--

src/const.h

@@ -1,7 +1,7 @@
 #include <string_view>
 #ifndef VERSION
 
-#define VERSION "0.5"
+#define VERSION "0.6"
 #define NAME "bakatui"
 
 inline constexpr auto hash_djb2a(const std::string_view sv) {

src/helper_funcs.cpp

@@ -9,6 +9,7 @@
 #include <fstream>
 #include <iostream>
 #include <locale>
+#include <panel.h>
 #include <string>
 #include <termios.h>
 #include <unistd.h>
@@ -217,4 +218,16 @@ std::wstring string_to_wstring(const std::string &str) {
 std::string wstring_to_string(const std::wstring &wstr) {
   std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
   return converter.to_bytes(wstr);
-}
+}
+
+void move_panel_relative(PANEL *panel, int dy, int dx) {
+  WINDOW *win = panel_window(panel);
+  int y, x;
+
+  getbegyx(win, y, x);
+
+  int new_y = y + dy;
+  int new_x = x + dx;
+
+  move_panel(panel, new_y, new_x);
+}

src/timetable.cpp

@@ -3,6 +3,7 @@
 #include "const.h"
 #include "helper_funcs.h"
 #include "net.h"
+#include "types.h"
 #include <cstdint>
 #include <curses.h>
 #include <cwchar>
@@ -10,6 +11,7 @@
 #include <iostream>
 #include <ncurses.h>
 #include <nlohmann/json.hpp>
+#include <panel.h>
 #include <string>
 #include <vector>
 
@@ -204,7 +206,7 @@ void timetable_page() {
     }
     std::cerr << RED "[ERROR]" << RESET " Hour with id " << HourIdLookupTable[i]
               << " not found\n";
-    goto timetable_error_exit;
+    safe_exit(128);
 
   hour_id_found:
 
@@ -241,8 +243,6 @@ void timetable_page() {
       try {
         if (atom->contains("Change") && !atom->at("Change").is_null()) {
 
-          std::clog << "Change: " << atom->at("Change") << "\n";
-
           switch (
               hash_djb2a(atom->at("Change")["ChangeType"].get<std::string>())) {
           case "Canceled"_sh:
@@ -317,8 +317,102 @@ void timetable_page() {
     }
   }
   refresh();
-  getch();
+
-timetable_error_exit:
+  SelectorType selected_cell(0, 0, 0, num_of_columns - 1, 0, num_of_days - 1);
+  std::array<WINDOW *, 4> selector_windows;
+  std::array<PANEL *, 4> selector_panels;
+
+  {
+    const chtype corners[] = {
+        ACS_ULCORNER, /* Upper left corner */
+        ACS_URCORNER, /* Upper right corner */
+        ACS_LLCORNER, /* Lower left corner */
+        ACS_LRCORNER  /* Lower right corner */
+    };
+
+    unsigned short x_offset, y_offset;
+    for (uint8_t i = 0; i < selector_windows.size(); i++) {
+
+      if (!(i % 2 == 0)) {
+        x_offset = cell_width - 1;
+      } else {
+        x_offset = 0;
+      }
+      if (!(i < 2)) {
+        y_offset = cell_height - 1;
+      } else {
+        y_offset = 0;
+      }
+
+      selector_windows[i] =
+          newwin(1, 1, DEFAULT_OFFSET + y_offset, DEFAULT_OFFSET + x_offset);
+      selector_panels[i] = new_panel(selector_windows[i]);
+      wattron(selector_windows[i], COLOR_PAIR(COLOR_RED));
+      mvwaddch(selector_windows[i], 0, 0, corners[i]);
+      wattroff(selector_windows[i], COLOR_PAIR(COLOR_RED));
+    }
+  }
+
+  update_panels();
+  doupdate();
+
+  int ch;
+  while ((ch = getch()) != KEY_F(1)) {
+  run_loop_again:
+    switch (ch) {
+    case KEY_UP:
+    case 'k':
+      selected_cell.y--;
+      break;
+    case KEY_DOWN:
+    case 'j':
+      selected_cell.y++;
+      break;
+    case KEY_LEFT:
+    case 'h':
+      selected_cell.x--;
+      break;
+    case KEY_RIGHT:
+    case 'l':
+      selected_cell.x++;
+      break;
+    }
+    { // print selected indicator
+      chtype top_left_corner =
+          mvwinch(cells[selected_cell.y][selected_cell.x], 0, 0);
+
+      if (!((top_left_corner & A_CHARTEXT) == 32)) {
+        for (uint8_t i = 0; i < selector_panels.size(); i++) {
+          unsigned short x_offset, y_offset;
+          if (!(i % 2 == 0)) {
+            x_offset = cell_width - 1;
+          } else {
+            x_offset = 0;
+          }
+          if (!(i < 2)) {
+            y_offset = cell_height - 1;
+          } else {
+            y_offset = 0;
+          }
+
+          move_panel(selector_panels[i],
+                     DEFAULT_OFFSET + y_offset + selected_cell.y * cell_height,
+                     DEFAULT_OFFSET + x_offset + selected_cell.x * cell_width);
+        }
+        for (uint8_t i = 0; i < num_of_days; i++) {
+          for (uint8_t j = 0; j < num_of_columns; j++) {
+            wrefresh(cells[i][j]);
+          }
+        }
+        update_panels();
+        doupdate();
+
+      } else {
+        // skip if the cell is empty
+        goto run_loop_again;
+      }
+    }
+  }
   delete[] day_windows;
   delete[] lesson_windows;
   endwin();

src/types.h

@@ -2,8 +2,146 @@
 #ifndef _ba_ty_hg_
 #define _ba_ty_hg_
 
+#include <istream>
 struct Config {
-    bool verbose = false;
+  bool verbose = false;
-    bool ignoressl = false;
+  bool ignoressl = false;
 };
+
+class LimitedInt {
+private:
+  int value;
+  const int min_value;
+  const int max_value;
+
+  void setValue(int new_value) {
+    int range = max_value - min_value + 1;
+    if (new_value < min_value || new_value > max_value) {
+      new_value = ((new_value - min_value) % range + range) % range + min_value;
+    }
+    value = new_value;
+  }
+
+public:
+  // Constructors
+  LimitedInt(int initial_value = 0, int min = std::numeric_limits<int>::min(),
+             int max = std::numeric_limits<int>::max())
+      : min_value(min), max_value(max) {
+    if (min >= max)
+      throw std::invalid_argument("Min must be less than max");
+    setValue(initial_value);
+  }
+
+  // Conversion operators
+  operator int() const { return value; } // Implicit conversion to int
+
+  // Assignment operators
+  LimitedInt &operator=(int rhs) {
+    setValue(rhs);
+    return *this;
+  }
+
+  // Compound assignment with BoundedInt
+  LimitedInt &operator+=(const LimitedInt &rhs) {
+    setValue(value + rhs.value);
+    return *this;
+  }
+
+  // Compound assignment with int
+  LimitedInt &operator+=(int rhs) {
+    setValue(value + rhs);
+    return *this;
+  }
+
+  // Similarly define -=, *=, /=, %=, &=, |=, ^=, <<=, >>= for both types
+
+  // Increment/decrement
+  LimitedInt &operator++() { // Prefix ++
+    setValue(value + 1);
+    return *this;
+  }
+
+  LimitedInt operator++(int) { // Postfix ++
+    LimitedInt temp = *this;
+    setValue(value + 1);
+    return temp;
+  }
+
+  LimitedInt &operator--() { // Prefix --
+    setValue(value - 1);
+    return *this;
+  }
+
+  LimitedInt operator--(int) { // Postfix --
+    LimitedInt temp = *this;
+    setValue(value - 1);
+    return temp;
+  }
+
+  // Binary arithmetic operators
+  friend LimitedInt operator+(const LimitedInt &lhs, const LimitedInt &rhs) {
+    LimitedInt result = lhs;
+    result += rhs;
+    return result;
+  }
+
+  friend LimitedInt operator+(const LimitedInt &lhs, int rhs) {
+    LimitedInt result = lhs;
+    result += rhs;
+    return result;
+  }
+
+  friend LimitedInt operator+(int lhs, const LimitedInt &rhs) {
+    LimitedInt result(lhs, rhs.min_value, rhs.max_value);
+    result += rhs;
+    return result;
+  }
+
+  // Similarly define -, *, /, %, &, |, ^, <<, >> for all combinations
+
+  // Unary operators
+  LimitedInt operator-() const {
+    return LimitedInt(-value, min_value, max_value);
+  }
+
+  LimitedInt operator+() const { return *this; }
+
+  // Comparison operators
+  friend bool operator==(const LimitedInt &lhs, const LimitedInt &rhs) {
+    return lhs.value == rhs.value;
+  }
+
+  friend bool operator!=(const LimitedInt &lhs, const LimitedInt &rhs) {
+    return lhs.value != rhs.value;
+  }
+
+  friend bool operator<(const LimitedInt &lhs, const LimitedInt &rhs) {
+    return lhs.value < rhs.value;
+  }
+
+  // Similarly define >, <=, >= for both BoundedInt and int comparisons
+
+  // Stream operators
+  friend std::ostream &operator<<(std::ostream &os, const LimitedInt &bi) {
+    os << bi.value;
+    return os;
+  }
+
+  friend std::istream &operator>>(std::istream &is, LimitedInt &bi) {
+    int temp;
+    is >> temp;
+    bi.setValue(temp);
+    return is;
+  }
+};
+
+struct SelectorType {
+  LimitedInt x;
+  LimitedInt y;
+
+  SelectorType(int xArg, int yArg, int min_limit_x, int max_limit_x,
+               int min_limit_y, int max_limit_y)
+      : x(xArg, min_limit_x, max_limit_x), y(yArg, min_limit_y, max_limit_y) {}
+};
+
 #endif