ECGraphicViewImp.cpp

//
//  ECGraphicViewImp.cpp
//  
//
//  Created by Yufeng Wu on 3/2/22.
//

#include "ECGraphicViewImp.h"
#include "allegro5/allegro_primitives.h"
#include <allegro5/allegro_image.h>
#include <allegro5/allegro5.h>
#include <allegro5/allegro_font.h>
#include <allegro5/allegro_ttf.h>
#include <iostream>

using namespace std;

const float FPS = 60;

//***********************************************************
// Allegro colors

ALLEGRO_COLOR arrayAllegroColors[ECGV_NUM_COLORS] =
{
    al_map_rgb_f(0, 0, 0),
    al_map_rgb_f(255,255,255),
    al_map_rgb_f(255,0,0),
    al_map_rgb_f(0,255,0),
    al_map_rgb_f(0,0,255),
    al_map_rgb_f(255,255,0),
    al_map_rgb_f(255,0,255),
    al_map_rgb_f(0,255,255),
    al_map_rgb_f(.54,.54,.54),
};

//***********************************************************
// A graphic view implementation
// This is built on top of Allegro library

ECGraphicViewImp :: ECGraphicViewImp(int width, int height) : widthView(width), heightView(height), fRedraw(false), display(NULL), timer(NULL), event_queue(NULL)
{
    Init();
}
ECGraphicViewImp :: ~ECGraphicViewImp()
{
    Shutdown();
}

// Show the view. This would enter a forever loop, until quit is set
void ECGraphicViewImp :: Show()
{
    
    // draw something

    //SetRedraw(true);
    //int cursorxDown=-100, cursoryDown=-100, cursorxUp=-100, cursoryUp=-100;
    Clear(ECGV_WHITE);
    DrawModeLabel();
    al_flip_display();
    //al_flip_display();

    ECObserverSubject ObserverSubject = ECObserverSubject();
    
    MouseUp *mouseUpObserver = new MouseUp(this);
    MouseDown *mouseDownObserver = new MouseDown(this);
    MouseMoving *mouseMovingObserver = new MouseMoving(this);
    SpaceUp* spaceUpObersver = new SpaceUp(this);
    DKeyUp* dKeyUpObserver = new DKeyUp(this);
    ZKeyUp* zKeyUpObserver = new ZKeyUp(this);
    YKeyUp* yKeyUpObserver = new YKeyUp(this);

    ObserverSubject.Attach(mouseUpObserver);
    ObserverSubject.Attach(mouseDownObserver);
    ObserverSubject.Attach(mouseMovingObserver);
    ObserverSubject.Attach(spaceUpObersver);
    ObserverSubject.Attach(dKeyUpObserver);
    ObserverSubject.Attach(zKeyUpObserver);
    ObserverSubject.Attach(yKeyUpObserver);

    while(true)
    {
        // get current event
        evtCurrent = WaitForEvent();
        //std::std::cout << "evt: " << evtCurrent << std::endl;
        
        if( evtCurrent == ECGV_EV_NULL )
        {
            continue;
        }
        
        if( evtCurrent == ECGV_EV_CLOSE)
        {
            break;
        }

        ObserverSubject.Notify(evtCurrent);
        
        if( evtCurrent == ECGV_EV_TIMER)
        {
            if( fRedraw )
            {
                RenderEnd();
                fRedraw = false;
            }
        }

        // Get Cursor Position
        GetCursorPosition(cursorx, cursory);
        
        #if 0
        // handle this event: TBD
        int cursorx, cursory;
        GetCursorPosition(cursorx, cursory);
//cout << "Event: " << evt << endl;
        if(evtCurrent == ECGV_EV_MOUSE_BUTTON_DOWN)
        {
            cout << "Cursor down: (" << cursorx << "," << cursory << ")\n";
            cursorxDown = cursorx;
            cursoryDown = cursory;
        }
        if(evtCurrent == ECGV_EV_MOUSE_BUTTON_UP)
        {
            cout << "Cursor up: (" << cursorx << "," << cursory << ")\n";
            cursorxUp = cursorx;
            cursoryUp = cursory;
            fRedraw = true;
        }
        if(evtCurrent == ECGV_EV_MOUSE_MOVING)
        {
            if( cursorxDown >= 0 )
            {
                cout << "Current cursor position: " << cursorx << "," << cursory << endl;
                RenderStart();
                DrawRectangle(cursorxDown, cursoryDown, cursorx, cursory,1);
                RenderEnd();
            }
        }
        if( evtCurrent == ECGV_EV_TIMER)
        {
            if( fRedraw )
            {
                RenderStart();
cout << "down:(" << cursorxDown <<"," << cursoryDown << ") up: (" << cursorxUp << "," << cursoryUp << ")\n";
                //DrawLine(cursorxDown, cursoryDown, cursorxUp, cursoryUp);
                DrawRectangle(cursorxDown, cursoryDown, cursorxUp, cursoryUp);
                RenderEnd();
                fRedraw = false;
                cursorxDown = -100;
                cursoryDown = -100;
            }
        }
#endif
    }
}

