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