system.c

gehe zur Dokumentation dieser Datei

#pragma once
#include <stdio.h>
#include <stdarg.h>
#include <string.h>

struct OutBuffer display;
CONSOLE_SCREEN_BUFFER_INFO csbi;
int consoleBufferWidth = 80;
int consoleBufferHeight = 15;

void initBuffer(){
    //set text size maximum and insert a first empty line
    display.first = NULL;
    display.last = NULL;
    display.lineCount = 0;
    display.vAlign = 0;
    display.hAlign = 0;
}

struct LineItem* insertNewLineItem(struct LineItem* prev, struct LineItem* next, int maxTextLength){

    //allocate memory for line item
    struct LineItem* newLine = malloc(sizeof(struct LineItem));
    if (newLine==NULL){
        exit(EXITCODE_OUTOFMEMORY);
    }

    //allocate memory for text
    newLine->text = malloc(maxTextLength * sizeof(char) * UTF_MULTIPLIER + 1);
    if (newLine->text==NULL){
        exit(EXITCODE_OUTOFMEMORY);
    }
    newLine->text[0] = '\0';

    //set line properties
    newLine->align = (prev!=NULL?prev->align:-1);
    newLine->byteSize = 0;
    newLine->length = 0;

    //relink previous item if given
    newLine->prev = prev;
    if (prev!=NULL){
        newLine->prev->next = newLine;
    }

    //chain to next item if given
    newLine->next = next;
    if (newLine->next!=NULL){
        newLine->next->prev = newLine;
    }

    //update buffer's first&last pointers
    if (prev==NULL){
        display.first = newLine;
    }
    if (next==NULL){
        display.last = newLine;
    }

    //update line count and return created line
    display.lineCount++;
    return newLine;
}

void deleteLineItem(struct LineItem* line, int deleteAllBelow){
    if (line==NULL){
        return;
    }

    if (!deleteAllBelow){
        //fix the chain by connecting the following line to the previous
        if (line->prev!=NULL){
            line->prev->next = line->next;
        }
    } else {
        //recursive delete requested
        if (line->next!=NULL){
            deleteLineItem(line->next,1);
        }
        if (line->prev!=NULL){
            line->prev->next = NULL;
        }
    }
    free(line->text);
    free(line);
    display.lineCount--;
}

int copyChar(char* src, char* dst){

    //determine the length of the string, see http://en.wikipedia.org/wiki/UTF-8#Description
    int bytes = 0;
    char slider = *src;
    while ((slider & 0x80) == 0x80){
        slider<<=1;
        bytes++;
    }
    bytes+=!bytes;

    //copy <bytes>-byte long character
    int cursor = 0;
    int length = bytes;
    while (length--){
        dst[cursor] = src[cursor];
        cursor++;
    }

    //append null byte and return length of copied data
    dst[cursor] = '\0';
    return bytes;
}

int output(const char* input, ...){
    if (display.first==NULL || display.last==NULL){
        exit(EXITCODE_BUFFERERROR);
    }

    int result;
    va_list args;
    va_start(args, input);
    va_end(args);

    //writing to string buffer
    char buffer[OUTPUT_MAXBUFFER+1];
    buffer[0] = '\0';
    result = vsnprintf(buffer, OUTPUT_MAXBUFFER+1, input, args);

    //keep track of string buffer position and the current line to write to
    int i = 0;
    struct LineItem* current = display.last;

    //loop through buffer and copy to lines
    while(buffer[i]!='\0'){
        if (current->length < display.maxTextLength && buffer[i]!='\n'){
            //line not full yet, copy char
            int increase = copyChar(buffer+i, current->text+current->byteSize);
            i += increase;
            current->byteSize += increase;
            current->length++;
        } else {
            //end line in input: start new line
            if (buffer[i]=='\n'){
                i++;
            }
            //end line or line full, create new one
            current->next = insertNewLineItem(current, NULL, display.maxTextLength);
            current = current->next;
        }
    }

    return result;
}

