Mercurial > public > ostc4
annotate Discovery/Src/gfx_engine.c @ 471:73da921869d9 fix-bat-2
bugfix: implement battery charge percentage in dive header
This commit is (much) less trivial than the related 919e5cb51c92.
First, rename the CCRmode attribute (corresponding to byte Ox59) of
the SLogbookHeaderOSTC3. This byte (according to the hwOS interface
document) does not contain any CCR related value, but it contains
"battery information". Already since 2017, this byte is used from
libdivecomputer to interface the charge percentage. So, its
renamed from CCRmode to batteryCharge, to reflect its true purpose.
Now, simply add a batteryCharge attribute to the SLogbookHeader
(and see below why that is possible, without breaking things).
The remaining changes are trivial to implement battery charge
percentage in dive header.
Caveat: do not get confused by the exact role of the individual
logbook header types. SLogbookHeaderOSTC3 is the formal type of
the logbook format that the OSTC4 produces. This format is
supposed to identical to the format, as is used in hwOS for the
series of small OSTCs. Only some values of attributes are different.
For example, the OSTC4 supports VPM, so byte 0x79 (deco model used
for this dive) also has a value for VPM. But the SLogbookHeader
type, despite its name and structure, is *not* a true logbook
header, as it includes attributes that are not available in the
SLogbookHeaderOSTC3 formal header type.
Signed-off-by: Jan Mulder <jan@jlmulder.nl>
| author | Jan Mulder <jlmulder@xs4all.nl> |
|---|---|
| date | Wed, 22 Apr 2020 13:08:57 +0200 |
| parents | e141b571a03d |
| children | 89f6857276f8 |
| rev | line source |
|---|---|
| 38 | 1 /** |
| 2 ****************************************************************************** | |
| 3 * @file gfx_engine.c | |
| 4 * @author heinrichs weikamp gmbh | |
| 5 * @version V0.0.2 | |
| 6 * @date 30-April-2014 | |
| 7 * @brief Main source file of GFX Graphic Engine | |
| 8 * This file provides firmware functions to manage the following | |
| 9 * functions to draw on the screen: | |
| 10 * + write string to display | |
| 11 * | |
| 12 ****************************************************************************** | |
| 13 * @attention | |
| 14 * | |
| 15 * <h2><center>© COPYRIGHT(c) 2014 heinrichs weikamp</center></h2> | |
| 16 * | |
| 17 ****************************************************************************** | |
| 18 */ | |
| 19 | |
| 20 /* Includes ------------------------------------------------------------------*/ | |
| 21 | |
| 22 #include <stdlib.h> | |
| 23 #include <stdint.h> | |
| 24 | |
| 25 #include "stm32f4xx_hal.h" | |
| 26 | |
| 27 #include "gfx.h" | |
| 28 #include "gfx_engine.h" | |
| 29 #include "gfx_fonts.h" | |
| 30 #include "gfx_colors.h" | |
| 31 #include "ostc.h" | |
| 32 #include "settings.h" | |
| 33 #include "text_multilanguage.h" | |
| 34 | |
| 35 /* Exported variables --------------------------------------------------------*/ | |
| 36 | |
| 37 /* Private types -------------------------------------------------------------*/ | |
| 38 | |
| 39 typedef struct | |
| 40 { | |
| 41 uint32_t Xdelta; | |
| 42 uint32_t Ydelta; | |
| 43 uint8_t invert; | |
| 44 uint8_t color; | |
| 45 uint8_t dualFont; | |
| 46 uint8_t resize; | |
| 47 uint32_t font; | |
| 48 uint8_t spaceMode; | |
| 49 uint8_t singleSpaceWithSizeOfNextChar; | |
| 50 uint8_t useTinyFont; | |
| 51 uint32_t TinyFont; | |
| 52 int8_t TinyFontExtraYdelta; | |
| 53 tFont *actualFont; | |
| 54 uint8_t doubleSize; | |
| 55 } GFX_CfgWriteString; | |
| 56 | |
| 57 typedef struct | |
| 58 { | |
| 59 uint32_t pBuffer; | |
| 60 uint32_t height; | |
| 61 uint32_t width; | |
| 62 uint32_t leftStart; | |
| 63 uint32_t bottomStart; | |
| 64 } GFX_layerSingle; | |
| 65 /* | |
| 66 typedef struct | |
| 67 { | |
| 68 GFX_layerSingle top; | |
| 69 GFX_layerSingle bottom; | |
| 70 } GFX_layersTopBottom; | |
| 71 */ | |
| 72 typedef struct | |
| 73 { | |
| 74 uint32_t pActualTopBuffer; | |
| 75 uint32_t pNextTopBuffer[2]; | |
| 76 GFX_layerSingle actualBottom; | |
| 77 GFX_layerSingle nextBottom[2]; | |
| 78 uint8_t boolNextTop; | |
| 79 uint8_t boolNextBottom; | |
| 80 } GFX_layerControl; | |
| 81 | |
| 82 typedef struct | |
| 83 { | |
| 84 uint32_t StartAddress; | |
| 85 int8_t status; | |
| 86 uint8_t caller; | |
| 87 } SFrameList; | |
| 88 | |
| 89 enum FRAMESTATE | |
| 90 { | |
| 91 CLEAR = 0, | |
| 92 BLOCKED, | |
| 93 RELEASED | |
| 94 }; | |
| 95 | |
| 96 enum LOGOSTATE | |
| 97 { | |
| 98 LOGOOFF = 0, | |
| 99 LOGOSTART = 1, | |
| 100 LOGOSTOP = 255 | |
| 101 }; | |
| 102 | |
| 103 // should be 43 | |
| 104 #define MAXFRAMES 39 | |
| 105 | |
| 106 #define SDRAM_BANK_ADDR ((uint32_t)0xD0000000) | |
| 107 #define FBGlobalStart SDRAM_BANK_ADDR | |
| 108 #define FBOffsetEachIndex (800*480*2) | |
| 109 | |
| 110 #define SDRAM_DOUBLE_BUFFER_ONE ((uint32_t)(FBGlobalStart + (MAXFRAMES * FBOffsetEachIndex))) | |
| 111 #define SDRAM_DOUBLE_BUFFER_TWO ((uint32_t)(SDRAM_DOUBLE_BUFFER_ONE + (2 * FBOffsetEachIndex))) | |
| 112 #define SDRAM_DOUBLE_BUFFER_END ((uint32_t)(SDRAM_DOUBLE_BUFFER_TWO + (2 * FBOffsetEachIndex))) | |
| 113 | |
| 114 /* Semi Private variables ---------------------------------------------------------*/ | |
| 115 | |
| 116 DMA2D_HandleTypeDef Dma2dHandle; | |
|
297
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
117 static LTDC_HandleTypeDef LtdcHandle; |
| 38 | 118 |
| 119 /* Private variables ---------------------------------------------------------*/ | |
| 120 | |
|
297
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
121 static uint8_t DMA2D_at_work = 0; |
|
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
122 |
|
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
123 static GFX_layerControl FrameHandler = { 0 }; |
|
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
124 |
|
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
125 static uint32_t pInvisibleFrame = 0; |
|
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
126 static uint32_t pLogoFrame = 0; |
|
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
127 static uint8_t logoStatus; |
|
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
128 static uint32_t pBackgroundHwFrame = 0; |
|
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
129 static uint8_t backgroundHwStatus; |
|
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
130 |
|
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
131 static SFrameList frame[MAXFRAMES]; |
| 38 | 132 |
| 133 #define MAXFRAMECOUNTER (28) | |
|
297
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
134 static uint8_t frameCounter[MAXFRAMECOUNTER] = { 0 }; |
|
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
135 |
|
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
136 static _Bool lock_changeLTDC = 0; |
|
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
137 |
|
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
138 static void GFX_clear_frame_immediately(uint32_t pDestination); |
|
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
139 static void GFX_draw_image_color(GFX_DrawCfgScreen *hgfx, SWindowGimpStyle window, const tImage *image); |
| 38 | 140 /* ITM Trace-----------------------------------------------------------------*/ |
| 141 | |
| 142 #include "stdio.h" | |
| 143 | |
| 144 #define ITM_Port8(n) (*((volatile unsigned char *)(0xE0000000+4*n))) | |
| 145 #define ITM_Port16(n) (*((volatile unsigned short*)(0xE0000000+4*n))) | |
| 146 #define ITM_Port32(n) (*((volatile unsigned long *)(0xE0000000+4*n))) | |
| 147 | |
| 148 #define DEMCR (*((volatile unsigned long *)(0xE000EDFC))) | |
| 149 #define TRCENA 0x01000000 | |
| 150 | |
| 151 struct __FILE { int handle; /* Add whatever needed */ }; | |
| 152 FILE __stdout; | |
| 153 FILE __stdin; | |
| 154 | |
| 155 int fputc(int ch, FILE *f) { | |
| 156 if (DEMCR & TRCENA) { | |
| 157 while (ITM_Port32(0) == 0); | |
| 158 ITM_Port8(0) = ch; | |
| 159 } | |
| 160 return(ch); | |
| 161 } | |
| 162 | |
| 163 uint32_t MinU32GFX(uint32_t a, uint32_t b) | |
| 164 { | |
| 165 return ((a<b)?a:b); | |
| 166 } | |
| 167 | |
| 168 | |
| 169 uint32_t MaxU32GFX(uint32_t a, uint32_t b) | |
| 170 { | |
| 171 return((a>b)?a:b); | |
| 172 } | |
| 173 | |
| 174 /* Private function prototypes -----------------------------------------------*/ | |
| 175 | |
| 176 static uint32_t GFX_write_char(GFX_DrawCfgWindow* hgfx, GFX_CfgWriteString* cfg, uint8_t character, tFont *Font); | |
| 177 static uint32_t GFX_write_substring(GFX_CfgWriteString* cfg, GFX_DrawCfgWindow* hgfx, uint8_t textId, int8_t nextCharFor2Byte); | |
|
297
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
178 static uint32_t GFX_write__Modify_Xdelta__Centered(GFX_CfgWriteString* cfg, GFX_DrawCfgWindow* hgfx, const char *pText); |
|
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
179 static uint32_t GFX_write__Modify_Xdelta__RightAlign(GFX_CfgWriteString* cfg, GFX_DrawCfgWindow* hgfx, const char *pTextInput); |
| 38 | 180 static void GFX_Error_Handler(void); |
| 181 static void GFX_Dma2d_TransferComplete(DMA2D_HandleTypeDef* Dma2dHandle); | |
| 182 static void GFX_Dma2d_TransferError(DMA2D_HandleTypeDef* Dma2dHandle); | |
|
297
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
183 static void GFX_clear_frame_dma2d(uint8_t frameId); |
|
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
184 |
|
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
185 static uint32_t GFX_doubleBufferOne(void); |
|
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
186 static uint32_t GFX_doubleBufferTwo(void); |
| 38 | 187 |
| 188 | |
| 189 /* Exported functions --------------------------------------------------------*/ | |
| 190 | |
| 191 uint8_t GFX_logoStatus(void) | |
| 192 { | |
| 193 return logoStatus; | |
| 194 } | |
| 195 | |
| 196 void GFX_SetWindowLayer0(uint32_t pDestination, int16_t XleftGimpStyle, int16_t XrightGimpStyle, int16_t YtopGimpStyle, int16_t YbottomGimpStyle) | |
| 197 { | |
| 198 int16_t XSize, YSize, X0, Y0; | |
| 199 | |
| 200 if(XleftGimpStyle < 0) XleftGimpStyle = 0; | |
| 201 if(XrightGimpStyle < 0) XrightGimpStyle = 0; | |
| 202 if(XleftGimpStyle > 799) XleftGimpStyle = 800; | |
| 203 if(XrightGimpStyle > 799) XrightGimpStyle = 800; | |
| 204 | |
| 205 if(YtopGimpStyle < 0) YtopGimpStyle = 0; | |
| 206 if(YbottomGimpStyle < 0) YbottomGimpStyle = 0; | |
| 207 if(YtopGimpStyle > 479) YtopGimpStyle = 480; | |
| 208 if(YbottomGimpStyle > 479) YbottomGimpStyle = 480; | |
| 209 | |
| 210 /* | |
| 211 XSize = YbottomGimpStyle - YtopGimpStyle; | |
| 212 YSize = XrightGimpStyle - XleftGimpStyle; | |
| 213 if((XSize <= 0) || (YSize <= 0)) | |
| 214 return; | |
| 215 X0 = 479 - YbottomGimpStyle; | |
| 216 Y0 = XleftGimpStyle; | |
| 217 while((LTDC->CPSR & LTDC_CPSR_CYPOS) <= (uint32_t)800); | |
| 218 HAL_LTDC_SetWindowSize(&LtdcHandle, XSize, YSize, LayerIdx); | |
| 219 HAL_LTDC_SetWindowPosition(&LtdcHandle, X0, Y0,LayerIdx); | |
| 220 HAL_LTDC_SetAddress(&LtdcHandle, pDestination, LayerIdx); | |
| 221 */ | |
| 222 | |
| 223 XSize = XrightGimpStyle - XleftGimpStyle; | |
| 224 YSize = YbottomGimpStyle - YtopGimpStyle; | |
| 225 if((XSize <= 0) || (YSize <= 0)) | |
| 226 return; | |
| 227 Y0 = 479 - YbottomGimpStyle; | |
| 228 X0 = XleftGimpStyle; | |
| 229 | |
| 230 GFX_SetFrameBottom(pDestination, X0, Y0, XSize, YSize); | |
| 231 } | |
| 232 | |
| 233 | |
| 234 void GFX_logoAutoOff(void) | |
| 235 { | |
| 236 if(logoStatus == LOGOOFF) | |
| 237 logoStatus = LOGOSTART; | |
| 238 } | |
| 239 | |
| 240 | |
| 241 void GFX_hwBackgroundOn(void) | |
| 242 { | |
| 243 backgroundHwStatus = LOGOSTART; | |
| 244 } | |
| 245 | |
| 246 | |
| 247 void GFX_hwBackgroundOff(void) | |
| 248 { | |
| 249 backgroundHwStatus = LOGOSTOP; | |
| 250 } | |
| 251 | |
| 252 | |
| 314 | 253 void GFX_build_hw_background_frame(void) |
| 38 | 254 { |
| 255 GFX_DrawCfgScreen tLogoTemp; | |
| 256 SWindowGimpStyle windowGimp; | |
| 257 | |
| 258 pBackgroundHwFrame = getFrame(1); | |
| 259 backgroundHwStatus = 0; | |
| 260 | |
| 261 tLogoTemp.FBStartAdress = pBackgroundHwFrame; | |
| 262 tLogoTemp.ImageHeight = 480; | |
| 263 tLogoTemp.ImageWidth = 800; | |
| 264 tLogoTemp.LayerIndex = 1; | |
| 265 | |
| 266 windowGimp.left = (800 - 400) / 2; | |
| 267 windowGimp.top = 0;//(480 - 46) / 2; | |
| 268 | |
| 269 GFX_draw_image_color(&tLogoTemp, windowGimp, &ImgHWcolor); | |
| 270 /* | |
| 271 char localtext[256]; | |
| 272 uint8_t ptr = 0; | |
| 273 | |
| 274 localtext[ptr++] = ' '; | |
| 275 localtext[ptr++] = ' '; | |
| 276 localtext[ptr++] = 'O'; | |
| 277 localtext[ptr++] = 'S'; | |
| 278 localtext[ptr++] = ' '; | |
| 279 ptr += GFX_printf_firmware(&localtext[ptr]); | |
| 280 localtext[ptr] = 0; | |
| 281 | |
| 282 write_content_simple(&tLogoTemp, 0, 800, 240-24, &FontT24,localtext,CLUT_Font020); | |
| 283 */ | |
| 284 } | |
| 285 | |
| 286 | |
| 314 | 287 void GFX_build_logo_frame(void) |
| 38 | 288 { |
| 289 GFX_DrawCfgScreen tLogoTemp; | |
| 290 SWindowGimpStyle windowGimp; | |
| 291 | |
| 292 pLogoFrame = getFrame(1); | |
| 293 logoStatus = LOGOOFF; | |
| 294 | |
| 295 tLogoTemp.FBStartAdress = pLogoFrame; | |
| 296 tLogoTemp.ImageHeight = 480; | |
| 297 tLogoTemp.ImageWidth = 800; | |
| 298 tLogoTemp.LayerIndex = 1; | |
| 299 | |
| 300 windowGimp.left = (800 - 400) / 2; | |
| 301 windowGimp.top = (480 - 46) / 2; | |
| 302 | |
| 303 GFX_draw_image_color(&tLogoTemp, windowGimp, &ImgHWcolor); | |
| 304 /* | |
| 305 char localtext[256]; | |
| 306 uint8_t ptr = 0; | |
| 307 | |
| 308 localtext[ptr++] = ' '; | |
| 309 localtext[ptr++] = ' '; | |
| 310 localtext[ptr++] = 'O'; | |
| 311 localtext[ptr++] = 'S'; | |
| 312 localtext[ptr++] = ' '; | |
| 313 ptr += GFX_printf_firmware(&localtext[ptr]); | |
| 314 localtext[ptr] = 0; | |
| 315 | |
| 316 write_content_simple(&tLogoTemp, 0, 800, 240-24, &FontT24,localtext,CLUT_Font020); | |
| 317 */ | |
| 318 } | |
| 319 | |
| 320 | |
| 321 void GFX_init(uint32_t * pDestinationOut) | |
| 322 { | |
| 323 frame[0].StartAddress = FBGlobalStart; | |
| 324 GFX_clear_frame_immediately(frame[0].StartAddress); | |
| 325 frame[0].status = CLEAR; | |
| 326 frame[0].caller = 0; | |
| 327 | |
| 328 for(int i=1;i<MAXFRAMES;i++) | |
| 329 { | |
| 330 frame[i].StartAddress = frame[i-1].StartAddress + FBOffsetEachIndex; | |
| 331 GFX_clear_frame_immediately(frame[i].StartAddress); | |
| 332 frame[i].status = CLEAR; | |
| 333 frame[i].caller = 0; | |
| 334 } | |
| 335 | |
| 336 for(int i=1;i<MAXFRAMECOUNTER;i++) | |
| 337 { | |
| 338 frameCounter[i] = 0; | |
| 339 } | |
| 340 | |
| 341 pInvisibleFrame = getFrame(2); | |
| 342 *pDestinationOut = pInvisibleFrame; | |
| 343 | |
| 344 GFX_build_logo_frame(); | |
| 345 GFX_build_hw_background_frame(); | |
| 346 | |
| 347 /* Register to memory mode with ARGB8888 as color Mode */ | |
| 348 Dma2dHandle.Init.Mode = DMA2D_R2M; | |
| 349 Dma2dHandle.Init.ColorMode = DMA2D_ARGB4444;//to fake AL88, before: DMA2D_ARGB8888; | |
| 350 Dma2dHandle.Init.OutputOffset = 0; | |
| 351 | |
| 352 /* DMA2D Callbacks Configuration */ | |
| 353 Dma2dHandle.XferCpltCallback = GFX_Dma2d_TransferComplete; | |
| 354 Dma2dHandle.XferErrorCallback = GFX_Dma2d_TransferError; | |
| 355 | |
| 356 Dma2dHandle.Instance = DMA2D; | |
| 357 | |
| 358 /* DMA2D Initialisation */ | |
| 359 if(HAL_DMA2D_Init(&Dma2dHandle) != HAL_OK) | |
| 360 GFX_Error_Handler(); | |
| 361 | |
| 362 if(HAL_DMA2D_ConfigLayer(&Dma2dHandle, 1) != HAL_OK) | |
| 363 GFX_Error_Handler(); | |
| 364 | |
| 365 DMA2D_at_work = 255; | |
| 366 } | |
| 367 | |
| 368 | |
| 369 void GFX_SetFrameTop(uint32_t pDestination) | |
| 370 { | |
| 371 lock_changeLTDC = 1; | |
| 372 uint8_t boolNextTop = !FrameHandler.boolNextTop; | |
| 373 | |
| 374 if(pDestination == 0) | |
| 375 pDestination = pInvisibleFrame; | |
| 376 | |
| 377 FrameHandler.pNextTopBuffer[boolNextTop] = pDestination; | |
| 378 FrameHandler.boolNextTop = boolNextTop; | |
| 379 lock_changeLTDC = 0; | |
| 380 } | |
| 381 | |
| 382 | |
| 383 void GFX_SetFrameBottom(uint32_t pDestination, uint32_t x0, uint32_t y0, uint32_t width, uint32_t height) | |
| 384 { | |
| 385 lock_changeLTDC = 1; | |
| 386 uint8_t boolNextBottom = !FrameHandler.boolNextBottom; | |
| 387 | |
| 388 if(pDestination == 0) | |
| 389 pDestination = pInvisibleFrame; | |
| 390 | |
| 391 FrameHandler.nextBottom[boolNextBottom].pBuffer = pDestination; | |
| 392 FrameHandler.nextBottom[boolNextBottom].height = height; | |
| 393 FrameHandler.nextBottom[boolNextBottom].width = width; | |
| 394 FrameHandler.nextBottom[boolNextBottom].leftStart = x0; | |
| 395 FrameHandler.nextBottom[boolNextBottom].bottomStart = y0; | |
| 396 FrameHandler.boolNextBottom = boolNextBottom; | |
| 397 lock_changeLTDC = 0; | |
| 398 } | |
| 399 | |
| 400 | |
| 401 void GFX_SetFramesTopBottom(uint32_t pTop, uint32_t pBottom, uint32_t heightBottom) | |
| 402 { | |
| 403 GFX_SetFrameTop(pTop); | |
| 404 GFX_SetFrameBottom(pBottom, 0, 0, 800, heightBottom); | |
| 405 } | |
| 406 | |
| 407 | |
|
297
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
408 static uint32_t GFX_get_pActualFrameTop(void) |
| 38 | 409 { |
| 410 return FrameHandler.pActualTopBuffer; | |
| 411 } | |
| 412 | |
| 413 | |
|
297
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
414 static uint32_t GFX_get_pActualFrameBottom(void) |
| 38 | 415 { |
| 416 return FrameHandler.actualBottom.pBuffer; | |
| 417 } | |
| 418 | |
| 419 | |
| 420 void GFX_start_VSYNC_IRQ(void) | |
| 421 { | |
| 422 GPIO_InitTypeDef GPIO_InitStructure; | |
| 423 | |
| 424 GPIO_InitStructure.Mode = GPIO_MODE_IT_FALLING; | |
| 425 GPIO_InitStructure.Pull = GPIO_NOPULL; | |
| 426 GPIO_InitStructure.Speed = GPIO_SPEED_LOW; | |
| 427 GPIO_InitStructure.Pin = VSYNC_IRQ_PIN; | |
| 428 HAL_GPIO_Init(VSYNC_IRQ_GPIO_PORT, &GPIO_InitStructure); | |
| 429 | |
| 430 HAL_NVIC_SetPriority(VSYNC_IRQ_EXTI_IRQn, 1, 0); | |
| 431 HAL_NVIC_EnableIRQ(VSYNC_IRQ_EXTI_IRQn); | |
| 432 } | |
| 433 | |
| 434 | |
| 435 void GFX_change_LTDC(void) | |
| 436 { | |
| 437 if(lock_changeLTDC == 1) | |
| 438 return; | |
| 439 | |
| 440 uint32_t pTop = 0; | |
| 441 uint32_t pBot = 0; | |
| 442 uint32_t heightBot = 0; | |
| 443 uint32_t widthBot = 0; | |
| 444 uint32_t leftStartBot = 0; | |
| 445 uint32_t bottomStartBot = 0; | |
| 446 uint8_t change_position = 0; | |
| 447 uint8_t change_size = 0; | |
| 448 | |
| 449 // Top Frame | |
| 450 pTop = FrameHandler.pNextTopBuffer[FrameHandler.boolNextTop]; | |
| 451 if(FrameHandler.pActualTopBuffer != pTop) | |
| 452 { | |
| 453 HAL_LTDC_SetAddress(&LtdcHandle, pTop, 1); | |
| 454 FrameHandler.pActualTopBuffer = pTop; | |
| 455 } | |
| 456 | |
| 457 // Bottom Frame | |
| 458 if(logoStatus != LOGOOFF) | |
| 459 { | |
| 460 switch(logoStatus) | |
| 461 { | |
| 462 case LOGOSTART: | |
| 463 HAL_LTDC_SetAlpha(&LtdcHandle, 0, 1); | |
| 464 HAL_LTDC_SetAlpha(&LtdcHandle, 34, 0); | |
| 465 HAL_LTDC_ConfigCLUT(&LtdcHandle, (uint32_t *)indexHWcolor, indexHWcolorSIZE, 0); | |
| 466 HAL_LTDC_SetAddress(&LtdcHandle, pLogoFrame, 0); | |
| 467 HAL_LTDC_SetWindowSize(&LtdcHandle, 480, 800, 0); | |
| 468 HAL_LTDC_SetWindowPosition(&LtdcHandle, 0, 0, 0); | |
| 469 logoStatus = 2; | |
| 470 break; | |
| 471 | |
| 472 case LOGOSTOP: | |
| 473 HAL_LTDC_SetAlpha(&LtdcHandle, 255, 1); | |
| 474 HAL_LTDC_ConfigCLUT(&LtdcHandle, ColorLUT, CLUT_END, 0); | |
| 475 | |
| 476 pBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].pBuffer; | |
| 477 heightBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].height; | |
| 478 widthBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].width; | |
| 479 leftStartBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].leftStart; | |
| 480 bottomStartBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].bottomStart; | |
| 481 HAL_LTDC_SetWindowSize(&LtdcHandle, heightBot, widthBot, 0); | |
| 482 HAL_LTDC_SetWindowPosition(&LtdcHandle, bottomStartBot, leftStartBot, 0); | |
| 483 HAL_LTDC_SetAddress(&LtdcHandle, pBot, 0); | |
| 484 HAL_LTDC_SetAlpha(&LtdcHandle, 255, 0); | |
| 485 FrameHandler.actualBottom.height = heightBot; | |
| 486 FrameHandler.actualBottom.width = widthBot; | |
| 487 FrameHandler.actualBottom.leftStart = leftStartBot; | |
| 488 FrameHandler.actualBottom.bottomStart = bottomStartBot; | |
| 489 FrameHandler.actualBottom.pBuffer = pBot; | |
| 490 | |
| 491 logoStatus = LOGOOFF; | |
| 492 if(backgroundHwStatus == 2) | |
| 493 { | |
| 494 backgroundHwStatus = LOGOSTART; | |
| 495 } | |
| 496 break; | |
| 497 default: | |
| 498 if(logoStatus < 35) | |
| 499 { | |
| 500 logoStatus++; | |
| 501 if(logoStatus <= 15) | |
| 502 HAL_LTDC_SetAlpha(&LtdcHandle, 17*logoStatus, 0); | |
| 503 } | |
| 504 else | |
| 505 { | |
| 506 logoStatus +=20; | |
| 507 HAL_LTDC_SetAlpha(&LtdcHandle, logoStatus-55, 1); | |
| 508 HAL_LTDC_SetAlpha(&LtdcHandle, 255+55-logoStatus, 0); | |
| 509 } | |
| 510 break; | |
| 511 } | |
| 512 return; | |
| 513 } | |
| 514 else if (backgroundHwStatus != LOGOOFF) | |
| 515 { | |
| 516 switch(backgroundHwStatus) | |
| 517 { | |
| 518 case LOGOSTART: | |
| 519 HAL_LTDC_ConfigCLUT(&LtdcHandle, (uint32_t *)indexHWcolor, indexHWcolorSIZE, 0); | |
| 520 HAL_LTDC_SetAddress(&LtdcHandle, pBackgroundHwFrame, 0); | |
| 521 HAL_LTDC_SetWindowSize(&LtdcHandle, 480, 800, 0); | |
| 522 HAL_LTDC_SetWindowPosition(&LtdcHandle, 0, 0, 0); | |
| 523 backgroundHwStatus = 2; | |
| 524 break; | |
| 525 | |
| 526 case LOGOSTOP: | |
| 527 HAL_LTDC_ConfigCLUT(&LtdcHandle, ColorLUT, CLUT_END, 0); | |
| 528 pBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].pBuffer; | |
| 529 heightBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].height; | |
| 530 widthBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].width; | |
| 531 leftStartBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].leftStart; | |
| 532 bottomStartBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].bottomStart; | |
| 533 HAL_LTDC_SetWindowSize(&LtdcHandle, heightBot, widthBot, 0); | |
| 534 HAL_LTDC_SetWindowPosition(&LtdcHandle, bottomStartBot, leftStartBot, 0); | |
| 535 HAL_LTDC_SetAddress(&LtdcHandle, pBot, 0); | |
| 536 HAL_LTDC_SetAlpha(&LtdcHandle, 255, 0); | |
| 537 FrameHandler.actualBottom.height = heightBot; | |
| 538 FrameHandler.actualBottom.width = widthBot; | |
| 539 FrameHandler.actualBottom.leftStart = leftStartBot; | |
| 540 FrameHandler.actualBottom.bottomStart = bottomStartBot; | |
| 541 FrameHandler.actualBottom.pBuffer = pBot; | |
| 542 backgroundHwStatus = LOGOOFF; | |
| 543 break; | |
| 544 | |
| 545 default: | |
| 546 break; | |
| 547 } | |
| 548 return; | |
| 549 } | |
| 550 else | |
| 551 { | |
| 552 pBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].pBuffer; | |
| 553 heightBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].height; | |
| 554 widthBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].width; | |
| 555 leftStartBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].leftStart; | |
| 556 bottomStartBot = FrameHandler.nextBottom[FrameHandler.boolNextBottom].bottomStart; | |
| 557 | |
| 558 if(FrameHandler.actualBottom.pBuffer == pBot) | |
| 559 pBot = 0; | |
| 560 | |
| 561 if((FrameHandler.actualBottom.height != heightBot) || (FrameHandler.actualBottom.width != widthBot)) | |
| 562 change_size = 1; | |
| 563 | |
| 564 if((FrameHandler.actualBottom.leftStart != leftStartBot) || (FrameHandler.actualBottom.bottomStart != bottomStartBot)) | |
| 565 change_position = 1; | |
| 566 | |
| 567 if(pBot || change_size || change_position) | |
| 568 { | |
| 569 if(heightBot && widthBot) | |
| 570 HAL_LTDC_SetWindowSize(&LtdcHandle, heightBot, widthBot, 0); | |
| 571 | |
| 572 if(change_position || leftStartBot || bottomStartBot) | |
| 573 HAL_LTDC_SetWindowPosition(&LtdcHandle, bottomStartBot, leftStartBot, 0); | |
| 574 | |
| 575 if(pBot) | |
| 576 HAL_LTDC_SetAddress(&LtdcHandle, pBot, 0); | |
| 577 | |
| 578 if(change_size) | |
| 579 { | |
| 580 FrameHandler.actualBottom.height = heightBot; | |
| 581 FrameHandler.actualBottom.width = widthBot; | |
| 582 } | |
| 583 if(change_position) | |
| 584 { | |
| 585 FrameHandler.actualBottom.leftStart = leftStartBot; | |
| 586 FrameHandler.actualBottom.bottomStart = bottomStartBot; | |
| 587 } | |
| 588 if(pBot) | |
| 589 FrameHandler.actualBottom.pBuffer = pBot; | |
| 590 } | |
| 591 } | |
| 592 } | |
| 593 | |
| 594 uint8_t GFX_is_colorschemeDiveStandard(void) | |
| 595 { | |
| 596 return (ColorLUT[CLUT_Font027] == 0x00FFFFFF); | |
| 597 } | |
| 598 | |
| 599 | |
| 600 void change_CLUT_entry(uint8_t entryToChange, uint8_t entryUsedForChange) | |
| 601 { | |
| 602 /* bug fix | |
| 603 static uint8_t counter = 0; | |
| 604 | |
| 605 if(entryToChange == 0x1C) | |
| 606 counter++; | |
| 607 */ | |
| 608 ColorLUT[entryToChange] = ColorLUT[entryUsedForChange]; | |
| 609 HAL_LTDC_ConfigCLUT(&LtdcHandle, ColorLUT, CLUT_END, 1); | |
| 610 if(logoStatus == LOGOOFF) | |
| 611 HAL_LTDC_ConfigCLUT(&LtdcHandle, ColorLUT, CLUT_END, 0); | |
| 612 } | |
| 613 | |
| 614 | |
| 615 void GFX_use_colorscheme(uint8_t colorscheme) | |
| 616 { | |
| 617 uint8_t ColorSchemeStart; | |
| 618 | |
| 619 if(colorscheme > 3) | |
| 620 colorscheme = 0; | |
| 621 | |
| 622 ColorSchemeStart = CLUT_Colorscheme0 + (8 * colorscheme); | |
| 623 for(int i=1; i<8; i++) | |
| 624 { | |
| 625 ColorLUT[CLUT_Font027 + i] = ColorLUT[ColorSchemeStart + i]; | |
| 626 } | |
| 627 change_CLUT_entry(CLUT_Font027, ColorSchemeStart); | |
| 628 } | |
| 629 | |
| 630 | |
| 631 void GFX_VGA_transform(uint32_t pSource, uint32_t pDestination) | |
| 632 { | |
| 633 int h, v; | |
| 634 uint32_t offsetSource, offsetSourceStartOfLine; | |
| 635 | |
| 636 offsetSourceStartOfLine = 480 + 480 - 2; | |
| 637 for(v=0;v<480;v++) | |
| 638 { | |
| 639 offsetSource = offsetSourceStartOfLine; | |
| 640 for(h=0;h<640;h++) | |
| 641 { | |
| 642 *(__IO uint8_t*)pDestination = *(uint8_t*)(pSource + offsetSource); | |
| 643 pDestination++; | |
| 644 offsetSource += 1; | |
| 645 *(__IO uint8_t*)pDestination = *(uint8_t*)(pSource + offsetSource); | |
| 646 pDestination++; | |
| 647 offsetSource += 480 + 479; | |
| 648 } | |
| 649 offsetSourceStartOfLine -= 2; | |
| 650 } | |
| 651 } | |
| 652 | |
|
297
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
653 |
|
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
654 static void GFX_clear_frame_immediately(uint32_t pDestination) |
| 38 | 655 { |
| 656 uint32_t i; | |
| 121 | 657 uint32_t* pfill = (uint32_t*) pDestination; |
| 658 | |
| 38 | 659 |
| 660 for(i = 200*480; i > 0; i--) | |
| 661 { | |
| 121 | 662 *pfill++ = 0; |
| 663 *pfill++ = 0; | |
| 38 | 664 } |
| 665 } | |
| 666 | |
| 667 | |
| 668 void GFX_clear_window_immediately(GFX_DrawCfgWindow* hgfx) | |
| 669 { | |
| 670 uint32_t pDestination, i, j; | |
| 671 uint16_t left, width, bottom, height, nextlineStep; | |
| 672 | |
| 673 pDestination = (uint32_t)hgfx->Image->FBStartAdress; | |
| 674 | |
| 675 left = hgfx->WindowX0; | |
| 676 width = 1 + hgfx->WindowX1 - left; | |
| 677 bottom = hgfx->WindowY0; | |
| 678 height = 1 + hgfx->WindowY1 - bottom; | |
| 679 nextlineStep = hgfx->Image->ImageHeight - height; | |
| 680 nextlineStep *= 2; | |
| 681 | |
| 682 pDestination += 2 * bottom; | |
| 683 pDestination += 2 * hgfx->Image->ImageHeight * left; | |
| 684 | |
| 685 for(j = width; j > 0; j--) | |
| 686 { | |
| 687 for(i = height; i > 0; i--) | |
| 688 { | |
| 689 *(__IO uint16_t*)pDestination = 0; | |
| 690 pDestination += 2; | |
| 691 } | |
| 692 pDestination += nextlineStep; | |
| 693 } | |
| 694 } | |
| 695 | |
| 696 | |
|
297
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
697 static void GFX_clear_frame_dma2d(uint8_t frameId) |
| 38 | 698 { |
| 699 if(frameId >= MAXFRAMES) | |
| 700 return; | |
| 701 | |
| 702 DMA2D_at_work = frameId; | |
| 703 | |
| 704 if (HAL_DMA2D_Start_IT(&Dma2dHandle, 0x0000000000, frame[frameId].StartAddress, 480, 800) != HAL_OK) | |
| 705 GFX_Error_Handler(); | |
| 706 } | |
| 707 | |
| 708 | |
| 709 void GFX_fill_buffer(uint32_t pDestination, uint8_t alpha, uint8_t color) | |
| 710 { | |
| 711 | |
| 121 | 712 union al88_u |
| 38 | 713 { |
| 714 uint8_t al8[2]; | |
| 715 uint16_t al88; | |
| 716 }; | |
| 717 union al88_u colorcombination; | |
| 718 uint32_t i; | |
| 121 | 719 uint32_t* pfill = (uint32_t*) pDestination; |
| 720 uint32_t fillpattern; | |
| 38 | 721 |
| 722 colorcombination.al8[0] = color; | |
| 723 colorcombination.al8[1] = alpha; | |
| 724 | |
| 121 | 725 fillpattern = (colorcombination.al88 << 16) | colorcombination.al88; |
| 726 for(i = 800*480/2; i > 0; i--) | |
| 38 | 727 { |
| 121 | 728 *pfill++ = fillpattern; |
| 38 | 729 } |
| 730 } | |
| 731 | |
| 732 | |
|
297
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
733 static void gfx_flip(point_t *p1, point_t *p2) |
| 38 | 734 { |
| 735 point_t temp; | |
| 736 | |
| 737 temp = *p1; | |
| 738 *p1 = *p2; | |
| 739 *p2 = temp; | |
| 740 } | |
| 741 | |
| 742 | |
| 743 static inline void gfx_brush(uint8_t thickness, GFX_DrawCfgScreen *hgfx, uint16_t x0, uint16_t y0, uint8_t color) | |
| 744 { | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
745 uint16_t* pDestination; |
| 38 | 746 uint8_t offset = thickness/2; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
747 int16_t stepdir; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
748 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
749 SSettings* pSettings; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
750 pSettings = settingsGetPointer(); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
751 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
752 if(pSettings->FlipDisplay) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
753 { |
| 114 | 754 pDestination = (uint16_t*)hgfx->FBStartAdress; |
| 755 pDestination += (hgfx->ImageHeight * (hgfx->ImageWidth - x0 + offset)) + (480 - y0+offset); | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
756 stepdir = -1; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
757 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
758 else |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
759 { |
| 114 | 760 pDestination = (uint16_t*)hgfx->FBStartAdress; |
| 761 pDestination += (x0 - offset)*hgfx->ImageHeight + (y0-offset); | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
762 stepdir = 1; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
763 } |
| 38 | 764 for(int x=thickness;x>0;x--) |
| 765 { | |
| 766 for(int y=thickness;y>0;y--) | |
| 767 { | |
| 768 *(__IO uint16_t*)pDestination = 0xFF00 + color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
769 pDestination += stepdir; |
| 38 | 770 } |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
771 pDestination += stepdir * (hgfx->ImageHeight - thickness); |
| 38 | 772 } |
| 773 } | |
| 774 | |
| 775 | |
| 776 void GFX_draw_thick_line(uint8_t thickness, GFX_DrawCfgScreen *hgfx, point_t start, point_t stop, uint8_t color) | |
| 777 { | |
| 778 if(thickness < 2) | |
| 779 GFX_draw_line(hgfx, start, stop, color); | |
| 780 | |
| 781 int x0 = start.x; | |
| 782 int y0 = start.y; | |
| 783 int x1 = stop.x; | |
| 784 int y1 = stop.y; | |
| 785 int dx = abs(x1-x0), sx = x0<x1 ? 1 : -1; | |
| 786 int dy = abs(y1-y0), sy = y0<y1 ? 1 : -1; | |
| 787 int err = (dx>dy ? dx : -dy)/2, e2; | |
| 788 | |
| 789 | |
| 790 if(start.x == stop.x) | |
| 791 { | |
| 792 if(start.y > stop.y) gfx_flip(&start,&stop); | |
| 793 for (int j = stop.y - start.y; j > 0; j--) | |
| 794 { | |
| 795 gfx_brush(thickness,hgfx,start.x,start.y++,color); | |
| 796 } | |
| 797 } | |
| 798 else | |
| 799 if(start.y == stop.y) | |
| 800 { | |
| 801 if(start.x > stop.x) gfx_flip(&start,&stop); | |
| 802 | |
| 803 for (int j = stop.x - start.x; j > 0; j--) | |
| 804 { | |
| 805 gfx_brush(thickness,hgfx,start.x++,start.y,color); | |
| 806 } | |
| 807 } | |
| 808 else // diagonal | |
| 809 { | |
| 810 for(;;) | |
| 811 { | |
| 812 gfx_brush(thickness,hgfx,x0,y0,color); | |
| 813 if (x0==x1 && y0==y1) break; | |
| 814 e2 = err; | |
| 815 if (e2 >-dx) { err -= dy; x0 += sx; } | |
| 816 if (e2 < dy) { err += dx; y0 += sy; } | |
| 817 } | |
| 818 } | |
| 819 } | |
| 820 | |
| 821 | |
| 822 void GFX_draw_line(GFX_DrawCfgScreen *hgfx, point_t start, point_t stop, uint8_t color) | |
| 823 { | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
824 uint16_t* pDestination; |
| 38 | 825 uint32_t j; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
826 int16_t stepdir; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
827 SSettings* pSettings; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
828 pSettings = settingsGetPointer(); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
829 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
830 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
831 /* horizontal line */ |
| 38 | 832 if(start.x == stop.x) |
| 833 { | |
| 834 if(start.y > stop.y) gfx_flip(&start,&stop); | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
835 |
| 114 | 836 pDestination = (uint16_t*)hgfx->FBStartAdress; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
837 if(pSettings->FlipDisplay) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
838 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
839 pDestination += (800 - start.x) * hgfx->ImageHeight; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
840 pDestination += (480 - start.y); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
841 stepdir = -1; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
842 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
843 else |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
844 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
845 pDestination += start.x * hgfx->ImageHeight; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
846 pDestination += start.y; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
847 stepdir = 1; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
848 } |
| 38 | 849 for (j = stop.y - start.y; j > 0; j--) |
| 850 { | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
851 *(__IO uint16_t*)pDestination = 0xFF00 + color; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
852 pDestination += stepdir; |
| 38 | 853 } |
| 854 } | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
855 else /* vertical line ? */ |
| 38 | 856 if(start.y == stop.y) |
| 857 { | |
| 858 if(start.x > stop.x) gfx_flip(&start,&stop); | |
| 114 | 859 pDestination = (uint16_t*)hgfx->FBStartAdress; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
860 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
861 if(pSettings->FlipDisplay) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
862 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
863 pDestination += (800 - start.x) * hgfx->ImageHeight; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
864 pDestination += (480 - start.y); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
865 stepdir = -1; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
866 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
867 else |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
868 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
869 pDestination += start.x * hgfx->ImageHeight; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
870 pDestination += start.y; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
871 stepdir = 1; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
872 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
873 |
| 38 | 874 for (j = stop.x - start.x; j > 0; j--) |
| 875 { | |
| 876 *(__IO uint16_t*)pDestination = 0xFF00 + color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
877 pDestination += stepdir * hgfx->ImageHeight; |
| 38 | 878 } |
| 879 } | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
880 else /* diagonal */ |
| 38 | 881 { |
| 882 int x0 = start.x; | |
| 883 int y0 = start.y; | |
| 884 int x1 = stop.x; | |
| 885 int y1 = stop.y; | |
| 886 int dx = abs(x1-x0), sx = x0<x1 ? 1 : -1; | |
| 887 int dy = abs(y1-y0), sy = y0<y1 ? 1 : -1; | |
| 888 int err = (dx>dy ? dx : -dy)/2, e2; | |
| 889 | |
| 890 for(;;) | |
| 891 { | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
892 pDestination = (uint16_t*)hgfx->FBStartAdress; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
893 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
894 if(pSettings->FlipDisplay) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
895 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
896 pDestination += (((800 - x0) * hgfx->ImageHeight) + (480 - y0)); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
897 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
898 else |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
899 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
900 pDestination += ((x0 * hgfx->ImageHeight) + y0); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
901 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
902 |
| 38 | 903 *(__IO uint16_t*)pDestination = 0xFF00 + color; |
| 904 if (x0==x1 && y0==y1) break; | |
| 905 e2 = err; | |
| 906 if (e2 >-dx) { err -= dy; x0 += sx; } | |
| 907 if (e2 < dy) { err += dx; y0 += sy; } | |
| 908 } | |
| 909 } | |
| 910 } | |
| 911 | |
| 912 | |
| 913 void GFX_draw_image_monochrome(GFX_DrawCfgScreen *hgfx, SWindowGimpStyle window, const tImage *image, uint8_t color) | |
| 914 { | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
915 uint16_t* pDestination; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
916 uint32_t j; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
917 point_t start, stop; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
918 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
919 SSettings* pSettings; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
920 pSettings = settingsGetPointer(); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
921 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
922 start.x = window.left; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
923 start.y = (hgfx->ImageHeight - image->height - window.top); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
924 stop.y = start.y + image->height; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
925 stop.x = start.x + image->width; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
926 j = 0; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
927 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
928 if(pSettings->FlipDisplay) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
929 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
930 for(int xx = start.x; xx < stop.x; xx++) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
931 { |
| 114 | 932 pDestination = (uint16_t*)hgfx->FBStartAdress; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
933 pDestination += (hgfx->ImageHeight - start.y) + (stop.x * hgfx->ImageHeight) ; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
934 pDestination -= (xx - start.x) * hgfx->ImageHeight; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
935 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
936 for(int yy = start.y; yy < stop.y; yy++) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
937 { |
| 114 | 938 *(__IO uint16_t*)pDestination-- = (image->data[j++] << 8) + color; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
939 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
940 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
941 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
942 else |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
943 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
944 for(int xx = start.x; xx < stop.x; xx++) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
945 { |
| 114 | 946 pDestination = (uint16_t*)hgfx->FBStartAdress; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
947 pDestination += xx * hgfx->ImageHeight; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
948 pDestination += start.y; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
949 for(int yy = start.y; yy < stop.y; yy++) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
950 { |
| 114 | 951 *(__IO uint16_t*)pDestination++ = (image->data[j++] << 8) + color; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
952 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
953 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
954 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
955 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
956 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
957 |
|
297
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
958 static void GFX_draw_image_color(GFX_DrawCfgScreen *hgfx, SWindowGimpStyle window, const tImage *image) |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
959 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
960 uint16_t* pDestination; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
961 |
| 38 | 962 uint32_t j; |
| 963 point_t start, stop; | |
| 964 | |
| 965 start.x = window.left; | |
| 966 start.y = (hgfx->ImageHeight - image->height - window.top); | |
| 967 stop.y = start.y + image->height; | |
| 968 stop.x = start.x + image->width; | |
| 969 j = 0; | |
| 970 | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
971 SSettings* pSettings; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
972 pSettings = settingsGetPointer(); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
973 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
974 if(pSettings->FlipDisplay) |
| 38 | 975 { |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
976 for(int xx = start.x; xx < stop.x; xx++) |
| 38 | 977 { |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
978 pDestination = (uint16_t*)hgfx->FBStartAdress; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
979 pDestination += (hgfx->ImageHeight - start.y) + (stop.x * hgfx->ImageHeight); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
980 pDestination -= (xx - start.x) * hgfx->ImageHeight; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
981 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
982 for(int yy = start.y; yy < stop.y; yy++) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
983 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
984 *(__IO uint16_t*)pDestination-- = 0xFF << 8 | image->data[j++]; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
985 } |
| 38 | 986 } |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
987 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
988 else |
| 38 | 989 { |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
990 for(int xx = start.x; xx < stop.x; xx++) |
| 38 | 991 { |
| 114 | 992 pDestination = (uint16_t*)hgfx->FBStartAdress; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
993 pDestination += xx * hgfx->ImageHeight; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
994 pDestination += start.y; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
995 for(int yy = start.y; yy < stop.y; yy++) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
996 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
997 *(__IO uint16_t*)pDestination++ = 0xFF << 8 | image->data[j++]; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
998 } |
| 38 | 999 } |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1000 } |
| 38 | 1001 } |
| 1002 | |
| 1003 | |
| 1004 /* this is NOT fast nor optimized */ | |
|
297
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
1005 static void GFX_draw_pixel(GFX_DrawCfgScreen *hgfx, int16_t x, int16_t y, uint8_t color) |
| 38 | 1006 { |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1007 uint16_t* pDestination; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1008 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1009 SSettings* pSettings; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1010 pSettings = settingsGetPointer(); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1011 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1012 pDestination = (uint16_t*)hgfx->FBStartAdress; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1013 if(pSettings->FlipDisplay) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1014 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1015 pDestination += (800 - x) * hgfx->ImageHeight; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1016 pDestination += (480 - y); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1017 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1018 else |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1019 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1020 pDestination += x * hgfx->ImageHeight; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1021 pDestination += y; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1022 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1023 *(__IO uint16_t*)pDestination = 0xFF << 8 | color; |
| 38 | 1024 } |
| 1025 | |
| 1026 /* this is NOT fast nor optimized */ | |
| 1027 void GFX_draw_circle(GFX_DrawCfgScreen *hgfx, point_t center, uint8_t radius, int8_t color) | |
| 1028 { | |
| 1029 int x, y; | |
| 1030 int l; | |
| 1031 int r2, y2; | |
| 1032 int y2_new; | |
| 1033 int ty; | |
| 1034 | |
| 1035 /* cos pi/4 = 185363 / 2^18 (approx) */ | |
| 1036 l = (radius * 185363) >> 18; | |
| 1037 | |
| 1038 /* hw */ | |
| 1039 l += 1; | |
| 1040 | |
| 1041 /* At x=0, y=radius */ | |
| 1042 y = radius; | |
| 1043 | |
| 1044 r2 = y2 = y * y; | |
| 1045 ty = (2 * y) - 1; | |
| 1046 y2_new = r2 + 3; | |
| 1047 | |
| 1048 for (x = 0; x <= l; x++) { | |
| 1049 y2_new -= (2 * x) - 3; | |
| 1050 | |
| 1051 if ((y2 - y2_new) >= ty) { | |
| 1052 y2 -= ty; | |
| 1053 y -= 1; | |
| 1054 ty -= 2; | |
| 1055 } | |
| 1056 | |
| 1057 GFX_draw_pixel (hgfx, x + center.x, y + center.y, color); | |
| 1058 GFX_draw_pixel (hgfx, x + center.x, -y + center.y, color); | |
| 1059 GFX_draw_pixel (hgfx, -x + center.x, y + center.y, color); | |
| 1060 GFX_draw_pixel (hgfx, -x + center.x, -y + center.y, color); | |
| 1061 | |
| 1062 GFX_draw_pixel (hgfx, y + center.x, x + center.y, color); | |
| 1063 GFX_draw_pixel (hgfx, y + center.x, -x + center.y, color); | |
| 1064 GFX_draw_pixel (hgfx, -y + center.x, x + center.y, color); | |
| 1065 GFX_draw_pixel (hgfx, -y + center.x, -x + center.y, color); | |
| 1066 } | |
| 1067 } | |
| 1068 | |
| 1069 | |
| 1070 void GFX_draw_colorline(GFX_DrawCfgScreen *hgfx, point_t start, point_t stop, uint8_t color) | |
| 1071 { | |
| 1072 uint32_t pDestination; | |
| 1073 uint32_t j; | |
| 1074 uint32_t temp; | |
| 1075 | |
| 1076 if(start.x == stop.x) | |
| 1077 { | |
| 1078 if(stop.y < start.y) | |
| 1079 { | |
| 1080 temp = stop.y; | |
| 1081 stop.y = start.y; | |
| 1082 start.y = temp; | |
| 1083 } | |
| 1084 pDestination = (uint32_t)hgfx->FBStartAdress; | |
| 1085 pDestination += start.x * hgfx->ImageHeight * 2; | |
| 1086 pDestination += start.y * 2; | |
| 1087 for (j = stop.y - start.y; j > 0; j--) | |
| 1088 { | |
| 1089 *(__IO uint8_t*)pDestination = color; | |
| 1090 pDestination += 1; | |
| 1091 *(__IO uint8_t*)pDestination = 0xFF; | |
| 1092 pDestination += 1; | |
| 1093 } | |
| 1094 } | |
| 1095 else | |
| 1096 if(start.y == stop.y) | |
| 1097 { | |
| 1098 if(stop.x < start.x) | |
| 1099 { | |
| 1100 temp = stop.x; | |
| 1101 stop.x = start.x; | |
| 1102 start.x = temp; | |
| 1103 } | |
| 1104 pDestination = (uint32_t)hgfx->FBStartAdress; | |
| 1105 pDestination += start.x * hgfx->ImageHeight * 2; | |
| 1106 pDestination += start.y * 2; | |
| 1107 for (j = stop.x - start.x; j > 0; j--) | |
| 1108 { | |
| 1109 *(__IO uint8_t*)pDestination = color; | |
| 1110 pDestination += 1; | |
| 1111 *(__IO uint8_t*)pDestination = 0xFF; | |
| 1112 pDestination -= 1; | |
| 1113 pDestination += hgfx->ImageHeight * 2; | |
| 1114 } | |
| 1115 } | |
| 1116 else // diagonal Bresenham's_line_algorithm | |
| 1117 { | |
| 1118 int x0 = start.x; | |
| 1119 int y0 = start.y; | |
| 1120 int x1 = stop.x; | |
| 1121 int y1 = stop.y; | |
| 1122 int dx = abs(x1-x0), sx = x0<x1 ? 1 : -1; | |
| 1123 int dy = abs(y1-y0), sy = y0<y1 ? 1 : -1; | |
| 1124 int err = (dx>dy ? dx : -dy)/2, e2; | |
| 1125 | |
| 1126 for(;;) | |
| 1127 { | |
| 1128 pDestination = (uint32_t)hgfx->FBStartAdress; | |
| 1129 pDestination += ((x0 * hgfx->ImageHeight) + y0) * 2; | |
| 1130 *(__IO uint8_t*)pDestination = color; | |
| 1131 pDestination += 1; | |
| 1132 *(__IO uint8_t*)pDestination = 0xFF; | |
| 1133 if (x0==x1 && y0==y1) break; | |
| 1134 e2 = err; | |
| 1135 if (e2 >-dx) { err -= dy; x0 += sx; } | |
| 1136 if (e2 < dy) { err += dx; y0 += sy; } | |
| 1137 } | |
| 1138 } | |
| 1139 } | |
| 1140 | |
| 1141 | |
| 1142 void GFX_draw_Grid(GFX_DrawCfgScreen *hgfx, SWindowGimpStyle window, int vlines, float vdeltaline, int hlines, float hdeltalines, uint8_t color) | |
| 1143 { | |
| 1144 point_t p1; | |
| 1145 point_t p2; | |
| 1146 int winthight = window.bottom - window.top; | |
| 1147 int winwidth = window.right - window.left; | |
| 1148 float deltaline = 0; | |
| 1149 | |
| 1150 if(vlines > 0) | |
| 1151 { | |
| 1152 deltaline = ((float)winwidth) /vlines; | |
| 1153 | |
| 1154 p1.y = 479 - window.top; | |
| 1155 p2.y = 479 - window.bottom; | |
| 1156 for(int i = 0; i <= vlines; i++) | |
| 1157 { | |
| 1158 p1.x = window.left + (int)(i * deltaline + 0.5f); | |
| 1159 p2.x = p1.x ; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1160 //GFX_draw_colorline(hgfx, p1,p2, color ); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1161 GFX_draw_line(hgfx, p1,p2, color ); |
| 38 | 1162 } |
| 1163 } | |
| 1164 if(vdeltaline > 0) | |
| 1165 { | |
| 1166 p1.y = 479 - window.top; | |
| 1167 p2.y = 479 - window.bottom; | |
| 1168 for(int i = 0; i < winwidth/vdeltaline; i++) | |
| 1169 { | |
| 1170 p1.x = window.left + (int)(i * vdeltaline + 0.5f); | |
| 1171 p2.x = p1.x ; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1172 // GFX_draw_colorline(hgfx, p1,p2, color ); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1173 GFX_draw_line(hgfx, p1,p2, color ); |
| 38 | 1174 } |
| 1175 } | |
| 1176 if(hlines > 0) | |
| 1177 { | |
| 1178 deltaline = ((float)winthight)/hlines; | |
| 1179 p1.x = window.left; | |
| 1180 p2.x = window.right; | |
| 1181 for(int i = 0; i <= hlines; i++) | |
| 1182 { | |
| 1183 p1.y = 479 - window.top - (int)(i * deltaline + 0.5f); | |
| 1184 p2.y = p1.y; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1185 // GFX_draw_colorline(hgfx, p1,p2, color ); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1186 GFX_draw_line(hgfx, p1,p2, color ); |
| 38 | 1187 } |
| 1188 } | |
| 1189 } | |
| 1190 | |
| 1191 // =============================================================================== | |
| 1192 // GFX_graph_print | |
| 1193 /// @brief Print all those nice curves, especially in logbook und miniLiveLogGraph | |
| 1194 /// @version 0.0.2 hw 160519 | |
| 1195 /// | |
| 1196 /// 151022 hw -bug fix | |
| 1197 /// - die aktuelle Version macht keine Linien mehr �ber die gesamte Bildschirmh�he. | |
| 1198 /// - daf�r sind L�cher in der Kurve (z.B. Temperaturgraph Tauchgang Matthias 17.10.15 15:19) | |
| 1199 /// | |
| 1200 /// more details about range can be found in show_logbook_logbook_show_log_page2() - temperature graph | |
| 1201 /// | |
| 1202 /// @param window: top and bottom is only the range used by the data of the graph, not the entire screen / scale | |
| 1203 /// @param drawVeilUntil: ist auff�llen des Bereichs unter der Kurve mit etwas hellerer Farbe | |
| 1204 /// @param Xdivide: wird bisher nichr benutzt. | |
| 1205 // =============================================================================== | |
| 1206 | |
| 1207 | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1208 void GFX_graph_print(GFX_DrawCfgScreen *hgfx, const SWindowGimpStyle *window, const int16_t drawVeilUntil, uint8_t Xdivide, uint16_t dataMin, uint16_t dataMax, uint16_t *data, uint16_t datalength, uint8_t color, uint8_t *colour_data) |
| 38 | 1209 { |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1210 uint16_t* pDestination_tmp; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1211 uint16_t* pDestination_start; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1212 uint16_t* pDestination_end; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1213 uint16_t* pDestination_zero_veil; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1214 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1215 SSettings* pSettings; |
| 38 | 1216 |
| 1217 uint32_t max = 0; | |
| 1218 int windowheight = -1; | |
| 1219 int windowwidth = -1; | |
| 1220 int i = -1; | |
| 1221 int w1 = -1; | |
| 1222 int w2 = -1; | |
| 1223 | |
| 1224 uint32_t h_ulong = 0; | |
| 1225 uint32_t h_ulong_old = 0; | |
| 1226 _Bool invert = 0; | |
| 1227 | |
| 1228 uint16_t dataDelta = 0; | |
| 1229 uint16_t dataDeltaHalve = 0; | |
| 1230 uint16_t dataTemp = 0; | |
| 1231 | |
| 1232 uint8_t colorDataTemp; | |
| 1233 uint8_t colormask = 0; | |
| 1234 | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1235 pSettings = settingsGetPointer(); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1236 pDestination_zero_veil = 0; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1237 |
| 38 | 1238 if(dataMin > dataMax) |
| 1239 { | |
| 1240 uint16_t dataFlip; | |
| 1241 dataFlip = dataMin; | |
| 1242 dataMin = dataMax; | |
| 1243 dataMax = dataFlip; | |
| 1244 invert = 1; | |
| 1245 } | |
| 1246 else | |
| 1247 invert = 0; | |
| 1248 | |
| 1249 colormask = color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1250 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1251 pSettings = settingsGetPointer(); |
| 38 | 1252 |
| 1253 if(window->bottom > 479) | |
| 1254 return; | |
| 1255 if(window->top > 479) | |
| 1256 return; | |
| 1257 if(window->right > 799) | |
| 1258 return; | |
| 1259 if(window->left > 799) | |
| 1260 return; | |
| 1261 if(window->bottom < 0) | |
| 1262 return; | |
| 1263 if(window->top < 0) | |
| 1264 return; | |
| 1265 if(window->right < 0) | |
| 1266 return; | |
| 1267 if(window->left < 0) | |
| 1268 return; | |
| 1269 if(window->bottom <= window->top) | |
| 1270 return; | |
| 1271 if(window->right <= window->left) | |
| 1272 return; | |
| 1273 | |
| 1274 windowheight = window->bottom - window->top ; | |
| 1275 windowwidth = window->right - window->left; | |
| 1276 w1 = 0; | |
| 1277 w2 = 0; | |
| 1278 if(dataMax == dataMin) | |
| 1279 dataMax++; | |
| 1280 dataDelta = (unsigned long)(dataMax - dataMin); | |
| 1281 dataDeltaHalve = dataDelta / 2; | |
|
296
87f83879cecb
Possible bugfix: do not use bitwise and (&)
Jan Mulder <jlmulder@xs4all.nl>
parents:
121
diff
changeset
|
1282 while((w1 <= windowwidth) && (w2 < datalength)) |
| 38 | 1283 { |
| 1284 int tmp = (10 * w1 * (long)datalength)/windowwidth; | |
| 1285 w2 = tmp/10; | |
| 1286 int rest = tmp - w2*10; | |
| 1287 if(rest >= 5) | |
| 1288 w2++; | |
| 1289 | |
| 1290 if((datalength - 1) < w2) | |
| 1291 w2 = datalength-1; | |
| 1292 | |
| 1293 if(colour_data != NULL) | |
| 1294 { | |
| 1295 colorDataTemp = colour_data[w2]; | |
| 1296 colormask = color + colorDataTemp; | |
| 1297 } | |
| 1298 | |
| 1299 dataTemp = data[w2]; | |
| 1300 if(Xdivide > 1) | |
| 1301 { | |
| 1302 w2++; | |
| 1303 for(i=1;i<Xdivide;i++) | |
| 1304 { | |
| 1305 if(data[w2]>dataTemp) | |
| 1306 dataTemp = data[w2]; | |
| 1307 w2++; | |
| 1308 } | |
| 1309 } | |
| 1310 | |
| 1311 if(dataTemp > dataMin) | |
| 1312 dataTemp -= dataMin; | |
| 1313 else | |
| 1314 dataTemp = 0; | |
| 1315 | |
| 1316 if(invert) | |
| 1317 { | |
| 1318 if(dataTemp < dataDelta) | |
| 1319 dataTemp = dataDelta - dataTemp; | |
| 1320 else | |
| 1321 dataTemp = 0; | |
| 1322 } | |
| 1323 | |
| 1324 h_ulong = (unsigned long)dataTemp; | |
| 1325 h_ulong *= windowheight; | |
| 1326 h_ulong += dataDeltaHalve; | |
| 1327 h_ulong /= dataDelta; | |
| 1328 | |
| 1329 if(h_ulong > (window->bottom - window->top)) | |
| 1330 h_ulong = (window->bottom - window->top); | |
| 1331 | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1332 if(!pSettings->FlipDisplay) |
| 38 | 1333 { |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1334 if(drawVeilUntil > 0) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1335 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1336 pDestination_zero_veil = (uint16_t*)hgfx->FBStartAdress; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1337 pDestination_zero_veil += ((479 - (drawVeilUntil - 2) ) + ((w1 + window->left) * hgfx->ImageHeight) ); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1338 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1339 else if(drawVeilUntil < 0 ) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1340 { |
| 114 | 1341 pDestination_zero_veil = (uint16_t*)hgfx->FBStartAdress; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1342 pDestination_zero_veil += ((479 + (drawVeilUntil)) + ((w1 + window->left) * hgfx->ImageHeight) ); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1343 } |
| 38 | 1344 } |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1345 else |
| 38 | 1346 { |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1347 if(drawVeilUntil > 0) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1348 { |
| 114 | 1349 pDestination_zero_veil = (uint16_t*)hgfx->FBStartAdress; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1350 pDestination_zero_veil += (((drawVeilUntil) ) + ( (window->right - w1) * hgfx->ImageHeight) ); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1351 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1352 else if(drawVeilUntil < 0 ) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1353 { |
| 114 | 1354 pDestination_zero_veil = (uint16_t*)hgfx->FBStartAdress; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1355 pDestination_zero_veil += 479 - drawVeilUntil + ( (window->right - w1 -1) * hgfx->ImageHeight); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1356 } |
| 38 | 1357 } |
| 1358 if(h_ulong + window->top > max) | |
| 1359 { | |
| 1360 max = h_ulong + window->top; | |
| 1361 } | |
| 1362 | |
| 1363 // hw 160519 wof�r ist das? Damit funktioniert Temperatur 25,5�C nicht! | |
| 1364 // if((dataMax == 255) || (data[w2] != 255)) | |
| 1365 // { | |
| 1366 //output_content[pointer] = colormask; | |
| 1367 //output_mask[pointer] = true; | |
| 1368 if(w1 > 0) | |
| 1369 { | |
| 114 | 1370 pDestination_start = (uint16_t*)hgfx->FBStartAdress; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1371 if(!pSettings->FlipDisplay) |
| 38 | 1372 { |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1373 pDestination_start += (((479 - (window->top)) + ((w1 + window->left) * hgfx->ImageHeight))); |
| 38 | 1374 } |
| 1375 else | |
| 1376 { | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1377 pDestination_start += (((window->top) + ((window->right - w1) * hgfx->ImageHeight))); |
| 38 | 1378 } |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1379 pDestination_end = pDestination_start; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1380 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1381 if(!pSettings->FlipDisplay) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1382 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1383 if(h_ulong >= h_ulong_old) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1384 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1385 pDestination_start -= h_ulong_old; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1386 pDestination_end -= h_ulong; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1387 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1388 else |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1389 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1390 pDestination_start -= h_ulong; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1391 pDestination_end -= h_ulong_old; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1392 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1393 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1394 else |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1395 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1396 if(h_ulong < h_ulong_old) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1397 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1398 pDestination_start += h_ulong_old; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1399 pDestination_end += h_ulong; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1400 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1401 else |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1402 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1403 pDestination_start += h_ulong; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1404 pDestination_end += h_ulong_old; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1405 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1406 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1407 |
| 38 | 1408 |
| 1409 // deco stops | |
| 1410 if(drawVeilUntil < 0) | |
| 1411 { | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1412 if(!pSettings->FlipDisplay) |
| 38 | 1413 { |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1414 pDestination_tmp = pDestination_end; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1415 while(pDestination_tmp <= pDestination_zero_veil) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1416 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1417 *(__IO uint16_t*)pDestination_tmp = (0x80 << 8) | colormask; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1418 pDestination_tmp++; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1419 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1420 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1421 else |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1422 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1423 pDestination_tmp = pDestination_zero_veil; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1424 while(pDestination_tmp <= pDestination_end) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1425 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1426 *(__IO uint16_t*)pDestination_tmp = (0x80 << 8) | colormask; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1427 pDestination_tmp++; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1428 } |
| 38 | 1429 } |
| 1430 } | |
| 1431 else | |
| 1432 { | |
| 1433 // regular graph with veil underneath if requested | |
| 1434 // von oben nach unten | |
| 1435 // von grossen pDestination Werten zu kleinen pDestination Werten | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1436 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1437 pDestination_tmp = pDestination_start; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1438 while(pDestination_tmp >= pDestination_end) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1439 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1440 *(__IO uint16_t*)pDestination_tmp = (0xFF << 8) | colormask ; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1441 pDestination_tmp--; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1442 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1443 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1444 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1445 if(!pSettings->FlipDisplay) |
| 38 | 1446 { |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1447 while((drawVeilUntil > 0) && (pDestination_tmp >= pDestination_zero_veil)) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1448 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1449 *(__IO uint16_t*)pDestination_tmp = (0x20 << 8) | colormask ; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1450 pDestination_tmp--; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1451 } |
| 38 | 1452 } |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1453 else |
| 38 | 1454 { |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1455 pDestination_tmp = pDestination_start; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1456 while((drawVeilUntil > 0) && (pDestination_tmp <= pDestination_zero_veil)) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1457 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1458 *(__IO uint16_t*)pDestination_tmp = (0x20 << 8) | colormask ; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1459 pDestination_tmp++; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1460 } |
| 38 | 1461 } |
| 1462 } | |
| 1463 } | |
| 1464 h_ulong_old = h_ulong; | |
| 1465 // } | |
| 1466 w1++; | |
| 1467 w2++; | |
| 1468 } | |
| 1469 } | |
| 1470 | |
| 1471 | |
| 1472 void GFX_draw_header(GFX_DrawCfgScreen *hgfx, uint8_t colorId) | |
| 1473 { | |
| 1474 uint32_t pDestination; | |
| 1475 point_t start, stop, now; | |
| 1476 uint8_t alpha; | |
| 1477 | |
| 1478 /* display coordinate system */ | |
| 1479 start.y = 400; | |
| 1480 stop.y = 479; | |
| 1481 | |
| 1482 start.x = 0; | |
| 1483 stop.x = 799; | |
| 1484 | |
| 1485 now.y = start.y; | |
| 1486 now.x = start.x; | |
| 1487 | |
| 1488 while (now.x <= stop.x) | |
| 1489 { | |
| 1490 now.y = start.y; | |
| 1491 pDestination = (uint32_t)hgfx->FBStartAdress; | |
| 1492 pDestination += now.x * hgfx->ImageHeight * 2; | |
| 1493 pDestination += now.y * 2; | |
| 1494 now.x += 1; | |
| 1495 | |
| 1496 alpha = 27; | |
| 1497 while(alpha < 246) | |
| 1498 { | |
| 1499 alpha += 9; | |
| 1500 *(__IO uint8_t*)pDestination = colorId; | |
| 1501 pDestination += 1; | |
| 1502 *(__IO uint8_t*)pDestination = alpha; | |
| 1503 pDestination += 1; | |
| 1504 now.y += 1; | |
| 1505 } | |
| 1506 | |
| 1507 while(now.y <= stop.y) | |
| 1508 { | |
| 1509 *(__IO uint8_t*)pDestination = colorId; | |
| 1510 pDestination += 1; | |
| 1511 *(__IO uint8_t*)pDestination = 0xFF; | |
| 1512 pDestination += 1; | |
| 1513 now.y += 1; | |
| 1514 } | |
| 1515 } | |
| 1516 } | |
| 1517 | |
| 1518 void GFX_draw_box2(GFX_DrawCfgScreen *hgfx, point_t start, point_t stop, uint8_t color, uint8_t roundCorners) | |
| 1519 { | |
| 1520 point_t point2, point4; | |
| 1521 | |
| 1522 if(roundCorners) | |
| 1523 { | |
| 1524 point2.x = stop.x - start.x; | |
| 1525 point2.y = stop.y - start.y; | |
| 1526 GFX_draw_box(hgfx,start,point2,1,color); | |
| 1527 } | |
| 1528 else | |
| 1529 { | |
| 1530 point2.x = stop.x; | |
| 1531 point2.y = start.y; | |
| 1532 | |
| 1533 point4.x = start.x; | |
| 1534 point4.y = stop.y; | |
| 1535 | |
| 1536 GFX_draw_line(hgfx,start,point2,color); | |
| 1537 GFX_draw_line(hgfx,point2,stop,color); | |
| 1538 GFX_draw_line(hgfx,stop,point4,color); | |
| 1539 GFX_draw_line(hgfx,point4,start,color); | |
| 1540 } | |
| 1541 } | |
| 1542 | |
| 1543 void GFX_draw_box(GFX_DrawCfgScreen *hgfx, point_t LeftLow, point_t WidthHeight, uint8_t Style, uint8_t color) | |
| 1544 { | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1545 uint16_t* pDestination; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1546 uint16_t* pStart; |
| 38 | 1547 uint32_t j; |
| 1548 uint32_t lineWidth, lineHeight; | |
| 1549 int x, y; | |
| 1550 uint8_t intensity; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1551 int stepdir; |
| 38 | 1552 |
| 1553 typedef struct { | |
| 1554 int x; | |
| 1555 int y; | |
| 1556 uint8_t intensity; | |
| 1557 } corner_t; | |
| 1558 const corner_t corner[16] = { | |
| 1559 {3,3,255}, // nur einmal | |
| 1560 {9,0,242}, | |
| 1561 {8,0,194}, | |
| 1562 {7,0,115}, | |
| 1563 {6,0,36}, | |
| 1564 {9,1,33}, | |
| 1565 {8,1,84}, | |
| 1566 {7,1,161}, | |
| 1567 {6,1,255}, | |
| 1568 {5,1,242}, | |
| 1569 {4,1,36}, | |
| 1570 {6,2,33}, | |
| 1571 {5,2,84}, | |
| 1572 {4,2,255}, | |
| 1573 {3,2,84}, | |
| 1574 {4,3,110} | |
| 1575 }; | |
| 1576 | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1577 SSettings* pSettings; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1578 pSettings = settingsGetPointer(); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1579 |
| 38 | 1580 lineWidth = WidthHeight.x; |
| 1581 lineHeight = WidthHeight.y; | |
| 114 | 1582 pStart = (uint16_t*)hgfx->FBStartAdress; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1583 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1584 if(!pSettings->FlipDisplay) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1585 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1586 pStart += LeftLow.x * hgfx->ImageHeight; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1587 pStart += LeftLow.y; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1588 stepdir = 1; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1589 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1590 else |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1591 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1592 pStart += (800 - LeftLow.x - 1) * hgfx->ImageHeight; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1593 pStart += (480 - LeftLow.y); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1594 stepdir = -1; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1595 } |
| 38 | 1596 |
| 1597 // Untere Linie | |
| 1598 pDestination = pStart; | |
| 1599 if(Style) | |
| 1600 { | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1601 pDestination += stepdir * 10 * hgfx->ImageHeight; |
| 38 | 1602 lineWidth -= 18; |
| 1603 } | |
| 1604 for (j = lineWidth; j > 0; j--) | |
| 1605 { | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1606 |
| 38 | 1607 *(__IO uint16_t*)pDestination = 0xFF00 + color; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1608 pDestination += stepdir * hgfx->ImageHeight; |
| 38 | 1609 } |
| 1610 | |
| 1611 // Obere Linie | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1612 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1613 pDestination = pStart + stepdir * WidthHeight.y; |
| 38 | 1614 if(Style) |
| 1615 { | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1616 pDestination += stepdir * 10 * hgfx->ImageHeight; |
| 38 | 1617 } |
| 1618 | |
| 1619 for (j = lineWidth; j > 0; j--) | |
| 1620 { | |
| 1621 *(__IO uint16_t*)pDestination = 0xFF00 + color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1622 pDestination += stepdir * hgfx->ImageHeight; |
| 38 | 1623 } |
| 1624 | |
| 1625 // Linke Linie | |
| 1626 pDestination = pStart; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1627 |
| 38 | 1628 if(Style) |
| 1629 { | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1630 pDestination += stepdir * 10; |
| 38 | 1631 lineHeight -= 18; |
| 1632 } | |
| 1633 | |
| 1634 for (j = lineHeight; j > 0; j--) | |
| 1635 { | |
| 1636 *(__IO uint16_t*)pDestination = 0xFF00 + color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1637 pDestination += stepdir; |
| 38 | 1638 } |
| 1639 | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1640 |
| 38 | 1641 // Rechte Linie |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1642 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1643 pDestination = pStart + stepdir * WidthHeight.x * hgfx->ImageHeight; |
| 38 | 1644 if(Style) |
| 1645 { | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1646 pDestination += stepdir * 10; |
| 38 | 1647 } |
| 1648 | |
| 1649 for (j = lineHeight; j > 0; j--) | |
| 1650 { | |
| 1651 *(__IO uint16_t*)pDestination = 0xFF00 + color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1652 pDestination += stepdir; |
| 38 | 1653 } |
| 1654 | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1655 |
| 38 | 1656 // Ecken wenn notwendig == Style |
| 1657 if(Style) | |
| 1658 { | |
| 1659 // links unten | |
| 1660 pDestination = pStart; | |
| 1661 x = corner[0].x; | |
| 1662 y = corner[0].y; | |
| 1663 intensity = corner[0].intensity; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1664 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1665 *(__IO uint16_t*)(pDestination + stepdir * (y + (x * hgfx->ImageHeight))) = (intensity << 8) + color; |
| 38 | 1666 |
| 1667 for(j = 15; j > 0; j--) | |
| 1668 { | |
| 1669 x = corner[j].x; | |
| 1670 y = corner[j].y; | |
| 1671 intensity = corner[j].intensity; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1672 *(__IO uint16_t*)(pDestination + stepdir * (y + (x * hgfx->ImageHeight))) = (intensity << 8) + color; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1673 *(__IO uint16_t*)(pDestination + stepdir * (x + (y * hgfx->ImageHeight))) = (intensity << 8) + color; |
| 38 | 1674 } |
| 1675 // links oben | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1676 pDestination = pStart + stepdir * WidthHeight.y; |
| 38 | 1677 x = corner[0].x; |
| 1678 y = corner[0].y; | |
| 1679 intensity = corner[0].intensity; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1680 *(__IO uint16_t*)(pDestination + stepdir * (-y + (x * hgfx->ImageHeight))) = (intensity << 8) + color; |
| 38 | 1681 |
| 1682 for(j = 15; j > 0; j--) | |
| 1683 { | |
| 1684 x = corner[j].x; | |
| 1685 y = corner[j].y; | |
| 1686 intensity = corner[j].intensity; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1687 *(__IO uint16_t*)(pDestination + stepdir * (-y + (x * hgfx->ImageHeight))) = (intensity << 8) + color; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1688 *(__IO uint16_t*)(pDestination + stepdir * (-x + (y * hgfx->ImageHeight))) = (intensity << 8) + color; |
| 38 | 1689 } |
| 1690 // rechts unten | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1691 pDestination = pStart + stepdir * WidthHeight.x * hgfx->ImageHeight; |
| 38 | 1692 x = corner[0].x; |
| 1693 y = corner[0].y; | |
| 1694 intensity = corner[0].intensity; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1695 *(__IO uint16_t*)(pDestination + stepdir * (y - (x * hgfx->ImageHeight))) = (intensity << 8) + color; |
| 38 | 1696 |
| 1697 for(j = 15; j > 0; j--) | |
| 1698 { | |
| 1699 x = corner[j].x; | |
| 1700 y = corner[j].y; | |
| 1701 intensity = corner[j].intensity; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1702 *(__IO uint16_t*)(pDestination + stepdir * (y - (x * hgfx->ImageHeight))) = (intensity << 8) + color; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1703 *(__IO uint16_t*)(pDestination + stepdir * (x - (y * hgfx->ImageHeight))) = (intensity << 8) + color; |
| 38 | 1704 } |
| 1705 // rechts oben | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1706 pDestination = pStart + stepdir * WidthHeight.y + stepdir * WidthHeight.x * hgfx->ImageHeight; |
| 38 | 1707 x = corner[0].x; |
| 1708 y = corner[0].y; | |
| 1709 intensity = corner[0].intensity; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1710 *(__IO uint16_t*)(pDestination + stepdir * -1 * (y + (x * hgfx->ImageHeight))) = (intensity << 8) + color; |
| 38 | 1711 |
| 1712 for(j = 15; j > 0; j--) | |
| 1713 { | |
| 1714 x = corner[j].x; | |
| 1715 y = corner[j].y; | |
| 1716 intensity = corner[j].intensity; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1717 *(__IO uint16_t*)(pDestination + stepdir * -1 * (y + (x * hgfx->ImageHeight))) = (intensity << 8) + color; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1718 *(__IO uint16_t*)(pDestination + stepdir * -1 * (x + (y * hgfx->ImageHeight))) = (intensity << 8) + color; |
| 38 | 1719 } |
| 1720 } | |
| 1721 } | |
| 1722 | |
| 1723 | |
| 1724 /** | |
| 1725 ****************************************************************************** | |
| 1726 * @brief GFX write label. / Write string with defined color | |
| 1727 * @author heinrichs weikamp gmbh | |
| 1728 * @version V0.0.1 | |
| 1729 * @date 07-July-2014 | |
| 1730 ****************************************************************************** | |
| 1731 * | |
| 1732 * @param hgfx: check gfx_engine.h. | |
| 1733 * @param color: 16bit Alpha+CLUT. | |
| 1734 * @retval None | |
| 1735 */ | |
| 1736 | |
| 1737 uint32_t GFX_write_label(const tFont *Font, GFX_DrawCfgWindow* hgfx, const char *pText, uint8_t color) | |
| 1738 { | |
| 1739 return GFX_write_string_color(Font, hgfx, pText, 0, color); | |
| 1740 } | |
| 1741 | |
| 1742 | |
| 1743 /** | |
| 1744 ****************************************************************************** | |
| 1745 * @brief GFX writeGfx_write_label_varstring. / Write string with all parameters and font color options | |
| 1746 * @author Peter Ryser | |
| 1747 * @version V0.0.1 | |
| 1748 * @date 22-April-2014 | |
| 1749 ****************************************************************************** | |
| 1750 * | |
| 1751 * @param XleftGimpStyle: | |
| 1752 * @param XrightGimpStyle: | |
| 1753 * @param YtopGimpStyle: | |
| 1754 * @param color: | |
| 1755 * @param tFont: | |
| 1756 * @param text: text to be printed | |
| 1757 * @retval None | |
| 1758 */ | |
| 1759 | |
| 1760 void Gfx_write_label_var(GFX_DrawCfgScreen *screenInput, uint16_t XleftGimpStyle, uint16_t XrightGimpStyle, uint16_t YtopGimpStyle, const tFont *Font, const uint8_t color, const char *text) | |
| 1761 { | |
| 1762 | |
| 1763 GFX_DrawCfgWindow hgfx; | |
| 1764 | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1765 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1766 SSettings* pSettings; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1767 pSettings = settingsGetPointer(); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1768 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1769 |
| 38 | 1770 if(XrightGimpStyle > 799) |
| 1771 XrightGimpStyle = 799; | |
| 1772 if(XleftGimpStyle >= XrightGimpStyle) | |
| 1773 XleftGimpStyle = 0; | |
| 1774 if(YtopGimpStyle > 479) | |
| 1775 YtopGimpStyle = 479; | |
| 1776 hgfx.Image = screenInput; | |
| 1777 hgfx.WindowNumberOfTextLines = 1; | |
| 1778 hgfx.WindowLineSpacing = 0; | |
| 1779 hgfx.WindowTab = 0; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1780 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1781 if(!pSettings->FlipDisplay) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1782 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1783 hgfx.WindowX0 = XleftGimpStyle; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1784 hgfx.WindowX1 = XrightGimpStyle; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1785 hgfx.WindowY1 = 479 - YtopGimpStyle; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1786 if(hgfx.WindowY1 < Font->height) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1787 hgfx.WindowY0 = 0; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1788 else |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1789 hgfx.WindowY0 = hgfx.WindowY1 - Font->height; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1790 } |
| 38 | 1791 else |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1792 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1793 hgfx.WindowX0 = 800 - XrightGimpStyle; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1794 hgfx.WindowX1 = 800 - XleftGimpStyle; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1795 hgfx.WindowY0 = YtopGimpStyle; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1796 if(hgfx.WindowY0 + Font->height > 480) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1797 hgfx.WindowY1 = 480; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1798 else |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1799 hgfx.WindowY1 = hgfx.WindowY0 + Font->height; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
1800 } |
| 38 | 1801 GFX_write_label(Font, &hgfx, text, color); |
| 1802 } | |
| 1803 | |
| 1804 /** | |
| 1805 ****************************************************************************** | |
| 1806 * @brief GFX write string. / Write string with all parameters and font options | |
| 1807 * @author heinrichs weikamp gmbh | |
| 1808 * @version V0.0.1 | |
| 1809 * @date 22-April-2014 | |
| 1810 ****************************************************************************** | |
| 1811 * | |
| 1812 * @param hgfx: check gfx_engine.h. | |
| 1813 * @param color: 32bit ARGB8888. | |
| 1814 * @retval None | |
| 1815 */ | |
| 1816 | |
| 1817 uint16_t GFX_return_offset(const tFont *Font, char *pText, uint8_t position) | |
| 1818 { | |
| 1819 char character; | |
| 1820 uint16_t digit, i; | |
| 1821 uint8_t found; | |
| 1822 uint16_t distance; | |
| 1823 | |
| 1824 if(position == 0) | |
| 1825 return 0; | |
| 1826 | |
| 1827 distance = 0; | |
| 1828 for(digit = 0; digit < position; digit++) | |
| 1829 { | |
| 1830 character = pText[digit]; | |
| 1831 if(character == 0) | |
| 1832 return 0; | |
| 1833 | |
| 1834 found = 0; | |
| 1835 for(i=0;i<Font->length;i++) | |
| 1836 { | |
| 1837 if(Font->chars[i].code == character) | |
| 1838 { | |
| 1839 found = 1; | |
| 1840 break; | |
| 1841 } | |
| 1842 } | |
| 1843 if(found) | |
| 1844 { | |
| 1845 distance += (uint16_t)(Font->chars[i].image->width); | |
| 1846 if(Font == &FontT144) | |
| 1847 distance += 3; | |
| 1848 else | |
| 1849 if(Font == &FontT105) | |
| 1850 distance += 2; | |
| 1851 } | |
| 1852 } | |
| 1853 return distance; | |
| 1854 | |
| 1855 /* FEHLT: | |
| 1856 if(*pText < ' ') | |
| 1857 if((*pText) & 0x80) | |
| 1858 | |
| 1859 if(((tFont *)settings.font == &FontT105) && settings.dualFont && ((*pText == '.') || (*pText == ':'))) | |
| 1860 settings.font = (uint32_t)&FontT54; | |
| 1861 */ | |
| 1862 } | |
| 1863 | |
| 1864 void GFX_clean_line(GFX_DrawCfgWindow* hgfx, uint32_t line_number) | |
| 1865 { | |
| 1866 uint16_t height; | |
| 1867 uint32_t pDestination, i, j; | |
| 1868 uint16_t left, width, bottom, nextlineStep; | |
| 1869 | |
| 1870 bottom = hgfx->WindowY0; | |
| 1871 | |
| 1872 if(hgfx->WindowNumberOfTextLines && line_number && (line_number <= hgfx->WindowNumberOfTextLines)) | |
| 1873 { | |
| 1874 bottom += hgfx->WindowLineSpacing * (hgfx->WindowNumberOfTextLines - line_number); | |
| 1875 height = hgfx->WindowLineSpacing; | |
| 1876 } | |
| 1877 else | |
| 1878 { | |
| 1879 height = 1 + hgfx->WindowY1 - bottom; | |
| 1880 } | |
| 1881 | |
| 1882 pDestination = (uint32_t)hgfx->Image->FBStartAdress; | |
| 1883 | |
| 1884 left = hgfx->WindowX0; | |
| 1885 width = 1 + hgfx->WindowX1 - left; | |
| 1886 nextlineStep = hgfx->Image->ImageHeight - height; | |
| 1887 nextlineStep *= 2; | |
| 1888 pDestination += 2 * bottom; | |
| 1889 pDestination += 2 * hgfx->Image->ImageHeight * left; | |
| 1890 | |
| 1891 for(j = width; j > 0; j--) | |
| 1892 { | |
| 1893 for(i = height; i > 0; i--) | |
| 1894 { | |
| 1895 *(__IO uint16_t*)pDestination = 0; | |
| 1896 pDestination += 2; | |
| 1897 } | |
| 1898 pDestination += nextlineStep; | |
| 1899 } | |
| 1900 } | |
| 1901 | |
| 1902 | |
| 1903 void GFX_clean_area(GFX_DrawCfgScreen *tMscreen, uint16_t XleftGimpStyle, uint16_t XrightGimpStyle, uint16_t YtopGimpStyle, uint16_t YBottomGimpStyle) | |
| 1904 { | |
| 1905 uint16_t height; | |
| 1906 uint32_t pDestination, i, j; | |
| 1907 int32_t left, width, bottom, nextlineStep; | |
| 1908 | |
| 1909 bottom = tMscreen->ImageHeight - YBottomGimpStyle; | |
| 1910 height = 1 + YBottomGimpStyle - YtopGimpStyle; | |
| 1911 | |
| 1912 if(bottom < 0) | |
| 1913 bottom = 0; | |
| 1914 if(height > tMscreen->ImageHeight) | |
| 1915 height = tMscreen->ImageHeight; | |
| 1916 | |
| 1917 pDestination = tMscreen->FBStartAdress; | |
| 1918 | |
| 1919 left = XleftGimpStyle; | |
| 1920 width = 1 + XrightGimpStyle - left; | |
| 1921 if(width < 1) | |
| 1922 width = 1; | |
| 1923 | |
| 1924 if(width > tMscreen->ImageWidth) | |
| 1925 width = tMscreen->ImageWidth; | |
| 1926 | |
| 1927 nextlineStep = tMscreen->ImageHeight - height; | |
| 1928 nextlineStep *= 2; | |
| 1929 pDestination += 2 * bottom; | |
| 1930 pDestination += 2 * tMscreen->ImageHeight * left; | |
| 1931 | |
| 1932 for(j = width; j > 0; j--) | |
| 1933 { | |
| 1934 for(i = height; i > 0; i--) | |
| 1935 { | |
| 1936 *(__IO uint16_t*)pDestination = 0; | |
| 1937 pDestination += 2; | |
| 1938 } | |
| 1939 pDestination += nextlineStep; | |
| 1940 } | |
| 1941 } | |
| 1942 | |
| 1943 | |
| 1944 uint32_t GFX_write_string(const tFont *Font, GFX_DrawCfgWindow* hgfx, const char *pText, uint32_t line_number) | |
| 1945 { | |
| 1946 return GFX_write_string_color(Font, hgfx, pText, line_number, 0); | |
| 1947 } | |
| 1948 | |
| 1949 uint32_t GFX_write_string_color(const tFont *Font, GFX_DrawCfgWindow* hgfx, const char *pText, uint32_t line_number, uint8_t color) | |
| 1950 { | |
| 1951 if(hgfx->Image->FBStartAdress < FBGlobalStart) | |
| 1952 return 0; | |
| 1953 | |
| 1954 GFX_CfgWriteString settings; | |
| 1955 uint32_t newXdelta; | |
| 1956 uint8_t minimal = 0; | |
| 1957 // uint32_t try_again; | |
| 1958 | |
| 1959 if(hgfx->WindowNumberOfTextLines && line_number && (line_number <= hgfx->WindowNumberOfTextLines)) | |
| 1960 { | |
| 1961 settings.Ydelta = hgfx->WindowLineSpacing * (hgfx->WindowNumberOfTextLines - line_number); | |
| 1962 } | |
| 1963 else | |
| 1964 { | |
| 1965 settings.Ydelta = 0; | |
| 1966 } | |
| 1967 settings.font = (uint32_t)Font; | |
| 1968 settings.Xdelta = 0; | |
| 1969 settings.color = color; | |
| 1970 settings.invert = 0; | |
| 1971 settings.resize = 0; | |
| 1972 settings.dualFont = 0; | |
| 1973 settings.spaceMode = 0; | |
| 1974 settings.singleSpaceWithSizeOfNextChar = 0; | |
| 1975 settings.useTinyFont = 0; | |
| 1976 settings.TinyFontExtraYdelta = 0; | |
| 1977 settings.TinyFont = (uint32_t)Font; | |
| 1978 settings.doubleSize = 0; | |
| 1979 | |
| 1980 if((*pText) == TXT_MINIMAL) // for customtext and anything with Sonderzeichen | |
| 1981 minimal = 1; | |
| 1982 else | |
| 1983 minimal = 0; | |
| 1984 | |
| 1985 if(Font == &FontT144) | |
| 1986 settings.TinyFont = (uint32_t)&FontT84; | |
| 1987 else | |
| 1988 if(Font == &FontT105) | |
| 1989 settings.TinyFont = (uint32_t)&FontT54; | |
| 1990 else | |
| 1991 if(Font == &FontT54) | |
| 1992 { | |
| 1993 settings.TinyFont = (uint32_t)&FontT48; | |
| 1994 settings.TinyFontExtraYdelta = -9; | |
| 1995 } | |
| 1996 else | |
| 1997 if(Font == &FontT48) | |
| 1998 { | |
| 1999 settings.TinyFont = (uint32_t)&FontT24; | |
| 2000 settings.TinyFontExtraYdelta = 6; | |
| 2001 } | |
| 2002 else | |
| 2003 if(Font == &FontT42) | |
| 2004 { | |
| 2005 settings.TinyFont = (uint32_t)&FontT24; | |
| 2006 settings.TinyFontExtraYdelta = 2; | |
| 2007 } | |
| 2008 | |
| 2009 settings.actualFont = (tFont *)settings.font; | |
| 2010 | |
| 2011 while ((*pText != 0) && (settings.Xdelta != 0x0000FFFF))// und fehlend: Abfrage window / image size | |
| 2012 { | |
| 2013 // try_again = 0; | |
| 2014 | |
| 2015 if((*pText == '\177') && !minimal) | |
| 2016 { | |
| 2017 if(settings.singleSpaceWithSizeOfNextChar) | |
| 2018 { | |
| 2019 settings.singleSpaceWithSizeOfNextChar = 0; | |
| 2020 pText++; | |
| 2021 settings.Xdelta += *pText; | |
| 2022 } | |
| 2023 else | |
| 2024 settings.singleSpaceWithSizeOfNextChar = 1; | |
| 2025 } | |
| 2026 else | |
| 2027 if(*pText < ' ') | |
| 2028 { | |
| 2029 /* Xdelta -inline- changes */ | |
| 2030 if((*pText == '\t') && !minimal) | |
| 2031 settings.Xdelta = hgfx->WindowTab - hgfx->WindowX0; | |
| 2032 else | |
| 2033 if(*pText == '\r') // carriage return, no newline | |
| 2034 settings.Xdelta = 0; | |
| 2035 else | |
| 2036 if((*pText == '\001') && !minimal) // center | |
| 2037 settings.Xdelta = GFX_write__Modify_Xdelta__Centered(&settings, hgfx, pText+1); | |
| 2038 else | |
| 2039 if((*pText == '\002') && !minimal) // right | |
| 2040 settings.Xdelta = GFX_write__Modify_Xdelta__RightAlign(&settings, hgfx, pText+1); | |
| 2041 else | |
| 2042 if((*pText == '\003') && !minimal) // doubleSize | |
| 2043 settings.doubleSize = 1; | |
| 2044 else | |
| 2045 /* Xdelta -up/down changes */ | |
| 2046 if((*pText == '\f') && !minimal) // form feed = top align | |
| 2047 { | |
| 2048 if((hgfx->WindowY1 - hgfx->WindowY0) >= ((tFont *)settings.font)->height) | |
| 2049 { | |
| 2050 settings.Ydelta = hgfx->WindowY1 - hgfx->WindowY0; | |
| 2051 settings.Ydelta -= ((tFont *)settings.font)->height; | |
| 2052 } | |
| 2053 } | |
| 2054 else | |
| 2055 if(*pText == '\n') // newline, no carriage return | |
| 2056 { | |
| 2057 if(hgfx->WindowNumberOfTextLines && (line_number < hgfx->WindowNumberOfTextLines)) | |
| 2058 { | |
| 2059 line_number++; | |
| 2060 settings.Ydelta = hgfx->WindowLineSpacing * (hgfx->WindowNumberOfTextLines - line_number); | |
| 2061 } | |
| 2062 } | |
| 2063 else | |
| 2064 /* Font style changes */ | |
| 2065 if(*pText == '\a') | |
| 2066 settings.invert = 1; | |
| 2067 else | |
| 2068 if((*pText == '\016') && !minimal) | |
| 2069 { | |
| 2070 if(settings.dualFont == 0) | |
| 2071 settings.dualFont = 1; | |
| 2072 else | |
| 2073 settings.actualFont = (tFont *)settings.TinyFont; | |
| 2074 } | |
| 2075 else | |
| 2076 if((*pText == '\017') && !minimal) | |
| 2077 { | |
| 2078 settings.dualFont = 0; | |
| 2079 settings.actualFont = (tFont *)settings.font; | |
| 2080 } | |
| 2081 else | |
| 2082 if((*pText == '\005') && !minimal) | |
| 2083 { | |
| 2084 newXdelta = GFX_write_char(hgfx, &settings, 'a', (tFont *)&Awe48); | |
| 2085 settings.Xdelta = newXdelta; | |
| 2086 } | |
| 2087 else | |
| 2088 if((*pText == '\006') && !minimal) | |
| 2089 { | |
| 2090 newXdelta = GFX_write_char(hgfx, &settings, 'b', (tFont *)&Awe48); | |
| 2091 settings.Xdelta = newXdelta; | |
| 2092 } | |
| 2093 else | |
| 2094 if((*pText >= '\020') && (*pText <= '\032') && !minimal) | |
| 2095 settings.color = *pText - '\020'; | |
| 2096 else | |
| 2097 if((*pText == '\034') && !minimal) | |
| 2098 settings.spaceMode = 1; | |
| 2099 else | |
| 2100 if((*pText == '\035') && !minimal) | |
| 2101 settings.spaceMode = 0; | |
| 2102 } | |
| 2103 else | |
| 2104 if(((*pText) == TXT_2BYTE) && !minimal) | |
| 2105 { | |
| 2106 pText++; | |
| 2107 settings.Xdelta = GFX_write_substring(&settings, hgfx, (uint8_t)TXT_2BYTE, (int8_t)*pText); | |
| 2108 } | |
| 2109 else | |
| 2110 if(((*pText) & 0x80) && !minimal) | |
| 2111 settings.Xdelta = GFX_write_substring(&settings, hgfx, (uint8_t)*pText, 0); | |
| 2112 else | |
| 2113 if(!settings.invert && (*pText == ' ')) | |
| 2114 { | |
| 2115 if(settings.spaceMode == 0) | |
| 2116 settings.Xdelta += ((tFont *)settings.font)->spacesize; | |
| 2117 else | |
| 2118 settings.Xdelta += ((tFont *)settings.font)->spacesize2Monospaced; | |
| 2119 } | |
| 2120 else | |
| 2121 if((settings.spaceMode == 1) && (*pText == ' ')) | |
| 2122 settings.Xdelta += ((tFont *)settings.font)->spacesize2Monospaced; | |
| 2123 else | |
| 2124 { | |
| 2125 if(((tFont *)settings.font == &FontT144) && ((*pText == '.') || (*pText == ':'))) | |
| 2126 settings.actualFont = (tFont *)settings.TinyFont; | |
| 2127 else | |
| 2128 if(((tFont *)settings.font == &FontT105) && settings.dualFont && ((*pText == '.') || (*pText == ':'))) | |
| 2129 settings.actualFont = (tFont *)settings.TinyFont; | |
| 2130 | |
| 2131 if(settings.actualFont == (tFont *)settings.TinyFont) | |
| 2132 settings.Ydelta += settings.TinyFontExtraYdelta; | |
| 2133 | |
| 2134 newXdelta = GFX_write_char(hgfx, &settings, *(uint8_t *)pText, settings.actualFont); | |
| 2135 settings.Xdelta = newXdelta; | |
| 2136 | |
| 2137 if(settings.actualFont == (tFont *)settings.TinyFont) | |
| 2138 settings.Ydelta -= settings.TinyFontExtraYdelta; | |
| 2139 } | |
| 2140 if(pText != 0) /* for TXT_2BYTE */ | |
| 2141 pText++; | |
| 2142 } | |
| 2143 return settings.Ydelta; | |
| 2144 } | |
| 2145 | |
| 2146 /* Private functions ---------------------------------------------------------*/ | |
| 2147 /****************************************************************************** | |
| 2148 Static Function | |
| 2149 *******************************************************************************/ | |
| 2150 | |
| 2151 /** | |
| 2152 ****************************************************************************** | |
| 2153 * @brief GFX write substring. / Write string without parameters | |
| 2154 * @author heinrichs weikamp gmbh | |
| 2155 * @version V0.0.1 | |
| 2156 * @date 22-April-2014 | |
| 2157 ****************************************************************************** | |
| 2158 * | |
| 2159 * @param hgfx: check gfx_engine.h. | |
| 2160 * @param color: 32bit ARGB8888. | |
| 2161 * @retval None | |
| 2162 */ | |
| 2163 | |
| 2164 static uint32_t GFX_write_substring(GFX_CfgWriteString* cfg, GFX_DrawCfgWindow* hgfx, uint8_t textId, int8_t nextCharFor2Byte) | |
| 2165 { | |
| 2166 uint8_t i, j; | |
| 2167 uint32_t found; | |
| 2168 uint32_t pText; | |
| 58 | 2169 uint16_t decodeUTF8; |
| 38 | 2170 uint8_t gfx_selected_language; |
| 2171 #ifndef BOOTLOADER_STANDALONE | |
| 2172 SSettings *pSettings; | |
| 2173 pSettings = settingsGetPointer(); | |
| 2174 gfx_selected_language = pSettings->selected_language; | |
| 2175 if(gfx_selected_language >= LANGUAGE_END) | |
| 2176 #endif | |
| 2177 gfx_selected_language = 0; | |
| 58 | 2178 |
| 2179 | |
| 38 | 2180 // ----------------------------- |
| 58 | 2181 if(textId != (uint8_t)TXT_2BYTE) |
| 38 | 2182 { |
| 2183 found = 0; | |
| 2184 j = 0; | |
| 2185 for(i=(uint8_t)TXT_Language;i<(uint8_t)TXT_END;i++) | |
| 2186 { | |
| 2187 if(text_array[j].code == textId) | |
| 2188 { | |
| 2189 found = 1; | |
| 2190 break; | |
| 2191 } | |
| 2192 j++; | |
| 2193 } | |
| 2194 if(!found) | |
| 2195 return cfg->Xdelta; | |
| 58 | 2196 |
| 38 | 2197 // ----------------------------- |
| 2198 pText = (uint32_t)text_array[j].text[gfx_selected_language]; | |
| 2199 if(!pText) | |
| 2200 pText = (uint32_t)text_array[j].text[0]; | |
| 2201 else | |
| 2202 if(*(char*)pText == 0) | |
| 2203 pText = (uint32_t)text_array[j].text[0]; | |
| 2204 } | |
| 2205 // ----------------------------- | |
| 2206 else | |
| 2207 { | |
| 2208 if(!nextCharFor2Byte) | |
| 2209 return cfg->Xdelta; | |
| 2210 | |
| 2211 found = 0; | |
| 2212 for(j=0;j<(uint8_t)TXT2BYTE_END-(uint8_t)TXT2BYTE_START;j++) | |
| 2213 { | |
| 2214 if((uint8_t)text_array2[j].code == (uint8_t)nextCharFor2Byte) | |
| 2215 { | |
| 2216 found = 1; | |
| 2217 break; | |
| 2218 } | |
| 2219 } | |
| 2220 if(!found) | |
| 2221 return cfg->Xdelta; | |
| 2222 // ----------------------------- | |
| 2223 pText = (uint32_t)text_array2[j].text[gfx_selected_language]; | |
| 2224 if(!pText) | |
| 2225 pText = (uint32_t)text_array2[j].text[0]; | |
| 2226 else | |
| 2227 if(*(char*)pText == 0) | |
| 2228 pText = (uint32_t)text_array2[j].text[0]; | |
| 2229 } | |
| 2230 // ----------------------------- | |
| 2231 | |
| 2232 if(cfg->actualFont == (tFont *)cfg->TinyFont) | |
| 2233 cfg->Ydelta += cfg->TinyFontExtraYdelta; | |
| 2234 | |
| 2235 while (*(char*)pText != 0)// und fehlend: Abfrage window / image size | |
| 2236 { | |
| 2237 if(*(char*)pText == '\t') | |
| 2238 cfg->Xdelta = hgfx->WindowTab - hgfx->WindowX0; | |
| 2239 else | |
| 2240 if(*(char*)pText == ' ') | |
| 2241 cfg->Xdelta += ((tFont *)cfg->actualFont)->spacesize; | |
| 2242 else | |
| 58 | 2243 if((*(char*)pText) & 0x80) /* Identify a UNICODE character other than standard ASCII using the highest bit */ |
| 2244 { | |
| 2245 decodeUTF8 = ((*(char*)pText) & 0x1F) << 6; /* use 5bits of first byte for upper part of unicode */ | |
| 2246 pText++; | |
| 2247 decodeUTF8 |= (*(char*)pText) & 0x3F; /* add lower 6bits as second part of the unicode */ | |
| 2248 if (decodeUTF8 <= 0xff) /* The following function has a uint8 input parameter ==> no UNICODEs > 0xff supported */ | |
| 2249 { | |
| 2250 cfg->Xdelta = GFX_write_char(hgfx, cfg, (uint8_t)decodeUTF8, (tFont *)cfg->actualFont); | |
| 2251 } | |
| 2252 } | |
| 2253 else | |
| 38 | 2254 cfg->Xdelta = GFX_write_char(hgfx, cfg, *(uint8_t *)pText, (tFont *)cfg->actualFont); |
| 2255 | |
| 2256 pText++; | |
| 2257 } | |
| 2258 | |
| 2259 if(cfg->actualFont == (tFont *)cfg->TinyFont) | |
| 2260 cfg->Ydelta -= cfg->TinyFontExtraYdelta; | |
| 2261 | |
| 2262 return cfg->Xdelta; | |
| 2263 } | |
| 2264 | |
| 2265 | |
| 2266 /** | |
| 2267 ****************************************************************************** | |
| 2268 * @brief GFX write char. / Write non-inverted, non-colored with entire 8 bit range | |
| 2269 * @author heinrichs weikamp gmbh | |
| 2270 * @version V0.0.1 | |
| 2271 * @date 22-April-2014 | |
| 2272 ****************************************************************************** | |
| 2273 * | |
| 2274 * @param hgfx: check gfx_engine.h. | |
| 2275 * @param Ydelta: input | |
| 2276 * @param character: character | |
| 2277 * @param *Font: pointer to font to be used for this char | |
| 2278 * @retval Ydelta: 0x0000FFFF if not successful or char_truncated | |
| 2279 */ | |
| 2280 | |
| 2281 static uint32_t GFX_write_char_doubleSize(GFX_DrawCfgWindow* hgfx, GFX_CfgWriteString* cfg, uint8_t character, tFont *Font) | |
| 2282 { | |
| 2283 uint32_t i, j; | |
| 2284 uint32_t width, height; | |
| 2285 uint32_t found; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2286 uint16_t* pDestination; |
| 38 | 2287 uint32_t pSource; |
| 2288 uint32_t OffsetDestination; | |
| 2289 uint32_t width_left; | |
| 2290 uint32_t height_left; | |
| 2291 uint32_t char_truncated_WidthFlag; | |
| 2292 uint32_t char_truncated_Height; | |
| 2293 uint8_t fill; | |
| 2294 uint32_t widthFont, heightFont; | |
| 2295 uint32_t nextLine; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2296 int32_t stepdir; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2297 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2298 SSettings* pSettings; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2299 pSettings = settingsGetPointer(); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2300 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2301 if(pSettings->FlipDisplay) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2302 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2303 stepdir = -1; /* decrement address while putting pixels */ |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2304 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2305 else |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2306 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2307 stepdir = 1; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2308 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2309 |
| 38 | 2310 |
| 2311 if(hgfx->Image->ImageWidth <= (hgfx->WindowX0 + cfg->Xdelta)) | |
| 2312 return 0x0000FFFF; | |
| 2313 | |
| 2314 // ----------------------------- | |
| 2315 found = 0; | |
| 2316 for(i=0;i<Font->length;i++) | |
| 2317 { | |
| 2318 if(Font->chars[i].code == character) | |
| 2319 { | |
| 2320 found = 1; | |
| 2321 break; | |
| 2322 } | |
| 2323 } | |
| 2324 if(!found) | |
| 2325 return cfg->Xdelta; | |
| 2326 | |
| 2327 pSource = ((uint32_t)Font->chars[i].image->data); | |
| 119 | 2328 pDestination = (uint16_t*)(hgfx->Image->FBStartAdress); |
| 38 | 2329 |
| 2330 heightFont = Font->chars[i].image->height; | |
| 2331 widthFont = Font->chars[i].image->width; | |
| 2332 | |
| 2333 height = heightFont*2; | |
| 2334 width = widthFont*2; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2335 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2336 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2337 if(pSettings->FlipDisplay) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2338 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2339 pDestination += (uint32_t)(hgfx->WindowX1 - cfg->Xdelta) * hgfx->Image->ImageHeight; /* set pointer to delta row */ |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2340 pDestination += (hgfx->WindowY1 - cfg->Ydelta); /* set pointer to delta colum */ |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2341 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2342 else |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2343 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2344 pDestination += (uint32_t)(hgfx->WindowX0 + cfg->Xdelta) * hgfx->Image->ImageHeight; /* set pointer to delta row */ |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2345 pDestination += (hgfx->WindowY0 + cfg->Ydelta); /* set pointer to delta colum */ |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2346 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2347 OffsetDestination = (hgfx->Image->ImageHeight - height); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2348 nextLine = hgfx->Image->ImageHeight; |
| 38 | 2349 |
| 2350 // ----------------------------- | |
| 2351 char_truncated_WidthFlag = 0; | |
| 2352 width_left = hgfx->Image->ImageWidth - (hgfx->WindowX0 + cfg->Xdelta); | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2353 |
| 38 | 2354 if(width_left < width) |
| 2355 { | |
| 2356 char_truncated_WidthFlag = 1; | |
| 2357 width = width_left; | |
| 2358 widthFont = width/2; | |
| 2359 } | |
| 2360 // ----------------------------- | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2361 |
| 38 | 2362 char_truncated_Height = 0; |
| 2363 height_left = hgfx->Image->ImageHeight - (hgfx->WindowY0 + cfg->Ydelta); | |
| 2364 if(height_left < height) | |
| 2365 { | |
| 2366 char_truncated_Height = height - height_left; | |
| 2367 if((char_truncated_Height & 1) != 0) | |
| 2368 { | |
| 2369 height_left -= 1; | |
| 2370 char_truncated_Height += 1; | |
| 2371 } | |
| 2372 height = height_left; | |
| 2373 heightFont = height/2; | |
| 2374 } | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2375 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2376 OffsetDestination += char_truncated_Height; |
| 38 | 2377 // ----------------------------- |
| 2378 if(height == 0) | |
| 2379 return 0x0000FFFF; | |
| 2380 // ----------------------------- | |
| 2381 | |
| 2382 if(cfg->singleSpaceWithSizeOfNextChar) | |
| 2383 { | |
| 2384 cfg->singleSpaceWithSizeOfNextChar = 0; | |
| 2385 | |
| 2386 if(cfg->invert) | |
| 2387 fill = 0xFF; | |
| 2388 else | |
| 2389 fill = 0; | |
| 2390 | |
| 2391 height /= 2; | |
| 2392 for(i = width; i > 0; i--) | |
| 2393 { | |
| 2394 for (j = height; j > 0; j--) | |
| 2395 { | |
| 119 | 2396 *(__IO uint16_t*)pDestination = fill << 8 | cfg->color; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2397 pDestination += stepdir; |
| 119 | 2398 *(__IO uint16_t*)pDestination = fill << 8 | cfg->color; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2399 pDestination += stepdir; |
| 38 | 2400 } |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2401 pDestination += stepdir * OffsetDestination; |
| 38 | 2402 } |
| 2403 } | |
| 2404 else | |
| 2405 if(cfg->invert) | |
| 2406 { | |
| 2407 if((heightFont & 3) == 0) /* unroll for perfomance, by 4 if possible, by 2 (16bit) otherwise */ | |
| 2408 { | |
| 2409 heightFont /= 4; | |
| 2410 for(i = widthFont; i > 0; i--) | |
| 2411 { | |
| 2412 if(*(uint8_t*)pSource != 0x01) | |
| 2413 { | |
| 2414 for (j = heightFont; j > 0; j--) | |
| 2415 { | |
| 119 | 2416 *(__IO uint16_t*)pDestination = (0xFF - *(uint8_t*)pSource) << 8 | cfg->color; |
| 2417 *(__IO uint16_t*)(pDestination + nextLine) = (0xFF - *(uint8_t*)pSource) << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2418 pDestination += stepdir; |
| 119 | 2419 *(__IO uint16_t*)pDestination = (0xFF - *(uint8_t*)pSource) << 8 | cfg->color; |
| 2420 *(__IO uint16_t*)(pDestination + nextLine) = (0xFF - *(uint8_t*)pSource) << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2421 pDestination += stepdir; |
| 38 | 2422 pSource++; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2423 |
| 119 | 2424 *(__IO uint16_t*)pDestination = (0xFF - *(uint8_t*)pSource) << 8 | cfg->color; |
| 2425 *(__IO uint16_t*)(pDestination + nextLine) = (0xFF - *(uint8_t*)pSource) << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2426 pDestination += stepdir; |
| 119 | 2427 *(__IO uint16_t*)pDestination = (0xFF - *(uint8_t*)pSource) << 8 | cfg->color; |
| 2428 *(__IO uint16_t*)(pDestination + nextLine) = (0xFF - *(uint8_t*)pSource) << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2429 pDestination += stepdir; |
| 38 | 2430 pSource++; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2431 |
| 119 | 2432 *(__IO uint16_t*)pDestination = (0xFF - *(uint8_t*)pSource) << 8 | cfg->color; |
| 2433 *(__IO uint16_t*)(pDestination + nextLine) = (0xFF - *(uint8_t*)pSource) << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2434 pDestination += stepdir; |
| 119 | 2435 *(__IO uint16_t*)pDestination = (0xFF - *(uint8_t*)pSource) << 8 | cfg->color; |
| 2436 *(__IO uint16_t*)(pDestination + nextLine) = (0xFF - *(uint8_t*)pSource) << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2437 pDestination += stepdir; |
| 38 | 2438 pSource++; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2439 |
| 119 | 2440 *(__IO uint16_t*)pDestination = (0xFF - *(uint8_t*)pSource) << 8 | cfg->color; |
| 2441 *(__IO uint16_t*)(pDestination + nextLine) = (0xFF - *(uint8_t*)pSource) << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2442 pDestination += stepdir; |
| 119 | 2443 *(__IO uint16_t*)pDestination = (0xFF - *(uint8_t*)pSource) << 8 | cfg->color; |
| 2444 *(__IO uint16_t*)(pDestination + nextLine) = (0xFF - *(uint8_t*)pSource) << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2445 pDestination += stepdir; |
| 38 | 2446 pSource++; |
| 2447 } | |
| 2448 pSource += char_truncated_Height; | |
| 2449 } | |
| 2450 else | |
| 2451 { | |
| 2452 pSource++; | |
| 2453 for (j = height; j > 0; j--) | |
| 2454 { | |
| 119 | 2455 *(__IO uint16_t*)pDestination = 0xFF << 8 | cfg->color; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2456 *(__IO uint16_t*)(pDestination + nextLine) = cfg->color << 8 |0xFF; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2457 pDestination += stepdir; |
| 119 | 2458 *(__IO uint16_t*)pDestination = 0xFF << 8 | cfg->color; |
| 2459 *(__IO uint16_t*)(pDestination + nextLine) = 0xFF << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2460 pDestination += stepdir; |
| 119 | 2461 *(__IO uint16_t*)pDestination = 0xFF << 8 | cfg->color; |
| 2462 *(__IO uint16_t*)(pDestination + nextLine) = 0xFF << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2463 pDestination += stepdir; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2464 *(__IO uint16_t*)pDestination = cfg->color << 8 |0xFF; |
| 119 | 2465 *(__IO uint16_t*)(pDestination + nextLine) = 0xFF << 8 | cfg->color; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2466 pDestination += stepdir; |
| 119 | 2467 *(__IO uint16_t*)pDestination = 0xFF << 8 | cfg->color; |
| 2468 *(__IO uint16_t*)(pDestination + nextLine) = 0xFF << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2469 pDestination += stepdir; |
| 119 | 2470 *(__IO uint16_t*)pDestination = 0xFF << 8 | cfg->color; |
| 2471 *(__IO uint16_t*)(pDestination + nextLine) = 0xFF << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2472 pDestination += stepdir; |
| 119 | 2473 *(__IO uint16_t*)pDestination = 0xFF << 8 | cfg->color; |
| 2474 *(__IO uint16_t*)(pDestination + nextLine) = 0xFF << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2475 pDestination += stepdir; |
| 119 | 2476 *(__IO uint16_t*)pDestination = 0xFF << 8 | cfg->color; |
| 2477 *(__IO uint16_t*)(pDestination + nextLine) = 0xFF << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2478 pDestination += stepdir; |
| 38 | 2479 } |
| 2480 } | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2481 pDestination += (OffsetDestination + nextLine) * stepdir; |
| 38 | 2482 } |
| 2483 } | |
| 2484 else | |
| 2485 { | |
| 2486 heightFont /= 2; | |
| 2487 for(i = widthFont; i > 0; i--) | |
| 2488 { | |
| 2489 if(*(uint8_t*)pSource != 0x01) | |
| 2490 { | |
| 2491 for (j = heightFont; j > 0; j--) | |
| 2492 { | |
| 119 | 2493 *(__IO uint16_t*)pDestination = (0xFF - *(uint8_t*)pSource) << 8 | cfg->color; |
| 2494 *(__IO uint16_t*)(pDestination + nextLine) = (0xFF - *(uint8_t*)pSource) << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2495 pDestination += stepdir; |
| 119 | 2496 *(__IO uint16_t*)pDestination = (0xFF - *(uint8_t*)pSource) << 8 | cfg->color; |
| 2497 *(__IO uint16_t*)(pDestination + nextLine) = (0xFF - *(uint8_t*)pSource) << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2498 pDestination += stepdir; |
| 38 | 2499 pSource++; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2500 |
| 119 | 2501 *(__IO uint16_t*)pDestination = (0xFF - *(uint8_t*)pSource) << 8 | cfg->color; |
| 2502 *(__IO uint16_t*)(pDestination + nextLine) = (0xFF - *(uint8_t*)pSource) << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2503 pDestination += stepdir; |
| 119 | 2504 *(__IO uint16_t*)pDestination = (0xFF - *(uint8_t*)pSource) << 8 | cfg->color; |
| 2505 *(__IO uint16_t*)(pDestination + nextLine) = (0xFF - *(uint8_t*)pSource) << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2506 pDestination += stepdir; |
| 38 | 2507 pSource++; |
| 2508 } | |
| 2509 pSource += char_truncated_Height; | |
| 2510 } | |
| 2511 else | |
| 2512 { | |
| 2513 pSource++; | |
| 2514 for (j = heightFont; j > 0; j--) | |
| 2515 { | |
| 119 | 2516 *(__IO uint16_t*)pDestination = 0xFF << 8 | cfg->color; |
| 2517 *(__IO uint16_t*)(pDestination + nextLine) = 0xFF << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2518 pDestination += stepdir; |
| 119 | 2519 *(__IO uint16_t*)pDestination = 0xFF << 8 | cfg->color; |
| 2520 *(__IO uint16_t*)(pDestination + nextLine) = 0xFF << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2521 pDestination += stepdir; |
| 119 | 2522 *(__IO uint16_t*)pDestination = 0xFF << 8 | cfg->color; |
| 2523 *(__IO uint16_t*)(pDestination + nextLine) = 0xFF << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2524 pDestination += stepdir; |
| 119 | 2525 *(__IO uint16_t*)pDestination = 0xFF << 8 | cfg->color; |
| 2526 *(__IO uint16_t*)(pDestination + nextLine) = 0xFF << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2527 pDestination += stepdir; |
| 38 | 2528 } |
| 2529 } | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2530 pDestination += (OffsetDestination + nextLine) * stepdir; |
| 38 | 2531 } |
| 2532 } | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2533 } /* inverted */ |
| 38 | 2534 else |
| 2535 { | |
| 2536 if((heightFont & 3) == 0) /* unroll for perfomance, by 4 if possible, by 2 (16bit) otherwise */ | |
| 2537 { | |
| 2538 heightFont /= 4; | |
| 2539 for(i = widthFont; i > 0; i--) | |
| 2540 { | |
| 2541 if(*(uint8_t*)pSource != 0x01) | |
| 2542 { | |
| 2543 for (j = heightFont; j > 0; j--) | |
| 2544 { | |
| 119 | 2545 *(__IO uint16_t*)pDestination = *(uint8_t*)pSource << 8 | cfg->color; |
| 2546 *(__IO uint16_t*)(pDestination + (stepdir * nextLine)) = *(uint8_t*)pSource << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2547 pDestination += stepdir; |
| 119 | 2548 *(__IO uint16_t*)pDestination = *(uint8_t*)pSource << 8 | cfg->color; |
| 2549 *(__IO uint16_t*)(pDestination + (stepdir * nextLine)) = *(uint8_t*)pSource << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2550 pDestination += stepdir; |
| 38 | 2551 pSource++; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2552 |
| 119 | 2553 *(__IO uint16_t*)pDestination = *(uint8_t*)pSource << 8 | cfg->color; |
| 2554 *(__IO uint16_t*)(pDestination + (stepdir * nextLine)) = *(uint8_t*)pSource << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2555 pDestination += stepdir; |
| 119 | 2556 *(__IO uint16_t*)pDestination = *(uint8_t*)pSource << 8 | cfg->color; |
| 2557 *(__IO uint16_t*)(pDestination + (stepdir * nextLine)) = *(uint8_t*)pSource << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2558 pDestination += stepdir; |
| 38 | 2559 pSource++; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2560 |
| 119 | 2561 *(__IO uint16_t*)pDestination = *(uint8_t*)pSource << 8 | cfg->color; |
| 2562 *(__IO uint16_t*)(pDestination + (stepdir * nextLine)) = *(uint8_t*)pSource << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2563 pDestination += stepdir; |
| 119 | 2564 *(__IO uint16_t*)pDestination = *(uint8_t*)pSource << 8 | cfg->color; |
| 2565 *(__IO uint16_t*)(pDestination + (stepdir * nextLine)) = *(uint8_t*)pSource << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2566 pDestination += stepdir; |
| 38 | 2567 pSource++; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2568 |
| 119 | 2569 *(__IO uint16_t*)pDestination = *(uint8_t*)pSource << 8 | cfg->color; |
| 2570 *(__IO uint16_t*)(pDestination + (stepdir * nextLine)) = *(uint8_t*)pSource << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2571 pDestination += stepdir; |
| 119 | 2572 *(__IO uint16_t*)pDestination = *(uint8_t*)pSource << 8 | cfg->color; |
| 2573 *(__IO uint16_t*)(pDestination + (stepdir * nextLine)) = *(uint8_t*)pSource << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2574 pDestination += stepdir; |
| 38 | 2575 pSource++; |
| 2576 } | |
| 2577 pSource += char_truncated_Height; | |
| 2578 } | |
| 2579 else | |
| 2580 { | |
| 2581 pSource++; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2582 pDestination += stepdir * height; |
| 38 | 2583 } |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2584 pDestination += stepdir * (OffsetDestination + nextLine); |
| 38 | 2585 } |
| 2586 } | |
| 2587 else | |
| 2588 { | |
| 2589 heightFont /= 2; | |
| 2590 for(i = widthFont; i > 0; i--) | |
| 2591 { | |
| 2592 if(*(uint8_t*)pSource != 0x01) | |
| 2593 { | |
| 2594 for (j = heightFont; j > 0; j--) | |
| 2595 { | |
| 119 | 2596 *(__IO uint16_t*)pDestination = *(uint8_t*)pSource << 8 | cfg->color; |
| 2597 *(__IO uint16_t*)(pDestination + (stepdir * nextLine)) = *(uint8_t*)pSource << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2598 pDestination += stepdir; |
| 119 | 2599 *(__IO uint16_t*)pDestination = *(uint8_t*)pSource << 8 | cfg->color; |
| 2600 *(__IO uint16_t*)(pDestination + (stepdir * nextLine)) = *(uint8_t*)pSource << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2601 pDestination += stepdir; |
| 38 | 2602 pSource++; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2603 |
| 119 | 2604 *(__IO uint16_t*)pDestination = *(uint8_t*)pSource << 8 | cfg->color; |
| 2605 *(__IO uint16_t*)(pDestination + (stepdir * nextLine)) = *(uint8_t*)pSource << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2606 pDestination += stepdir; |
| 119 | 2607 *(__IO uint16_t*)pDestination = *(uint8_t*)pSource << 8 | cfg->color; |
| 2608 *(__IO uint16_t*)(pDestination + (stepdir * nextLine)) = *(uint8_t*)pSource << 8 | cfg->color; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2609 pDestination += stepdir; |
| 38 | 2610 pSource++; |
| 2611 } | |
| 2612 pSource += char_truncated_Height; | |
| 2613 } | |
| 2614 else | |
| 2615 { | |
| 2616 pSource++; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2617 pDestination += stepdir * height; |
| 38 | 2618 } |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2619 pDestination += stepdir * (OffsetDestination + nextLine); |
| 38 | 2620 } |
| 2621 } | |
| 2622 } | |
| 2623 | |
| 2624 // ----------------------------- | |
| 2625 | |
| 2626 if(Font == &FontT144) | |
| 2627 width += 6; | |
| 2628 else | |
| 2629 if(Font == &FontT105) | |
| 2630 width += 4; | |
| 2631 | |
| 2632 // ----------------------------- | |
| 2633 | |
| 2634 if(char_truncated_WidthFlag) | |
| 2635 return 0x0000FFFF; | |
| 2636 else | |
| 2637 return cfg->Xdelta + width; | |
| 2638 | |
| 2639 } | |
| 2640 | |
| 2641 | |
| 2642 /** | |
| 2643 ****************************************************************************** | |
| 2644 * @brief GFX write char. / Write non-inverted, non-colored with entire 8 bit range | |
| 2645 * @author heinrichs weikamp gmbh | |
| 2646 * @version V0.0.1 | |
| 2647 * @date 22-April-2014 | |
| 2648 ****************************************************************************** | |
| 2649 * | |
| 2650 * @param hgfx: check gfx_engine.h. | |
| 2651 * @param Ydelta: input | |
| 2652 * @param character: character | |
| 2653 * @param *Font: pointer to font to be used for this char | |
| 2654 * @retval Ydelta: 0x0000FFFF if not successful or char_truncated | |
| 2655 */ | |
| 2656 | |
| 2657 static uint32_t GFX_write_char(GFX_DrawCfgWindow* hgfx, GFX_CfgWriteString* cfg, uint8_t character, tFont *Font) | |
| 2658 { | |
| 2659 if(cfg->doubleSize) | |
| 2660 { | |
| 2661 return GFX_write_char_doubleSize(hgfx, cfg, character, Font); | |
| 2662 } | |
| 2663 | |
| 2664 uint32_t i, j; | |
| 2665 uint32_t width, height; | |
| 2666 uint32_t found; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2667 uint16_t* pDestination; |
| 38 | 2668 uint32_t pSource; |
| 2669 uint32_t OffsetDestination; | |
| 2670 uint32_t width_left; | |
| 2671 uint32_t height_left; | |
| 2672 uint32_t char_truncated_WidthFlag; | |
| 2673 uint32_t char_truncated_Height; | |
| 2674 uint8_t fill; | |
| 121 | 2675 uint32_t fillpattern; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2676 int16_t stepdir; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2677 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2678 SSettings* pSettings; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2679 pSettings = settingsGetPointer(); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2680 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2681 if(pSettings->FlipDisplay) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2682 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2683 stepdir = -1; /* decrement address while putting pixels */ |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2684 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2685 else |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2686 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2687 stepdir = 1; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2688 } |
| 38 | 2689 |
| 2690 if(hgfx->Image->ImageWidth <= (hgfx->WindowX0 + cfg->Xdelta)) | |
| 2691 return 0x0000FFFF; | |
| 2692 | |
| 2693 // ----------------------------- | |
| 2694 found = 0; | |
| 2695 for(i=0;i<Font->length;i++) | |
| 2696 { | |
| 2697 if(Font->chars[i].code == character) | |
| 2698 { | |
| 2699 found = 1; | |
| 2700 break; | |
| 2701 } | |
| 2702 } | |
| 2703 if(!found) | |
| 2704 return cfg->Xdelta; | |
| 2705 // ----------------------------- | |
| 2706 /* | |
| 2707 if(Font == &Font144) | |
| 2708 cfg->Xdelta += 3; | |
| 2709 else | |
| 2710 if(Font == &Font84) | |
| 2711 cfg->Xdelta += 2; | |
| 2712 */ | |
| 2713 // ----------------------------- | |
| 2714 | |
| 2715 | |
| 2716 pSource = ((uint32_t)Font->chars[i].image->data); | |
| 119 | 2717 pDestination = (uint16_t*)(hgfx->Image->FBStartAdress); |
| 2718 | |
| 38 | 2719 |
| 2720 height = Font->chars[i].image->height; | |
| 2721 width = Font->chars[i].image->width; | |
| 2722 | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2723 OffsetDestination = hgfx->Image->ImageHeight - height; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2724 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2725 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2726 /* Xyyyyy y= height */ |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2727 /* Xyyyyy x= width */ |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2728 /* Xyyyyy */ |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2729 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2730 if(pSettings->FlipDisplay) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2731 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2732 pDestination += (hgfx->WindowX1 - cfg->Xdelta) * hgfx->Image->ImageHeight; /* set pointer to delta row */ |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2733 pDestination += (hgfx->WindowY1 - cfg->Ydelta); /* set pointer to delta colum */ |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2734 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2735 else |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2736 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2737 pDestination += (hgfx->WindowX0 + cfg->Xdelta) * hgfx->Image->ImageHeight; /* set pointer to delta row */ |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2738 pDestination += (hgfx->WindowY0 + cfg->Ydelta); /* set pointer to delta colum */ |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2739 } |
| 38 | 2740 |
| 2741 | |
| 2742 // ----------------------------- | |
| 2743 char_truncated_WidthFlag = 0; | |
| 2744 width_left = hgfx->Image->ImageWidth - (hgfx->WindowX0 + cfg->Xdelta); | |
| 2745 if(width_left < width) | |
| 2746 { | |
| 2747 char_truncated_WidthFlag = 1; | |
| 2748 width = width_left; | |
| 2749 } | |
| 2750 // ----------------------------- | |
| 2751 char_truncated_Height = 0; | |
| 2752 height_left = hgfx->Image->ImageHeight - (hgfx->WindowY0 + cfg->Ydelta); | |
| 2753 if(height_left < height) | |
| 2754 { | |
| 2755 char_truncated_Height = height - height_left; | |
| 2756 if((char_truncated_Height & 1) != 0) | |
| 2757 { | |
| 2758 height_left -= 1; | |
| 2759 char_truncated_Height += 1; | |
| 2760 } | |
| 2761 height = height_left; | |
| 2762 } | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2763 OffsetDestination += char_truncated_Height; |
| 38 | 2764 // ----------------------------- |
| 2765 if(height == 0) | |
| 2766 return 0x0000FFFF; | |
| 2767 // ----------------------------- | |
| 2768 | |
| 2769 if(cfg->singleSpaceWithSizeOfNextChar) | |
| 2770 { | |
| 2771 cfg->singleSpaceWithSizeOfNextChar = 0; | |
| 2772 | |
| 2773 if(cfg->invert) | |
| 2774 fill = 0xFF; | |
| 2775 else | |
| 2776 fill = 0; | |
| 2777 | |
| 2778 height /= 2; | |
| 2779 for(i = width; i > 0; i--) | |
| 2780 { | |
| 2781 for (j = height; j > 0; j--) | |
| 2782 { | |
| 119 | 2783 *(__IO uint16_t*)pDestination = fill << 8 | cfg->color; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2784 pDestination += stepdir; |
| 119 | 2785 *(__IO uint16_t*)pDestination = fill << 8 | cfg->color; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2786 pDestination += stepdir; |
| 38 | 2787 } |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2788 pDestination += stepdir * OffsetDestination; |
| 38 | 2789 } |
| 2790 } | |
| 2791 else | |
| 2792 if(cfg->invert) | |
| 2793 { | |
| 2794 if((height & 3) == 0) /* unroll for perfomance, by 4 if possible, by 2 (16bit) otherwise */ | |
| 2795 { | |
| 2796 height /= 4; | |
| 2797 for(i = width; i > 0; i--) | |
| 2798 { | |
| 2799 if(*(uint8_t*)pSource != 0x01) | |
| 2800 { | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2801 |
| 38 | 2802 for (j = height; j > 0; j--) |
| 2803 { | |
| 119 | 2804 *(__IO uint16_t*)pDestination = (0xFF - *(uint8_t*)pSource++) << 8 | cfg->color; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2805 pDestination += stepdir; |
| 119 | 2806 *(__IO uint16_t*)pDestination = (0xFF - *(uint8_t*)pSource++) << 8 | cfg->color; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2807 pDestination += stepdir; |
| 119 | 2808 *(__IO uint16_t*)pDestination = (0xFF - *(uint8_t*)pSource++) << 8 | cfg->color; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2809 pDestination += stepdir; |
| 119 | 2810 *(__IO uint16_t*)pDestination = (0xFF - *(uint8_t*)pSource++) << 8 | cfg->color; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2811 pDestination += stepdir; |
| 38 | 2812 } |
| 2813 pSource += char_truncated_Height; | |
| 2814 } | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2815 else /* empty line => fast fill */ |
| 38 | 2816 { |
| 2817 pSource++; | |
| 121 | 2818 fillpattern = (( 0xFF << 8 | cfg->color) << 16) | ( 0xFF << 8 | cfg->color); |
| 2819 if(pSettings->FlipDisplay) pDestination--; /* address fill from high to low */ | |
| 38 | 2820 for (j = height; j > 0; j--) |
| 2821 { | |
| 121 | 2822 *(__IO uint32_t*)pDestination = fillpattern; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2823 pDestination += stepdir; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2824 pDestination += stepdir; |
| 121 | 2825 *(__IO uint32_t*)pDestination = fillpattern; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2826 pDestination += stepdir; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2827 pDestination += stepdir; |
| 38 | 2828 } |
| 121 | 2829 if(pSettings->FlipDisplay) pDestination++; |
| 38 | 2830 } |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2831 pDestination += stepdir * OffsetDestination; |
| 38 | 2832 } |
| 2833 } | |
| 2834 else | |
| 2835 { | |
| 2836 height /= 2; | |
| 2837 for(i = width; i > 0; i--) | |
| 2838 { | |
| 2839 if(*(uint8_t*)pSource != 0x01) | |
| 2840 { | |
| 2841 for (j = height; j > 0; j--) | |
| 2842 { | |
| 119 | 2843 *(__IO uint16_t*)pDestination = (0xFF - *(uint8_t*)pSource++) << 8 | cfg->color; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2844 pDestination += stepdir; |
| 119 | 2845 *(__IO uint16_t*)pDestination = (0xFF - *(uint8_t*)pSource++) << 8 | cfg->color; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2846 pDestination += stepdir; |
| 38 | 2847 } |
| 2848 pSource += char_truncated_Height; | |
| 2849 } | |
| 2850 else | |
| 2851 { | |
| 2852 pSource++; | |
| 2853 for (j = height; j > 0; j--) | |
| 2854 { | |
| 119 | 2855 *(__IO uint16_t*)pDestination = 0xFF << 8 | cfg->color; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2856 pDestination += stepdir; |
| 119 | 2857 *(__IO uint16_t*)pDestination = 0xFF << 8 | cfg->color; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2858 pDestination += stepdir; |
| 38 | 2859 } |
| 2860 } | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2861 pDestination += stepdir * OffsetDestination; |
| 38 | 2862 } |
| 2863 } | |
| 2864 } | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2865 else /* not inverted */ |
| 38 | 2866 { |
| 2867 if((height & 3) == 0) /* unroll for perfomance, by 4 if possible, by 2 (16bit) otherwise */ | |
| 2868 { | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2869 |
| 38 | 2870 height /= 4; |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2871 |
| 38 | 2872 for(i = width; i > 0; i--) |
| 2873 { | |
| 2874 if(*(uint8_t*)pSource != 0x01) | |
| 2875 { | |
| 2876 for (j = height; j > 0; j--) | |
| 2877 { | |
| 119 | 2878 *(__IO uint16_t*)pDestination = ( *(uint8_t*)pSource++ << 8) | (cfg->color); |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2879 pDestination += stepdir; |
| 119 | 2880 *(__IO uint16_t*)pDestination = ( *(uint8_t*)pSource++ << 8) | (cfg->color); |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2881 pDestination += stepdir; |
| 119 | 2882 *(__IO uint16_t*)pDestination = ( *(uint8_t*)pSource++ << 8) | (cfg->color); |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2883 pDestination += stepdir; |
| 119 | 2884 *(__IO uint16_t*)pDestination = ( *(uint8_t*)pSource++ << 8) | (cfg->color); |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2885 pDestination += stepdir; |
| 38 | 2886 } |
| 121 | 2887 |
| 38 | 2888 pSource += char_truncated_Height; |
| 2889 } | |
| 119 | 2890 else /* clear line */ |
| 38 | 2891 { |
| 2892 pSource++; | |
| 121 | 2893 fillpattern = (cfg->color << 16) | cfg->color; |
| 2894 if(pSettings->FlipDisplay) pDestination--; /* address fill from high to low */ | |
| 2895 | |
| 119 | 2896 for (j = height; j > 0; j--) |
| 2897 { | |
| 121 | 2898 *(__IO uint32_t*)pDestination = fillpattern; |
| 119 | 2899 pDestination += stepdir; |
| 2900 pDestination += stepdir; | |
| 121 | 2901 *(__IO uint32_t*)pDestination = fillpattern; |
| 119 | 2902 pDestination += stepdir; |
| 2903 pDestination += stepdir; | |
| 2904 } | |
| 121 | 2905 if(pSettings->FlipDisplay) pDestination++; |
| 38 | 2906 } |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2907 pDestination += stepdir * OffsetDestination; |
| 38 | 2908 } |
| 2909 } | |
| 2910 else | |
| 2911 { | |
| 2912 height /= 2; | |
| 2913 for(i = width; i > 0; i--) | |
| 2914 { | |
| 2915 if(*(uint8_t*)pSource != 0x01) | |
| 2916 { | |
| 2917 for (j = height; j > 0; j--) | |
| 2918 { | |
| 119 | 2919 *(__IO uint16_t*)pDestination = ( *(uint8_t*)pSource++ << 8) | (cfg->color); |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2920 pDestination += stepdir; |
| 119 | 2921 *(__IO uint16_t*)pDestination = ( *(uint8_t*)pSource++ << 8) | (cfg->color); |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2922 pDestination += stepdir; |
| 38 | 2923 } |
| 2924 pSource += char_truncated_Height; | |
| 2925 } | |
| 119 | 2926 else /* clear line */ |
| 38 | 2927 { |
| 2928 pSource++; | |
| 119 | 2929 for (j = height; j > 0; j--) |
| 2930 { | |
| 2931 *(__IO uint16_t*)pDestination = cfg->color; | |
| 2932 pDestination += stepdir; | |
| 2933 *(__IO uint16_t*)pDestination = cfg->color; | |
| 2934 pDestination += stepdir; | |
| 2935 } | |
| 38 | 2936 } |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
2937 pDestination += stepdir * OffsetDestination; |
| 38 | 2938 } |
| 2939 } | |
| 2940 } | |
| 2941 | |
| 2942 // ----------------------------- | |
| 2943 | |
| 2944 if(Font == &FontT144) | |
| 2945 width += 3; | |
| 2946 else | |
| 2947 if(Font == &FontT105) | |
| 2948 width += 2; | |
| 2949 /* | |
| 2950 else | |
| 2951 if(Font == &Font144) | |
| 2952 width += 3; | |
| 2953 else | |
| 2954 if(Font == &Font84) | |
| 2955 width += 1; | |
| 2956 */ | |
| 2957 // ----------------------------- | |
| 2958 | |
| 2959 if(char_truncated_WidthFlag) | |
| 2960 return 0x0000FFFF; | |
| 2961 else | |
| 2962 return cfg->Xdelta + width; | |
| 2963 } | |
| 2964 | |
| 2965 | |
| 2966 /** | |
| 2967 ****************************************************************************** | |
| 2968 * @brief GFX write Modify helper for center and right align. | |
| 2969 * @author heinrichs weikamp gmbh | |
| 2970 * @version V0.0.1 | |
| 2971 * @date 17-March-2015 | |
| 2972 ****************************************************************************** | |
| 2973 * | |
| 2974 * @param *cText: output | |
| 2975 * @param *pTextInput: input | |
| 2976 * @param gfx_selected_language: gfx_selected_language | |
| 2977 * @retval counter and *cText content | |
| 2978 */ | |
|
297
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
2979 static int8_t GFX_write__Modify_helper(char *cText, const char *pTextInput, uint8_t gfx_selected_language) |
| 38 | 2980 { |
| 2981 uint32_t pText, backup; | |
| 2982 uint8_t textId; | |
| 2983 int8_t counter; | |
| 2984 uint32_t found; | |
| 2985 uint32_t j; | |
| 2986 | |
| 2987 pText = (uint32_t)pTextInput; | |
| 2988 counter = 0; | |
| 2989 while((counter < 100) && (*(char*)pText != 0) && (*(char*)pText != '\r')) | |
| 2990 { | |
| 2991 if((*(char*)pText) == TXT_2BYTE) | |
| 2992 { | |
| 2993 backup = pText; | |
| 2994 | |
| 2995 found = 0; | |
| 2996 j = 0; | |
| 2997 textId = (int8_t)*(char*)(pText + 1); | |
| 2998 if(textId != 0) | |
| 2999 { | |
| 3000 for(j=0;j<(uint8_t)TXT2BYTE_END-(uint8_t)TXT2BYTE_START;j++) | |
| 3001 { | |
| 3002 if((uint8_t)text_array2[j].code == (uint8_t)textId) | |
| 3003 { | |
| 3004 found = 1; | |
| 3005 break; | |
| 3006 } | |
| 3007 } | |
| 3008 if(found) | |
| 3009 { | |
| 3010 pText = (uint32_t)text_array2[j].text[gfx_selected_language]; | |
| 3011 if(!pText) | |
| 3012 pText = (uint32_t)text_array2[j].text[0]; | |
| 3013 else | |
| 3014 if(*(char*)pText == 0) | |
| 3015 pText = (uint32_t)text_array2[j].text[0]; | |
| 3016 | |
| 3017 while((counter < 100) && (*(char*)pText != 0)) | |
| 3018 cText[counter++] = *(char*)pText++; | |
| 3019 } | |
| 3020 pText = backup + 2; | |
| 3021 } | |
| 3022 else | |
| 3023 pText = 0; | |
| 3024 } | |
| 3025 if((*(char*)pText) & 0x80) | |
| 3026 { | |
| 3027 backup = pText; | |
| 3028 | |
| 3029 found = 0; | |
| 3030 j = 0; | |
| 3031 textId = (uint8_t)*(char*)pText; | |
| 3032 for(uint8_t ii=(uint8_t)TXT_Language;ii<(uint8_t)TXT_END;ii++) | |
| 3033 { | |
| 3034 if(text_array[j].code == textId) | |
| 3035 { | |
| 3036 found = 1; | |
| 3037 break; | |
| 3038 } | |
| 3039 j++; | |
| 3040 } | |
| 3041 if(found) | |
| 3042 { | |
| 3043 pText = (uint32_t)text_array[j].text[gfx_selected_language]; | |
| 3044 if(!pText) | |
| 3045 pText = (uint32_t)text_array[j].text[0]; | |
| 3046 else | |
| 3047 if(*(char*)pText == 0) | |
| 3048 pText = (uint32_t)text_array[j].text[0]; | |
| 3049 | |
| 3050 while((counter < 100) && (*(char*)pText != 0)) | |
| 3051 cText[counter++] = *(char*)pText++; | |
| 3052 } | |
| 3053 pText = backup + 1; | |
| 3054 } | |
| 3055 else | |
| 3056 { | |
| 3057 cText[counter++] = *(char*)pText++; | |
| 3058 } | |
| 3059 } | |
| 3060 cText[counter] = 0; | |
| 3061 return counter; | |
| 3062 } | |
| 3063 | |
| 3064 | |
| 3065 /** | |
| 3066 ****************************************************************************** | |
| 3067 * @brief GFX write Modify Ydelta for align. / calc Ydelta for start | |
| 3068 * @author heinrichs weikamp gmbh | |
| 3069 * @version V0.0.1 | |
| 3070 * @date 22-April-2014 | |
| 3071 ****************************************************************************** | |
| 3072 * | |
| 3073 * @param *hgfx: check gfx_engine.h. | |
| 3074 * @param *cfg: Ydelta, Font | |
| 3075 * @param *pText: character | |
| 3076 * @retval Ydelta: 0 if text has to start left ( and probably does not fit) | |
| 3077 */ | |
| 3078 | |
|
297
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
3079 static uint32_t GFX_write__Modify_Xdelta__Centered(GFX_CfgWriteString* cfg, GFX_DrawCfgWindow* hgfx, const char *pTextInput) |
| 38 | 3080 { |
| 3081 char cText[101]; | |
| 3082 uint32_t result; | |
| 3083 uint32_t Xsum; | |
| 3084 uint32_t i, j; | |
| 3085 uint8_t gfx_selected_language; | |
| 3086 uint32_t pText; | |
| 58 | 3087 uint16_t decodeUTF8; |
| 38 | 3088 |
| 3089 #ifndef BOOTLOADER_STANDALONE | |
| 3090 SSettings *pSettings; | |
| 3091 pSettings = settingsGetPointer(); | |
| 3092 gfx_selected_language = pSettings->selected_language; | |
| 3093 if(gfx_selected_language >= LANGUAGE_END) | |
| 3094 #endif | |
| 3095 gfx_selected_language = 0; | |
| 3096 // ----------------------------- | |
| 3097 | |
| 3098 GFX_write__Modify_helper(cText,pTextInput,gfx_selected_language); | |
| 3099 | |
| 3100 pText = (uint32_t)&cText[0]; | |
| 3101 Xsum = 0; | |
| 3102 j = 0; | |
| 3103 while (*(char*)pText != 0)// und fehlend: Abfrage window / image size | |
| 3104 { | |
| 58 | 3105 if((*(char*)pText) & 0x80) /* Identify a UNICODE character other than standard ASCII using the highest bit */ |
| 3106 { | |
| 3107 decodeUTF8 = ((*(char*)pText) & 0x1F) << 6; /* use 5bits of first byte for upper part of unicode */ | |
| 3108 pText++; | |
| 3109 decodeUTF8 |= (*(char*)pText) & 0x3F; /* add lower 6bits as second part of the unicode */ | |
| 3110 } | |
| 3111 else | |
| 3112 { | |
| 3113 decodeUTF8 = *(char*)pText; /* place ASCII char */ | |
| 3114 } | |
| 3115 | |
| 38 | 3116 for(i=0;i<((tFont *)cfg->font)->length;i++) |
| 3117 { | |
| 58 | 3118 if(((tFont *)cfg->font)->chars[i].code == decodeUTF8) |
| 38 | 3119 { |
| 3120 Xsum += ((tFont *)cfg->font)->chars[i].image->width; | |
| 3121 break; | |
| 3122 } | |
| 3123 } | |
| 3124 pText++; | |
| 3125 j++; | |
| 3126 if(((tFont *)cfg->font == &FontT144) && (*(char*)pText != 0)) | |
| 3127 Xsum += 3; | |
| 3128 else | |
| 3129 if(((tFont *)cfg->font == &FontT105) && (*(char*)pText != 0)) | |
| 3130 Xsum += 2; | |
| 3131 } | |
| 3132 pText -= j; | |
| 3133 | |
| 3134 if(cfg->doubleSize) | |
| 3135 Xsum *= 2; | |
| 3136 | |
| 3137 result = hgfx->WindowX1 - hgfx->WindowX0; | |
| 3138 if(Xsum < result) | |
| 3139 { | |
| 3140 result -= Xsum; | |
| 3141 result /= 2; | |
| 3142 } | |
| 3143 else | |
| 3144 result = 0; | |
| 3145 return result; | |
| 3146 } | |
| 3147 | |
| 3148 | |
|
297
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
3149 static uint32_t GFX_write__Modify_Xdelta__RightAlign(GFX_CfgWriteString* cfg, GFX_DrawCfgWindow* hgfx, const char *pTextInput) |
| 38 | 3150 { |
| 3151 char cText[101]; | |
| 3152 uint32_t result; | |
| 3153 uint32_t Xsum; | |
| 3154 uint32_t i, j; | |
| 3155 tFont *font; | |
| 3156 uint8_t gfx_selected_language; | |
| 3157 uint32_t pText; | |
| 3158 uint8_t setToTinyFont = 0; | |
| 58 | 3159 uint16_t decodeUTF8; |
| 38 | 3160 |
| 3161 #ifndef BOOTLOADER_STANDALONE | |
| 3162 SSettings *pSettings; | |
| 3163 pSettings = settingsGetPointer(); | |
| 3164 gfx_selected_language = pSettings->selected_language; | |
| 3165 if(gfx_selected_language >= LANGUAGE_END) | |
| 3166 #endif | |
| 3167 gfx_selected_language = 0; | |
| 3168 // ----------------------------- | |
| 3169 | |
| 3170 GFX_write__Modify_helper(cText,pTextInput,gfx_selected_language); | |
| 3171 pText = (uint32_t)&cText[0]; | |
| 3172 | |
| 3173 // ----------------------------- | |
| 3174 | |
| 3175 setToTinyFont = 0; | |
| 3176 font = (tFont *)cfg->font; | |
| 3177 Xsum = 0; | |
| 3178 j = 0; | |
| 3179 | |
| 3180 while (*(char*)pText != 0)// und fehlend: Abfrage window / image size | |
| 3181 { | |
| 3182 if((font == &FontT144) && (*(char*)pText == '.')) | |
| 3183 { | |
| 3184 font = (tFont *)&FontT84; | |
| 3185 } | |
| 3186 else | |
| 3187 if((font == &FontT105) && (*(char*)pText == '\16')) // two times to start tiny font | |
| 3188 { | |
| 3189 if(!setToTinyFont) | |
| 3190 setToTinyFont = 1; | |
| 3191 else | |
| 3192 font = (tFont *)&FontT54; | |
| 3193 } | |
| 3194 else | |
| 3195 if((font == &FontT105) && cfg->dualFont && ((*(char*)pText == '.') || (*(char*)pText == ':'))) | |
| 3196 { | |
| 3197 font = (tFont *)&FontT54; | |
| 3198 } | |
| 3199 | |
| 3200 if(*(char*)pText == ' ') | |
| 3201 { | |
| 3202 Xsum += font->spacesize; | |
| 3203 } | |
| 3204 else | |
| 3205 { | |
| 58 | 3206 if((*(char*)pText) & 0x80) /* Identify a UNICODE character other than standard ASCII using the highest bit */ |
| 3207 { | |
| 3208 decodeUTF8 = ((*(char*)pText) & 0x1F) << 6; /* use 5bits of first byte for upper part of unicode */ | |
| 3209 pText++; | |
| 3210 decodeUTF8 |= (*(char*)pText) & 0x3F; /* add lower 6bits as second part of the unicode */ | |
| 3211 } | |
| 3212 else | |
| 3213 { | |
| 3214 decodeUTF8 = *(char*)pText; | |
| 3215 } | |
| 38 | 3216 for(i=0;i<font->length;i++) |
| 3217 { | |
| 58 | 3218 if(font->chars[i].code == decodeUTF8) |
| 38 | 3219 { |
| 3220 Xsum += font->chars[i].image->width; | |
| 3221 break; | |
| 3222 } | |
| 3223 } | |
| 3224 } | |
| 3225 pText++; | |
| 3226 j++; | |
| 3227 if((font == &FontT144) && (*(char*)pText != 0)) | |
| 3228 Xsum += 3; | |
| 3229 else | |
| 3230 if((font == &FontT105) && (*(char*)pText != 0)) | |
| 3231 Xsum += 2; | |
| 3232 } | |
| 3233 pText -= j; | |
| 3234 | |
| 3235 if(cfg->doubleSize) | |
| 3236 Xsum *= 2; | |
| 3237 | |
| 3238 result = hgfx->WindowX1 - hgfx->WindowX0 - 1; | |
| 3239 if(Xsum < result) | |
| 3240 result -= Xsum; | |
| 3241 else | |
| 3242 result = 0; | |
| 3243 | |
| 3244 return result; | |
| 3245 } | |
| 3246 | |
| 3247 void GFX_LTDC_Init(void) | |
| 3248 { | |
| 3249 /* | |
| 3250 HSYNC=10 (9+1) | |
| 3251 HBP=10 (19-10+1) | |
| 3252 ActiveW=480 (499-10-10+1) | |
| 3253 HFP=8 (507-480-10-10+1) | |
| 3254 | |
| 3255 VSYNC=2 (1+1) | |
| 3256 VBP=2 (3-2+1) | |
| 3257 ActiveH=800 (803-2-2+1) | |
| 3258 VFP=2 (805-800-2-2+1) | |
| 3259 */ | |
| 3260 | |
| 3261 /* Timing configuration */ | |
| 3262 /* Horizontal synchronization width = Hsync - 1 */ | |
| 3263 LtdcHandle.Init.HorizontalSync = 9; | |
| 3264 /* Vertical synchronization height = Vsync - 1 */ | |
| 3265 LtdcHandle.Init.VerticalSync = 1; | |
| 3266 /* Accumulated horizontal back porch = Hsync + HBP - 1 */ | |
| 3267 LtdcHandle.Init.AccumulatedHBP = 19; | |
| 3268 /* Accumulated vertical back porch = Vsync + VBP - 1 */ | |
| 3269 LtdcHandle.Init.AccumulatedVBP = 3; | |
| 3270 /* Accumulated active width = Hsync + HBP + Active Width - 1 */ | |
| 3271 LtdcHandle.Init.AccumulatedActiveW = 499;//500;//499; | |
| 3272 /* Accumulated active height = Vsync + VBP + Active Heigh - 1 */ | |
| 3273 LtdcHandle.Init.AccumulatedActiveH = 803; | |
| 3274 /* Total width = Hsync + HBP + Active Width + HFP - 1 */ | |
| 3275 LtdcHandle.Init.TotalWidth = 507;//508;//507; | |
| 3276 /* Total height = Vsync + VBP + Active Heigh + VFP - 1 */ | |
| 3277 LtdcHandle.Init.TotalHeigh = 805; | |
| 3278 | |
| 3279 /* Configure R,G,B component values for LCD background color */ | |
| 3280 LtdcHandle.Init.Backcolor.Red= 0; | |
| 3281 LtdcHandle.Init.Backcolor.Blue= 0; | |
| 3282 LtdcHandle.Init.Backcolor.Green= 0; | |
| 3283 | |
| 3284 /* LCD clock configuration */ | |
| 3285 /* PLLSAI_VCO Input = HSE_VALUE/PLL_M = 1 Mhz */ | |
| 3286 /* PLLSAI_VCO Output = PLLSAI_VCO Input * PLLSAIN = 192 Mhz */ | |
| 3287 /* PLLLCDCLK = PLLSAI_VCO Output/PLLSAIR = 192/4 = 48 Mhz */ | |
| 3288 /* LTDC clock frequency = PLLLCDCLK / LTDC_PLLSAI_DIVR_8 = 48/4 = 6Mhz */ | |
| 3289 | |
| 3290 /* done in main.c SystemClockConfig | |
| 3291 | |
| 3292 PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LTDC; | |
| 3293 PeriphClkInitStruct.PLLSAI.PLLSAIN = 192; | |
| 3294 PeriphClkInitStruct.PLLSAI.PLLSAIR = 4; | |
| 3295 PeriphClkInitStruct.PLLSAIDivR = RCC_PLLSAIDIVR_8; | |
| 3296 HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct); | |
| 3297 */ | |
| 3298 /* Polarity */ | |
| 3299 LtdcHandle.Init.HSPolarity = LTDC_HSPOLARITY_AL; | |
| 3300 LtdcHandle.Init.VSPolarity = LTDC_VSPOLARITY_AL; | |
| 3301 LtdcHandle.Init.DEPolarity = LTDC_DEPOLARITY_AL; | |
| 3302 LtdcHandle.Init.PCPolarity = LTDC_PCPOLARITY_IIPC;//LTDC_PCPOLARITY_IPC; | |
| 3303 | |
| 3304 LtdcHandle.Instance = LTDC; | |
| 3305 | |
| 3306 /* Configure the LTDC */ | |
| 3307 if(HAL_LTDC_Init(&LtdcHandle) != HAL_OK) // auch init der GPIO Pins | |
| 3308 { | |
| 3309 /* Initialization Error */ | |
| 3310 GFX_Error_Handler(); | |
| 3311 } | |
| 3312 } | |
| 3313 | |
| 3314 void GFX_LTDC_LayerDefaultInit(uint16_t LayerIndex, uint32_t FB_Address) | |
| 3315 { | |
| 3316 LTDC_LayerCfgTypeDef Layercfg; | |
| 3317 | |
| 3318 /* Layer Init */ | |
| 3319 Layercfg.WindowX0 = 0; | |
| 3320 Layercfg.WindowX1 = 480; | |
| 3321 Layercfg.WindowY0 = 0; | |
| 3322 Layercfg.WindowY1 = 800; | |
| 3323 Layercfg.PixelFormat = LTDC_PIXEL_FORMAT_AL88;//LTDC_PIXEL_FORMAT_ARGB8888; | |
| 3324 Layercfg.FBStartAdress = FB_Address; | |
| 3325 Layercfg.Alpha = 255; | |
| 3326 Layercfg.Alpha0 = 0; | |
| 3327 Layercfg.Backcolor.Blue = 0; | |
| 3328 Layercfg.Backcolor.Green = 0; | |
| 3329 Layercfg.Backcolor.Red = 0; | |
| 3330 Layercfg.BlendingFactor1 = LTDC_BLENDING_FACTOR1_PAxCA; | |
| 3331 Layercfg.BlendingFactor2 = LTDC_BLENDING_FACTOR2_PAxCA; | |
| 3332 Layercfg.ImageWidth = 480; | |
| 3333 Layercfg.ImageHeight = 800; | |
| 3334 | |
| 3335 HAL_LTDC_ConfigCLUT(&LtdcHandle, ColorLUT, CLUT_END, LayerIndex); | |
| 3336 HAL_LTDC_ConfigLayer(&LtdcHandle, &Layercfg, LayerIndex); | |
| 3337 HAL_LTDC_EnableCLUT(&LtdcHandle, LayerIndex); | |
| 3338 } | |
| 3339 | |
|
297
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
3340 static uint32_t GFX_doubleBufferOne(void) |
| 38 | 3341 { |
| 3342 return SDRAM_DOUBLE_BUFFER_ONE; | |
| 3343 } | |
| 3344 | |
| 3345 | |
|
297
87d54b4fd946
cleanup: remove unused code, make static, remove commented code
Jan Mulder <jlmulder@xs4all.nl>
parents:
296
diff
changeset
|
3346 static uint32_t GFX_doubleBufferTwo(void) |
| 38 | 3347 { |
| 3348 return SDRAM_DOUBLE_BUFFER_TWO; | |
| 3349 } | |
| 3350 | |
| 3351 uint32_t getFrame(uint8_t callerId) | |
| 3352 { | |
| 3353 uint8_t i; | |
| 3354 | |
| 3355 i = 0; | |
| 3356 while((i < MAXFRAMES) && (frame[i].status != CLEAR)) | |
| 3357 i++; | |
| 3358 | |
| 3359 if((i < MAXFRAMES) && (frame[i].status == CLEAR)) | |
| 3360 { | |
| 3361 frame[i].status = BLOCKED; | |
| 3362 frame[i].caller = callerId; | |
| 3363 return frame[i].StartAddress; | |
| 3364 } | |
| 3365 | |
| 3366 i = 0; | |
| 3367 while((i < MAXFRAMES) && (frame[i].status != RELEASED)) | |
| 3368 i++; | |
| 3369 | |
| 3370 if((i < MAXFRAMES) && (frame[i].status == RELEASED)) | |
| 3371 { | |
| 3372 GFX_clear_frame_immediately(frame[i].StartAddress); | |
| 3373 frame[i].status = BLOCKED; | |
| 3374 return frame[i].StartAddress; | |
| 3375 } | |
| 3376 return 0; | |
| 3377 } | |
| 3378 | |
| 3379 | |
| 3380 void GFX_forceReleaseFramesWithId(uint8_t callerId) | |
| 3381 { | |
| 3382 for(int i=0; i<MAXFRAMES; i++) | |
| 3383 if((frame[i].caller == callerId) && (frame[i].status == BLOCKED)) | |
| 3384 frame[i].status = RELEASED; | |
| 3385 } | |
| 3386 | |
| 3387 | |
| 3388 void releaseAllFramesExcept(uint8_t callerId, uint32_t frameStartAddress) | |
| 3389 { | |
| 3390 for(int i=0; i<MAXFRAMES; i++) | |
| 3391 if((frame[i].caller == callerId) && (frame[i].status == BLOCKED) && (frame[i].StartAddress != frameStartAddress)) | |
| 3392 frame[i].status = RELEASED; | |
| 3393 } | |
| 3394 | |
| 3395 | |
| 3396 uint8_t releaseFrame(uint8_t callerId, uint32_t frameStartAddress) | |
| 3397 { | |
| 3398 static uint8_t countErrorCalls = 0; | |
| 3399 | |
| 3400 if(frameStartAddress < FBGlobalStart) | |
| 3401 return 2; | |
| 3402 | |
| 3403 | |
| 3404 uint8_t i; | |
| 3405 | |
| 3406 i = 0; | |
| 3407 while((i < MAXFRAMES) && (frame[i].StartAddress != frameStartAddress)) | |
| 3408 i++; | |
| 3409 | |
| 3410 if((i < MAXFRAMES) && (frame[i].StartAddress == frameStartAddress)) | |
| 3411 { | |
| 3412 if(frame[i].caller == callerId) | |
| 3413 { | |
| 3414 frame[i].status = RELEASED; | |
| 3415 return 1; | |
| 3416 } | |
| 3417 else | |
| 3418 countErrorCalls++; | |
| 3419 } | |
| 3420 return 0; | |
| 3421 } | |
| 3422 | |
| 3423 | |
| 3424 uint16_t blockedFramesCount(void) | |
| 3425 { | |
| 3426 uint16_t count = MAXFRAMES; | |
| 3427 | |
| 3428 for(int i = 0;i<MAXFRAMES;i++) | |
| 3429 if(frame[i].status == BLOCKED) | |
| 3430 count--; | |
| 3431 | |
| 3432 return count; | |
| 3433 } | |
| 3434 | |
| 3435 | |
| 3436 void housekeepingFrame(void) | |
| 3437 { | |
| 3438 static uint8_t countLogClear = 0; | |
| 3439 | |
| 3440 if(DMA2D_at_work != 255) | |
| 3441 return; | |
| 3442 | |
| 3443 /* new for debug hw 151202 */ | |
| 3444 for(int i=1;i<MAXFRAMECOUNTER;i++) | |
| 3445 { | |
| 3446 frameCounter[i] = 0; | |
| 3447 } | |
| 3448 for(int i=1;i<MAXFRAMES;i++) | |
| 3449 { | |
| 3450 if(frame[i].status == BLOCKED) | |
| 3451 { | |
| 3452 if(frame[i].caller < (MAXFRAMECOUNTER - 2)) | |
| 3453 frameCounter[frame[i].caller]++; | |
| 3454 else | |
| 3455 frameCounter[MAXFRAMECOUNTER-3]++; | |
| 3456 } | |
| 3457 else | |
| 3458 if(frame[i].status == RELEASED) | |
| 3459 frameCounter[MAXFRAMECOUNTER-2]++; | |
| 3460 else | |
| 3461 frameCounter[MAXFRAMECOUNTER-1]++; | |
| 3462 } | |
| 3463 | |
| 3464 | |
| 3465 uint8_t i; | |
| 3466 | |
| 3467 i = 0; | |
| 3468 while((i < MAXFRAMES) && ((frame[i].status != RELEASED) || (frame[i].StartAddress == GFX_get_pActualFrameTop()) || (frame[i].StartAddress == GFX_get_pActualFrameBottom()))) | |
| 3469 i++; | |
| 3470 | |
| 3471 if((i < MAXFRAMES) && (frame[i].status == RELEASED)) | |
| 3472 { | |
| 3473 if(frame[i].caller == 15) | |
| 3474 countLogClear++; | |
| 3475 GFX_clear_frame_dma2d(i); | |
| 3476 } | |
| 3477 } | |
| 3478 | |
| 3479 | |
| 3480 static void GFX_Dma2d_TransferComplete(DMA2D_HandleTypeDef* Dma2dHandle) | |
| 3481 { | |
| 3482 if(DMA2D_at_work < MAXFRAMES) | |
| 3483 frame[DMA2D_at_work].status = CLEAR; | |
| 3484 | |
| 3485 DMA2D_at_work = 255; | |
| 3486 } | |
| 3487 | |
| 3488 | |
| 3489 static void GFX_Dma2d_TransferError(DMA2D_HandleTypeDef* Dma2dHandle) | |
| 3490 { | |
| 3491 | |
| 3492 } | |
| 3493 | |
| 3494 static void GFX_Error_Handler(void) | |
| 3495 { | |
| 3496 /* Turn LED3 on */ | |
| 3497 // BSP_LED_On(LED3); | |
| 3498 while(1) | |
| 3499 { | |
| 3500 } | |
| 3501 } | |
| 3502 | |
| 3503 void write_content_simple(GFX_DrawCfgScreen *tMscreen, uint16_t XleftGimpStyle, uint16_t XrightGimpStyle, uint16_t YtopGimpStyle, const tFont *Font, const char *text, uint8_t color) | |
| 3504 { | |
| 3505 GFX_DrawCfgWindow hgfx; | |
| 3506 | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3507 SSettings* pSettings; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3508 pSettings = settingsGetPointer(); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3509 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3510 if(!pSettings->FlipDisplay) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3511 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3512 if(XrightGimpStyle > 799) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3513 XrightGimpStyle = 799; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3514 if(XleftGimpStyle >= XrightGimpStyle) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3515 XleftGimpStyle = 0; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3516 if(YtopGimpStyle > 479) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3517 YtopGimpStyle = 479; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3518 } |
| 38 | 3519 hgfx.Image = tMscreen; |
| 3520 hgfx.WindowNumberOfTextLines = 1; | |
| 3521 hgfx.WindowLineSpacing = 0; | |
| 3522 hgfx.WindowTab = 0; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3523 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3524 if(!pSettings->FlipDisplay) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3525 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3526 hgfx.WindowX0 = XleftGimpStyle; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3527 hgfx.WindowX1 = XrightGimpStyle; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3528 hgfx.WindowY1 = 479 - YtopGimpStyle; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3529 if(hgfx.WindowY1 < Font->height) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3530 hgfx.WindowY0 = 0; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3531 else |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3532 hgfx.WindowY0 = hgfx.WindowY1 - Font->height; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3533 } |
| 38 | 3534 else |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3535 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3536 hgfx.WindowX0 = 800 - XrightGimpStyle; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3537 hgfx.WindowX1 = 800 - XleftGimpStyle; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3538 hgfx.WindowY0 = YtopGimpStyle; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3539 if(hgfx.WindowY0 + Font->height >= 479) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3540 hgfx.WindowY1 = 479; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3541 else |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3542 hgfx.WindowY1 = hgfx.WindowY0 + Font->height; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3543 } |
| 38 | 3544 GFX_write_string_color(Font, &hgfx, text, 0, color); |
| 3545 } | |
| 3546 | |
| 3547 | |
| 3548 void gfx_write_topline_simple(GFX_DrawCfgScreen *tMscreen, const char *text, uint8_t color) | |
| 3549 { | |
| 3550 GFX_DrawCfgWindow hgfx; | |
| 3551 const tFont *Font = &FontT48; | |
| 3552 | |
| 3553 hgfx.Image = tMscreen; | |
| 3554 hgfx.WindowNumberOfTextLines = 1; | |
| 3555 hgfx.WindowLineSpacing = 0; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3556 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3557 SSettings* pSettings; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3558 pSettings = settingsGetPointer(); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3559 |
| 38 | 3560 hgfx.WindowTab = 0; |
| 3561 hgfx.WindowX0 = 20; | |
| 3562 hgfx.WindowX1 = 779; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3563 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3564 if(!pSettings->FlipDisplay) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3565 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3566 hgfx.WindowY1 = 479; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3567 hgfx.WindowY0 = hgfx.WindowY1 - Font->height; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3568 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3569 else |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3570 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3571 hgfx.WindowY0 = 0; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3572 hgfx.WindowY1 = Font->height; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3573 } |
| 38 | 3574 GFX_write_label(Font, &hgfx, text, color); |
| 3575 } | |
| 3576 | |
| 3577 | |
| 3578 void gfx_write_page_number(GFX_DrawCfgScreen *tMscreen, uint8_t page, uint8_t total, uint8_t color) | |
| 3579 { | |
| 3580 GFX_DrawCfgWindow hgfx; | |
| 3581 const tFont *Font = &FontT48; | |
| 3582 char text[7]; | |
| 3583 uint8_t i, secondDigitPage, secondDigitTotal; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3584 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3585 SSettings* pSettings; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3586 pSettings = settingsGetPointer(); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3587 |
| 38 | 3588 hgfx.Image = tMscreen; |
| 3589 hgfx.WindowNumberOfTextLines = 1; | |
| 3590 hgfx.WindowLineSpacing = 0; | |
| 3591 hgfx.WindowTab = 0; | |
|
110
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3592 |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3593 if(!pSettings->FlipDisplay) |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3594 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3595 hgfx.WindowX1 = 779; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3596 hgfx.WindowX0 = hgfx.WindowX1 - (25*5); |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3597 hgfx.WindowY1 = 479; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3598 hgfx.WindowY0 = hgfx.WindowY1 - Font->height; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3599 } |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3600 else |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3601 { |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3602 hgfx.WindowX1 = 25*5; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3603 hgfx.WindowX0 = 0; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3604 hgfx.WindowY1 = Font->height;; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3605 hgfx.WindowY0 = 0; |
|
cc8e24374b83
Added option to handled mirrored display to existing functions
Ideenmodellierer
parents:
58
diff
changeset
|
3606 } |
| 38 | 3607 if(page > 99) |
| 3608 page = 99; | |
| 3609 if(total > 99) | |
| 3610 total = 99; | |
| 3611 | |
| 3612 i = 0; | |
| 3613 text[i++] = '\002'; | |
| 3614 | |
| 3615 secondDigitPage = page / 10; | |
| 3616 page -= secondDigitPage * 10; | |
| 3617 | |
| 3618 secondDigitTotal = total / 10; | |
| 3619 total -= secondDigitTotal * 10; | |
| 3620 | |
| 3621 if(secondDigitPage) | |
| 3622 text[i++] = '0' + secondDigitPage; | |
| 3623 text[i++] = '0' + page; | |
| 3624 | |
| 3625 text[i++] = '/'; | |
| 3626 | |
| 3627 if(secondDigitTotal) | |
| 3628 text[i++] = '0' + secondDigitTotal; | |
| 3629 text[i++] = '0' + total; | |
| 3630 | |
| 3631 text[i] = 0; | |
| 3632 | |
| 3633 GFX_clear_window_immediately(&hgfx); | |
| 3634 GFX_write_label(Font, &hgfx, text, color); | |
| 3635 } | |
| 3636 | |
| 3637 | |
| 3638 uint8_t gfx_number_to_string(uint8_t max_digits, _Bool fill, char *pText, uint32_t input) | |
| 3639 { | |
| 3640 uint8_t digits[10]; | |
| 3641 uint32_t number, divider; | |
| 3642 int first; | |
| 3643 uint8_t out; | |
| 3644 | |
| 3645 number = input; | |
| 3646 first = 0; | |
| 3647 divider = 1000000000; | |
| 3648 for(int i=9;i>=0;i--) | |
| 3649 { | |
| 3650 digits[i] = (uint8_t)(number / divider); | |
| 3651 number -= digits[i] * divider; | |
| 3652 divider /= 10; | |
| 3653 if((first == 0) && (digits[i] != 0)) | |
| 3654 first = i; | |
| 3655 } | |
| 3656 | |
| 3657 if((first + 1) > max_digits) | |
| 3658 { | |
| 3659 for(int i = 0; i<max_digits; i++) | |
| 3660 pText[i] = '9'; | |
| 3661 out = max_digits; | |
| 3662 } | |
| 3663 else if(fill) | |
| 3664 { | |
| 3665 int i = 0; | |
| 3666 for(int k = max_digits; k>0; k--) | |
| 3667 pText[i++] = digits[k -1] + '0'; | |
| 3668 out = max_digits; | |
| 3669 } | |
| 3670 else | |
| 3671 { | |
| 3672 int i = 0; | |
| 3673 for(int k = first; k>=0; k--) | |
| 3674 pText[i++] = digits[k] + '0'; | |
| 3675 out = i; | |
| 3676 } | |
| 3677 | |
| 3678 return out; | |
| 3679 } | |
| 3680 | |
| 3681 | |
| 3682 /* output is | |
| 3683 * 0-> | |
| 3684 * | | |
| 3685 * v | |
| 3686 * | |
| 3687 * input is | |
| 3688 * | |
| 3689 * -> | |
| 3690 * A | |
| 3691 * | | |
| 3692 * 0 | |
| 3693 */ | |
| 3694 void GFX_screenshot(void) | |
| 3695 { | |
| 3696 uint32_t pSource = GFX_get_pActualFrameTop(); | |
| 3697 uint32_t pSourceBottom =GFX_get_pActualFrameBottom(); | |
| 3698 uint32_t pBottomNew = getFrame(99); | |
| 3699 uint32_t pDestination = GFX_doubleBufferOne(); | |
| 3700 uint32_t sourceNow; | |
| 3701 | |
| 3702 | |
| 3703 uint32_t bot_leftStart = FrameHandler.actualBottom.leftStart; // x0 z.B. 0 | |
| 3704 uint32_t bot_bottomStart = FrameHandler.actualBottom.bottomStart; // y0 z.B. 25 | |
| 3705 uint32_t bot_width = FrameHandler.actualBottom.width; // 800 | |
| 3706 uint32_t bot_height = FrameHandler.actualBottom.height; // 390 | |
| 3707 | |
| 3708 struct split | |
| 3709 { | |
| 3710 uint8_t blue; | |
| 3711 uint8_t green; | |
| 3712 uint8_t red; | |
| 3713 uint8_t alpha; | |
| 3714 }; | |
| 3715 | |
| 3716 union inout_u | |
| 3717 { | |
| 3718 uint32_t in; | |
| 3719 struct split out; | |
| 3720 }; | |
| 3721 | |
| 3722 union inout_u value; | |
| 3723 | |
| 3724 /* test | |
| 3725 uint32_t pSourceTemp = pSource + (2*479); | |
| 3726 for (int j = 0xFFFF; j > 0x00FF; j -= 0x0100) | |
| 3727 { | |
| 3728 *(__IO uint16_t*)pSourceTemp = j; | |
| 3729 pSourceTemp += 480*2; | |
| 3730 } | |
| 3731 */ | |
| 3732 // Top Layer | |
| 3733 const unsigned width = 800, height = 480; | |
| 3734 const uint32_t heightX2 = height*2; | |
| 3735 | |
| 3736 for(unsigned y = 0; y < height; y++) | |
| 3737 { | |
| 3738 sourceNow = pSource + 2 * ((height - 1) - y); | |
| 3739 for(unsigned x = 0; x < width; x++) | |
| 3740 { | |
| 3741 // sourceNow += 2 * height * x + 2 * (height - 1 - y); | |
| 3742 value.in = ColorLUT[*(__IO uint8_t*)(sourceNow)]; | |
| 3743 value.out.alpha = *(__IO uint8_t*)(sourceNow + 1); | |
| 3744 | |
| 3745 *(__IO uint8_t*)(pDestination++) = value.out.red; | |
| 3746 *(__IO uint8_t*)(pDestination++) = value.out.green; | |
| 3747 *(__IO uint8_t*)(pDestination++) = value.out.blue; | |
| 3748 *(__IO uint8_t*)(pDestination++) = value.out.alpha; | |
| 3749 sourceNow += heightX2; | |
| 3750 } | |
| 3751 } | |
| 3752 | |
| 3753 // Bottom Layer | |
| 3754 // build newBottom | |
| 3755 pSource = pSourceBottom; | |
| 3756 for(unsigned x = bot_leftStart; x < bot_leftStart+bot_width; x++) | |
| 3757 { | |
| 3758 for(unsigned y = bot_bottomStart; y < bot_bottomStart+bot_height; y++) | |
| 3759 { | |
| 3760 pDestination = pBottomNew + (2 * y); | |
| 3761 pDestination += heightX2 * x; | |
| 3762 *(__IO uint16_t*)(pDestination) = *(__IO uint16_t*)(pSource); | |
| 3763 pSource += 2; | |
| 3764 } | |
| 3765 } | |
| 3766 | |
| 3767 // output Bottom Layer | |
| 3768 pSource = pBottomNew; | |
| 3769 pDestination = GFX_doubleBufferTwo(); | |
| 3770 | |
| 3771 for(unsigned y = 0; y < height; y++) | |
| 3772 { | |
| 3773 sourceNow = pSource + 2 * ((height - 1) - y); | |
| 3774 for(unsigned x = 0; x < width; x++) | |
| 3775 { | |
| 3776 // sourceNow = pSource + 2 * height * x + 2 * (height - 1 - y); | |
| 3777 value.in = ColorLUT[*(__IO uint8_t*)(sourceNow)]; | |
| 3778 value.out.alpha = *(__IO uint8_t*)(sourceNow + 1); | |
| 3779 | |
| 3780 *(__IO uint8_t*)(pDestination++) = value.out.red; | |
| 3781 *(__IO uint8_t*)(pDestination++) = value.out.green; | |
| 3782 *(__IO uint8_t*)(pDestination++) = value.out.blue; | |
| 3783 *(__IO uint8_t*)(pDestination++) = value.out.alpha; | |
| 3784 sourceNow += heightX2; | |
| 3785 } | |
| 3786 } | |
| 3787 releaseFrame(99,pBottomNew); | |
| 3788 /* | |
| 3789 // das kommt dazu! | |
| 3790 unsigned yEnd = 480 - FrameHandler.actualBottom.bottomStart; | |
| 3791 unsigned yStart = yEnd - FrameHandler.actualBottom.height; | |
| 3792 | |
| 3793 if(yStart > 0) | |
| 3794 { | |
| 3795 for(unsigned y = 0; y < yStart; y++) | |
| 3796 for(unsigned x = 0; x < width; x++) | |
| 3797 { | |
| 3798 *(__IO uint8_t*)(pDestination++) = 0; | |
| 3799 *(__IO uint8_t*)(pDestination++) = 0; | |
| 3800 *(__IO uint8_t*)(pDestination++) = 0; | |
| 3801 *(__IO uint8_t*)(pDestination++) = 0; | |
| 3802 } | |
| 3803 } | |
| 3804 for(unsigned y = yStart; y < yEnd; y++) | |
| 3805 for(unsigned x = 0; x < width; x++) | |
| 3806 { | |
| 3807 sourceNow = pSource + 2 * height * x + 2 * (height - 1 - y); | |
| 3808 value.in = ColorLUT[*(__IO uint8_t*)(sourceNow)]; | |
| 3809 value.out.alpha = *(__IO uint8_t*)(sourceNow + 1); | |
| 3810 | |
| 3811 *(__IO uint8_t*)(pDestination++) = value.out.red; | |
| 3812 *(__IO uint8_t*)(pDestination++) = value.out.green; | |
| 3813 *(__IO uint8_t*)(pDestination++) = value.out.blue; | |
| 3814 *(__IO uint8_t*)(pDestination++) = value.out.alpha; | |
| 3815 } | |
| 3816 if(yEnd < 480) | |
| 3817 { | |
| 3818 for(unsigned y = yEnd; y < 480; y++) | |
| 3819 for(unsigned x = 0; x < width; x++) | |
| 3820 { | |
| 3821 *(__IO uint8_t*)(pDestination++) = 0; | |
| 3822 *(__IO uint8_t*)(pDestination++) = 0; | |
| 3823 *(__IO uint8_t*)(pDestination++) = 0; | |
| 3824 *(__IO uint8_t*)(pDestination++) = 0; | |
| 3825 } | |
| 3826 } | |
| 3827 */ | |
| 3828 } |