reformat

c_os/devices/LFBgraphics.cc

@@ -15,12 +15,10 @@
 #include "devices/LFBgraphics.h"
 #include "kernel/Globals.h"
 
-
 /* Hilfsfunktionen */
 void swap(unsigned int* a, unsigned int* b);
 int abs(int a);
 
-
 /*****************************************************************************
  * Methode:         LFBgraphics::drawMonoBitmap                              *
  *---------------------------------------------------------------------------*
@@ -61,7 +59,6 @@ inline void LFBgraphics::drawMonoBitmap( unsigned int x, unsigned int y,
     }
 }
 
-
 /*****************************************************************************
  * Methode:         LFBgraphics::drawString                                  *
  *---------------------------------------------------------------------------*
@@ -76,16 +73,13 @@ inline void LFBgraphics::drawMonoBitmap( unsigned int x, unsigned int y,
  *****************************************************************************/
 void LFBgraphics::drawString(Font& fnt, unsigned int x, unsigned int y,
                              unsigned int col, char* str, unsigned int len) {
-    unsigned int i;
+    for (unsigned int i = 0; i < len; ++i) {
-        
-    for(i = 0; i < len; ++i) {
         drawMonoBitmap(x, y, fnt.get_char_width(), fnt.get_char_height(),
                        fnt.getChar(*(str + i)), col);
         x += fnt.get_char_width();
     }
 }
 
-
 /*****************************************************************************
  * Methode:         LFBgraphics::drawPixel                                   *
  *---------------------------------------------------------------------------*
@@ -97,13 +91,16 @@ void LFBgraphics::drawString(Font &fnt, unsigned int x, unsigned int y,
 void LFBgraphics::drawPixel(unsigned int x, unsigned int y, unsigned int col) {
     unsigned char* ptr = (unsigned char*)lfb;
 
-    if (hfb == 0 || lfb == 0) return ;
+    if (hfb == 0 || lfb == 0) {
+        return;
+    }
 
     if (mode == 0) ptr = (unsigned char*)hfb;
 
     // Pixel ausserhalb des sichtbaren Bereichs?
-    if (x<0 || x>=xres || y<0 || y>yres)
+    if (x < 0 || x >= xres || y < 0 || y > yres) {
         return;
+    }
 
     // Adresse des Pixels berechnen und Inhalt schreiben
     switch (bpp) {
@@ -118,20 +115,25 @@ void LFBgraphics::drawPixel(unsigned int x, unsigned int y,unsigned int col) {
         return;
     case 24:
         ptr += (3 * x + 3 * y * xres);
-            *ptr = (col & 0xFF); ptr++;
+        *ptr = (col & 0xFF);
-            *ptr = ((col>>8) & 0xFF); ptr++;
+        ptr++;
-            *ptr = ((col>>16) & 0xFF); ptr++;
+        *ptr = ((col >> 8) & 0xFF);
+        ptr++;
+        *ptr = ((col >> 16) & 0xFF);
+        ptr++;
         return;
     case 32:
         ptr += (4 * x + 4 * y * xres);
-            *ptr = (col & 0xFF); ptr++;
+        *ptr = (col & 0xFF);
-            *ptr = ((col>>8) & 0xFF); ptr++;
+        ptr++;
-            *ptr = ((col>>16) & 0xFF); ptr++;
+        *ptr = ((col >> 8) & 0xFF);
+        ptr++;
+        *ptr = ((col >> 16) & 0xFF);
+        ptr++;
         return;
     }
 }
 
-
 /*****************************************************************************
  * Methode:         LFBgraphics::clear                                       *
  *---------------------------------------------------------------------------*
@@ -141,44 +143,48 @@ void LFBgraphics::clear() {
     unsigned int* ptr = (unsigned int*)lfb;
     unsigned int i;
 
+    if (hfb == 0 || lfb == 0) {
+        return;
+    }
 
-    if (hfb == 0 || lfb == 0) return ;
+    if (mode == 0) {
-
+        ptr = (unsigned int*)hfb;
-    if (mode == 0) ptr = (unsigned int *) hfb;
+    }
 
     switch (bpp) {
     case 8:
-            for (i=0; i < ((xres/4)*yres); i++)
+        for (i = 0; i < ((xres / 4) * yres); i++) {
             *(ptr++) = 0;
+        }
         return;
     case 15:
     case 16:
-            for (i=0; i < (2*(xres/4)*yres); i++)
+        for (i = 0; i < (2 * (xres / 4) * yres); i++) {
             *(ptr++) = 0;
+        }
         return;
     case 24:
-            for (i=0; i < (3*(xres/4)*yres); i++)
+        for (i = 0; i < (3 * (xres / 4) * yres); i++) {
             *(ptr++) = 0;
+        }
         return;
     case 32:
-            for (i=0; i < (4*(xres/4)*yres); i++)
+        for (i = 0; i < (4 * (xres / 4) * yres); i++) {
             *(ptr++) = 0;
+        }
         return;
     }
 }
 
-
 /*****************************************************************************
  * Methode:         LFBgraphics::setDrawingBuff                              *
  *---------------------------------------------------------------------------*
  * Beschreibung:    Stellt ein, ob in den sichtbaren Puffer gezeichnet wird. *
  *****************************************************************************/
-void LFBgraphics::setDrawingBuff(int v) 
+void LFBgraphics::setDrawingBuff(int v) {
-{
     mode = v;
 }
 
-
 /*****************************************************************************
  * Methode:         LFBgraphics::copyHiddenToVisible                         *
  *---------------------------------------------------------------------------*
@@ -193,37 +199,39 @@ void LFBgraphics::copyHiddenToVisible() {
 
     switch (bpp) {
     case 8:
-            for (i=0; i < ((xres/4)*yres); i++)
+        for (i = 0; i < ((xres / 4) * yres); i++) {
             *(dptr++) = *(sptr++);
+        }
         return;
     case 15:
     case 16:
-            for (i=0; i < (2*(xres/4)*yres); i++)
+        for (i = 0; i < (2 * (xres / 4) * yres); i++) {
             *(dptr++) = *(sptr++);
+        }
         return;
     case 24:
-            for (i=0; i < (3*(xres/4)*yres); i++)
+        for (i = 0; i < (3 * (xres / 4) * yres); i++) {
             *(dptr++) = *(sptr++);
+        }
         return;
     case 32:
-            for (i=0; i < (4*(xres/4)*yres); i++)
+        for (i = 0; i < (4 * (xres / 4) * yres); i++) {
             *(dptr++) = *(sptr++);
+        }
         return;
     }
 }
 
-
-
 void swap(unsigned int* a, unsigned int* b) {
-   int h;
+    int h = *a;
-   
-   h = *a;
 
     *a = *b;
     *b = h;
 }
 
 int abs(int a) {
-	if (a<0) return -a;
+    if (a < 0) {
+        return -a;
+    }
     return a;
 }

c_os/devices/LFBgraphics.h

@@ -17,7 +17,6 @@
 
 #include "devices/fonts/Fonts.h"
 
-
 // Hilfsfunktionen um Farbwerte fuer einen Pixel zu erzeugen
 #define RGB_24(r, g, b) (unsigned int)((r << 16) + (g << 8) + b)
 
@@ -27,7 +26,7 @@
 class LFBgraphics {
 
 private:
-    LFBgraphics (const LFBgraphics &copy);  // Verhindere Kopieren
+    LFBgraphics(const LFBgraphics& copy) = delete;  // Verhindere Kopieren
 
     // Hilfsfunktion fuer drawString
     void drawMonoBitmap(unsigned int x, unsigned int y,
@@ -41,7 +40,7 @@ public:
     unsigned int hfb;         // Adresse des versteckten Buffers (optional, fuer Animationen)
     unsigned int mode;        // Zeichnen im sichtbaren = 1 oder unsichtbaren = 0 Puffer
 
-    LFBgraphics () { mode = BUFFER_VISIBLE; };
+    LFBgraphics() : mode(BUFFER_VISIBLE) {};
 
     void clear();
     void drawPixel(unsigned int x, unsigned int y, unsigned int col);
@@ -54,7 +53,6 @@ public:
 
     // kopiert 'hfb' nach 'lfb'
     void copyHiddenToVisible();
-    
 };
 
 #endif

c_os/main.cc

@@ -13,6 +13,7 @@
 #include "kernel/Globals.h"
 #include "user/CoopThreadDemo.h"
 #include "user/HelloWorldThread.h"
+#include "user/VBEdemo.h"
 
 int main() {
     kout.clear();
@@ -25,7 +26,7 @@ int main() {
 
     // Startmeldung
     if constexpr (!DEBUG) {
-        kout << "HHUos 0.6\n"
+        kout << "HHUos 0.7\n"
              << "=========\n"
              << "Unterstuetzte Funktionen:\n"
              << "   - Bildschirmausgaben\n"
@@ -34,6 +35,7 @@ int main() {
              << "   - Einfache Heap verwaltung\n"
              << "   - Tastatureingaben per Interrupt\n"
              << "   - Kooperative Threads\n"
+             << "   - VESA Graphics Mode\n"
              << endl;
     }
 
@@ -54,7 +56,9 @@ int main() {
 
     // Threads anlegen
     // scheduler.ready(new HelloWorldThread());
-    scheduler.ready(new CoopThreadDemo());
+    // scheduler.ready(new CoopThreadDemo());
+
+    scheduler.ready(new VBEdemo());
 
     // Scheduler starten (schedule() erzeugt den Idle-Thread)
     scheduler.schedule();

c_os/user/VBEdemo.cc

@@ -8,26 +8,22 @@
  * Autor:           Michael Schoettner, HHU, 26.12.2016                      *
  *****************************************************************************/
 
-#include "kernel/Globals.h"
 #include "user/VBEdemo.h"
 #include "devices/fonts/Fonts.h"
+#include "kernel/Globals.h"
 
 // Bitmap
 #include "bmp_hhu.cc"
 
-
 /*****************************************************************************
  * Methode:         VBEdemo::linInterPol1D                                   *
  *---------------------------------------------------------------------------*
  * Beschreibung:    Farbwert in einer Dimension interpoliert berechnen.      *
  *****************************************************************************/
 int VBEdemo::linInterPol1D(int x, int xr, int l, int r) {
-    return ((((l>>16)*(xr-x)+(r>>16)*x)/xr)<<16)
+    return ((((l >> 16) * (xr - x) + (r >> 16) * x) / xr) << 16) | (((((l >> 8) & 0xFF) * (xr - x) + ((r >> 8) & 0xFF) * x) / xr) << 8) | (((l & 0xFF) * (xr - x) + (r & 0xFF) * x) / xr);
-    |(((((l>>8)&0xFF)*(xr-x)+((r>>8)&0xFF)*x)/xr)<<8)
-    |(((l&0xFF)*(xr-x)+(r&0xFF)*x)/xr);
 }
 
-
 /*****************************************************************************
  * Methode:         VBEdemo::linInterPol2D                                   *
  *---------------------------------------------------------------------------*
@@ -39,14 +35,14 @@ int VBEdemo::linInterPol2D(int x, int y, int lt, int rt, int lb, int rb) {
                          linInterPol1D(x, vesa.xres, lb, rb));
 }
 
-
 /*****************************************************************************
  * Methode:         VBEdemo::drawColors                                      *
  *---------------------------------------------------------------------------*
  * Beschreibung:    Pixel-Demo.                                              *
  *****************************************************************************/
 void VBEdemo::drawColors() {
-    int x_res=640, y_res=480;
+    int x_res = 640;
+    int y_res = 480;
 
     for (int y = 0; y < y_res; y++) {
         for (int x = 0; x < x_res; x++) {
@@ -55,7 +51,6 @@ void VBEdemo::drawColors () {
     }
 }
 
-
 /*****************************************************************************
  * Methode:         VBEdemo::drawBitmap                                      *
  *---------------------------------------------------------------------------*
@@ -68,10 +63,8 @@ void VBEdemo::drawBitmap () {
     unsigned char* sprite_pixel = (unsigned char*)hhu.pixel_data;
 
     /* Hier muss Code eingefuegt werden */
-
 }
 
-
 /*****************************************************************************
  * Methode:         VBEdemo::drawFonts                                       *
  *---------------------------------------------------------------------------*
@@ -80,10 +73,8 @@ void VBEdemo::drawBitmap () {
 void VBEdemo::drawFonts() {
 
     /* Hier muss Code eingefuegt werden */
-   
 }
 
-
 /*****************************************************************************
  * Methode:         VBEdemo::run                                             *
  *---------------------------------------------------------------------------*

c_os/user/VBEdemo.h

@@ -10,14 +10,12 @@
 #ifndef __VBEdemo_include__
 #define __VBEdemo_include__
 
-
 #include "kernel/threads/Thread.h"
 
-
 class VBEdemo : public Thread {
 
 private:
-    VBEdemo (const VBEdemo &copy); // Verhindere Kopieren
+    VBEdemo(const VBEdemo& copy) = delete;  // Verhindere Kopieren
 
     // Hilfsfunktionen fuer drawColors()
     int linInterPol1D(int x, int xr, int l, int r);
@@ -25,10 +23,10 @@ private:
 
 public:
     // Gib dem Anwendungsthread einen Stack.
-    VBEdemo () : Thread () { }
+    VBEdemo() {}
 
     // Thread-Startmethode
-    void run ();
+    void run() override;
 
     // Farbraum ausgeben
     void drawColors();