void flushBuffer(){
    if (display.first==NULL || display.last==NULL){
        exit(EXITCODE_BUFFERERROR);
    }

    if(GetConsoleScreenBufferInfo(GetStdHandle( STD_OUTPUT_HANDLE ),&csbi)) {
        consoleBufferWidth = csbi.dwSize.X;
        consoleBufferHeight = csbi.dwSize.Y;
        if(!FANCY_FONT){
            consoleBufferHeight = 23;
        }
    }

    consoleClear();

    /*### DEBUGGING START ###*/
#ifdef DEBUG
//  static int flushed = 0;
//  printf("DEBUG: printing %d-line buffer (%d.)",display.lineCount,++flushed);
//  struct LineItem* debugchain = display.first;
//  printf(", chain: %d",(int)debugchain);
//  do {
//      printf("(%d)->%d",debugchain->length,(int)debugchain->next);
//      debugchain = debugchain->next;
//  } while (debugchain!=NULL);
//  printf(". [END:%d]\n--------------------------------------------------\n",(int)display.last);
#endif // DEBUG
    /*### DEBUGGING END ###*/

    int i;

    if (display.vAlign==0){
        int marginTopSize = consoleBufferHeight/2 - display.lineCount/2 -1;
        if (marginTopSize > 5){
            printfBanner(consoleBufferWidth,0);
            marginTopSize -= 5;
        }
        for(i = 0; i < marginTopSize; i++){
            printf("\n");
        }
    }

    struct LineItem* current = display.first;
    const int MAX_CHARS_BORDER = 4;
    const int MAX_BYTES_PER_LINE = (display.maxTextLength + MAX_CHARS_BORDER + 1) * sizeof(char) * UTF_MULTIPLIER;
    char* collector = malloc(display.lineCount * MAX_BYTES_PER_LINE + 1);
    if (collector==NULL){
        exit(EXITCODE_OUTOFMEMORY);
    }
    collector[0] = '\0';

    //calculate left margin for box position
    int leftMarginSize = 1;
    if (display.hAlign==0){
        leftMarginSize = consoleBufferWidth/2 - display.maxTextLength/2 - 1;
    }
    char* leftMargin = malloc(sizeof(char)*leftMarginSize+1);
    if (leftMargin==NULL){
        exit(EXITCODE_OUTOFMEMORY);
    }
    memset(leftMargin,' ',leftMarginSize);
    leftMargin[leftMarginSize] = '\0';

    //draw header line
    strcat(collector,leftMargin);
    strcat(collector,FONT_DPIPE_TOP_LEFT);
    for (i = 0; i < display.maxTextLength; i++){
        strcat(collector,FONT_DPIPE_HORI_BAR);
    }
    strcat(collector,FONT_DPIPE_TOP_RIGHT);
    strcat(collector,"\n");

    //temporary:
    printf("%s",collector);
    collector[0] = '\0';

    //draw lines
    int leftPaddingSize = 0;
    int rightPaddingSize;

    while (current!=NULL){
        //padding calculations
        switch (current->align){
        case -1:
            leftPaddingSize = 0;
            break;
        case 0:
            leftPaddingSize = display.maxTextLength/2 - current->length/2;
            break;
        case +1:
            leftPaddingSize = display.maxTextLength - current->length;
            break;
        }
        rightPaddingSize = display.maxTextLength - current->length - leftPaddingSize;

        //left border and left padding
        strcat(collector,leftMargin);
        strcat(collector,FONT_DPIPE_VERT_BAR);
        strcatRepeat(collector," ",leftPaddingSize);
        //text
        strcat(collector,current->text);
        //right padding and right border
        strcatRepeat(collector," ",rightPaddingSize);
        strcat(collector,FONT_DPIPE_VERT_BAR);
        strcat(collector,"\n");
        current = current->next;
        //temporary:
        printf("%s",collector);
        collector[0] = '\0';
    }
    //draw footer line
    strcat(collector,leftMargin);
    strcat(collector,FONT_DPIPE_BOTTOM_LEFT);
    for (i = 0; i < display.maxTextLength; i++){
        strcat(collector,FONT_DPIPE_HORI_BAR);
    }
    strcat(collector,FONT_DPIPE_BOTTOM_RIGHT);

    printf("%s",collector);
    collector[0] = '\0';

    free(collector);

    deleteLineItem(display.first, 1);
    initBuffer();
}

