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