notepad_point.cpp

Go to the documentation of this file.

/*
 * File Name: notepad_point.cpp
 */

/*
 * This file is part of notepad.
 *
 * notepad is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * notepad is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * Copyright (C) 2010 IREX Technologies B.V.
 * All rights reserved.
 */

#include "notepad_point.h"
#include "log.h"

#define CNMAX(x,y) (x < y)? y: x

namespace notepad 
{
    CNPoint::CNPoint()
        :
            x(0),
            y(0)
    {
    }

    CNPoint::~CNPoint()
    {
    }

    CNPoint::CNPoint(const CNPoint& src)
    {
        x = src.x;
        y = src.y;
    }

    CNPoint& CNPoint::operator=(const CNPoint& rhs)
    {
        x = rhs.x;
        y = rhs.y;
        return *this;
    }

    // use this constructor to init from window view -> X and Y are coordinates within a gdk_window
    CNPoint::CNPoint(int an_X, int a_Y)
        :
            x(0),
            y(0)
    {
        //LOGPRINTF("X = %d, Y = %d", an_X, a_Y);

        if ( rotation == NP_PORTRAIT )
        {
            x = an_X + left_border;
            y = a_Y + top_border;
        }
        else if ( rotation == NP_CLOCKWISE) 
        {
            x = a_Y + top_border;
            y = screen_width - an_X - left_border;
        }
        else if ( rotation == NP_ANTICLOCKWISE) 
        {
            x = screen_height - a_Y - bottom_border;
            y = an_X + left_border;
        }

        clipToMaxBorder();
 
        // Post: instance inv. holds: x and y delta coordinates
        //LOGPRINTF("this->x = %d, this->y = %d", x,y);
    }

    // use this contructor to init from storageView -> p.x and p.y are coordinates from a point from a stroke from liberscribble
    CNPoint::CNPoint(const ScbPoint& p)
        :
            x(0),
            y(0)
    {
        x = p.x + left_border;
        y = p.y + top_border; 
    }

    // this is the deltaview: x and y are always in portrait and absolute screen (delta fb) coordinates
    ScbPoint CNPoint::deviceView()
    {
        ScbPoint p = {0,0};
        p.x = x;
        p.y = y;
        return p;
    }

    // this is the windowView: x and y are dependant of orientation and borders and as such relative to the window coordinates
    ScbPoint CNPoint::windowView()
    {
        ScbPoint p = {0,0};
        if ( rotation == NP_PORTRAIT )
        {
            p.x = x - left_border;
            p.y = y - top_border;
        }
        else if ( rotation == NP_CLOCKWISE) 
        {
            p.x = screen_width - y - left_border;
            p.y = x - top_border;
        }
        else if ( rotation == NP_ANTICLOCKWISE) 
        {
            p.x = y - left_border;
            p.y = screen_height - bottom_border - x;
        }
        return p;
    }
    // this is the storageview: x and y are absolute and always in portrait and absolute screen coordinates
    ScbPoint CNPoint::storageView()
    {
        ScbPoint p = {0,0};
        p.x = x - left_border;
        p.y = y - top_border;
        return p;
    }

    void CNPoint::setRotation(np_rotation aRotation)
    {
        // there are only 4 relevant transitions.
        // others do not happen (e.g. landscape clockwise to landscape anticlockwise
        if (rotation == NP_PORTRAIT)
        {
            if (aRotation != rotation )
            {
                int temp = screen_width;
                screen_width = screen_height;
                screen_height = temp;
            }
        }
        rotation = aRotation;
        LOGPRINTF("width = %d, height = %d, left = %d, right = %d, top = %d, bottom = %d", screen_width, screen_height, left_border, right_border, top_border, bottom_border);
    }

    void CNPoint::setBorders(int left, int right, int top, int bottom)
    {
        max_border = 0;

        left_border = left;
        right_border = right;
        top_border = top;
        bottom_border = bottom;

        max_border = CNMAX(max_border, left_border);
        max_border = CNMAX(max_border, right_border);
        max_border = CNMAX(max_border, top_border);
        max_border = CNMAX(max_border, bottom_border);
    }

    void CNPoint::setClipBorder(int border)
    {
        max_border = border+1; // just 1px within
    }

    void CNPoint::setScreen(int w, int h)
    {
        CNPoint::screen_width = w;
        CNPoint::screen_height = h;
    }

    void CNPoint::clipToMaxBorder()
    {
        int w = screen_width - max_border;
        int h = screen_height - max_border;
        if ( rotation != NP_PORTRAIT )
        {
            h = screen_width - max_border;
            w = screen_height - max_border;
        }

        if ( x < max_border ) x = max_border;
        if ( y < max_border ) y = max_border;
        if ( x > w ) x = w;
        if ( y > h ) y = h;

    }

    np_rotation CNPoint::rotation = NP_PORTRAIT;
    int CNPoint::left_border = 0;
    int CNPoint::right_border = 0;
    int CNPoint::top_border = 0;
    int CNPoint::bottom_border = 0;
    int CNPoint::max_border = 0;
    int CNPoint::screen_width = 0;
    int CNPoint::screen_height = 0;

}