void ECGraphicViewImp :: RenderStart()
{
    //std::std::cout << "Redraw bitmap..." << GetPosX() << "," << GetPosY() << std::endl;
    al_clear_to_color(al_map_rgb(255,255,255));
}


void ECGraphicViewImp :: RenderEnd()
{
//    al_draw_bitmap(algBitmap, GetPosX(), GetPosY(), 0);
    al_flip_display();
}

    
void ECGraphicViewImp :: Init()
{
    id = 1;
std::cout << "Start init..\n";
    if(!al_init()) {
        std::cout << "failed to initialize allegro!\n";
        exit(-1);
    }
    
    if(!al_install_keyboard()) {
        std::cout << "failed to initialize the keyboard!\n";
        exit(-1);
    }
    
    if(!al_install_mouse()) {
        std::cout << "failed to initialize the mouse!\n";
        exit(-1);
    }
    timer = al_create_timer(1.0 / FPS);
    if(!timer) {
        std::cout << "failed to create timer!\n";
        exit(-1);
    }
    // create the display
    display = al_create_display(widthView, heightView);
    if(!display) {
        std::cout << "failed to create display!\n";
        Shutdown();
        exit( -1);
    }
    al_set_target_bitmap(al_get_backbuffer(display));
    // setup events
    event_queue = al_create_event_queue();
    if(!event_queue) {
        fprintf(stderr, "failed to create event_queue!\n");
        Shutdown();
        exit( -1);
    }
//std::cout << "3\n";
//#if 0
    al_register_event_source(event_queue, al_get_display_event_source(display));
    al_register_event_source(event_queue, al_get_timer_event_source(timer));
    al_register_event_source(event_queue, al_get_keyboard_event_source());
    al_register_event_source(event_queue, al_get_mouse_event_source());
//#endif
    al_clear_to_color(al_map_rgb(255,255,255));
    al_flip_display();
    al_start_timer(timer);
    
    // init image
    al_init_image_addon();
    al_init_primitives_addon();
    

    al_set_window_title(al_get_current_display(), "CSE 3150 - Project 2");

    // Set Default Mode to EDIT
    _mode = ECGRAPHICVIEW_EDITMODE;
    _modeStr = "Edit Mode";
    
    _isEditingRect = false;
    _mouseDown = false;

    _warning = "";

    // Set cursor positions to default
    cursorxDown = cursoryDown = cursorxUp = cursoryUp = -1;
    
    // Create new bitmap and set it as target
    std::cout << "Done with initialization.\n";
}

void ECGraphicViewImp :: Shutdown()
{
    //
    if( display != NULL)
    {
        al_destroy_display(display);
        display = NULL;
    }
    if( timer != NULL )
    {
        al_destroy_timer(timer);
        timer = NULL;
    }
    if( event_queue != NULL )
    {
        al_destroy_event_queue(event_queue);
        event_queue = NULL;
    }
}

