---

/home/landauf/painter/miniproject/effects/classes.cpp

Go to the documentation of this file.

#include "classes.h"

// Point                                                                     //
point::point(int _x, int _y)
{
    x = _x;
    y = _y;
}

bool point::checkArea(point _low, point _high)
{
    return (x >= _low.x && x <= _high.x && y >= _low.y && y <= _high.y);
}

void point::set(int _x, int _y)
{
    x = _x;
    y = _y;
}

// Limit                                                                     //
limit::limit(int _low, int _high)
{
    low = _low;
    high = _high;
}

bool limit::checkLimit(float _value)
{
    return (_value >= low && _value <= high);
}

float limit::forceLimit(float _value)
{
    if (_value > high)
        return high;
    else if (_value < low)
        return low;
    else
        return _value;
}

int limit::intForceLimit(float _value)
{
    if (_value > high)
        return int(high);
    else if (_value < low)
        return int(low);
    else
        return int(_value);
}

void limit::set(int _low, int _high)
{
    low = _low;
    high = _high;
}

// Matrix                                                                    //
matrix::matrix(float *_E, char _dimension, short int _division)
{
    dimension = _dimension;
    division = _division;
    this->convertMatrix(_E);
}

matrix::~matrix()
{   
}

void matrix::convertMatrix(float *_E)
{
    for (int y = 0; y < 11; y++)
    {
        for (int x = 0; x < 11; x++)
        {
            if (x >= (5-dimension) && x <= (5+dimension) && y >= (5-dimension) && y <= (5+dimension))
                E[y][x] = *(_E + (dimension*2+1)*(y-5+dimension) + (x-5+dimension));
            else
                E[y][x] = 0;
        }
    }
}

Rgba applyMatrix(ImageRGBA *_img, matrix *_M, int _x, int _y, point _lowArea, point _highArea)
{
    if (_img && _M)
    {
        int mx, my, location;
        float R = 0, G = 0, B = 0;
        
        for (int y = (5 - _M->dimension); y <= (5 + _M->dimension); y++)
        {
            for (int x = (5 - _M->dimension); x <= (5 + _M->dimension); x++)
            {
                mx = _x - 5 + x;
                my = _y - 5 + y;
                
                if (mx < _lowArea.x)
                    mx = _lowArea.x;
                if (my < _lowArea.y)
                    my = _lowArea.y;
                if (mx > _highArea.x)
                    mx = _highArea.x;
                if (my > _highArea.y)
                    my = _highArea.y;
                
                location = mx + _img->width * my;
                
                R += _M->E[y][x] * _img->data[location].r;
                G += _M->E[y][x] * _img->data[location].g;
                B += _M->E[y][x] * _img->data[location].b;
            }
        }
        
        R = (R / _M->division);
        G = (G / _M->division);
        B = (B / _M->division);
        
        if (R > 255) { R = 255; }
        else if (R < 0) { R = 0; }
        if (G > 255) { G = 255; }
        else if (G < 0) { G = 0; }
        if (B > 255) { B = 255; }
        else if (B < 0) { B = 0; }
             
        return (Rgba){int(R), int(G), int(B), 255};
    }
    else
        return (Rgba){0, 0, 0, 255};
}

// Effect                                                                    //
effect::effect(ImageRGBA *_img, ImageRGBA *_temp, ImageRGBA *_temp2, ImageRGBA *_hud, ImageRGBA *_menu, bool _bArea, point _lowArea, point _highArea)
{
    glutSetWindowTitle("Paint Application");
    startup(_img, _temp, _temp2, _hud, _menu, _bArea, _lowArea, _highArea);
}

effect::~effect()
{
}

void effect::startup(ImageRGBA *_img, ImageRGBA *_temp, ImageRGBA *_temp2, ImageRGBA *_hud, ImageRGBA *_menu, bool _bArea, point _lowArea, point _highArea)
{
    if (_img)
    {
        img = _img;
        temp = _temp;
        temp2 = _temp2;
        hud = _hud;
        menu = _menu;
        
        display = img;
        limitX.set(0, img->width - 1);
        limitY.set(0, img->height - 1);
    
        mouse.set(0, 0);
        LBpressed = false;
        RBpressed = false;
        inAction = false;
        inActionState = true;
        
        bMenu = false;
        bColorMenu = false;
//        bProgressBar = false;
        myColor = (Rgba){0, 0, 0, 255};
//        progress = 0;
        mode = 1;
        numModes = 1;
        value1 = 0;
        value2 = 0;
        limitValue1.set(0, 0);
        limitValue2.set(0, 0);
        areaColorOffset = 0;
        limitRGBA.set(0, 255);

        myAngleXY = 0;
        myAngleZ = 0;
        myStrength = 0;
        
        
        for (int i = 0; i < 10; i++)
            M[i] = 0;
        
        bArea = _bArea;    
        if (bArea)
        {
            lowArea.set(_lowArea.x, _lowArea.y);
            highArea.set(_highArea.x, _highArea.y);
        }
        else
        {
            lowArea.set(0, 0);
            highArea.set(img->width - 1, img->height - 1);
        }
    }
}

void effect::idle()
{
    inAction = inActionState;

    this->idleAction();
    this->showHud();
}

void effect::idleAction()
{
}

