├── README.md
├── main.c
└── makefile


/README.md:
--------------------------------------------------------------------------------
 1 | # pixt
 2 | 
 3 | A stripped down cli text editor that features a directory navigator for quicker traversal.
 4 | 
 5 | <p align="center"><img src="https://i.imgur.com/8ux4rhh.png"/></p>
 6 | 
 7 | ## Feature Request
 8 | 
 9 | If you want a new feature please open a issue on this repository.
10 | 
11 | ## Hot Keys
12 | 
13 | ### Browser Mode
14 | 
15 | Ctrl-N : Creates an empty file in the current directory and enteres editing mode.
16 | 
17 | ESC->Enter : Quit.
18 | 
19 | ##
20 | 
21 | Use the arrow keys to navigate your directories.
22 | 
23 | When a file is selected and you hit the right arrow -- a preview of the file will appear.
24 | 
25 | After previewing the file -- hit enter to edit the file.
26 | 
27 | <p align="center"><img src="https://i.imgur.com/XMeV2nB.png"/></p>
28 | 
29 | ### Editor Mode
30 | 
31 | Ctrl-O : Enter Save Prompt.
32 | 
33 | Ctrl-X : Exit editor (return to Browser Mode).
34 | 
35 | Ctrl-Y : Page Up.
36 | 
37 | Ctrl-V : Page Down.
38 | 
39 | ESC->Enter : Quit.
40 | 


