256 lines
6.9 KiB
C
256 lines
6.9 KiB
C
/*
|
|
|
|
u8g2_hvline.c
|
|
|
|
Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)
|
|
|
|
Copyright (c) 2016, olikraus@gmail.com
|
|
All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without modification,
|
|
are permitted provided that the following conditions are met:
|
|
|
|
* Redistributions of source code must retain the above copyright notice, this list
|
|
of conditions and the following disclaimer.
|
|
|
|
* Redistributions in binary form must reproduce the above copyright notice, this
|
|
list of conditions and the following disclaimer in the documentation and/or other
|
|
materials provided with the distribution.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
|
|
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
|
|
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
|
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
|
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
Calltree
|
|
|
|
void u8g2_DrawHVLine(u8g2_t *u8g2, u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t len, uint8_t dir)
|
|
u8g2->cb->draw_l90
|
|
u8g2_draw_hv_line_2dir
|
|
u8g2->ll_hvline(u8g2, x, y, len, dir);
|
|
|
|
|
|
*/
|
|
|
|
#include "u8g2.h"
|
|
#include <assert.h>
|
|
|
|
/*==========================================================*/
|
|
/* intersection procedure */
|
|
|
|
/*
|
|
Description:
|
|
clip range from pos a (included) with line len (a+len excluded) agains c (included) to d (excluded)
|
|
Assumptions:
|
|
len > 0
|
|
c <= d (this is not checked)
|
|
will return 0 if there is no intersection and if a > b
|
|
|
|
*/
|
|
|
|
static uint8_t u8g2_clip_intersection2(u8g2_uint_t *ap, u8g2_uint_t *len, u8g2_uint_t c, u8g2_uint_t d)
|
|
{
|
|
u8g2_uint_t a = *ap;
|
|
u8g2_uint_t b;
|
|
b = a;
|
|
b += *len;
|
|
|
|
/*
|
|
Description:
|
|
clip range from a (included) to b (excluded) agains c (included) to d (excluded)
|
|
Assumptions:
|
|
a <= b (violation is checked and handled correctly)
|
|
c <= d (this is not checked)
|
|
will return 0 if there is no intersection and if a > b
|
|
|
|
optimized clipping: c is set to 0 --> 27 Oct 2018: again removed the c==0 assumption
|
|
|
|
replaced by uint8_t u8g2_clip_intersection2
|
|
*/
|
|
|
|
/* handle the a>b case correctly. If code and time is critical, this could */
|
|
/* be removed completly (be aware about memory curruption for wrong */
|
|
/* arguments) or return 0 for a>b (will lead to skipped lines for wrong */
|
|
/* arguments) */
|
|
|
|
/* removing the following if clause completly may lead to memory corruption of a>b */
|
|
if ( a > b )
|
|
{
|
|
/* replacing this if with a simple "return 0;" will not handle the case with negative a */
|
|
if ( a < d )
|
|
{
|
|
b = d;
|
|
b--;
|
|
}
|
|
else
|
|
{
|
|
a = c;
|
|
}
|
|
}
|
|
|
|
/* from now on, the asumption a <= b is ok */
|
|
|
|
if ( a >= d )
|
|
return 0;
|
|
if ( b <= c )
|
|
return 0;
|
|
if ( a < c )
|
|
a = c;
|
|
if ( b > d )
|
|
b = d;
|
|
|
|
*ap = a;
|
|
b -= a;
|
|
*len = b;
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
/*==========================================================*/
|
|
/* draw procedures */
|
|
|
|
/*
|
|
x,y Upper left position of the line within the pixel buffer
|
|
len length of the line in pixel, len must not be 0
|
|
dir 0: horizontal line (left to right)
|
|
1: vertical line (top to bottom)
|
|
This function first adjusts the y position to the local buffer. Then it
|
|
will clip the line and call u8g2_draw_low_level_hv_line()
|
|
|
|
*/
|
|
void u8g2_draw_hv_line_2dir(u8g2_t *u8g2, u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t len, uint8_t dir)
|
|
{
|
|
|
|
/* clipping happens before the display rotation */
|
|
|
|
/* transform to pixel buffer coordinates */
|
|
y -= u8g2->pixel_curr_row;
|
|
|
|
u8g2->ll_hvline(u8g2, x, y, len, dir);
|
|
}
|
|
|
|
|
|
/*
|
|
This is the toplevel function for the hv line draw procedures.
|
|
This function should be called by the user.
|
|
|
|
"dir" may have 4 directions: 0 (left to right), 1, 2, 3 (down up)
|
|
*/
|
|
void u8g2_DrawHVLine(u8g2_t *u8g2, u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t len, uint8_t dir)
|
|
{
|
|
/* Make a call to the callback function (e.g. u8g2_draw_l90_r0). */
|
|
/* The callback may rotate the hv line */
|
|
/* after rotation this will call u8g2_draw_hv_line_4dir() */
|
|
|
|
#ifdef U8G2_WITH_CLIP_WINDOW_SUPPORT
|
|
if ( u8g2->is_page_clip_window_intersection != 0 )
|
|
#endif /* U8G2_WITH_CLIP_WINDOW_SUPPORT */
|
|
if ( len != 0 )
|
|
{
|
|
|
|
/* convert to two directions */
|
|
if ( len > 1 )
|
|
{
|
|
if ( dir == 2 )
|
|
{
|
|
x -= len;
|
|
x++;
|
|
}
|
|
else if ( dir == 3 )
|
|
{
|
|
y -= len;
|
|
y++;
|
|
}
|
|
}
|
|
dir &= 1;
|
|
|
|
/* clip against the user window */
|
|
if ( dir == 0 )
|
|
{
|
|
if ( y < u8g2->user_y0 )
|
|
return;
|
|
if ( y >= u8g2->user_y1 )
|
|
return;
|
|
if ( u8g2_clip_intersection2(&x, &len, u8g2->user_x0, u8g2->user_x1) == 0 )
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if ( x < u8g2->user_x0 )
|
|
return;
|
|
if ( x >= u8g2->user_x1 )
|
|
return;
|
|
if ( u8g2_clip_intersection2(&y, &len, u8g2->user_y0, u8g2->user_y1) == 0 )
|
|
return;
|
|
}
|
|
|
|
|
|
u8g2->cb->draw_l90(u8g2, x, y, len, dir);
|
|
}
|
|
}
|
|
|
|
void u8g2_DrawHLine(u8g2_t *u8g2, u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t len)
|
|
{
|
|
// #ifdef U8G2_WITH_INTERSECTION
|
|
// if ( u8g2_IsIntersection(u8g2, x, y, x+len, y+1) == 0 )
|
|
// return;
|
|
// #endif /* U8G2_WITH_INTERSECTION */
|
|
u8g2_DrawHVLine(u8g2, x, y, len, 0);
|
|
}
|
|
|
|
void u8g2_DrawVLine(u8g2_t *u8g2, u8g2_uint_t x, u8g2_uint_t y, u8g2_uint_t len)
|
|
{
|
|
// #ifdef U8G2_WITH_INTERSECTION
|
|
// if ( u8g2_IsIntersection(u8g2, x, y, x+1, y+len) == 0 )
|
|
// return;
|
|
// #endif /* U8G2_WITH_INTERSECTION */
|
|
u8g2_DrawHVLine(u8g2, x, y, len, 1);
|
|
}
|
|
|
|
void u8g2_DrawPixel(u8g2_t *u8g2, u8g2_uint_t x, u8g2_uint_t y)
|
|
{
|
|
#ifdef U8G2_WITH_INTERSECTION
|
|
if ( y < u8g2->user_y0 )
|
|
return;
|
|
if ( y >= u8g2->user_y1 )
|
|
return;
|
|
if ( x < u8g2->user_x0 )
|
|
return;
|
|
if ( x >= u8g2->user_x1 )
|
|
return;
|
|
#endif /* U8G2_WITH_INTERSECTION */
|
|
u8g2_DrawHVLine(u8g2, x, y, 1, 0);
|
|
}
|
|
|
|
/*
|
|
Assign the draw color for all drawing functions.
|
|
color may be 0 or 1. The actual color is defined by the display.
|
|
With color = 1 the drawing function will set the display memory to 1.
|
|
For OLEDs this ususally means, that the pixel is enabled and the LED
|
|
at the pixel is turned on.
|
|
On an LCD it usually means that the LCD segment of the pixel is enabled,
|
|
which absorbs the light.
|
|
For eInk/ePaper it means black ink.
|
|
|
|
7 Jan 2017: Allow color value 2 for XOR operation.
|
|
|
|
*/
|
|
void u8g2_SetDrawColor(u8g2_t *u8g2, uint8_t color)
|
|
{
|
|
u8g2->draw_color = color; /* u8g2_SetDrawColor: just assign the argument */
|
|
if ( color >= 3 )
|
|
u8g2->draw_color = 1; /* u8g2_SetDrawColor: make color as one if arg is invalid */
|
|
}
|
|
|