void effect::move()
{
    inAction = inActionState;

    bool buttonPressed = false;
    if (bMenu && LBpressed)
        buttonPressed = this->useMenu(false);

    this->moveAction();
    this->showHud();
}

void effect::moveAction()
{
}

void effect::LB(bool _state)
{
    bool buttonPressed = false;
    if (bMenu && _state)
        buttonPressed = this->useMenu(true);

    if (!buttonPressed)
        LBpressed = _state;
    
    this->LBAction();
}

void effect::LBAction()
{
}

void effect::RB(bool _state)
{
    RBpressed = _state;
    
    this->RBAction();
}

void effect::RBAction()
{
}

void effect::colorChangeAction()
{
}

void effect::key(unsigned char _key)
{
    inAction = inActionState;

    if (_key == ' ')
        bMenu = !bMenu;
}

void effect::specialKey(int _key)
{
    inAction = inActionState;

    if (_key <= numModes)
        this->changeMode(_key);
        
    if (_key == GLUT_KEY_LEFT || _key == GLUT_KEY_RIGHT || _key == GLUT_KEY_UP || _key == GLUT_KEY_DOWN)
        this->changeValue(_key);
}

void effect::setXY(float _x, float _y)
{
    mouse.set(int(_x), int(_y));
}

void effect::changeMode(char _mode)
{
    mode = _mode;
}

void effect::changeValue(char _key)
{
}

void effect::showArea()
{
    areaColorOffset++;
    areaColorOffset %= 8;
    lowArea.x = int(limitX.forceLimit(lowArea.x));
    lowArea.y = int(limitY.forceLimit(lowArea.y));
    highArea.x = int(limitX.forceLimit(highArea.x));
    highArea.y = int(limitY.forceLimit(highArea.y));

//    imageRgbaInvertLine(img, hud, lowArea.x, lowArea.y + 1, lowArea.x, highArea.y - 1);
    imageRgbaDrawVerticalAreaLine(hud, lowArea.y, highArea.y, lowArea.x, areaColorOffset);
//    imageRgbaInvertLine(img, hud, lowArea.x, lowArea.y, highArea.x, lowArea.y);
    imageRgbaDrawHorizontalAreaLine(hud, lowArea.x, highArea.x, lowArea.y, areaColorOffset);
//    imageRgbaInvertLine(img, hud, highArea.x, lowArea.y + 1, highArea.x, highArea.y - 1);
    imageRgbaDrawVerticalAreaLine(hud, lowArea.y, highArea.y, highArea.x, areaColorOffset);
//    imageRgbaInvertLine(img, hud, lowArea.x, highArea.y, highArea.x, highArea.y);
    imageRgbaDrawHorizontalAreaLine(hud, lowArea.x, highArea.x, highArea.y, areaColorOffset);
}

void effect::showMenu()
{
    int offsetX, offsetY, number;
    
// Zeile 1
    // save
    number = 0;
    offsetX = 0;    offsetY = 0;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
    
    // backwards
    number = 1;
    offsetX = 20;    offsetY = 0;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // zoom in
    number = 7;
    offsetX = 50;    offsetY = 0;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // zoom out
    number = 8;
    offsetX = 70;    offsetY = 0;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // close
    number = 2;
    offsetX = hud->width - 20;  offsetY = 0;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];

// Zeile 2
    // paint
    number = 3;
    offsetX = 0;    offsetY = 30;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // selection
    number = 4;
    offsetX = 20;    offsetY = 30;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // scroll
    number = 5;
    offsetX = 40;    offsetY = 30;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // telescope
    number = 6;
    offsetX = 60;    offsetY = 30;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];

// Zeile 3
    // brightness
    number = 9;
    offsetX = 0;    offsetY = 60;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // contrast
    number = 10;
    offsetX = 20;    offsetY = 60;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // saturation
    number = 11;
    offsetX = 40;    offsetY = 60;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // hue
    number = 12;
    offsetX = 60;    offsetY = 60;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // colorize
    number = 13;
    offsetX = 80;    offsetY = 60;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // channel
    number = 14;
    offsetX = 100;    offsetY = 60;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // gray
    number = 15;
    offsetX = 130;    offsetY = 60;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // invert
    number = 16;
    offsetX = 150;    offsetY = 60;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // posterize
    number = 17;
    offsetX = 170;    offsetY = 60;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // solarize
    number = 18;
    offsetX = 190;    offsetY = 60;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
// Zeile 4
    // ripple
    number = 19;
    offsetX = 0;    offsetY = 80;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // bulb
    number = 20;
    offsetX = 20;    offsetY = 80;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // twirl
    number = 21;
    offsetX = 40;    offsetY = 80;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // lens
    number = 22;
    offsetX = 60;    offsetY = 80;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // wave
    number = 23;
    offsetX = 80;    offsetY = 80;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // buttonize
    number = 24;
    offsetX = 110;    offsetY = 80;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // glass
    number = 25;
    offsetX = 130;    offsetY = 80;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
// zeile 5
    // mosaik
    number = 26;
    offsetX = 0;    offsetY = 100;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // box
    number = 27;
    offsetX = 20;    offsetY = 100;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // comb
    number = 28;
    offsetX = 40;    offsetY = 100;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // dots
    number = 29;
    offsetX = 60;    offsetY = 100;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // lines
    number = 30;
    offsetX = 90;    offsetY = 100;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // rgbpoints
    number = 31;
    offsetX = 110;    offsetY = 100;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // noise
    number = 32;
    offsetX = 130;    offsetY = 100;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];

