A Very Simple Double Screen Buffer

The reason for creating a screen buffer is to have greater control over how things are displayed on  screen. It acts as an 'intermediary' step in memory before printing the final result to the terminal. If you have another copy of the buffer in memory, you can revert to previous stages.

Imagine you want to display a window to the user. Before doing so, you push the current screen to the old buffer. You show the new screen with the window on it and finally you pop or recover the previous screen from the old buffer. If you just update to screen the characters that have changed you can avoid any flickering effects that will come about by updating the whole screen every time.

In the old days of DOS, this could be achieved by accessing an absolute address in memory $B800:$0000.

[Old buffer] ----> [Current Buffer] -----> [Final Display]

To create the buffer, we need to know the terminal dimensions in rows and columns. (See previous post). Because the terminal dimensions vary, we cannot predict before execution how large the buffer will be. That's why we need a dynamic structure in memory. My version uses a single linked list composed of cells. Each cell accounts for every 'pixel' on screen and records some attributes in a structure form -  namely, the character to be displayed along with its background and foreground colors. The size of our list will be determined by rows x columns. This representation in memory of the screen will need subroutines to control the display. Everything you want to show on screen will be printed to the buffer first. Then the update routine will finally show the final composition to the user. An additional buffer, called old_buffer, will help us revert to previous screens so as to show, for instance, a window area to the user and then closing it without affecting the text or screen portion that was behind it prior to the window being shown. The next step will be to create dynamic windows that store the information behind them in their structure. 


Structure detail + Screen caps:

Dropdown menu in text-mode/terminal coded in C for linux.

Source code:
https://mega.nz/file/cP1ABB5Z#IgZ2C-rR8R6Tw3LoLao8EMJbaIXTkKjNvrQk3KEpajw

Instructions: Download, uncompress and type make to build. Execute: ./test1

YET MORE ANSI FUNCTIONS + TERMINAL DIMENSIONS

I'm working on creating a double screen buffer in C to have greater control of the display on the terminal. In the meantime, more useful functions useful to that end. :)

Show/Hide cursor:
void hide_cursor()
{
  printf("\e[?25l");
}

void show_cursor()
{
  printf("\e[?25h");
}

Draw box-like characters on Linux Terminal:

ASCII characters change from 106 to 121.

printf("%c(0", 0x1b); // Border chars on

printf("%c(B", 0x1b); // border chars off

Get Terminal Dimensions:

#include <sys/ioctl.h>
#include <stdio.h>

struct winsize max;
int get_terminal_dimensions(int *rows, int *columns)
{
//Get dimensions of screen and pass them by value.
  ioctl(0, TIOCGWINSZ , &max);
  *columns = max.ws_col;
  *rows = max.ws_row;
   return 0;
}

C POINTERS - CIRCULAR DOUBLY LINKED LIST

A Simple Selection Menu in C with Ansi functions. 
This time I'm working on creating a circular list with pointers so as to display choice menus in C using colors to highlight the items. 