void startBuffer(int maxTextLength){
    if (display.first!=NULL || display.last!=NULL){
        //display not initialized
        exit(EXITCODE_BUFFERERROR);
    }

    if (maxTextLength>consoleBufferWidth-4){
        //requested buffer too large for window size
        exit(EXITCODE_WINDOWERROR);
    }

    if (maxTextLength<1){
        exit(EXITCODE_BUFFERERROR);
    }

    display.maxTextLength = maxTextLength;
    deleteLineItem(display.first, 1);
    display.lineCount = 0;
    display.first = insertNewLineItem(NULL,NULL,maxTextLength);
}

void setLineAlign(int align){
    if(display.last==NULL){
        exit(EXITCODE_BUFFERERROR);
    }
    display.last->align = align;
}

void printfBanner(int width, int startAt){
    int length = 57;
    char* banner[5];
    banner[0] = "_________                              _____     _____ __\n";
    banner[1] = "__  ____/________________________________  /_    __  // /\n";
    banner[2] = "_  /    _  __ \\_  __ \\_  __ \\  _ \\  ___/  __/    _  // /_\n";
    banner[3] = "/ /___  / /_/ /  / / /  / / /  __/ /__ / /_      /__  __/\n";
    banner[4] = "\\____/  \\____//_/ /_//_/ /_/\\___/\\___/ \\__/        /_/   \n";
    int i;
    char* bannerBuffer = malloc(sizeof(char)*(width+1)*5);
    bannerBuffer[0] = '\0';
    for(i = startAt; i<5; i++){
        strcatRepeat(bannerBuffer," ",width/2-length/2-1);
        strcat(bannerBuffer,banner[i]);
    }
    printf("%s",bannerBuffer);
}

void animateBanner(int slideIn){
    int i = (slideIn ? 5 : 0);
    while(i >= 0 && i <=5){
        consoleClear();
        printfBanner(consoleBufferWidth,i);
        Sleep(50);
        i += (slideIn ? -1 : +1);
    }
}

void animateBox(int wFrom, int hFrom, int wTo, int hTo){
    int w = wFrom;
    int h = hFrom;
    while(w < wTo){
        printEmptyBox(w,h);
        w++;
    }
    while(h < hTo){
        printEmptyBox(w,h);
        h++;
    }
    while(h > hTo){
        printEmptyBox(w,h);
        h--;
    }
    while(w > wTo){
        printEmptyBox(w,h);
        w--;
    }
}

void printEmptyBox(int w, int h){
    int i;
    startBuffer(w);
    for (i = 0; i < h; i++) output("\n");
    flushBuffer();
}

void consoleClear(){
    //should clear the console on most plattforms
    #ifdef _WIN32
    //detected windows System (both 32 and 64bit)-->use windows clear
        system("CLS");
    #else
    //detected other (non windows) System-->unse Unix-clear
        system("clear");
    #endif

}
char lower_to_upper(char ch1)
{
      char ch2;

      if(ch1 >= 'a' && ch1 <= 'z'){
            ch2 = ('A' + ch1 - 'a');
            return ch2;
      }
      else{
            ch2 = ch1;
            return ch2;
      }
}

void strcatRepeat(char* target, const char* source, unsigned int howOften){
    int c;
    for(c = 0; c < howOften; c++){
        strcat(target,source);
    }
}