// zeile 6
    // blur
    number = 33;
    offsetX = 0;    offsetY = 120;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // sharpen
    number = 34;
    offsetX = 20;    offsetY = 120;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // edge
    number = 35;
    offsetX = 40;    offsetY = 120;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // emboss
    number = 36;
    offsetX = 60;    offsetY = 120;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // separate
    number = 37;
    offsetX = 80;    offsetY = 120;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // halfblur
    number = 38;
    offsetX = 100;    offsetY = 120;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // whiteblur
    number = 39;
    offsetX = 120;    offsetY = 120;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // blackblur
    number = 40;
    offsetX = 140;    offsetY = 120;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];

// zeile 7
    // chrome
    number = 41;
    offsetX = 0;    offsetY = 140;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // bw
    number = 42;
    offsetX = 20;    offsetY = 140;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // relief
    number = 43;
    offsetX = 40;    offsetY = 140;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // cutout
    number = 44;
    offsetX = 60;    offsetY = 140;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // brush
    number = 45;
    offsetX = 90;    offsetY = 140;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
            
    // spatter
    number = 46;
    offsetX = 110;    offsetY = 140;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];

    // strokes
    number = 47;
    offsetX = 130;    offsetY = 140;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];

    // starlight
    number = 48;
    offsetX = 160;    offsetY = 140;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];

    // shine
    number = 49;
    offsetX = 180;    offsetY = 140;
    for (int y = 0; y < 20; y++)
        for (int x = 0; x < 20; x++)
            hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];

// modes
    // mode = 1
    if (numModes > 1)
    {
        number = 101;
        offsetX = 0;    offsetY = 180;
        for (int y = 0; y < 20; y++)
            for (int x = 0; x < 20; x++)
                hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
    }

    // mode = 2
    if (numModes >= 2)
    {
        number = 102;
        offsetX = 20;    offsetY = 180;
        for (int y = 0; y < 20; y++)
            for (int x = 0; x < 20; x++)
                hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
    }

    // mode = 3
    if (numModes >= 3)
    {
        number = 103;
        offsetX = 40;    offsetY = 180;
        for (int y = 0; y < 20; y++)
            for (int x = 0; x < 20; x++)
                hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
    }

    // mode = 4
    if (numModes >= 4)
    {
        number = 104;
        offsetX = 60;    offsetY = 180;
        for (int y = 0; y < 20; y++)
            for (int x = 0; x < 20; x++)
                hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
    }

    // mode = 5
    if (numModes >= 5)
    {
        number = 105;
        offsetX = 80;    offsetY = 180;
        for (int y = 0; y < 20; y++)
            for (int x = 0; x < 20; x++)
                hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
    }

    // mode = 6
    if (numModes >= 6)
    {
        number = 106;
        offsetX = 100;    offsetY = 180;
        for (int y = 0; y < 20; y++)
            for (int x = 0; x < 20; x++)
                hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
    }

    // mode = 7
    if (numModes >= 7)
    {
        number = 107;
        offsetX = 120;    offsetY = 180;
        for (int y = 0; y < 20; y++)
            for (int x = 0; x < 20; x++)
                hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
    }

    // mode = 8
    if (numModes >= 8)
    {
        number = 108;
        offsetX = 140;    offsetY = 180;
        for (int y = 0; y < 20; y++)
            for (int x = 0; x < 20; x++)
                hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
    }
    