ECGVEventType ECGraphicViewImp :: WaitForEvent()
{
    //
    ALLEGRO_EVENT ev;
    al_wait_for_event(event_queue, &ev);
//cout << "Process event...\n";
    
    if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
    {
        return ECGV_EV_CLOSE;
    }
    else if(ev.type == ALLEGRO_EVENT_TIMER) {
        return ECGV_EV_TIMER;
    }
    else if(ev.type == ALLEGRO_EVENT_KEY_DOWN) {
        switch(ev.keyboard.keycode) {
            case ALLEGRO_KEY_UP:
                return ECGV_EV_KEY_DOWN_UP;
                
            case ALLEGRO_KEY_DOWN:
                return ECGV_EV_KEY_DOWN_DOWN;
                
            case ALLEGRO_KEY_LEFT:
                return ECGV_EV_KEY_DOWN_LEFT;
                
            case ALLEGRO_KEY_RIGHT:
                return ECGV_EV_KEY_DOWN_RIGHT;
                
            case ALLEGRO_KEY_Z:
                return ECGV_EV_KEY_DOWN_Z;
                
            case ALLEGRO_KEY_Y:
                return ECGV_EV_KEY_DOWN_Y;
            
            case ALLEGRO_KEY_D:
                return ECGV_EV_KEY_DOWN_D;
                
            case ALLEGRO_KEY_SPACE:
                return ECGV_EV_KEY_DOWN_SPACE;
            
            case ALLEGRO_KEY_G:
                return ECGV_EV_KEY_DOWN_G;
                
            case ALLEGRO_KEY_F:
                return ECGV_EV_KEY_DOWN_F;
                
            case ALLEGRO_KEY_LCTRL:
                return ECGV_EV_KEY_DOWN_CTRL;
                
            case ALLEGRO_KEY_RCTRL:
                return ECGV_EV_KEY_DOWN_CTRL;
                    
        }
    }
    else if(ev.type == ALLEGRO_EVENT_KEY_UP) {
        switch(ev.keyboard.keycode) {
            case ALLEGRO_KEY_UP:
                return ECGV_EV_KEY_UP_UP;
                
            case ALLEGRO_KEY_DOWN:
                return ECGV_EV_KEY_UP_DOWN;
                
            case ALLEGRO_KEY_LEFT:
                return ECGV_EV_KEY_UP_LEFT;
                
            case ALLEGRO_KEY_RIGHT:
                return ECGV_EV_KEY_UP_RIGHT;
                
            case ALLEGRO_KEY_ESCAPE:
                return ECGV_EV_KEY_UP_ESCAPE;
            
            case ALLEGRO_KEY_Z:
                return ECGV_EV_KEY_UP_Z;
                
            case ALLEGRO_KEY_Y:
                return ECGV_EV_KEY_UP_Y;
            
            case ALLEGRO_KEY_D:
                return ECGV_EV_KEY_UP_D;
                
            case ALLEGRO_KEY_SPACE:
                return ECGV_EV_KEY_UP_SPACE;
                
            case ALLEGRO_KEY_G:
                return ECGV_EV_KEY_UP_G;
                
            case ALLEGRO_KEY_F:
                return ECGV_EV_KEY_UP_F;
                
            case ALLEGRO_KEY_LCTRL:
                return ECGV_EV_KEY_UP_CTRL;
                
            case ALLEGRO_KEY_RCTRL:
                return ECGV_EV_KEY_UP_CTRL;
                
        }
    }
    else if(ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN)
    {
        return ECGV_EV_MOUSE_BUTTON_DOWN;
    }
    else if(ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_UP)
    {
        return ECGV_EV_MOUSE_BUTTON_UP;
    }
    else if(ev.type == ALLEGRO_EVENT_MOUSE_AXES)
    {
        return ECGV_EV_MOUSE_MOVING;
    }
//cout << "Event not recognized...\n";
    
    return ECGV_EV_NULL;
}

void ECGraphicViewImp :: GetCursorPosition(int &cx, int &cy) const
{
    ALLEGRO_MOUSE_STATE state;
    al_get_mouse_state(&state);
    cx = state.x;
    cy = state.y;
}

// Drawing functions
void  ECGraphicViewImp :: DrawLine(int x1, int y1, int x2, int y2, int thickness, ECGVColor color)
{
    // draw a line
    al_draw_line(x1,y1,x2,y2,arrayAllegroColors[color],thickness);
//std::cout << "Draw line: (" << x1 << "," << y1 << " to (" << x2 << "," << y2 << ")\n";
}

void ECGraphicViewImp :: DrawRectangle(int x1, int y1, int x2, int y2, int thickness, ECGVColor color)
{   
    //cout << x1 << " " << y1 << " " << x2 << " " << y2 << " " << thickness << " " << endl;
    al_draw_rectangle(x1, y1, x2, y2, arrayAllegroColors[color],thickness);
    cout << "Drew Rect" << endl;
}