--------------------------------------------------------------------------------
/main.c:
--------------------------------------------------------------------------------
   1 | //
   2 | //  main.c
   3 | //  
   4 | //
   5 | //  Created by fairy-slipper on 1/13/18.
   6 | //
   7 | 
   8 | #include <stdlib.h>
   9 | #include <stdio.h>
  10 | #include <string.h>
  11 | #include <sys/ioctl.h>
  12 | #include <time.h>
  13 | #include <pthread.h>
  14 | #include <unistd.h>
  15 | #include <signal.h>
  16 | #include <dirent.h>
  17 | #include <limits.h>
  18 | #include <ctype.h>
  19 | 
  20 | #define INIT 1
  21 | #define UPDATE 2
  22 | 
  23 | #define ANSI_COLOR_NORMAL  "\x1B[0m"
  24 | #define ANSI_COLOR_RED  "\x1B[31m"
  25 | #define ANSI_COLOR_GREEN   "\x1B[32m"
  26 | #define ANSI_COLOR_YELLOW  "\x1B[33m"
  27 | #define ANSI_COLOR_BLUE  "\x1B[34m"
  28 | #define ANSI_COLOR_PURPLE  "\x1B[35m"
  29 | #define ANSI_COLOR_CYAN  "\x1B[36m"
  30 | #define ANSI_COLOR_WHITE  "\x1B[37m"
  31 | 
  32 | #define ANSI_BLINK   "\x1b[5m"
  33 | #define ANSI_HIDE_CURSOR "\e[?25l"
  34 | #define ANSI_SHOW_CURSOR "\e[?25h"
  35 | 
  36 | const int MAX_CONSOLE_TEXT = 10000;
  37 | static int FILE_SIZE = 1000;
  38 | 
  39 | static volatile int appRunning = 1;
  40 | static struct winsize winsize;
  41 | static int cooked = 0;
  42 | static int editing = 0;
  43 | static int savePrompt = 0;
  44 | static int readyToRender = 1;
  45 | 
  46 | static char enteredChar = 0;
  47 | static char *consoleText;
  48 | static int cursorPosition = 2;
  49 | 
  50 | static int editingCursorPositionX = 1;
  51 | static int editingCursorPositionY = 1;
  52 | 
  53 | static FILE *fp = NULL;
  54 | static int fpOffset = 0;
  55 | static FILE *fpClone = NULL;
  56 | 
  57 | static char *newFileString;
  58 | static int newFileStrOffset = -1;
  59 | static int editingPageOffset;
  60 | static int currEditingPageOffset = 0;
  61 | 
  62 | struct dirent *pDirent;
  63 | struct dirent *selectedDirent;
  64 | static DIR *pDir;
  65 | static char cwd[PATH_MAX];
  66 | static char *currCloneFilePath;
  67 | static int directoryWidth = 0;
  68 | static int directoryHeight = 0;
  69 | static int contentCount;
  70 | static int numOfPagesNav = 0;
  71 | static int currPage = 0;
  72 | 
  73 | void appendChars(char subject[], const char insert[], int pos) {
  74 |     if(strlen(insert)+strlen(subject) > FILE_SIZE) {
  75 |         FILE_SIZE *= 2;
  76 |         newFileString = (char *)realloc(newFileString, FILE_SIZE);
  77 |     }
  78 |     char buf[FILE_SIZE];
  79 |     memset(buf, '\0', FILE_SIZE);
  80 |     strncpy(buf, subject, pos);
  81 |     int len = strlen(buf);
  82 |     strcpy(buf+len, insert);
  83 |     len += strlen(insert);
  84 |     strcpy(buf+len, subject+pos);
  85 |     strcpy(subject, buf);
  86 | }
  87 | 
  88 | void removeChar(char subject[], int pos) {
  89 |     memmove(&subject[pos], &subject[pos + 1], strlen(subject) - pos);
  90 | }
  91 | 
  92 | void analyzeDirectory() {
  93 |     rewinddir(pDir);
  94 |     directoryWidth = 0;
  95 |     directoryHeight = 0;
  96 |     while((pDirent = readdir(pDir)) != NULL) {
  97 |         if(directoryWidth < strlen(pDirent->d_name)) {
  98 |             directoryWidth = strlen(pDirent->d_name);
  99 |         }
 100 |         ++directoryHeight;
 101 |     }
 102 |     --directoryHeight;
 103 |     rewinddir(pDir);
 104 |     
 105 |     numOfPagesNav = (directoryHeight/winsize.ws_row) + 1;
 106 | }
 107 | 
 108 | void processVal(char val, int *idx) {
 109 |     int endIdx = *idx - 1;
 110 |     while(newFileString[endIdx] != '\n' && newFileString[endIdx] != ' ' && newFileString[endIdx] != '(' && newFileString[endIdx] != ')' && newFileString[endIdx] != ';' && newFileString[endIdx] != '\0') {
 111 |         endIdx++;
 112 |     }
 113 |     
 114 |     if(*idx - 1 == endIdx) {
 115 |         printf("%c", val);
 116 |         return;
 117 |     }
 118 |     
 119 |     char word[endIdx - *idx + 2];
 120 |     memset(word, '\0', sizeof(word));
 121 |     strncpy(word, &newFileString[*idx - 1], endIdx - *idx + 1);
 122 |     if(strcmp(word, "int") == 0) {
 123 |         printf("%sint%s", ANSI_COLOR_GREEN, ANSI_COLOR_NORMAL);
 124 |         (*idx) += 2;
 125 |     } else if(strcmp(word, "char") == 0) {
 126 |         printf("%schar%s", ANSI_COLOR_GREEN, ANSI_COLOR_NORMAL);
 127 |         (*idx) += 3;
 128 |     } else if(strcmp(word, "if") == 0) {
 129 |         printf("%sif%s", ANSI_COLOR_PURPLE, ANSI_COLOR_NORMAL);
 130 |         (*idx) += 1;
 131 |     } else if(strcmp(word, "else") == 0) {
 132 |         printf("%selse%s", ANSI_COLOR_PURPLE, ANSI_COLOR_NORMAL);
 133 |         (*idx) += 3;
 134 |     } else if(strcmp(word, "switch") == 0) {
 135 |         printf("%sswitch%s", ANSI_COLOR_PURPLE, ANSI_COLOR_NORMAL);
 136 |         (*idx) += 5;
 137 |     } else if(strcmp(word, "while") == 0) {
 138 |         printf("%swhile%s", ANSI_COLOR_PURPLE, ANSI_COLOR_NORMAL);
 139 |         (*idx) += 4;
 140 |     } else if(strcmp(word, "long") == 0) {
 141 |         printf("%slong%s", ANSI_COLOR_GREEN, ANSI_COLOR_NORMAL);
 142 |         (*idx) += 3;
 143 |     } else if(strcmp(word, "short") == 0) {
 144 |         printf("%sshort%s", ANSI_COLOR_GREEN, ANSI_COLOR_NORMAL);
 145 |         (*idx) += 4;
 146 |     } else if(strcmp(word, "float") == 0) {
 147 |         printf("%sfloat%s", ANSI_COLOR_GREEN, ANSI_COLOR_NORMAL);
 148 |         (*idx) += 4;
 149 |     } else if(strcmp(word, "double") == 0) {
 150 |         printf("%sdouble%s", ANSI_COLOR_GREEN, ANSI_COLOR_NORMAL);
 151 |         (*idx) += 5;
 152 |     } else if(strcmp(word, "struct") == 0) {
 153 |         printf("%sstruct%s", ANSI_COLOR_GREEN, ANSI_COLOR_NORMAL);
 154 |         (*idx) += 5;
 155 |     } else if(strcmp(word, "enum") == 0) {
 156 |         printf("%senum%s", ANSI_COLOR_GREEN, ANSI_COLOR_NORMAL);
 157 |         (*idx) += 3;
 158 |     } else if(strcmp(word, "return") == 0) {
 159 |         printf("%sreturn%s", ANSI_COLOR_YELLOW, ANSI_COLOR_NORMAL);
 160 |         (*idx) += 5;
 161 |     } else {
 162 |         
 163 |         int notNumber = 0;
 164 |         for(int i=0; i<strlen(word); i++) {
 165 |             if(!isdigit(word[i])) {
 166 |                 notNumber = 1;
 167 |                 break;
 168 |             }
 169 |         }
 170 |         if(!notNumber) {
 171 |             printf("%s%s%s", ANSI_COLOR_RED, word, ANSI_COLOR_NORMAL);
 172 |             (*idx) += (strlen(word) - 1);
 173 |             return;
 174 |         }
 175 |         
 176 |         int notAlnum = 0;
 177 |         for(int i=0; i<strlen(word); i++) {
 178 |             if(!isalnum(word[i])) {
 179 |                 notAlnum = 1;
 180 |                 break;
 181 |             }
 182 |         }
 183 |         if(!notAlnum) {
 184 |             if(newFileString[endIdx] == '(') {
 185 |                 printf("%s%s%s", ANSI_COLOR_CYAN, word, ANSI_COLOR_NORMAL);
 186 |                 (*idx) += (strlen(word) - 1);
 187 |                 return;
 188 |             }
 189 |         }
 190 |         
 191 |         printf("%s", word);
 192 |         (*idx) += (strlen(word) - 1);
 193 |     }
 194 | }
 195 | 
 196 | void refreshDisplay(int type) {
 197 |     contentCount = 0;
 198 |     readyToRender = 0;
 199 |     analyzeDirectory();
 200 |     
 201 |     if(type != INIT) {
 202 |         printf("%s", ANSI_HIDE_CURSOR);
 203 |         printf("\033[%i;%iH", 1, 1);
 204 |         rewind(stdout);
 205 |         if(!cooked) {
 206 |             printf("\r");
 207 |         }
 208 |     }
 209 |     
 210 |     int pageOffset = 0;
 211 |     while((pDirent = readdir(pDir)) != NULL) {
 212 |         if((numOfPagesNav - 1) == 0 || currPage == 0) {
 213 |             rewinddir(pDir);
 214 |             break;
 215 |         } else if(pageOffset >= currPage * winsize.ws_row) {
 216 |             break;
 217 |         }
 218 |         ++pageOffset;
 219 |     }
 220 |     
 221 |     int rowOffset = 0;
 222 |     if(cooked) {
 223 |         rowOffset = 2;
 224 |     }
 225 |     
 226 |     if(!editing) {
 227 |         int newLineFlag = 0;
 228 |         for(int h=0; h<winsize.ws_row - rowOffset; h++) {
 229 |             pDirent = readdir(pDir);
 230 |             
 231 |             int contentLen;
 232 |             if(pDirent != NULL) {
 233 |                 ++contentCount;
 234 |                 contentLen = strlen(pDirent->d_name);
 235 |             }
 236 |             int nonPrintable = 0;
 237 |             int tabOccured = 0;
 238 |             if(newLineFlag > 0) {--newLineFlag;}
 239 |             for(int w=0; w<winsize.ws_col; w++) {
 240 |                 if(w == 0) {
 241 |                     if(cursorPosition == h) {
 242 |                         printf("%s>%s", ANSI_COLOR_GREEN, ANSI_COLOR_NORMAL);
 243 |                         selectedDirent = pDirent;
 244 |                     } else {
 245 |                         printf(" ");
 246 |                     }
 247 |                 } else {
 248 |                     if(pDirent != NULL && contentLen > w - 1 && pDirent->d_name[w - 1] != '\n' && pDirent->d_name[w - 1] != '\r') {
 249 |                         printf("%c", pDirent->d_name[w - 1]);
 250 |                     } else if(directoryWidth + 2 == w) {
 251 |                         printf("|");
 252 |                     } else if(directoryWidth + 3 == w) {
 253 |                         printf(" ");
 254 |                     } else if(fp != NULL && w > directoryWidth + 3) {
 255 |                         int val;
 256 |                         fpOffset = ftell(fp);
 257 |                         if(tabOccured || newLineFlag) {
 258 |                             printf(" ");
 259 |                         } else if(!nonPrintable) {
 260 |                             val = fgetc(fp);
 261 |                             if((31 < val && val < 127) || val == 9) {
 262 |                                 if(val == 9) {
 263 |                                     tabOccured = 4;
 264 |                                     printf(" ");
 265 |                                 } else {
 266 |                                     printf("%c", val);
 267 |                                 }
 268 |                             } else {
 269 |                                 nonPrintable = 1;
 270 |                                 printf(" ");
 271 |                             }
 272 |                         } else {
 273 |                             printf(" ");
 274 |                             val = fgetc(fp);
 275 |                             if(val == '\n') {
 276 |                                 newLineFlag = 2;
 277 |                             } else if((31 < val && val < 127) || val == 9) {
 278 |                                 fseek(fp, -1, SEEK_CUR);
 279 |                             }
 280 |                         }
 281 |                     } else {
 282 |                         printf(" ");
 283 |                     }
 284 |                     if(tabOccured > 0) { --tabOccured;}
 285 |                 }
 286 |             }
 287 |         }
 288 |         if(cooked) {
 289 |             printf("\n");
 290 |         }
 291 |     } else {
 292 |         int *i = (int *)malloc(sizeof(int));
 293 |         *i = editingPageOffset;
 294 |         for(int h=0; h<winsize.ws_row - rowOffset; h++) {
 295 |             int newline = 0;
 296 |             int tabOccured = 0;
 297 |             for(int w=0; w<winsize.ws_col; w++) {
 298 |                 int val;
 299 |                 if(tabOccured || newline) {
 300 |                     printf(" ");
 301 |                 } else {
 302 |                     if((val = newFileString[(*i)++]) != '\0') {
 303 |                         if(val == 9) {
 304 |                             tabOccured = 4;
 305 |                             printf(" ");
 306 |                         } else if(val == '\n') {
 307 |                             newline = 1;
 308 |                             printf(" ");
 309 |                         } else {
 310 |                             int pre = *i;
 311 |                             processVal(val, i);
 312 |                             int post = *i;
 313 |                             w += (post - pre);
 314 |                         }
 315 |                     } else {
 316 |                         printf(" ");
 317 |                     }
 318 |                 }
 319 |                 if(tabOccured > 0) { --tabOccured;}
 320 |             }
 321 |         }
 322 |         free(i);
 323 |     }
 324 |     rewind(stdout);
 325 |     printf("%s", ANSI_SHOW_CURSOR);
 326 |     readyToRender = 1;
 327 | }
 328 | 
 329 | void downArrow(int enteredValue) {
 330 |     if(!editing) {
 331 |         if(fp != NULL) {
 332 |             fclose(fp);
 333 |         }
 334 |         ++cursorPosition;
 335 |         if(cursorPosition > contentCount - 1) {
 336 |             cursorPosition = 0;
 337 |             ++currPage;
 338 |             if(currPage > numOfPagesNav - 1) {
 339 |                 currPage = 0;
 340 |             }
 341 |         }
 342 |         refreshDisplay(UPDATE);
 343 |         printf("%s", ANSI_HIDE_CURSOR);
 344 |     } else {
 345 |         int i = 0;
 346 |         int flagWasNegative = 0;
 347 |         if(newFileStrOffset == -1 || newFileString[newFileStrOffset] == 10) {
 348 |             ++newFileStrOffset;
 349 |             flagWasNegative = 1;
 350 |         }
 351 |         
 352 |         while(newFileString[newFileStrOffset] != '\n' && newFileString[newFileStrOffset] != '\0') {
 353 |             if (i > winsize.ws_col) {
 354 |                 ++editingCursorPositionY;
 355 |                 if(flagWasNegative) {
 356 |                     --newFileStrOffset;
 357 |                 }
 358 |                 --newFileStrOffset;
 359 |                 if(editingCursorPositionY > winsize.ws_row) {
 360 |                     ++newFileStrOffset;
 361 |                     --editingCursorPositionY;
 362 |                     i = 0;
 363 |                     while(newFileString[editingPageOffset] != '\n' && newFileString[editingPageOffset] != '\0' && i < winsize.ws_col) {
 364 |                         ++editingPageOffset;
 365 |                         ++i;
 366 |                     }
 367 |                     ++editingPageOffset;
 368 |                     refreshDisplay(UPDATE);
 369 |                 }
 370 |                 printf("\033[%i;%iH", editingCursorPositionY, editingCursorPositionX);
 371 |                 return;
 372 |             }
 373 |             ++i;
 374 |             ++newFileStrOffset;
 375 |         }
 376 |         
 377 |         if(newFileString[newFileStrOffset] == '\0') {
 378 |             newFileStrOffset -= i;
 379 |             return;
 380 |         }
 381 |         
 382 |         if(newFileString[newFileStrOffset] == '\n') {
 383 |             ++newFileStrOffset;
 384 |         }
 385 |         
 386 |         if(i + editingCursorPositionX > winsize.ws_col) {
 387 |             editingCursorPositionX = ((i+editingCursorPositionX) % winsize.ws_col) - 1;
 388 |             ++editingCursorPositionY;
 389 |             newFileStrOffset-=2;
 390 |         } else {
 391 |             i = 1;
 392 |             int j = 0;
 393 |             while(i < editingCursorPositionX && newFileString[newFileStrOffset] != '\0' && newFileString[newFileStrOffset] != '\n') {
 394 |                 ++i;
 395 |                 ++j;
 396 |                 ++newFileStrOffset;
 397 |             }
 398 |             --newFileStrOffset;
 399 |             ++editingCursorPositionY;
 400 |             editingCursorPositionX = i;
 401 |         }
 402 |         if(editingCursorPositionY > winsize.ws_row) {
 403 |             --editingCursorPositionY;
 404 |             int q = 0;
 405 |             int p = 0;
 406 |             while(newFileString[editingPageOffset+q] != '\n' && newFileString[editingPageOffset+q] != '\0') {
 407 |                 if (q >= winsize.ws_col - 1) {
 408 |                     break;
 409 |                 }
 410 |                 ++q;
 411 |                 ++p;
 412 |             }
 413 |             editingPageOffset += (p+1);
 414 |             refreshDisplay(UPDATE);
 415 |         }
 416 |         printf("\033[%i;%iH", editingCursorPositionY, editingCursorPositionX);
 417 |     }
 418 | }
 419 | 
 420 | void upArrow(int enteredValue) {
 421 |     if(!editing) {
 422 |         if(fp != NULL) {
 423 |             fclose(fp);
 424 |         }
 425 |         --cursorPosition;
 426 |         if(cursorPosition < 0) {
 427 |             cursorPosition = winsize.ws_row - 1;
 428 |             --currPage;
 429 |             if(currPage < 0) {
 430 |                 currPage = numOfPagesNav - 1;
 431 |                 if(currPage != 0) {
 432 |                     cursorPosition = (directoryHeight - 1)%winsize.ws_row;
 433 |                 }
 434 |             }
 435 |         }
 436 |         refreshDisplay(UPDATE);
 437 |         printf("%s", ANSI_HIDE_CURSOR);
 438 |     } else {
 439 |         int i = 0;
 440 |         while(newFileStrOffset > -1 && newFileString[newFileStrOffset] != 10) {
 441 |             if (i >= winsize.ws_col - 1) {
 442 |                 --newFileStrOffset;
 443 |                 --editingCursorPositionY;
 444 |                 if(editingCursorPositionY <= 0) {
 445 |                     ++editingCursorPositionY;
 446 |                     int j = 0;
 447 |                     i = 1;
 448 |                     while(editingPageOffset - i > -1 && newFileString[editingPageOffset-i] != 10) {
 449 |                         ++j;
 450 |                         ++i;
 451 |                     }
 452 |                     
 453 |                     editingPageOffset -= winsize.ws_col;
 454 |                     refreshDisplay(UPDATE);
 455 |                 }
 456 |                 printf("\033[%i;%iH", editingCursorPositionY, editingCursorPositionX);
 457 |                 return;
 458 |             }
 459 |             ++i;
 460 |             --newFileStrOffset;
 461 |         }
 462 |         if(newFileString[newFileStrOffset] == '\n') {
 463 |             --newFileStrOffset;
 464 |         }
 465 |         
 466 |         int wrapFlag = 0;
 467 |         i = 0;
 468 |         while(newFileStrOffset > -1 && newFileString[newFileStrOffset] != 10) {
 469 |             if (i >= winsize.ws_col - 1) {
 470 |                 wrapFlag = 1;
 471 |             }
 472 |             --newFileStrOffset;
 473 |             ++i;
 474 |         }
 475 |         ++newFileStrOffset;
 476 |         
 477 |         if(wrapFlag) {
 478 |             if(editingCursorPositionY <= 2) {
 479 |                 editingCursorPositionX = (i)%winsize.ws_col;
 480 |                 ++newFileStrOffset;
 481 |             } else {
 482 |                 editingCursorPositionX = (i+1)%winsize.ws_col;
 483 |             }
 484 |         }
 485 |         
 486 |         i = 1;
 487 |         while(i < editingCursorPositionX) {
 488 |             if(newFileString[newFileStrOffset] == 10) {
 489 |                 break;
 490 |             } else if(newFileString[newFileStrOffset] == '\0') {
 491 |                 break;
 492 |             } else if(newFileString[newFileStrOffset] == 9) {
 493 |                 i+=4;
 494 |                 ++newFileStrOffset;
 495 |             } else {
 496 |                 i++;
 497 |                 ++newFileStrOffset;
 498 |             }
 499 |         }
 500 |         if(wrapFlag) {
 501 |             newFileStrOffset+=winsize.ws_col;
 502 |         }
 503 |         --newFileStrOffset;
 504 |         editingCursorPositionX = i;
 505 |         --editingCursorPositionY;
 506 |         if(editingCursorPositionY < 1) {
 507 |             if(wrapFlag) {
 508 |                 ++editingCursorPositionY;
 509 |                 i = 0;
 510 |                 int j = 0;
 511 |                 if(newFileString[editingPageOffset - j] == '\n') {
 512 |                     ++j;
 513 |                     ++i;
 514 |                 }
 515 |                 while(editingPageOffset - j > -1 && newFileString[editingPageOffset - j] != 10) {
 516 |                     ++j;
 517 |                     ++i;
 518 |                 }
 519 |                 if(newFileString[editingPageOffset - j] == '\n') {
 520 |                     ++j;
 521 |                     ++i;
 522 |                 }
 523 |                 while(editingPageOffset - j > -1 && newFileString[editingPageOffset - j] != 10) {
 524 |                     ++j;
 525 |                     ++i;
 526 |                 }
 527 |                 editingCursorPositionX = (i-1)%winsize.ws_col;
 528 |                 editingPageOffset-=editingCursorPositionX;
 529 |             } else {
 530 |                 ++editingCursorPositionY;
 531 |                 if(newFileString[editingPageOffset] == '\n') {
 532 |                     --editingPageOffset;
 533 |                 }
 534 |                 while(editingPageOffset > -1 && newFileString[editingPageOffset] != 10) {
 535 |                     --editingPageOffset;
 536 |                 }
 537 |                 if(newFileString[editingPageOffset] == '\n') {
 538 |                     --editingPageOffset;
 539 |                 }
 540 |                 while(editingPageOffset > -1 && newFileString[editingPageOffset] != 10) {
 541 |                     --editingPageOffset;
 542 |                 }
 543 |                 ++editingPageOffset;
 544 |                 i = 1;
 545 |                 int j = 0;
 546 |                 while(i < editingCursorPositionX) {
 547 |                     if(newFileString[editingPageOffset + j] == 10) {
 548 |                         break;
 549 |                     }
 550 |                     ++i;
 551 |                     ++j;
 552 |                 }
 553 |                 
 554 |                 editingCursorPositionX = i;
 555 |             }
 556 |             refreshDisplay(UPDATE);
 557 |         }
 558 |     }
 559 |     printf("\033[%i;%iH", editingCursorPositionY, editingCursorPositionX);
 560 | }
 561 | 
 562 | void rightArrow(int enteredValue) {
 563 |     if(!editing) {
 564 |         char tmp[sizeof(selectedDirent->d_name)];
 565 |         char cwdTmp[sizeof(cwd)];
 566 |         strcpy(tmp, selectedDirent->d_name);
 567 |         strcpy(cwdTmp, cwd);
 568 |         strcat(cwdTmp, "/");
 569 |         strcat(cwdTmp, tmp);
 570 |         closedir(pDir);
 571 |         pDir = opendir(cwdTmp);
 572 |         if (pDir != NULL) {
 573 |             strcpy(cwd, cwdTmp);
 574 |             cursorPosition = 2;
 575 |             currPage = 0;
 576 |         } else {
 577 |             pDir = opendir(cwd);
 578 |             fclose(fp);
 579 |             char filePath[sizeof(cwd)];
 580 |             memset(filePath, 0, sizeof(filePath));
 581 |             strcpy(filePath, cwd);
 582 |             strcat(filePath, "/");
 583 |             strcat(filePath, selectedDirent->d_name);
 584 |             strcpy(currCloneFilePath, filePath);
 585 |             strcat(currCloneFilePath, "-tmp");
 586 |             fp = fopen(filePath, "r");
 587 |         }
 588 |         refreshDisplay(UPDATE);
 589 |     } else {
 590 |         if(newFileString[newFileStrOffset+1] == '\0') {
 591 |             
 592 |         } else {
 593 |             ++newFileStrOffset;
 594 |             if(newFileString[newFileStrOffset] == 10 || enteredValue == 10) {
 595 |                 editingCursorPositionX = 1;
 596 |                 if(editingCursorPositionY < winsize.ws_row) {
 597 |                     ++editingCursorPositionY;
 598 |                 } else {
 599 |                     while(newFileString[editingPageOffset] != 10 && newFileString[editingPageOffset] != '\0') {
 600 |                         ++editingPageOffset;
 601 |                     }
 602 |                     if (newFileString[editingPageOffset] == 10) {
 603 |                         ++editingPageOffset;
 604 |                     }
 605 |                     refreshDisplay(UPDATE);
 606 |                 }
 607 |             } else if(newFileString[newFileStrOffset] == 9) {
 608 |                 editingCursorPositionX += 4;
 609 |             } else {
 610 |                 if(editingCursorPositionX < winsize.ws_col) {
 611 |                     ++editingCursorPositionX;
 612 |                 } else {
 613 |                     if(editingCursorPositionY < winsize.ws_row) {
 614 |                         editingCursorPositionX = 1;
 615 |                         editingCursorPositionY++;
 616 |                     } else {
 617 |                         int i = 0;
 618 |                         while(newFileString[newFileStrOffset + i] != 10 && newFileString[newFileStrOffset + i] != '\0' && i<winsize.ws_col) {
 619 |                             ++i;
 620 |                             ++editingPageOffset;
 621 |                         }
 622 |                         editingCursorPositionX = 1;
 623 |                         --newFileStrOffset;
 624 |                         refreshDisplay(UPDATE);
 625 |                     }
 626 |                 }
 627 |             }
 628 |             //printf("%c\n\n", newFileString[newFileStrOffset]);
 629 |             printf("\033[%i;%iH", editingCursorPositionY, editingCursorPositionX);
 630 |         }
 631 |     }
 632 | }
 633 | 
 634 | void leftArrow(enteredValue) {
 635 |     if(!editing) {
 636 |         int len = strlen(cwd);
 637 |         if(strcmp(cwd, "/")) {
 638 |             for(int i=len-1; i>=0; i--) {
 639 |                 if (cwd[i] == '/') {
 640 |                     cwd[i] = '\0';
 641 |                     if(cwd[0] == '\0') {
 642 |                         cwd[0] = '/';
 643 |                         cwd[1] = '\0';
 644 |                     }
 645 |                     break;
 646 |                 }
 647 |             }
 648 |         }
 649 |         closedir (pDir);
 650 |         pDir = opendir(cwd);
 651 |         if (pDir == NULL) {
 652 |             printf ("Cannot open directory\n");
 653 |         }
 654 |         cursorPosition = 2;
 655 |         currPage = 0;
 656 |         refreshDisplay(UPDATE);
 657 |     } else {
 658 |         if(newFileStrOffset - 1 < -1) {
 659 |             
 660 |         } else {
 661 |             if (editingCursorPositionY <= 1 && editingCursorPositionX <= 1) {
 662 |                 int i = 0;
 663 |                 int j = 0;
 664 |                 --editingPageOffset;
 665 |                 if(newFileString[editingPageOffset] == 10) {
 666 |                     --editingPageOffset;
 667 |                 }
 668 |                 while(newFileString[editingPageOffset - j] != 10 && editingPageOffset - j > -2) {
 669 |                     ++i;
 670 |                     ++j;
 671 |                 }
 672 |                 
 673 |                 --newFileStrOffset;
 674 |                 
 675 |                 editingCursorPositionX = (i%winsize.ws_col)+1;
 676 |                 for(int x=0; x<editingCursorPositionX-1; x++) {
 677 |                     --editingPageOffset;
 678 |                 }
 679 |                 
 680 |                 ++editingPageOffset;
 681 |                 refreshDisplay(UPDATE);
 682 |                 printf("\033[%i;%iH", editingCursorPositionY, editingCursorPositionX);
 683 |                 return;
 684 |             }
 685 |             if((newFileString[newFileStrOffset] == 10 && enteredValue != 127) || enteredValue == 600) {
 686 |                 if(editingCursorPositionY == 1) {
 687 |                     --editingPageOffset;
 688 |                     if (newFileString[editingPageOffset] == 10) {
 689 |                         --editingPageOffset;
 690 |                     }
 691 |                     while(newFileString[editingPageOffset] != 10 && newFileString[editingPageOffset] != '\0') {
 692 |                         --editingPageOffset;
 693 |                     }
 694 |                     if (newFileString[editingPageOffset] == 10) {
 695 |                         ++editingPageOffset;
 696 |                     }
 697 |                     int i = 1;
 698 |                     int cnt = 1;
 699 |                     while(newFileString[newFileStrOffset - i] != 10 && newFileStrOffset - i > -2) {
 700 |                         ++cnt;
 701 |                         ++i;
 702 |                     }
 703 |                     editingCursorPositionX = cnt;
 704 |                     refreshDisplay(UPDATE);
 705 |                 } else {
 706 |                     --editingCursorPositionY;
 707 |                     --newFileStrOffset;
 708 |                     int i = 0;
 709 |                     while(newFileString[newFileStrOffset - i] != 10 && newFileStrOffset - i > -1) {
 710 |                         ++i;
 711 |                     }
 712 |                     editingCursorPositionX = (i+1)%winsize.ws_col;
 713 |                 }
 714 |             } else if(newFileString[newFileStrOffset] == 9 || enteredValue == 700) {
 715 |                 editingCursorPositionX -= 4;
 716 |             } else {
 717 |                 if(editingCursorPositionX <= 1) {
 718 |                     int i = 0;
 719 |                     while(newFileString[newFileStrOffset - i] != 10 && newFileStrOffset - i > -1 && i < winsize.ws_col) {
 720 |                         ++i;
 721 |                     }
 722 |                     --editingCursorPositionY;
 723 |                     editingCursorPositionX = i;
 724 |                     --newFileStrOffset;
 725 |                     --newFileStrOffset;
 726 |                 } else {
 727 |                     --editingCursorPositionX;
 728 |                     --newFileStrOffset;
 729 |                 }
 730 |             }
 731 |             printf("\033[%i;%iH", editingCursorPositionY, editingCursorPositionX);
 732 |         }
 733 |     }
 734 | }
 735 | 
 736 | void cancelHandler(int x) {
 737 |     if(savePrompt) {
 738 |         savePrompt = 0;
 739 |         system("/bin/stty raw");
 740 |         cooked = 0;
 741 |         refreshDisplay(INIT);
 742 |         refreshDisplay(UPDATE);
 743 |         printf("%s", ANSI_SHOW_CURSOR);
 744 |         fputc(132, stdin);
 745 |     }
 746 | }
 747 | 
 748 | void *updateWindowSize() {
 749 |     for (;;) {
 750 |         int width = winsize.ws_col;
 751 |         int height = winsize.ws_row;
 752 |         ioctl(STDOUT_FILENO, TIOCGWINSZ, &winsize);
 753 |         if(width != winsize.ws_col || height != winsize.ws_row) {
 754 |             refreshDisplay(UPDATE);
 755 |         }
 756 |         usleep(250000);
 757 |     }
 758 | }
 759 | 
 760 | int main(int argc, char **argv) {
 761 |     
 762 |     ioctl(STDOUT_FILENO, TIOCGWINSZ, &winsize);
 763 |     pthread_t windowSizeUpdateThread;
 764 |     pthread_create(&windowSizeUpdateThread, NULL, updateWindowSize, NULL);
 765 |     system("/bin/stty raw");
 766 |     signal(SIGINT, cancelHandler);
 767 |     
 768 |     consoleText = (char *)malloc(MAX_CONSOLE_TEXT*sizeof(char));
 769 |     currCloneFilePath = (char *)malloc(MAX_CONSOLE_TEXT*sizeof(char));
 770 |     newFileString = (char *)malloc(FILE_SIZE*sizeof(char));
 771 |     memset(newFileString, '\0', FILE_SIZE);
 772 |     editingPageOffset = 0;
 773 |     
 774 |     if (getcwd(cwd, sizeof(cwd)) == NULL) {
 775 |         perror("getcwd() error");
 776 |     }
 777 |     
 778 |     pDir = opendir (cwd);
 779 |     if (pDir == NULL) {
 780 |         printf ("Cannot open directory\n");
 781 |     }
 782 |     
 783 |     refreshDisplay(INIT);
 784 |     refreshDisplay(UPDATE);
 785 |     
 786 |     char newFilename[1024];
 787 |     int newFilenamePos = 0;
 788 |     int lastEnteredChar = 0;
 789 |     int lastlastEnteredChar = 0;
 790 |     while ((enteredChar = fgetc(stdin)) != EOF && appRunning) {
 791 |         if(readyToRender) {
 792 |             //printf("%i\n", enteredChar);
 793 |             if((lastEnteredChar == 27 && enteredChar == 13) || (lastEnteredChar == 27 && enteredChar == 10)) {
 794 |                 appRunning = 0;
 795 |                 break;
 796 |             }
 797 |             if(savePrompt && enteredChar != 10) {
 798 |                 newFilename[newFilenamePos++] = enteredChar;
 799 |                 newFilename[newFilenamePos] = '\0';
 800 |                 continue;
 801 |             }
 802 |             if(savePrompt && enteredChar == 10) {
 803 |                 system("/bin/stty raw");
 804 |                 cooked = 0;
 805 |                 savePrompt = 0;
 806 |                 newFilenamePos = 0;
 807 |                 editing = 0;
 808 |                 char filePath[sizeof(cwd)];
 809 |                 memset(filePath, 0, sizeof(filePath));
 810 |                 strcpy(filePath, cwd);
 811 |                 strcat(filePath, "/");
 812 |                 strcpy(currCloneFilePath, filePath);
 813 |                 strcat(currCloneFilePath, newFilename);
 814 |                 fpClone = fopen(currCloneFilePath, "w+");
 815 |                 int val;
 816 |                 int i = 0;
 817 |                 while((val = newFileString[i++]) != '\0') {
 818 |                     int val2, val3, val4;
 819 |                     if(val == ' ') {
 820 |                         if((val2 = newFileString[i++]) == ' ') {
 821 |                             if((val3 = newFileString[i++]) == ' ') {
 822 |                                 if((val4 = newFileString[i++]) == ' ') {
 823 |                                     fputc('\t', fpClone);
 824 |                                 } else {
 825 |                                     fputc(val, fpClone);
 826 |                                     fputc(val2, fpClone);
 827 |                                     fputc(val3, fpClone);
 828 |                                     fputc(val4, fpClone);
 829 |                                 }
 830 |                             } else {
 831 |                                 fputc(val, fpClone);
 832 |                                 fputc(val2, fpClone);
 833 |                                 fputc(val3, fpClone);
 834 |                             }
 835 |                         } else {
 836 |                             fputc(val, fpClone);
 837 |                             fputc(val2, fpClone);
 838 |                         }
 839 |                     } else {
 840 |                         fputc(val, fpClone);
 841 |                     }
 842 |                 }
 843 |                 fclose(fpClone);
 844 |                 refreshDisplay(UPDATE);
 845 |             }
 846 |             if(editing && enteredChar == 15) {
 847 |                 savePrompt = 1;
 848 |                 system ("/bin/stty cooked");
 849 |                 cooked = 1;
 850 |                 refreshDisplay(UPDATE);
 851 |                 refreshDisplay(UPDATE);
 852 |                 if (fp != NULL) {
 853 |                     printf("Hit CTRL-C to Cancel. Save as (%s): ", selectedDirent->d_name);
 854 |                 } else {
 855 |                     printf("Hit CTRL-C to Cancel. Save as: ");
 856 |                 }
 857 |                 continue;
 858 |             }
 859 |             if(editing && enteredChar == 24) {
 860 |                 editing = 0;
 861 |                 fclose(fpClone);
 862 |                 remove(currCloneFilePath);
 863 |                 refreshDisplay(UPDATE);
 864 |                 continue;
 865 |             }
 866 |             if(editing && enteredChar == 22) {
 867 |                 while(editingCursorPositionY < winsize.ws_row) {
 868 |                     downArrow(-1);
 869 |                 }
 870 |                 for(int i=0; i<winsize.ws_row; i++) {
 871 |                     downArrow(-1);
 872 |                 }
 873 |                 continue;
 874 |             }
 875 |             if(editing && enteredChar == 25) {
 876 |                 while(editingCursorPositionY > 1) {
 877 |                     upArrow(-1);
 878 |                 }
 879 |                 for(int i=0; i<winsize.ws_row; i++) {
 880 |                     upArrow(-1);
 881 |                 }
 882 |                 continue;
 883 |             }
 884 |             if(enteredChar == 10 && cooked) {
 885 |                 refreshDisplay(UPDATE);
 886 |             }
 887 |             if(enteredChar == 13 && !cooked && !editing) {
 888 |                 if(fp != NULL) {
 889 |                     editing = 1;
 890 |                     rewind(fp);
 891 |                     fseek(fp, 0L, SEEK_END);
 892 |                     int sizeFile = ftell(fp);
 893 |                     if(sizeFile > FILE_SIZE) {
 894 |                         FILE_SIZE = sizeFile * 2;
 895 |                         newFileString = (char *)realloc(newFileString, FILE_SIZE);
 896 |                     }
 897 |                     rewind(fp);
 898 |                     int val;
 899 |                     int i = 0;
 900 |                     while((val = fgetc(fp)) != EOF) {
 901 |                         if(val == 10) {
 902 |                             int j = 1;
 903 |                             while(newFileString[i-j] == ' ') {
 904 |                                 ++j;
 905 |                             }
 906 |                             --j;
 907 |                             newFileString[i-j] = val;
 908 |                             i = i - j + 1;
 909 |                         } else if(val == 9) {
 910 |                             newFileString[i] = ' ';
 911 |                             newFileString[i+1] = ' ';
 912 |                             newFileString[i+2] = ' ';
 913 |                             newFileString[i+3] = ' ';
 914 |                             i+=4;
 915 |                         } else {
 916 |                             newFileString[i++] = val;
 917 |                         }
 918 |                     }
 919 |                     newFileString[i] = '\0';
 920 |                     rewind(fp);
 921 |                     refreshDisplay(UPDATE);
 922 |                     editingCursorPositionX = 1;
 923 |                     editingCursorPositionY = 1;
 924 |                     printf("\033[%i;%iH", editingCursorPositionY, editingCursorPositionX);
 925 |                 }
 926 |             } else if(enteredChar == 14 && !cooked && !editing) {
 927 |                 editing = 1;
 928 |                 refreshDisplay(UPDATE);
 929 |                 editingCursorPositionX = 1;
 930 |                 editingCursorPositionY = 1;
 931 |                 printf("\033[%i;%iH", editingCursorPositionY, editingCursorPositionX);
 932 | 
 933 |             } else if(!cooked) {
 934 |                 if(lastlastEnteredChar == 27 && lastEnteredChar == 91 && enteredChar == 65) {
 935 |                     upArrow(-1);
 936 |                 } else if(lastlastEnteredChar == 27 && lastEnteredChar == 91 && enteredChar == 66) {
 937 |                     downArrow(-1);
 938 |                 } else if(lastlastEnteredChar == 27 && lastEnteredChar == 91 && enteredChar == 67) {
 939 |                     rightArrow(-1);
 940 |                 } else if(lastlastEnteredChar == 27 && lastEnteredChar == 91 && enteredChar == 68) {
 941 |                     leftArrow(-1);
 942 |                 } else if(lastlastEnteredChar != 27 && lastEnteredChar != 27 && ((enteredChar > 31 && enteredChar < 127) || (enteredChar == 13))) {
 943 |                     if(enteredChar == 13) {enteredChar = '\n';}
 944 |                     char tmp[2];
 945 |                     tmp[0] = enteredChar;
 946 |                     tmp[1] = '\0';
 947 |                     appendChars(newFileString, tmp, newFileStrOffset+1);
 948 |                     refreshDisplay(UPDATE);
 949 |                     rightArrow(enteredChar);
 950 |                 } else if(enteredChar == 127) {
 951 |                     if(newFileStrOffset - 1 > -2) {
 952 |                         if(newFileString[newFileStrOffset] == 10) {
 953 |                             if(editingCursorPositionX <= 1) {
 954 |                                 if(editingCursorPositionY <= 1) {
 955 |                                     removeChar(newFileString, newFileStrOffset);
 956 |                                     leftArrow(-1);
 957 |                                     --editingCursorPositionX;
 958 |                                 } else {
 959 |                                     removeChar(newFileString, newFileStrOffset);
 960 |                                     leftArrow(-1);
 961 |                                     ++newFileStrOffset;
 962 |                                 }
 963 |                             }
 964 |                         } else if(newFileString[newFileStrOffset] == 9) {
 965 |                             editingCursorPositionX -= 4;
 966 |                             removeChar(newFileString, newFileStrOffset);
 967 |                             --newFileStrOffset;
 968 |                         } else {
 969 |                             if(editingCursorPositionX <= 1) {
 970 |                                 if(editingCursorPositionY <= 1) {
 971 |                                     int i = 0;
 972 |                                     while(newFileString[newFileStrOffset - i] != 10 && newFileStrOffset - i > -2 && i<winsize.ws_col) {
 973 |                                         i++;
 974 |                                         --editingPageOffset;
 975 |                                     }
 976 |                                     editingCursorPositionX = i;
 977 |                                     if(i == winsize.ws_col && newFileString[newFileStrOffset - i] != 10) {
 978 |                                         --newFileStrOffset;
 979 |                                     }
 980 |                                     removeChar(newFileString, newFileStrOffset);
 981 |                                     --newFileStrOffset;
 982 |                                 } else {
 983 |                                     removeChar(newFileString, newFileStrOffset);
 984 |                                     int i = 0;
 985 |                                     while(newFileString[newFileStrOffset - i] != 10 && newFileStrOffset - i > -2 && i<winsize.ws_col) {
 986 |                                         i++;
 987 |                                     }
 988 |                                     editingCursorPositionX = i;
 989 |                                     editingCursorPositionY--;
 990 |                                     --newFileStrOffset;
 991 |                                 }
 992 |                             } else {
 993 |                                 --editingCursorPositionX;
 994 |                                 removeChar(newFileString, newFileStrOffset);
 995 |                                 --newFileStrOffset;
 996 |                             }
 997 |                         }
 998 | 
 999 |                         refreshDisplay(UPDATE);
1000 | 
1001 |                         printf("\033[%i;%iH", editingCursorPositionY, editingCursorPositionX);
1002 |                     }
1003 |                 } else if(enteredChar == 9) {
1004 |                     appendChars(newFileString, " ", newFileStrOffset+1);
1005 |                     rightArrow(enteredChar);
1006 |                     appendChars(newFileString, " ", newFileStrOffset+1);
1007 |                     rightArrow(enteredChar);
1008 |                     appendChars(newFileString, " ", newFileStrOffset+1);
1009 |                     rightArrow(enteredChar);
1010 |                     appendChars(newFileString, " ", newFileStrOffset+1);
1011 |                     rightArrow(enteredChar);
1012 |                     refreshDisplay(UPDATE);
1013 |                     printf("\033[%i;%iH", editingCursorPositionY, editingCursorPositionX);
1014 |                 }
1015 |             }
1016 |             lastlastEnteredChar = lastEnteredChar;
1017 |             lastEnteredChar = enteredChar;
1018 |         }
1019 |     }
1020 |     
1021 |     printf(ANSI_COLOR_NORMAL);
1022 |     fclose(fp);
1023 |     fclose(fpClone);
1024 |     system ("/bin/stty cooked");
1025 |     printf("%s", ANSI_SHOW_CURSOR);
1026 |     closedir (pDir);
1027 |     free(consoleText);
1028 |     free(currCloneFilePath);
1029 |     
1030 |     return 0;
1031 | }
1032 | 


--------------------------------------------------------------------------------
/makefile:
--------------------------------------------------------------------------------
1 | defualt: main.c 
2 | 	gcc -std=c11 main.c -o pixt
3 | 


--------------------------------------------------------------------------------