// regler
    // value 1
    if (limitValue1.low != limitValue1.high)
    {
        number = 109;
        offsetX = 0;    offsetY = 200;
        for (int y = 0; y < 20; y++)
            for (int x = 0; x < 20; x++)
                hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
        number = 110;
        offsetX = 20;    offsetY = 200;
        for (int y = 0; y < 20; y++)
            for (int x = 0; x < 20; x++)
                hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
        number = 110;
        offsetX = 40;    offsetY = 200;
        for (int y = 0; y < 20; y++)
            for (int x = 0; x < 20; x++)
                hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
        number = 111;
        offsetX = 60;    offsetY = 200;
        for (int y = 0; y < 20; y++)
            for (int x = 0; x < 20; x++)
                hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];

        number = 112;
        offsetX = 0 + 7 + int((value1 - limitValue1.low) / (limitValue1.high - limitValue1.low) * 60);    offsetY = 200 + 3;
        for (int y = 0; y < 14; y++)
            for (int x = 0; x < 7; x++)
                hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
    }
    
    // value 2
    if (limitValue2.low != limitValue2.high)
    {
        number = 109;
        offsetX = 80;    offsetY = 200;
        for (int y = 0; y < 20; y++)
            for (int x = 0; x < 20; x++)
                hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
        number = 110;
        offsetX = 100;    offsetY = 200;
        for (int y = 0; y < 20; y++)
            for (int x = 0; x < 20; x++)
                hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
        number = 110;
        offsetX = 120;    offsetY = 200;
        for (int y = 0; y < 20; y++)
            for (int x = 0; x < 20; x++)
                hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
        number = 111;
        offsetX = 140;    offsetY = 200;
        for (int y = 0; y < 20; y++)
            for (int x = 0; x < 20; x++)
                hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];

        number = 112;
        offsetX = 80 + 7 + int((value2 - limitValue2.low) / (limitValue2.high - limitValue2.low) * 60);    offsetY = 200 + 3;
        for (int y = 0; y < 14; y++)
            for (int x = 0; x < 7; x++)
                hud->data[limitX.intForceLimit(x + offsetX) + hud->width * limitY.intForceLimit(y + offsetY)] = menu->data[number * 400 + x + 20 * y];
    }              
            
    if (bColorMenu)
    {
        for (int y = 0; y < 50; y++)
        {
            for (int x = 100; x < 165; x++)
            {
                if (x < img->width && y < img->height)
                {
                    float S = (1.0*(50-y)/25);
                    float V = (1.0*(y)/25);
                    if (V > 1) { V = 1; }
                    if (S > 1) { S = 1; }
                    hud->data[x + img->width * y] = HSVtoRGB((Hsva){1.0*(x-100)/65*360, S, V, 255});
                }
            }
        }
        for (int y = 0; y < 50; y++)
        {
            for (int x = 165; x < 180; x++)
            {
                int brightness = myColor.r + myColor.g + myColor.b;
                
                int location = x + img->width * y;
                hud->data[location].r = limitRGBA.intForceLimit(myColor.r + 1.0*(y-(1.0*brightness/(3*255)*50))/50*255);
                hud->data[location].g = limitRGBA.intForceLimit(myColor.g + 1.0*(y-(1.0*brightness/(3*255)*50))/50*255);
                hud->data[location].b = limitRGBA.intForceLimit(myColor.b + 1.0*(y-(1.0*brightness/(3*255)*50))/50*255);
                hud->data[location].a = 255;
            }
        }
        for (int y = 30; y < 50; y++)
        {
            for (int x = 190; x < 210; x++)
            {
                hud->data[x + img->width * y] = myColor;
            }
        }
    }
}
/*
void effect::showBar()
{
    for (int y = (img->height - 16); y < img->height; y++)
    {
        for (int x = (img->width - 106); x < img->width; x++)
        {
            if (y >= 0 && x >= 0)
            {
                if ((img->height - y) < 4 || (img->height - y) > 13 || (img->width - x) < 4 || (img->width - x) > 103)
                    hud->data[x + img->width * y] = (Rgba) { 160, 160, 160, 255 };
                else
                {
                    if ((100-(img->height - x - 4)) <= progress)
                        hud->data[x + img->width * y] = (Rgba) { 0, 0, 255, 255 };
                    else
                        hud->data[x + img->width * y] = (Rgba) { 200, 200, 200, 255 };
                }                    

            }
        }
    }
}
*/
bool effect::useMenu(bool firstClick)
{
    if (firstClick)
    {
        // Zeile 1
        if (mouse.x >= 0 && mouse.x < (0 + 20) && mouse.y >= 0 && mouse.y < (0 + 20)) // save (0)
        {    imageRgbaWriteTIFF("out.tif", img); bMenu = !bMenu; return true;   }
        else if (mouse.x >= 20 && mouse.x < (20 + 20) && mouse.y >= 0 && mouse.y < (0 + 20)) // backwards (1)
        {    resetImage(); bMenu = !bMenu; return true; }
        else if (mouse.x > (img->width - 20) && mouse.x <= img->width && mouse.y >= 0 && mouse.y < (0 +20)) // close (2)
        {    exit(0); return true; }
        else if (mouse.x >= 50 && mouse.x < (50 + 20) && mouse.y >= 0 && mouse.y < (0 + 20)) // zoom in (7)
        {    fwkSetDisplayZoom(2 * fwkGetDisplayZoom()); return true;    }
        else if (mouse.x >= 70 && mouse.x < (70 + 20) && mouse.y >= 0 && mouse.y < (0 + 20)) // zoom out (8)
        {    fwkSetDisplayZoom(0.5 * fwkGetDisplayZoom()); return true; }
    
        // Zeile 2
        else if (mouse.x >= 0 && mouse.x < (0 + 20) && mouse.y >= 30 && mouse.y < (30 + 20)) // draw (3)
        {    changeEffect(3); return true; }
        else if (mouse.x >= 20 && mouse.x < (20 + 20) && mouse.y >= 30 && mouse.y < (30 + 20)) // selection (4)
        {    changeEffect(4); return true; }
        else if (mouse.x >= 40 && mouse.x < (40 + 20) && mouse.y >= 30 && mouse.y < (30 + 20)) // scroll (5)
        {    changeEffect(5); return true; }
        else if (mouse.x >= 60 && mouse.x < (60 + 20) && mouse.y >= 30 && mouse.y < (30 + 20)) // telescope (6)
        {    changeEffect(6); return true; }
            
        // Zeile 3
        else if (mouse.x >= 0 && mouse.x < (0 + 20) && mouse.y >= 60 && mouse.y < (60 + 20)) // brightness (9)
        {    changeEffect(9); return true; }
        else if (mouse.x >= 20 && mouse.x < (20 + 20) && mouse.y >= 60 && mouse.y < (60 + 20)) // contrast (10)
        {    changeEffect(10); return true; }
        else if (mouse.x >= 40 && mouse.x < (40 + 20) && mouse.y >= 60 && mouse.y < (60 + 20)) // saturation (11)
        {    changeEffect(11); return true; }
        else if (mouse.x >= 60 && mouse.x < (60 + 20) && mouse.y >= 60 && mouse.y < (60 + 20)) // hue (12)
        {    changeEffect(12); return true; }
        else if (mouse.x >= 80 && mouse.x < (80 + 20) && mouse.y >= 60 && mouse.y < (60 + 20)) // colorize (13)
        {    changeEffect(13); return true; }
        else if (mouse.x >= 100 && mouse.x < (100 + 20) && mouse.y >= 60 && mouse.y < (60 + 20)) // channel (14)
        {    changeEffect(14); return true; }
        else if (mouse.x >= 130 && mouse.x < (130 + 20) && mouse.y >= 60 && mouse.y < (60 + 20)) // gray (15)
        {    changeEffect(15); return true; }
        else if (mouse.x >= 150 && mouse.x < (150 + 20) && mouse.y >= 60 && mouse.y < (60 + 20)) // invert (16)
        {    changeEffect(16); return true; }
        else if (mouse.x >= 170 && mouse.x < (170 + 20) && mouse.y >= 60 && mouse.y < (60 + 20)) // posterize (17)
        {    changeEffect(17); return true; }
        else if (mouse.x >= 190 && mouse.x < (190 + 20) && mouse.y >= 60 && mouse.y < (60 + 20)) // solarize (18)
        {    changeEffect(18); return true; }
    
        // Zeile 4
        else if (mouse.x >= 0 && mouse.x < (0 + 20) && mouse.y >= 80 && mouse.y < (80 + 20)) // ripple (19)
        {    changeEffect(19); return true; }
        else if (mouse.x >= 20 && mouse.x < (20 + 20) && mouse.y >= 80 && mouse.y < (80 + 20)) // bulb (20)
        {    changeEffect(20); return true; }
        else if (mouse.x >= 40 && mouse.x < (40 + 20) && mouse.y >= 80 && mouse.y < (80 + 20)) // twirl (21)
        {    changeEffect(21); return true; }
        else if (mouse.x >= 60 && mouse.x < (60 + 20) && mouse.y >= 80 && mouse.y < (80 + 20)) // lens (22)
        {    changeEffect(22); return true; }
        else if (mouse.x >= 80 && mouse.x < (80 + 20) && mouse.y >= 80 && mouse.y < (80 + 20)) // wave (23)
        {    changeEffect(23); return true; }
        else if (mouse.x >= 110 && mouse.x < (110 + 20) && mouse.y >= 80 && mouse.y < (80 + 20)) // buttonize (24)
        {    changeEffect(24); return true; }
         else if (mouse.x >= 130 && mouse.x < (130 + 20) && mouse.y >= 80 && mouse.y < (80 + 20)) // glass (25)
        {    changeEffect(25); return true; }
       
        // Zeile 5
        else if (mouse.x >= 0 && mouse.x < (0 + 20) && mouse.y >= 100 && mouse.y < (100 + 20)) // mosaik (26)
        {    changeEffect(26); return true; }
        else if (mouse.x >= 20 && mouse.x < (20 + 20) && mouse.y >= 100 && mouse.y < (100 + 20)) // box (27)
        {    changeEffect(27); return true; }
        else if (mouse.x >= 40 && mouse.x < (40 + 20) && mouse.y >= 100 && mouse.y < (100 + 20)) // comb (28)
        {    changeEffect(28); return true; }
        else if (mouse.x >= 60 && mouse.x < (60 + 20) && mouse.y >= 100 && mouse.y < (100 + 20)) // dots (29)
        {    changeEffect(29); return true; }
        else if (mouse.x >= 90 && mouse.x < (90 + 20) && mouse.y >= 100 && mouse.y < (100 + 20)) // lines (30)
        {    changeEffect(30); return true; }
        else if (mouse.x >= 110 && mouse.x < (110 + 20) && mouse.y >= 100 && mouse.y < (100 + 20)) // rgbdots (31)
        {    changeEffect(31); return true; }
        else if (mouse.x >= 130 && mouse.x < (130 + 20) && mouse.y >= 100 && mouse.y < (100 + 20)) // noise (32)
        {    changeEffect(32); return true; }

        // Zeile 6
        else if (mouse.x >= 0 && mouse.x < (0 + 20) && mouse.y >= 120 && mouse.y < (120 + 20)) // blur (33)
        {    changeEffect(33); return true; }
        else if (mouse.x >= 20 && mouse.x < (20 + 20) && mouse.y >= 120 && mouse.y < (120 + 20)) // sharpen (34)
        {    changeEffect(34); return true; }
        else if (mouse.x >= 40 && mouse.x < (40 + 20) && mouse.y >= 120 && mouse.y < (120 + 20)) // edge (35)
        {    changeEffect(35); return true; }
        else if (mouse.x >= 60 && mouse.x < (60 + 20) && mouse.y >= 120 && mouse.y < (120 + 20)) // emboss (36)
        {    changeEffect(36); return true; }
        else if (mouse.x >= 80 && mouse.x < (80 + 20) && mouse.y >= 120 && mouse.y < (120 + 20)) // separate (37)
        {    changeEffect(37); return true; }
        else if (mouse.x >= 100 && mouse.x < (100 + 20) && mouse.y >= 120 && mouse.y < (120 + 20)) // halbblur (38)
        {    changeEffect(38); return true; }
        else if (mouse.x >= 120 && mouse.x < (120 + 20) && mouse.y >= 120 && mouse.y < (120 + 20)) // whiteblur (39)
        {    changeEffect(39); return true; }
        else if (mouse.x >= 140 && mouse.x < (140 + 20) && mouse.y >= 120 && mouse.y < (120 + 20)) // blackblur (40)
        {    changeEffect(40); return true; }

        // Zeile 7
        else if (mouse.x >= 0 && mouse.x < (0 + 20) && mouse.y >= 140 && mouse.y < (140 + 20)) // chrome (41)
        {    changeEffect(41); return true; }
        else if (mouse.x >= 20 && mouse.x < (20 + 20) && mouse.y >= 140 && mouse.y < (140 + 20)) // bw (42)
        {    changeEffect(42); return true; }
        else if (mouse.x >= 40 && mouse.x < (40 + 20) && mouse.y >= 140 && mouse.y < (140 + 20)) // relief (43)
        {    changeEffect(43); return true; }
        else if (mouse.x >= 60 && mouse.x < (60 + 20) && mouse.y >= 140 && mouse.y < (140 + 20)) // cutout (44)
        {    changeEffect(44); return true; }
        else if (mouse.x >= 90 && mouse.x < (90 + 20) && mouse.y >= 140 && mouse.y < (140 + 20)) // brush (45)
        {    changeEffect(45); return true; }
        else if (mouse.x >= 110 && mouse.x < (110 + 20) && mouse.y >= 140 && mouse.y < (140 + 20)) // spatter (46)
        {    changeEffect(46); return true; }
        else if (mouse.x >= 130 && mouse.x < (130 + 20) && mouse.y >= 140 && mouse.y < (140 + 20)) // strokes (47)
        {    changeEffect(47); return true; }
        else if (mouse.x >= 160 && mouse.x < (160 + 20) && mouse.y >= 140 && mouse.y < (140 + 20)) // starlight (48)
        {    changeEffect(48); return true; }
        else if (mouse.x >= 180 && mouse.x < (180 + 20) && mouse.y >= 140 && mouse.y < (140 + 20)) // shine (49)
        {    changeEffect(49); return true; }

        // Modes
        else if (mouse.x >= 0 && mouse.x < (0 + 20) && mouse.y >= 180 && mouse.y < (180 + 20) && numModes > 1) // change mode 1
        {    changeMode(1); bMenu = !bMenu; return true; }
        else if (mouse.x >= 20 && mouse.x < (20 + 20) && mouse.y >= 180 && mouse.y < (180 + 20) && numModes >= 2) // change mode 2
        {    changeMode(2); bMenu = !bMenu; return true; }
        else if (mouse.x >= 40 && mouse.x < (40 + 20) && mouse.y >= 180 && mouse.y < (180 + 20) && numModes >= 3) // change mode 3
        {    changeMode(3); bMenu = !bMenu; return true; }
        else if (mouse.x >= 60 && mouse.x < (60 + 20) && mouse.y >= 180 && mouse.y < (180 + 20) && numModes >= 4) // change mode 4
        {    changeMode(4); bMenu = !bMenu; return true; }
        else if (mouse.x >= 80 && mouse.x < (80 + 20) && mouse.y >= 180 && mouse.y < (180 + 20) && numModes >= 5) // change mode 5
        {    changeMode(5); bMenu = !bMenu; return true; }
        else if (mouse.x >= 100 && mouse.x < (100 + 20) && mouse.y >= 180 && mouse.y < (180 + 20) && numModes >= 6) // change mode 6
        {    changeMode(6); bMenu = !bMenu; return true; }
        else if (mouse.x >= 120 && mouse.x < (120 + 20) && mouse.y >= 180 && mouse.y < (180 + 20) && numModes >= 7) // change mode 7
        {    changeMode(7); bMenu = !bMenu; return true; }
        else if (mouse.x >= 140 && mouse.x < (140 + 20) && mouse.y >= 180 && mouse.y < (180 + 20) && numModes >= 8) // change mode 8
        {    changeMode(8); bMenu = !bMenu; return true; }

        // Regler
//      else if (mouse.x >= (0 + 7 + int((value1 - limitValue1.low) / (limitValue1.high - limitValue1.low) * 60)) && mouse.x < ((0 + 7 + int((value1 - limitValue1.low) / (limitValue1.high - limitValue1.low) * 60)) + 7) && mouse.y >= (200 + 3) && mouse.y < ((200 + 3) + 14) && limitValue1.low != limitValue1.high) // value 1
        else if (mouse.x >= 2 && mouse.x < 78 && mouse.y >= (200 + 3) && mouse.y < ((200 + 3) + 14) && limitValue1.low != limitValue1.high) // value 1
        {    value1 = limitValue1.forceLimit(int(limitValue1.low + ((mouse.x - (10 + 0)) / 60.0 * (limitValue1.high - limitValue1.low)))); changeValue(0); return false; }
//      else if (mouse.x >= (80 + 7 + int((value1 - limitValue1.low) / (limitValue1.high - limitValue1.low) * 60)) && mouse.x < ((80 + 7 + int((value1 - limitValue1.low) / (limitValue1.high - limitValue1.low) * 60)) + 7) && mouse.y >= (200 + 3) && mouse.y < ((200 + 3) + 14) && limitValue2.low != limitValue2.high) // value 1
        else if (mouse.x >= 82 && mouse.x < 158 && mouse.y >= (200 + 3) && mouse.y < ((200 + 3) + 14) && limitValue2.low != limitValue2.high) // value 1
        {    value2 = limitValue2.forceLimit(int(limitValue2.low + ((mouse.x - (10 + 80)) / 60.0 * (limitValue2.high - limitValue2.low)))); changeValue(0); return false; }
        
        // Color Menu
        else if (bColorMenu && mouse.x >= 100 && mouse.x < 180 && mouse.y >= 0 && mouse.y < 50)
        {   myColor = hud->data[mouse.x + img->width * mouse.y]; myColor.a = 255; this->colorChangeAction(); return false;  }

        else    
            return false;
            
        
    }
    else
    {
// Regler
//      if (mouse.x >= (0 + 7 + int((value1 - limitValue1.low) / (limitValue1.high - limitValue1.low) * 60)) && mouse.x < ((0 + 7 + int((value1 - limitValue1.low) / (limitValue1.high - limitValue1.low) * 60)) + 7) && mouse.y >= (200 + 3) && mouse.y < ((200 + 3) + 14) && limitValue1.low != limitValue1.high) // value 1
        if (mouse.x >= 7 && mouse.x < 73 && mouse.y >= (200 + 3) && mouse.y < ((200 + 3) + 14) && limitValue1.low != limitValue1.high) // value 1
        {    value1 = limitValue1.forceLimit(int(limitValue1.low + ((mouse.x - (10 + 0)) / 60.0 * (limitValue1.high - limitValue1.low)))); changeValue(1); return true; }
//      else if (mouse.x >= (80 + 7 + int((value1 - limitValue1.low) / (limitValue1.high - limitValue1.low) * 60)) && mouse.x < ((80 + 7 + int((value1 - limitValue1.low) / (limitValue1.high - limitValue1.low) * 60)) + 7) && mouse.y >= (200 + 3) && mouse.y < ((200 + 3) + 14) && limitValue2.low != limitValue2.high) // value 1
        else if (mouse.x >= 87 && mouse.x < 153 && mouse.y >= (200 + 3) && mouse.y < ((200 + 3) + 14) && limitValue2.low != limitValue2.high) // value 1
        {    value2 = limitValue2.forceLimit(int(limitValue2.low + ((mouse.x - (10 + 80)) / 60.0 * (limitValue2.high - limitValue2.low)))); changeValue(1); return true; }
// Color Menu
        else if (bColorMenu && mouse.x >= 100 && mouse.x < 180 && mouse.y >= 0 && mouse.y < 50)
        {   myColor = hud->data[mouse.x + img->width * mouse.y]; myColor.a = 255; this->colorChangeAction(); return true;  }

        else    
            return false;
    }
}