In my implementation, I have used 3 external global pointers (head, former and tail). That probably means that I can only create one list as these pointers are global variables.

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <termios.h> #include <unistd.h> #include <sys/ioctl.h> /* Last modified : 19/9/2017 Coded by Velorek. Some of the terminal routines from: https://stackoverflow.com/questions/7469139/what-is-equivalent-to-getch-getche-in-linux Circular linked list to make a selection menu in C. Target OS: Linux. */ // Background colors low intensity #define B_BLACK 40 #define B_RED 41 #define B_GREEN 42 #define B_YELLOW 43 #define B_BLUE 44 #define B_MAGENTA 45 #define B_CYAN 46 #define B_WHITE 47 // Foreground colors low intensity #define F_BLACK 30 #define F_RED 31 #define F_GREEN 32 #define F_YELLOW 33 #define F_BLUE 34 #define F_MAGENTA 35 #define F_CYAN 36 #define F_WHITE 37 // Background colors high intensity #define BH_BLACK 100 #define BH_RED 101 #define BH_GREEN 102 #define BH_YELLOW 103 #define BH_BLUE 104 #define BH_MAGENTA 105 #define BH_CYAN 106 #define BH_WHITE 107 // Foreground colors high intensity #define FH_BLACK 90 #define FH_RED 91 #define FH_GREEN 92 #define FH_YELLOW 93 #define FH_BLUE 94 #define FH_MAGENTA 95 #define FH_CYAN 96 #define FH_WHITE 97 #define TRUE 1 #define FALSE 0 typedef int BOOL; /* Global Variables */ struct winsize max; static struct termios old, new; int rows, columns, old_rows, old_columns; typedef struct _listchoice { int index; // Item number int backcolor0; // Back and Fore colors when not selected int forecolor0; int backcolor1; // Back and Fore colors when selected int forecolor1; int wherex; // Position of the item int wherey; char *item; // Item string struct _listchoice *next; // Pointer to next item struct _listchoice *back; // Pointer to previous item. } LISTCHOICE; LISTCHOICE *head=NULL; LISTCHOICE *tail=NULL; LISTCHOICE *former=NULL; LISTCHOICE *mylist=NULL; /* Terminal manipulation routines */ void gotoxy(int x,int y) //Sets the cursor at the desired position. { printf("%c[%d;%df",0x1B,y,x); } void outputcolor(int foreground, int background) //Changes format foreground and background colors of display. { printf("%c[%d;%dm", 0x1b,foreground,background); } void screencol(int x) { //change color of entire screen gotoxy(0,0); outputcolor(0,x); printf("%c[2J", 0x1b); outputcolor(0,0); } /* Initialize new terminal i/o settings */ void initTermios(int echo) { tcgetattr(0, &old); /* grab old terminal i/o settings */ new = old; /* make new settings same as old settings */ new.c_lflag &= ~ICANON; /* disable buffered i/o */ new.c_lflag &= echo ? ECHO : ~ECHO; /* set echo mode */ tcsetattr(0, TCSANOW, &new); /* use these new terminal i/o settings now */ } /* Restore old terminal i/o settings */ void resetTermios(void) { tcsetattr(0, TCSANOW, &old); } /* Read 1 character - echo defines echo mode */ char getch_(int echo) { char ch; initTermios(echo); ch = getchar(); resetTermios(); return ch; } /* Read 1 character without echo */ char getch(void) { return getch_(0); } /* Read 1 character with echo */ char getche(void) { return getch_(1); } int get_terminal_dimensions(int *rows, int *columns) { //Get dimensions of screen by value. ioctl(0, TIOCGWINSZ , &max); *columns = max.ws_col; *rows = max.ws_row; return 0; } /* Dynamic List routines */ void add_item(LISTCHOICE *list_identifier, char *str, int x, int y,int bcolor0, int fcolor0, int bcolor1, int fcolor1) { LISTCHOICE *newp; if (head == NULL && list_identifier == NULL) { //Reserve memory list_identifier = (LISTCHOICE *) malloc(sizeof(LISTCHOICE)); head = list_identifier; tail = list_identifier; //Create first item of the list and assign properties to it. list_identifier->backcolor0 = bcolor0; list_identifier->backcolor1 = bcolor1; list_identifier->forecolor0 = fcolor0; list_identifier->forecolor1 = fcolor1; list_identifier->wherex = x; list_identifier->wherey = y; list_identifier-> item = (char *)malloc(strlen(str) +1); strcpy(list_identifier->item, str); list_identifier->next = head; list_identifier->back = head; list_identifier->index = 0; } else { //Circular list structure newp = (LISTCHOICE *) malloc(sizeof(LISTCHOICE)); former = tail; //former pointer points to previous-last item former->next = newp; //previous item forward points to current item newp->back = former; //new item back points to previous-last item tail = newp; //the tail now 'becomes' (points to) the new item head->back = tail; // This way we close the circular list : First item back points to last item tail->next = head; // Last item next points to first item. //Creates subsequent items of the list and assign properties to it. newp->backcolor0 = bcolor0; newp->backcolor1 = bcolor1; newp->forecolor0 = fcolor0; newp->forecolor1 = fcolor1; newp->wherex = x; newp->wherey = y; newp->item = (char*) malloc(strlen(str) + 1); strcpy(newp->item, str); newp->index = former->index + 1; } } void free_list(LISTCHOICE *list_identifier) { /* removes list from memory */ LISTCHOICE *aux, *p; aux = tail; do { p=aux; aux = aux->back; free(p->item); //free off the string field free(p); //remove item } while (aux != head->back); } void move_up(LISTCHOICE *aux) { //Unmark Former Item gotoxy(aux->wherex,aux->wherey); outputcolor(aux->forecolor0,aux->backcolor0); printf("%s\n", aux->item); //Highlight current item *aux=*aux->back; //Go to previous item gotoxy(aux->wherex,aux->wherey); outputcolor(aux->forecolor1,aux->backcolor1); printf("%s\n", aux->item); } void move_down(LISTCHOICE *aux) { //Unmark Former Item gotoxy(aux->wherex,aux->wherey); outputcolor(aux->forecolor0,aux->backcolor0); printf("%s\n", aux->item); //Highlight current item *aux=*aux->next; //Go to next item gotoxy(aux->wherex,aux->wherey); outputcolor(aux->forecolor1,aux->backcolor1); printf("%s\n", aux->item); } void display_list() { /* Displays the items contained in the list with the properties specified in init_list. until the auxiliary pointer reaches the first item again First item is equal to tail->next. */ LISTCHOICE *aux; aux = head; do { gotoxy(aux->wherex,aux->wherey); outputcolor(aux->forecolor0,aux->backcolor0); printf("%s\n", aux->item); aux = aux->next; } while (aux != tail->next); } void start_vmenu(LISTCHOICE *list_data) { /* Starts the selection menu */ char ch; LISTCHOICE aux; display_list(); //display whole list //Highlight first item on the list aux=*tail; //Auxiliary variable points to last item move_down(&aux); //Move down to point to highlight first item. ch=0; // reset and initialise ch value while (ch != 10) // enter key { ch=getch(); if (ch=='\033') // escape key { getch(); // read key again for arrow key combinations switch(getch()) { case 'A': // escape key + A => arrow key up move_up(&aux); break; case 'B': // escape key + B => arrow key down move_down(&aux); break; } } } if (ch==10) // enter key { //Pass data of last item by value. *list_data = aux; } } int main_screen() { //Draws the main screen int i,j; //Draw the main screen rows=0; columns=0; screencol(B_BLUE); gotoxy(1,1); outputcolor(0,F_WHITE); //Save previous values old_rows = rows; old_columns = columns; get_terminal_dimensions(&rows,&columns); if (rows==0) rows=25; //just in case it can't find the terminal dimensions if (columns==0) columns=80; //Draw upper and lower bars outputcolor(F_WHITE,B_CYAN); for (i=0;i<=columns;i++) { gotoxy(i,1); printf(" "); } outputcolor(F_WHITE,B_WHITE); for (i=0;i<=columns;i++) { gotoxy(i,rows); printf(" "); } outputcolor(F_BLACK,B_CYAN); gotoxy(1,1); printf(" File Options Help"); outputcolor(FH_WHITE,B_BLUE); gotoxy(2,3); printf("Selection Menu"); gotoxy(2,4); printf("=============="); gotoxy(columns-6,1); outputcolor(FH_YELLOW,B_CYAN); printf("%d:%d",columns,rows); outputcolor(F_BLACK,B_WHITE); gotoxy(1,rows); printf("- Coded by Velorek"); } int main() { LISTCHOICE data; screencol(FH_BLUE); main_screen(); add_item(mylist,"Option 1",3,6,B_BLUE,FH_WHITE,B_RED,F_WHITE); add_item(mylist,"Option 2",3,7,B_BLUE,FH_WHITE,B_RED,F_WHITE); add_item(mylist,"Option 3",3,8,B_BLUE,FH_WHITE,B_RED,F_WHITE); add_item(mylist,"Option 4",3,9,B_BLUE,FH_WHITE,B_RED,F_WHITE); add_item(mylist,"Option 5",3,10,B_BLUE,FH_WHITE,B_RED,F_WHITE); add_item(mylist,"Exit",3,11,B_BLUE,FH_WHITE,B_GREEN,F_WHITE); outputcolor(F_BLUE,B_BLACK); do { start_vmenu(&data); gotoxy(20,18); printf("You have selected: %i:%s\n",data.index+1,data.item); } while (strcmp(data.item,"Exit") != 0); free_list(mylist); screencol(B_BLACK); printf("\n"); return 0; }

 Display:

