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