void effect::showHud()
{
    if (bArea || bMenu)// || bProgressBar)
    {
        imageRgbaSet(hud, 0, 0, 0, 0);
        if (bArea)
            this->showArea();
        if (bMenu)
            this->showMenu();
//        if (bProgressBar)
//            this->showBar();
            
        for (int y = 0; y < img->height; y++)
        {
            for (int x = 0; x < img->width; x++)
            {
                int location = x + img->width * y;
                if (hud->data[location].a == 0)
                    hud->data[location] = img->data[location];
            }
        }
        display = hud;
        this->refreshImage();
    }
    else 
    {
        display = img;
        this->refreshImage();
    }
}

void effect::refreshImage()
{
    fwkSetDisplayImage(display);
//    fwkPostRedisplay();
}


// Color                                                                     //
void color::LBAction()
{
    if (LBpressed)
    {
        int location;
        for (int y = lowArea.y; y <= highArea.y; y++)
        {
            for (int x = lowArea.x; x <= highArea.x; x++)
            {
                location = x + img->width * y;
                this->action(location);
            }
        }
    }
}

void color::RBAction()
{
    if (RBpressed)
        imageRgbaCopy(temp, img);
}

void color::action(int location)
{
}

void color::changeValue(char _key)
{
    if (_key == GLUT_KEY_UP)
        value1 += 5;
    else if (_key == GLUT_KEY_DOWN)
        value1 -= 5;
        
    value1 = limitValue1.intForceLimit(value1);

    if (_key)
    {
        if (!LBpressed)
        {
            LBpressed = true;
            this->LBAction();
            LBpressed = false;
        }
        else
            this->LBAction();
    }
}