void ECGraphicViewImp :: DrawCircle(int xcenter, int ycenter, double radius, int thickness, ECGVColor color)
{
    al_draw_circle(xcenter, ycenter, radius, arrayAllegroColors[color], thickness);
}

void ECGraphicViewImp :: DrawEllipse(int xcenter, int ycenter, double radiusx, double radiusy, int thickness, ECGVColor color)
{
    al_draw_ellipse(xcenter, ycenter, radiusx, radiusy, arrayAllegroColors[color], thickness);
}

void ECGraphicViewImp :: DrawFilledRectangle(int x1, int y1, int x2, int y2, ECGVColor color)
{
    al_draw_filled_rectangle(x1, y1, x2, y2, arrayAllegroColors[color]);;
}

void ECGraphicViewImp :: DrawFilledCircle(int xcenter, int ycenter, double radius, ECGVColor color)
{
    al_draw_filled_circle(xcenter, ycenter, radius, arrayAllegroColors[color]);
}

void ECGraphicViewImp :: DrawFilledEllipse(int xcenter, int ycenter, double radiusx, double radiusy, ECGVColor color)
{
    al_draw_filled_ellipse(xcenter, ycenter, radiusx, radiusy, arrayAllegroColors[color]);
}

void ECGraphicViewImp :: DrawModeLabel() {
    DrawText(5,heightView-28,20,arrayAllegroColors[ECGV_BLACK],ALLEGRO_ALIGN_LEFT, _modeStr);
}

void ECGraphicViewImp :: DrawWarningLabel() {
    DrawText(widthView - 5,heightView-28,20,arrayAllegroColors[ECGV_RED],ALLEGRO_ALIGN_RIGHT, _warning);
}

void ECGraphicViewImp :: DrawText(float x, float y, float sz, ALLEGRO_COLOR color, int alignment, string text) {
    
    al_init_font_addon();
    al_init_ttf_addon();
    
    ALLEGRO_FONT* font = al_load_font("font.ttf", sz, 0);
    const char* _text = text.c_str();
    cout << "INPUT: " << _text << endl;
    al_draw_text(font, color, x, y, alignment, _text);
    // Check font is loaded
    if (!font) {
        fprintf(stderr, "failed to load font!\n");
        al_destroy_font(font);
    }

    al_destroy_font(font);
}

 bool ECGraphicViewImp::isPointInsideRect(RectObject* _rect, float xp, float yp) {

    float maxX = max(_rect->_x1, _rect->_x2);
    float maxY = max(_rect->_y1, _rect->_y2);

    float minX = min(_rect->_x1, _rect->_x2);
    float minY = min(_rect->_y1, _rect->_y2);

    if (xp >= minX && xp <= maxX && yp >= minY && yp <= maxY) {
        return true;
    }
    return false;
 }

 void ECGraphicViewImp::DrawAllObjects() {
    //cout << endl << "Drawing All Objects" << endl;
    cout << "Objects to Draw: " << _windowObjects.size();
    for (auto obj : _windowObjects) {
        if (auto rect = dynamic_cast<RectObject*>(obj)) {
            if (rect->_color == ECGV_BLUE) { cout << "BLUE" << endl;}
            DrawRectangle(rect->_x1, rect->_y1, rect->_x2, rect->_y2, rect->_thickness, rect->_color);
        }
    }

    DrawWarningLabel();
    DrawModeLabel();
    al_flip_display();

 }

 bool ECGraphicViewImp::isClickInsideRect(float xp, float yp) {
    cout << "Is Point Inside? " << xp << "," << yp << endl;
    for (auto obj : _windowObjects) {
        if (RectObject* rect = dynamic_cast<RectObject*>(obj)) {
            cout << "Is Point Inside Rect: x1:" << rect->_x1 << " y1: " << rect->_y1 << " x2: " << rect->_x2 << " y2: " << rect->_y2 << endl;
            if (isPointInsideRect(rect, cursorxDown, cursoryDown)) {
                _editingRect = rect;
                return true;
            }
        }
    }
    return false;
 }

 std::__1::__wrap_iter<WindowObject **> ECGraphicViewImp::objectIndexInWindow(WindowObject* obj) {
    auto i = _windowObjects.begin();
    for (WindowObject* o : _windowObjects) {
        if (o == obj) {
            return i;
        }
        i++;
    }
    return _windowObjects.end();
 }