We Love Colors - ANSI Functions II in C

You have several options to give your program a more attractive look in text-mode. Ncurses,for one, in Linux is an excellent choice. But if you want to keep it simple and do things fast, you can resort to using ANSI escape sequences. They work like a charm on Linux terminals. Unfortunately, its support was removed from Windows terminals. Although I hear Windows 10 has brought back support to these sequences. Alternatively, check Ansicon for windows support. 

From Wikipedia:

In C:

int gotoxy(int x,int y)
//Sets the cursor at the desired position.
{
  printf("%c[%d;%df",0x1B,y,x);
  return 0;
}

int outputcolor(int foreground, int background)
//Changes format foreground and background colors of display.
{
  printf("%c[%d;%dm", 0x1b,foreground,background);
  return 0;
}

int screencol(int x)
// Changes color of the entire screen.
{
  gotoxy(0,0);
  outputcolor(0,x);
  printf("%c[2J", 0x1b);
  outputcolor(0,0);
  return 0;
}

Cellular Automata - Rule 90 and Rule 110

A cellular automaton is a model used in computer science and mathematics. The idea is to model a dynamic system by using a number of cells. Each cell has one of several possible states. With each "turn" or iteration the state of the current cell is determined by two things: its current state, and the states of the neighbouring cells.

My program (coded in freepascal).