// Geometric                                                                 //
void geometric::idleAction()
{
}

void geometric::RBAction()
{
    if (RBpressed)
        imageRgbaCopy(temp, img);
}

void geometric::specialKey(int _key)
{
    inAction = inActionState;

    if (_key <= numModes)
        this->changeMode(_key);
        
    if (_key == GLUT_KEY_LEFT || _key == GLUT_KEY_RIGHT || _key == GLUT_KEY_UP || _key == GLUT_KEY_DOWN)
        this->changeValue(_key);
        
    if (_key == GLUT_KEY_END)
    {
        interpolate = !interpolate;
        if (!LBpressed)
        {
            LBpressed = true;
            this->idleAction();
            LBpressed = false;
        }
        else
            this->idleAction();
    }
}

void geometric::changeValue(char _key)
{
    if (_key == GLUT_KEY_UP)
        this->keyUP();
    else if (_key == GLUT_KEY_DOWN)
        this->keyDOWN();
    else if (_key == GLUT_KEY_LEFT)
        this->keyLEFT();
    else if (_key == GLUT_KEY_RIGHT)
        this->keyRIGHT();
        
    if (_key)
    {
        if (!LBpressed)
        {
            LBpressed = true;
            this->idleAction();
            LBpressed = false;
        }
        else
            this->idleAction();
    }
}

void geometric::keyRIGHT()
{
}

void geometric::keyLEFT()
{
}

void geometric::keyUP()
{
}

void geometric::keyDOWN()
{
}

// Distort                                                                   //
void distort::LBAction()
{
}

void distort::RBAction()
{
    if (RBpressed)
        imageRgbaCopy(temp, img);
}

void distort::changeValue(char _key)
{
    if (_key == GLUT_KEY_UP)
        value2 += 1;
    else if (_key == GLUT_KEY_DOWN)
        value2 -= 1;
    else if (_key == GLUT_KEY_RIGHT)
        value1 += 1;
    else if (_key == GLUT_KEY_LEFT)
        value1 -= 1;
        
    value1 = limitValue1.intForceLimit(value1);
    value2 = limitValue2.intForceLimit(value2);

    if (_key)
    {
        if (!LBpressed)
        {
            LBpressed = true;
            this->LBAction();
            LBpressed = false;
        }
        else
            this->LBAction();
    }
}

// Matrices                                                                   //
void matrices::RBAction()
{
    if (RBpressed)
        imageRgbaCopy(temp, img);
}

void matrices::LBAction()
{
    if (LBpressed)
    {
        for (int y = lowArea.y; y <= highArea.y; y++)
        {
            for (int x = lowArea.x; x <= highArea.x; x++)
            {
                this->matrixAction(x, y);
            }
        }
    }
}