Source WIKIPEDIA.

Rule 90:

current pattern	111	110	101	100	011	010	001	000
new state for center cell	0	1	0	1	1	0	1	0

Output generated by my freepascal program of rule 90:

Rule 110:

current pattern	111	110	101	100	011	010	001	000
new state for center cell	0	1	1	0	1	1	1	0

Output generated by my freepascal program of rule 110:

RGB Convert- Bitshift - SHR

If you want to convert an hexadecimal into its RGB components using a very fast technique then you should try Logical Shift. A logical shift is a bitwise operation that shifts all the bits of its operand. The two base variants are the logical left shift (SHL) and the logical right shift (SHR). They come from the good old days of Assembler.

So, how does it work? In our example, we will obtain the components or channels of the following hexadecimal value.

#ff0cf0 base 16

We want to get from 16714992 base 10 to:

red=255 ;  green=12 ; blue=240.

Note: To simplify we will just use 16 bytes and not RGBA of 24 bytes that includes the alpha (transparency) component. 

<Sample code in Freepascal:>

Program Convert;

var

  r,g,b: longint;

procedure RGB_Convert(RGB:longint; var r,g,b:longint); 

{Byvalue reference (var r,g,b). That means that we pass variables to the functions no values.}

begin

   R := (RGB shr 16);

   G := (RGB shr 8) and 255;

   B := (RGB) and 255;

end;

Begin

  RGB_Convert($ff0cf0,r,g,b);

End.

A Simple Scroll Function

Imagine you want to display a long list of items but you have a limited area to show them on screen. In that case, you have to resort to using scroll.  Let me explain in pseudo-code one way of doing it.

Length is a function that gives the number of items contained in an array of items.

In our example DisplayLength will tell us how many items will be shown on screen. Here, we have set its value to two.

DisplayLength = 2;

Index will be the variable that holds the pointer of the current item on the list. At the beginning, it will point to the first item on the list. Hence index=0;

(Note: Computer scientists always like to start counting at 0)

Index = 0; 

Scroll_Limit will tell us how far we can keep scrolling. When Index = Scroll-Limit that means that we have reached the end of our scroll capabilities and that all items have been displayed to the user.

This is how to calculate it.

Scroll_Limit = Length (List A) - DisplayLength

In our example. Scroll_Limit = (6 - 2) = 4.

Here is our list: 

LIST A   (6 items)                DISPLAY (2 items)

aaaaa 0  -> index points to first item;

bbbbb 1

ccccc 2    

ddddd 3  

eeeee 4    

fffff 5

Imagine that you want to go forward in your list by pressing the arrow down button  (while index <= scroll_Limit). Remember that in this example, Scroll_Limit=4. This would be the result.

CODE: IMPLEMENTATION OF A LIST WITH SCROLL IN C
 

Now to go back, say, with the press of the up arrow key. You just have to decrease the value of index.

index-=1; Remember to set the limit at 0. Allow the key to be processed only if index>0;

Output:

Learning C++ - Credit Card Verification

#include <iostream> #include <string> using namespace std; int isNumber(string temp) { // check whether the input is a // 16-digit number by comparing the items // in the string with the ascii values // for numbers starting at 0:48 to 9:57 int tc; for (int x =0; x<temp.length(); x++) { tc = temp[x]; if (tc>=48 && tc <= 57) { if (x==temp.length()-1) return 1; } else { return 0; } } } int val(char ch) { // change char of a number to its int value. // 0 in ascii starts at 48 hence the value in the return function. int tc; tc = ch; return (tc-48); } int luhn (string temp) { // luhn algorithm or modulo 10. // more info on wikipedia. int sum,total,valtemp; sum=0; for (int x=0; x< temp.length();x++) { if (x % 2 == 0) { valtemp = val(temp[x]) *2; if (valtemp > 9) valtemp -= 9; } else { valtemp = val(temp[x]); } sum += valtemp; } if (sum%10 == 0) { //number is valid. return 1; } else { //number is not valid return 0; } } int process(string temp) { // process user input if (temp.length() < 16 || temp.length()> 16) { cout << "Error: Please insert 16 digits." << endl; } else { if (isNumber(temp) == 1) { cout<<"Calculating..." << endl; if (luhn(temp)==1) { cout << "Validated: Credit card number is valid." << endl; } else { cout << "Credit card number is not valid" << endl; } } else { cout << "Only numbers are permitted." << endl; } } return 0; } int main() { string temp; //User Input. cout << "Check credit card(16 digits):"<< endl; cin >> temp; process(temp); return 0; }