void matrices::matrixAction(int _x, int _y)
{
    img->data[_x + img->width * _y] = applyMatrix(temp, M[int(value1)], _x, _y, lowArea, highArea);
}

void matrices::changeValue(char _key)
{
    if (_key == GLUT_KEY_UP)
        value1 += 1;
    else if (_key == GLUT_KEY_DOWN)
        value1 -= 1;

    if (_key == GLUT_KEY_LEFT)
        value2 -= 3;
    else if (_key == GLUT_KEY_RIGHT)
        value2 += 3;

    if (_key == 127)
    {
        strength -= 1;
        if (strength < 1)
            strength = 1;
    }
    else if (_key == GLUT_KEY_PAGE_DOWN)
    {
        strength += 1;
        if (strength > 30)
            strength = 30;
    }

    value1 = limitValue1.intForceLimit(value1);
    value2 = limitValue2.intForceLimit(value2);
    
    if (_key)
    {
        if (!LBpressed)
        {
            LBpressed = true;
            this->LBAction();
            LBpressed = false;
        }
        else
            this->LBAction();
    }
}

void matrices::key(unsigned char _key)
{
    inAction = inActionState;

    if (_key == ' ')
        bMenu = !bMenu;
    if (_key == 127)
        this->changeValue(_key);
}

void matrices::specialKey(int _key)
{
    inAction = inActionState;

    if (_key <= numModes)
        this->changeMode(_key);
        
    if (_key == GLUT_KEY_LEFT || _key == GLUT_KEY_RIGHT || _key == GLUT_KEY_UP || _key == GLUT_KEY_DOWN || _key == GLUT_KEY_PAGE_DOWN)
        this->changeValue(_key);
}

// Artistic                                                                  //
void artistic::RBAction()
{
    if (RBpressed)
        imageRgbaCopy(temp, img);
}

void artistic::changeValue(char _key)
{
    if (_key == GLUT_KEY_UP)
        value1 += 1;
    else if (_key == GLUT_KEY_DOWN)
        value1 -= 1;
    else if (_key == GLUT_KEY_RIGHT)
        value2 += 1;
    else if (_key == GLUT_KEY_LEFT)
        value2 -= 1;
        
    value1 = limitValue1.intForceLimit(value1);
    value2 = limitValue2.intForceLimit(value2);

    if (_key == 127)
    {
        strength -= 1;
        if (strength < 1)
            strength = 1;
    }
    else if (_key == GLUT_KEY_PAGE_DOWN)
    {
        strength += 1;
        if (strength > 30)
            strength = 30;
    }

    if (_key)
    {
        if (!LBpressed)
        {
            LBpressed = true;
            this->LBAction();
            LBpressed = false;
        }
        else
            this->LBAction();
    }
}

void artistic::key(unsigned char _key)
{
    inAction = inActionState;

    if (_key == ' ')
        bMenu = !bMenu;
    if (_key == 127)
        this->changeValue(_key);
}

void artistic::specialKey(int _key)
{
    inAction = inActionState;

    if (_key <= numModes)
        this->changeMode(_key);

    if (_key == GLUT_KEY_LEFT || _key == GLUT_KEY_RIGHT || _key == GLUT_KEY_UP || _key == GLUT_KEY_DOWN || _key == GLUT_KEY_PAGE_DOWN)
        this->changeValue(_key);
}

---