FreeCalypso > hg > leo2moko-debug
view g23m/condat/com/src/driver/display_obsolete.c @ 25:0a6d65238088 default tip
use neutralized version of bootloader.lib
| author | Space Falcon <falcon@ivan.Harhan.ORG> |
|---|---|
| date | Mon, 07 Sep 2015 18:21:02 +0000 |
| parents | 509db1a7b7b8 |
| children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | Project : | Modul : display.c +----------------------------------------------------------------------------- | Copyright 2002 Texas Instruments Berlin, AG | All rights reserved. | | This file is confidential and a trade secret of Texas | Instruments Berlin, AG | The receipt of or possession of this file does not convey | any rights to reproduce or disclose its contents or to | manufacture, use, or sell anything it may describe, in | whole, or in part, without the specific written consent of | Texas Instruments Berlin, AG. +----------------------------------------------------------------------------- | Purpose : +----------------------------------------------------------------------------- */ /* July 1, 2005 REF: CRR 32677 - xpradipg Description: Alignmnet of the display for each row. Send the un negated value to LCD driver Solution: The alignment of the display is corrected by decreasing the number of columns by 1. The negated value is corrected and sent to the driver June 03, 2005 REF: GSM-ENH-31636 xpradipg Description: Change the board ID for Isample to 71 and add new defination for the CALLISTO with baord ID 70 Solution: Add the definition of ALLISTO with board ID 70 and change the board Id to 71 for Isample Mar 30, 2005 REF: CRR 29986 xpradipg Description: Optimisation 1: Removal of unused variables and dynamically allocate/ deallocate mbndata Solution: removed the unused variable pictureCopy_col and the static qualifier so as to be accessed by the ATB module CRR 28825: xpradipg - 11 Feb 2005 Description:Extension of GDI-for display of ISample and code cleanup Solution: The code replication for D_Sample and E_sample are removed and a new flag is added for the ISample. currently the BOARD ID is set to 70 for CALLISTO and 71 for ISample. GW 31/01/03 - Added support for 16 bit LCD buffer - Split DSAMPLE_COLOUR code into DSAMPLE_COLOUR32 (original 32bits/pixel) and DSAMPLE_COLOUR16 (16 bits/pixel - untested) Removed CSAMPLE_COLOUR option Removed 'PLOT' option for D-sample - too slow to be useful */ #ifndef DRV_DSPL_C #define DRV_DSPL_C #endif /*==== INCLUDES ===================================================*/ #define ENTITY_CST #include <string.h> #if defined (WIN32) #include <stdio.h> #endif #include "typedefs.h" #include "gdi.h" #include "dspl.h" #include "font_bitmaps.h" #include "vsi.h" #include "custom.h" #include "gsm.h" #include "prim.h" #include "p_mmi.h" #include "tok.h" #include "cst/cst.h" #include "os.h" #include "rvf/rvf_api.h" #undef R2D_ENABLED #ifndef _SIMULATION_ #if (defined(_TARGET_) && (BOARD!=10) && (BOARD!=34)&& (BOARD!=35)&& (BOARD!=46)) /* * R2D is not supported by EP2 module (BOARD == 10, of customer 6351/36) * and by Avenger2/Perseus1 board (BOARD == 34). (dbachran / 2002-11-27) * and by P2 board (BOARD == 35) and F-sample (BOARD == 46) (rsauer / 2004-05-27) */ #define R2D_ENABLED #endif #endif #ifndef _SIMULATION_ #ifdef R2D_ENABLED #include "r2d/r2d.h" #include "r2d/r2d_config.h" #endif #endif /* GW enable/disable trace using the MMI */ /* NB. Traces are only for diagnostics while developing and must be removed for code deliveries!*/ /* defining mmi_trace as <empty> will remove them */ //#define MMI_TRACE #define mmi_trace //void mmi_trace(char* str); /*==== EXPORT =====================================================*/ #define ENCODE_OFFSET 24 //define EASY_TEXT_ENABLED /************************************************************************ * The following macros define what hardware we are running on and what * * drivers are being used to drive the display * * BSAMPLE - 84x48 display * * CSAMPLE - 84x48 display * * CSAMPLE_COLOUR - no longer supported * * DSAMPLE - 176x220 display which can be driven as 16 bit colour or b+w * * DSAMPLE_COLOUR - colour display * * DSAMPLE_COLOUR16 - 16 bits per pixel displayed * * NB. This has not been tested at all - it * * may not display correctly or may crash * * although it does not crash when enabled * * with the 32bit drivers) * * * * DSAMPLE_COLOUR32 - 32 bits per pixel displayed (16 bits are * * zero and have no effect) * * DSAMPLE_LITE - 1 bit per pixel (b+w display) * * GW SPR#1840 25/03/03 * * Also, the compiler switches have been added to allow us to develop * * the MMI for a different final format (b+w/smaller display). * * COLOURDISPLAY - If not defined - all output is to be b+w * * LSCREEN - If not defined - screen is 'small' - use the 8x6 font * *************************************************************************/ #if (defined(_TARGET_)) //#if (BOARD==33) #if ((BOARD == 8) || (BOARD == 9)) #define CSAMPLE #elif ((BOARD == 40) || (BOARD == 41)) #define DSAMPLE #elif (BOARD == 43) #define ESAMPLE //June 03, 2005 REF: GSM-ENH-31636 xpradipg #elif (BOARD == 70) #define CALLISTO //CRR 28825: xpradipg - 11 Feb 2005 #elif (BOARD == 71) // LCD enabling of ISAMPLE #define ISAMPLE #else //Other board type #define BSAMPLE #endif #else //_TARGET_ not defined //Not running on hardware - select the hw for simulation purposes. #define BSAMPLE //Also, if not already disabled - disable trace code #ifdef MMI_TRACE #undef MMI_TRACE #endif #endif //June 03, 2005 REF: GSM-ENH-31636 xpradipg //CRR 28825: xpradipg - 11 Feb 2005 #if (defined(DSAMPLE) || defined(ESAMPLE) || defined(ISAMPLE) || defined(CALLISTO)) /* For a start, we use exactly the same definitions for E-Sample as we do for D-Sample. IMPORTANT: If the E-Sample LCD differs from D-Sample, the following lines must be properly adapted! */ #if (R2D_LCD_DISPLAY == R2D_COLOR) #define DSAMPLE_COLOUR #if (R2D_PIXEL_POS_TO_BIT_POS == 5) #define DSAMPLE_COLOUR32 #endif #if (R2D_PIXEL_POS_TO_BIT_POS == 4) #define DSAMPLE_COLOUR16 #endif #else #define DSAMPLE_LITE #undef COLOURDISPLAY #endif #endif /* ESAMPLE */ //Ensure that if the H/W does not support colour, the compiler option is overridden //- we can display b+w only on a colour display but not the other way round #ifndef DSAMPLE_COLOUR #ifdef COLOURDISPLAY #undef COLOURDISPLAY #endif #endif /* USE_PLOT - Defined if we are to use r2d_draw_point to output a display This method will always produce a display (of sorts) but can be very slow USE_BLIT_RECT - Defined if we provide a 24 bit colour display and allow the riviera code to translate into the LCD format. USE_BUFFER - This must be defined if USE_BLIT_RECT is being used. This will require an image of the colour display to be stored in local memory. If neither are defined then we must create our buffer in the same format as the LCD. NB if 'USE_BLIT_RECT' is not defined, any changes to the h/w or driver software will have an impact on the code below. */ /*==== CONSTANTS ==================================================*/ // Mar 30, 2005 REF: CRR 29986 xpradipg // removed the static qualifier to be accessed by the ATB module. #ifdef FF_MMI_OPTIM const int translation_ascii_2_unicode[256] = { #else static const int translation_ascii_2_unicode[256] = { #endif 0x0000, 0x00A4, 0x00d8, 0xFFFF, 0x0394, 0x03A8, 0x00BF, 0x00F8, 0xFFFF, 0xFFFF, 0x000A, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026,0x0027, 0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F, 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F, 0x0040,0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F, /* SPR#2034 - SH */ 0xFFFF, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F, 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007A, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x00C7, 0x00FC, 0x00E9, 0x00E4, 0x00E0, 0x00E5, 0xFFFF, 0xFFFF, 0xFFFF, 0x00E8, 0xFFFF, 0xFFFF, 0x00EC, 0x00C4, 0x00C5, 0x00C9, 0x00E6, 0x00C6, 0xFFFF, 0x00F6, 0x00F2, 0xFFFF, 0x00F9, 0xFFFF, 0x00D6, 0x00DC, 0xFFFF, 0x00A3, 0x00A5, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x00F1, 0x00D1, 0xFFFF, 0xFFFF, 0x00A7, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x00A1, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x00DF, 0x0393, 0x03A0, 0x03A3, 0xFFFF, 0xFFFF, 0xFFFF, 0x03A6, 0x0398, 0x03A9, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x039B, 0x039E, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF }; /*==== VARIABLES ==================================================*/ //EXTERN UBYTE extDisplay; /* external display ? */ EXTERN UBYTE extDisplay; /* external display ? */ GLOBAL UBYTE dspl_char_type; /* * We don't need display.c with ACI-only builds, but CST references extDisplay * above, so we need to keep that one for now. * Only process this file, if MMI is set to 1 (SMI) or 2 (BMI). */ #if (MMI != 0) GLOBAL dspl_DevCaps displayData; #if defined (NEW_FRAME) EXTERN T_HANDLE hCommL1; #else EXTERN T_VSI_CHANDLE hCommL1; #endif static int scrEnabled = 0; /* screen update enable */ static int txtInvert = 0; //Text invert static T_HANDLE mmi_handle; static T_HANDLE hCommMMI = VSI_ERROR; /*==== FUNCTIONS ==================================================*/ /* * send to external Display */ LOCAL void dspl_SendDisplayReq (USHORT x, USHORT y, char *text); GLOBAL void kbd_test (UBYTE key); /* * TI driver functions */ extern void LCD_SetPower (void); extern void LCD_Reset (void); extern void LCD_Enable (int); extern void LCD_Clear (void); extern void LCD_WriteString (int y, int x, char *s); extern void LCD_PixBlt (int x, int y, int w, int h, char *bmp); extern void LCD_DrawIcon (int x, int y, char id); extern void LCD_TranslateBitmap (int w, int h, char *bo, char *bt); extern void LCD_Cursor (int row, int col); GLOBAL void rt_ExtPrimitive ( USHORT TaskHandle, USHORT DestComHandle, char *ExtDest, OS_QDATA *Msg ); /* * Internal Functions for Graphic Driver (Workaround) */ LOCAL void scrInit (void); LOCAL void scrExit (void); LOCAL void scrSize (int *x, int *y); #if (!CUST)//JVJE #if (CUST==1) LOCAL void scrClear (void); #endif LOCAL void scrClearRect (int px, int py, int sx, int sy); LOCAL void scrText (int x, int y, char *txt); LOCAL void scrText_Unicode (int x, int y, USHORT *txt); LOCAL void scrLine (int px, int py, int sx, int sy); LOCAL void scrRect (int px, int py, int sx, int sy); LOCAL int scrFntSelect (int font); LOCAL int scrFntHeight (void); LOCAL int scrFntGetFit (char *tp, int lineWidth); LOCAL int scrFntGetLen (char *tp, int nChars); LOCAL int scrBmpDraw (int px, int py, int sx, int sy, int ix, char *bm, int mode); LOCAL void scrCurType (int type); LOCAL void scrCursor (int x, int y); //accessible from outside e.g 3th application MMS void scrPoint (int px, int py, int col); LOCAL int scrUpdate (int onOff); LOCAL void scrText_Invert_Unicode (int x, int y, USHORT *txt); /*kk*/ LOCAL int checkPixelColour(int px, int py, U32 col); LOCAL void scrLCDUpdate (void); void scrText_Invert (int x, int y, char *txt); void scrDrawFilledRect (int px, int py, int sx, int sy, U32 col); int scrGetRealLength(char *str, int* totChar, int* totPixel); LOCAL void scrUnfocusDisplay(void); void dspl_show_bitmap(int x, int y,t_font_bitmap* current_bitmap,U32 attr ); GLOBAL UBYTE dspl_SetWindow(USHORT in_X1, USHORT in_Y1, USHORT in_X2, USHORT in_Y2); /*==== CONSTANTS ==================================================*/ /******************************************************************* * * * PART I: Driver Interface * * * *******************************************************************/ /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_Init | +--------------------------------------------------------------------+ PURPOSE : The function initializes the driverīs internal data. The function returns DRV_INITIALIZED if the driver has already been initialized and is ready to be used or already in use. In case of an initialization failure, which means that the driver cannot be used, the function returns DRV_INITFAILURE. */ GLOBAL UBYTE dspl_Init (void) { /* * Default is character Display */ displayData.DisplayType = DSPL_TYPE_CHARACTER; if (!extDisplay) /* use internal display */ { #if defined (SIMULATE_LCD) LCD_Reset (); /* use character oriented display */ LCD_Enable (1); LCD_Clear (); scrInit(); /* we need this also for glob vars, kk 14.02.2000*/ #else scrInit(); /* use graphic display */ #endif } else #if defined (SIMULATE_LCD) LCD_Enable (0); #else scrExit(); #endif return DRV_OK; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_Exit | +--------------------------------------------------------------------+ PURPOSE : The function is called when the driver functionality is not longer needed. The function "de-allocates" all allocated resources and finalizes the driver. */ GLOBAL void dspl_Exit (void) { scrExit(); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_Clear | +--------------------------------------------------------------------+ PURPOSE : This function is used to clear a specific region of the display using the current background colour. The region is specified by the upper left corner (X1, Y1) and the lower right corner (X2, Y2) inclusive. The background color can be set using dspl_SetBkgColor () function. */ GLOBAL UBYTE dspl_Clear (USHORT in_X1, USHORT in_Y1, USHORT in_X2, USHORT in_Y2) { scrClearRect ((int)in_X1,(int)in_Y1,(int)(in_X2-in_X1+1),(int)(in_Y2-in_Y1+1)); return DRV_OK; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_Clear | +--------------------------------------------------------------------+ PURPOSE : This function is used to clear a specific region of the display using the current background colour. The region is specified by the upper left corner (X1, Y1) and the lower right corner (X2, Y2) inclusive. The background color can be set using dspl_SetBkgColor () function. */ GLOBAL UBYTE dspl_ClearAll (void) { #if (!CUST) scrClear (); #endif return DRV_OK; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6147) MODULE : SMI_WM | | STATE : code ROUTINE : dspl_UnfocusDisplay | +--------------------------------------------------------------------+ PURPOSE : Calls the function that will cause the entire display to appear much darker, allowing the pop-up dialog to be more clearly the focus especially the softkeys. GW #2294 23/07/03 - Created */ GLOBAL UBYTE dspl_unfocusDisplay (void) { scrUnfocusDisplay(); return DRV_OK; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_Enable | +--------------------------------------------------------------------+ PURPOSE : The function is used to turn the display on or off. While a display is switched off, it is possible to perform any drawing function. */ GLOBAL UBYTE dspl_Enable (UBYTE in_Enable) { return scrUpdate (in_Enable); } /* xreddymn Apr-07-2005 MMI-SPR-29655: Added function to update region +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_Enable_Region | +--------------------------------------------------------------------+ PURPOSE : The function is used to update a region on the screen */ void dspl_Enable_Region(INT16 x1, INT16 y1, INT16 x2, INT16 y2) { #ifdef R2D_ENABLED r2d_flush_region(x1, y1, x2, y2); #endif } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_GetDeviceCaps | +--------------------------------------------------------------------+ PURPOSE : This function is used to retrieve the capabilities of the display device including the dimensions of the display and the logical unit in which the dimensions is measured. */ GLOBAL void dspl_GetDeviceCaps (dspl_DevCaps * out_DeviceCapsPtr) { int x,y; scrSize (&x, &y); out_DeviceCapsPtr->Height = (USHORT)y; out_DeviceCapsPtr->Width = (USHORT)x; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_SetDeviceCaps | +--------------------------------------------------------------------+ PURPOSE : This function is used to set the capabilities of the display device including the dimensions of the display and the logical unit in which the dimensions is measured. */ GLOBAL void dspl_SetDeviceCaps (dspl_DevCaps * in_DeviceCapsPtr) { displayData.DisplayType = in_DeviceCapsPtr->DisplayType; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_GetIconImage | +--------------------------------------------------------------------+ PURPOSE : This function is used to copy the image of a driver internal icon into an application specific icon buffer. The icon may modify the icon. In case of a successful completion the function returns DRV_OK. In case the size of the buffer where the icon image shall be copied is too small the driver returns DRV_INVALID_PARAMS. In case a specific driver implementation does not support this functionality the driver returns DSPL_FCT_NOTSUPPORTED. */ GLOBAL UBYTE dspl_GetIconImage (UBYTE in_Icon, USHORT in_Size, UBYTE * out_IconImagePtr) { return DSPL_FCT_NOTSUPPORTED; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_SetCursor | +--------------------------------------------------------------------+ PURPOSE : This function is used to change the current cursor settings. These settings include the type of cursor and the mode (e.g. static cursor, not flashing). A set of standard types and modes is defined. */ GLOBAL UBYTE dspl_SetCursor (UBYTE in_CursorType, UBYTE in_CursorMode) { return DRV_OK; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_SetCursorPos | +--------------------------------------------------------------------+ PURPOSE : This function is used to set the current cursor position. If the function succeeds, the cursor is set to the new position. If one of the values is out of range, the function returns DRV_INVALID_PARAMS. The number of rows and columns the display supports can be retrieved using the function dspl_GetDevCaps(). The upper left corner has the coordinates 0,0. The values in_X and in_Y are measured in logical units depending on the capabilities of the device. The means a graphical display will use pixels. GW 05/09/01 Added size x and size y parameters to allow for chinese chars. */ GLOBAL UBYTE dspl_SetCursorPos (USHORT in_X, USHORT in_Y, USHORT in_SizeX, USHORT in_SizeY ) { if (displayData.DisplayType EQ DSPL_TYPE_CHARACTER) { LCD_Cursor (in_Y, in_X); /* set cursor position */ if (extDisplay) /* if external display */ dspl_SendDisplayReq (in_X, in_Y, NULL); } else scrLine(in_X,in_Y+in_SizeY-1,in_X+in_SizeX-1,in_Y+in_SizeY-1); return DRV_OK; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_ShowCursor | +--------------------------------------------------------------------+ PURPOSE : This function is used to change the status of the cursor. The cursor can be visible or invisible. The function returns the previous status of the cursor. */ GLOBAL UBYTE dspl_ShowCursor (UBYTE in_Show) { return DSPL_CURSOR_VISIBLE; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_SetBkgColor | +--------------------------------------------------------------------+ PURPOSE : This function is used to change the color used for background painting. If the color is out of range, the driver returns DRV_INVALID_PARAMS and leaves the color unchanged. */ GLOBAL UBYTE dspl_SetBkgColor (UBYTE in_Color) { return DRV_OK; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_SetFrgColor | +--------------------------------------------------------------------+ PURPOSE : This function is used to change the color used for foreground painting, e.g. text color. If the color is out of range, the driver returns DRV_INVALID_PARAMS and leaves the color unchanged. set a call-back function which */ GLOBAL UBYTE dspl_SetFrgColor (UBYTE in_Color) { return DSPL_FCT_NOTSUPPORTED; } enum { COL_TYPE_FGD =0, COL_TYPE_BGD, COL_TYPE_HIGHLIGHT, COL_TYPE_BORDER, COL_TYPE_SHADOW, MAX_COL_TYPE }; enum { COL_CMD_INIT, COL_CMD_GET, COL_CMD_SET, COL_CMD_SETSHADOW, COL_CMD_RESTORECOL, MAX_COL_CMD }; //This definition allows us to have a transparent colour in 256 colour bitmaps. //We lose the colour nearly-black gray but I don't think it will be missed! //Better to lose white than gray but will require all icons to be updated! #define TRANSPARENT_256_COL 0x25 //This definition allows us to have a transparent colour in 16bit LCD colour bitmaps. //We lose almost white R=0xF8 G=0xFC B=0xF8. NB word is inverted #define TRANSPARENT_16BIT_COL 0x0020 //using ARGB format, transparent = 0xFFxxxxxx #define TRANSPARENT_32BIT_COLOUR 0xFF000000 //Hide colours LOCAL U32 colour_class (int cmd, int colId, U32 inColour) { static U32 g_col[MAX_COL_TYPE]; static U32 g_colOld[MAX_COL_TYPE]; switch (cmd) { case COL_CMD_INIT: colour_class(COL_CMD_SET, COL_TYPE_FGD, 0x00404040 ); colour_class(COL_CMD_SET, COL_TYPE_BGD, 0x00FFFFFF ); //white colour_class(COL_CMD_SET, COL_TYPE_HIGHLIGHT, 0x00FF00FF ); colour_class(COL_CMD_SET, COL_TYPE_BORDER, 0x00FFFFFF ); colour_class(COL_CMD_SET, COL_TYPE_SHADOW, 0x40010101 ); //50% translucency return (0); break; case COL_CMD_SET: if (inColour != 0) { g_colOld[colId] = g_col[colId]; g_col[colId] = inColour; } return(g_colOld[colId]); break; case COL_CMD_GET: #ifdef COLOURDISPLAY #ifdef DSAMPLE_COLOUR return(g_col[colId]); #endif #else switch (colId) { case COL_TYPE_FGD: return (0x00FFFFFF); case COL_TYPE_BGD: return (0x00000000); case COL_TYPE_HIGHLIGHT: return (0x00000000); case COL_TYPE_BORDER: return (0x00000000); case COL_TYPE_SHADOW: return (0x00000000); default: return (0); } #endif break; case COL_CMD_SETSHADOW: g_colOld[colId] = g_col[colId];//currently we dont really need to save the old value // set shadow to 50% black g_col[colId] = 0x40010101;// | ((inColour >> 2) & 0x003F3F3F); return(0x40010101); break; case COL_CMD_RESTORECOL: g_col[colId] = g_colOld[colId]; return (0); break; default: break; } return (0); } GLOBAL U32 dspl_SetFgdColour (U32 inColour) { return (colour_class(COL_CMD_SET, COL_TYPE_FGD, inColour)); } GLOBAL U32 dspl_SetBgdColour (U32 inColour) { return (colour_class(COL_CMD_SET, COL_TYPE_BGD, inColour)); } GLOBAL U32 dspl_SetHighlightColour (U32 inColour) { return (colour_class(COL_CMD_SET, COL_TYPE_HIGHLIGHT, inColour)); } GLOBAL U32 dspl_SetBorderColour (U32 inColour) { return (colour_class(COL_CMD_SET, COL_TYPE_BORDER, inColour)); } GLOBAL U32 dspl_SetShadowColour (U32 inColour) { return (colour_class(COL_CMD_SETSHADOW, COL_TYPE_SHADOW, inColour)); } GLOBAL U32 dspl_GetFgdColour ( void ) { return (colour_class(COL_CMD_GET, COL_TYPE_FGD, 0)); } GLOBAL U32 dspl_GetBgdColour ( void ) { return (colour_class(COL_CMD_GET, COL_TYPE_BGD, 0)); } GLOBAL U32 dspl_GetHighlightColour ( void ) { return (colour_class(COL_CMD_GET, COL_TYPE_HIGHLIGHT, 0)); } GLOBAL U32 dspl_GetBorderColour ( void ) { return (colour_class(COL_CMD_GET, COL_TYPE_BORDER, 0)); } GLOBAL U32 dspl_GetShadowColour (void) { return (colour_class(COL_CMD_GET, COL_TYPE_SHADOW, 0)); } GLOBAL void dspl_InitColour (void) { colour_class(COL_CMD_INIT, 0, 0); } GLOBAL void dspl_RestoreColour (void) { colour_class(COL_CMD_RESTORECOL, COL_TYPE_FGD, 0); colour_class(COL_CMD_RESTORECOL, COL_TYPE_BGD, 0); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_DrawIcon | +--------------------------------------------------------------------+ PURPOSE : This function is used to draw a driver internal icon. The origin of the icon is the upper left corner, defined by the parameters in_X/in_Y. */ GLOBAL UBYTE dspl_DrawIcon (UBYTE in_IconID, USHORT in_X, USHORT in_Y) { return DSPL_FCT_NOTSUPPORTED; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_DrawLine | +--------------------------------------------------------------------+ PURPOSE : This function is used to draw a line from a specific location defined by the parameters in_X1/in_Y1, to a specific location defined by the parameters in_X2/in_Y2. The displayīs origin is the upper left corner with the co-ordinates (0,0). The function uses the current foreground color, which can be set using the dspl_SetFrgColor (), to draw the line. */ GLOBAL UBYTE dspl_DrawLine (USHORT in_X1, USHORT in_Y1, USHORT in_X2, USHORT in_Y2) { scrLine(in_X1,in_Y1,in_X2,in_Y2); return DRV_OK; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_DrawRect | +--------------------------------------------------------------------+ PURPOSE : This function is used to draw a rectangle. The upper left corner of the rectangle is defined by the parameters in_X1/in_Y1. The lower right corner of the rectangle is defined by the parameters in_X2/in_Y2. The displayīs origin is the upper left corner with the co-ordinates (0,0). The function uses the current foreground color, which can be set using the dspl_SetFrgColor (), to draw the rectangle. */ GLOBAL UBYTE dspl_roundRectFill (int px, int py, int sx, int sy, int border) { int i,j,col; col = dspl_GetBgdColour(); scrDrawFilledRect(px-border,py, sx+border*2,sy, col ); scrDrawFilledRect(px,py-border, sx,sy+border*2, col ); for (i=0;i<border;i++) for (j=0;j<border-i;j++) { scrPoint(px-i, py-j,col); scrPoint(px+sx+i, py-j,col); scrPoint(px+sx+i, py+sy+j,col); scrPoint(px-i, py+sy+j,col); } return DRV_OK; } GLOBAL UBYTE dspl_roundRect (int px, int py, int sx, int sy, int border) { scrLine(px ,py-border, px+sx,py-border); scrLine(px,py+sy+border, px+sx,py+sy+border); scrLine(px-border ,py, px-border,py+sy); scrLine(px+sx+border,py, px+sx+border,py+sy); scrLine(px ,py-border, px-border ,py ); scrLine(px,py+sy+border, px-border,py+sy ); scrLine(px+sx,py+sy+border, px+sx+border,py+sy ); scrLine(px+sx+border,py, px+sx,py-border ); return DRV_OK; } GLOBAL UBYTE dspl_DrawRect (USHORT in_X1, USHORT in_Y1, USHORT in_X2, USHORT in_Y2) { scrRect(in_X1,in_Y1,in_X2-in_X1,in_Y2-in_Y1); return DRV_OK; } GLOBAL UBYTE dspl_DrawFilledRect (USHORT in_X1, USHORT in_Y1, USHORT in_X2, USHORT in_Y2) { scrDrawFilledRect(in_X1,in_Y1,in_X2-in_X1,in_Y2-in_Y1, dspl_GetFgdColour() ); return DRV_OK; } GLOBAL UBYTE dspl_DrawFilledBgdRect (USHORT in_X1, USHORT in_Y1, USHORT in_X2, USHORT in_Y2) { scrDrawFilledRect(in_X1,in_Y1,in_X2-in_X1,in_Y2-in_Y1, dspl_GetBgdColour() ); return DRV_OK; } GLOBAL UBYTE dspl_DrawFilledColRect (USHORT in_X1, USHORT in_Y1, USHORT in_X2, USHORT in_Y2, U32 Col) { scrDrawFilledRect(in_X1,in_Y1,in_X2-in_X1,in_Y2-in_Y1, Col ); return DRV_OK; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_DrawEllipse | +--------------------------------------------------------------------+ PURPOSE : This function is used to draw an ellipse. The center of the ellipse is the center of the bounding rectangle specified by the parameters. The displayīs origin is the upper left corner with the co-ordinates (0,0). The function uses the current foreground color, which can be set using the dspl_SetFrgColor (), to draw the ellipse. */ GLOBAL UBYTE dspl_DrawEllipse (USHORT in_X1, USHORT in_Y1, USHORT in_X2, USHORT in_Y2) { return DSPL_FCT_NOTSUPPORTED; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_BitBlt | +--------------------------------------------------------------------+ PURPOSE : This function is used to display a bitmap at the specified location using the raster operation provided. The bitmap format is customer specific but must include the size of the bitmap. */ GLOBAL UBYTE dspl_BitBlt2(short in_X, short in_Y, USHORT in_Width, USHORT in_Height, void * in_BmpPtr, USHORT in_index, int bmpFormat) { t_font_bitmap current_bitmap; char *bmpPtr; int bmpSize; int fScale = 1; int attr = SHOWBITMAP_NORMAL; bmpPtr = (char *)in_BmpPtr; if (bmpFormat == BMP_FORMAT_256_COLOUR) { bmpSize = in_Height*in_Width; //bitmaps are 256 colour bmpPtr = &bmpPtr[bmpSize*in_index]; //for bitmaps that have multiple states } else if (bmpFormat == BMP_FORMAT_32BIT_COLOUR) { bmpSize = in_Height*in_Width; //bitmaps are 256 colour bmpPtr = &bmpPtr[bmpSize*in_index]; //for bitmaps that have multiple states } else if (bmpFormat == BMP_FORMAT_16BIT_LCD_COLOUR) { #ifdef DSAMPLE_COLOUR32 fastCopyBitmap(in_X,in_Y, // start position of bitmap in_Width, in_Height, //size of bitmap (char*) in_BmpPtr, in_X,in_Y, // start position of output area in_Width, in_Height, //size of output area dspl_GetBgdColour(), bmpFormat); return DRV_OK; #else bmpSize = in_Height*in_Width*4; //bitmaps are 16bit colour bmpPtr = &bmpPtr[bmpSize*in_index]; //for bitmaps that have multiple states #endif } else if (bmpFormat == BMP_FORMAT_16BIT_LCD_COMPRESSED_COLOUR) { #ifdef DSAMPLE_COLOUR16 fastCopyBitmap(in_X,in_Y, // start position of bitmap in_Width, in_Height, //size of bitmap (char*) in_BmpPtr, in_X,in_Y, // start position of output area in_Width, in_Height, //size of output area dspl_GetBgdColour(), bmpFormat); return DRV_OK; #else bmpSize = in_Height*in_Width*2; //bitmaps are 16bit colour bmpPtr = &bmpPtr[bmpSize*in_index]; //for bitmaps that have multiple states #endif } else //b+w image { #ifdef MMI_TRACE mmi_trace("b+w image"); #endif if (bmpFormat == BMP_FORMAT_BW_2x4 ) { //Temp fix to display larger b+w bitmaps (160x124) attr = SHOWBITMAP_SCALE_2x4; in_Width = in_Width /2; in_Height = in_Height /4; #ifdef MMI_TRACE mmi_trace("Icontype = scale 2x4"); #endif } bmpSize = in_Height*((in_Width+7) >> 3); //bitmaps are unpacked bmpPtr = &bmpPtr[bmpSize*in_index]; //for bitmaps that have multiple states } current_bitmap.height = in_Height; current_bitmap.width = in_Width; current_bitmap.bitmapSize = 0;// bmpSize; current_bitmap.bitmap = bmpPtr; current_bitmap.format = bmpFormat; dspl_show_bitmap(in_X,in_Y, ¤t_bitmap, attr); return DRV_OK; } GLOBAL UBYTE dspl_BitBlt (USHORT in_X, USHORT in_Y, USHORT in_Width, USHORT in_Height, USHORT in_Index, void * in_BmpPtr, USHORT in_Rop) { #ifdef BSAMPLE //Use old procedure scrBmpDraw ((int)in_X, (int) in_Y, (int) in_Width, (int)in_Height, (int)in_Index, (char *)in_BmpPtr, (int)in_Rop); return DRV_OK; #else return (dspl_BitBlt2( (short) in_X, (short) in_Y, in_Width, in_Height, in_BmpPtr, in_Index, BMP_FORMAT_BW_UNPACKED)); #endif } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_SelectFontbyID | +--------------------------------------------------------------------+ PURPOSE : This function is used to select a font used for displaying text. Text can be displayed using the functions dspl_TextOut_Cmode. Driver specific fonts are identified be a font ID (parameter in_Font). The definition of fonts and font identifiers is not in scope of G23. Fonts and font identifiers have to be defined by the customer. The specific implementation of the display driver and the MMI using the driver have the knowledge about the available fonts, their identification and how to use them. */ GLOBAL UBYTE dspl_SelectFontbyID (UBYTE in_Font) { return DSPL_FCT_NOTSUPPORTED; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_SelectFontbyImage | +--------------------------------------------------------------------+ PURPOSE : This function is used to select a font used for displaying text. Text can be displayed using the functions dspl_TextOut_Cmode. Application specific fonts are identified by the parameter in_FontPtr, the address of the buffer containing the application specific font. The structure of the font image in not in the scope of G23. The structure of the font images have to be defined by the customer implementing the driver. */ GLOBAL UBYTE dspl_SelectFontbyImage (UBYTE * in_FontPtr) { return DSPL_FCT_NOTSUPPORTED; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_GetFontImage | +--------------------------------------------------------------------+ PURPOSE : This function is used to copy the image of a font into an application specific font buffer. The application may modify the font. In case of a successful completion the function returns DRV_OK. In case the size of the buffer where the font image shall be copied to is too small the driver returns DRV_INVALID_PARAMS. In case a specific driver implementation does not support this functionality the driver returns DSPL_FCT_NOTSUPPORTED. */ GLOBAL UBYTE dspl_GetFontImage (UBYTE in_Font, USHORT in_Size, UBYTE * out_FontPtr) { return DSPL_FCT_NOTSUPPORTED; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_GetFontHeight | +--------------------------------------------------------------------+ PURPOSE : This function is used to retrieve the vertical size of the currently selected font. The function returns the height measured in logical units depending on the device capabilities (e.g. pixels or multiple of characters). Call the function dspl_SelectFont() to select a font. */ GLOBAL UBYTE dspl_GetFontHeight (void) { return scrFntHeight(); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_GetTextExtent | +--------------------------------------------------------------------+ PURPOSE : This function is used to calculate the size of a 0-terminated string, to which the parameter in_Text points. The function returns the size needed to display the text. The value of the size is measured in units depending on the device capabilities (e.g. pixels or multiple of characters). Call the function dspl_SelectFont() to select a font. */ GLOBAL USHORT dspl_GetTextExtent_old (char * in_Text, USHORT in_Length) { if (displayData.DisplayType EQ DSPL_TYPE_CHARACTER) return in_Length; else return scrFntGetLen ( in_Text, ( int ) in_Length ); } GLOBAL USHORT dspl_GetTextExtent (char * in_Text, USHORT in_Length) { int nPixel=0; int nChar = in_Length; if (in_Text==NULL) return(0); if (displayData.DisplayType EQ DSPL_TYPE_CHARACTER ) { return in_Length; } scrGetRealLength(in_Text, &nChar, &nPixel); return (nPixel); } int dspl_GetTextExtent2 (char * in_Text, USHORT in_Length) { return (dspl_GetTextExtent ( in_Text, in_Length)); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_GetNcharToFit | +--------------------------------------------------------------------+ PURPOSE : This function is used to calculate the number of characters of the input string that will fit into the specified width. */ /*SPR 1541, added function*/ //Calculate number of chars that fit in the available space. GLOBAL USHORT dspl_GetNcharToFit (char * in_Text, USHORT pixelWidth) { int nPixel=pixelWidth; int nChar= 0; if (in_Text==NULL) return(0); scrGetRealLength(in_Text, &nChar, &nPixel); return (nChar); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_GetMaxTextLen | +--------------------------------------------------------------------+ PURPOSE : This function is used to calculate the sub-string (number of characters) of a 0-terminated string (in_Text) that can be displayed in the region given by the parameter in_HSize. The value of in_HSize is measured in logical units (e.g. pixels or multiple of characters). Call the function dspl_SelectFont() to select a font. */ GLOBAL USHORT dspl_GetMaxTextLen (char * in_Text, USHORT in_HSize) { if (displayData.DisplayType EQ DSPL_TYPE_CHARACTER) return strlen (in_Text); else return scrFntGetFit ( in_Text, ( int ) in_HSize ); } GLOBAL void dspl_set_char_type(UBYTE char_type){ dspl_char_type = char_type; } GLOBAL UBYTE dspl_get_char_type(void){ return dspl_char_type; } int dspl_getDisplayType( void ) { #ifndef COLOURDISPLAY return (DSPL_BW); #endif #ifdef R2D_ENABLED if (R2D_LCD_DISPLAY == R2D_COLOR) return (DSPL_COLOUR); else #endif return (DSPL_BW); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_TextOut_Cmode | +--------------------------------------------------------------------+ PURPOSE : This function is used to display a text at the given location in_X/in_Y uding the defined attributes (in_Attrib) and the currently selected color (foreground and background). The cursor position is left unchanged. The driver will not take the displays bounding rectangle into consideration and therefore text may be cut off. Linefeeds and carriage returns are not supported and there- fore must be handled by upper layers. GW 14/02/03 - SPR#1736 Modified code to call 'dspl_ScrText' to allow a border to be drawn round chinese characters. */ GLOBAL UBYTE dspl_TextOut_Cmode (USHORT in_X, USHORT in_Y, UBYTE in_Attrib, char * in_Text) { int in_X_signed; int in_Y_signed; int txtStyle=0; // SH - If we want signed coordinates (i.e. if x and y can have negative numbers) // we need to convert the unsigned values into two's complement. if (in_Attrib & DSPL_TXTATTR_SIGNED_COORDS) { in_X_signed = (SHORT)in_X; in_Y_signed = (SHORT)in_Y; } else { in_X_signed = in_X; in_Y_signed = in_Y; } #if defined (WIN32) if (scrEnabled) { if (in_Attrib & DSPL_TXTATTR_INVERS) { scrText_Invert(in_X, in_Y, in_Text); } else { scrText(in_X, in_Y, in_Text); } } else LCD_WriteString (in_Y, in_X, (UBYTE *) in_Text); #else if (displayData.DisplayType EQ DSPL_TYPE_CHARACTER) { if (in_Attrib & DSPL_TXTATTR_INVERS) { if (dspl_char_type == DSPL_TYPE_ASCII) scrText_Invert(6 * in_X + 2, 8 * in_Y, in_Text); else scrText_Invert_Unicode(12 * in_X + 2, 12 * in_Y,(USHORT*) in_Text); } else { if (dspl_char_type == DSPL_TYPE_ASCII) scrText(6 * in_X_signed + 2, 8 * in_Y_signed, in_Text); else scrText_Unicode(12 * in_X_signed + 2, 12 * in_Y_signed, (USHORT*)in_Text); } } else { txtStyle = 0; if (in_Attrib & DSPL_TXTATTR_INVERS) txtStyle = TXT_STYLE_INVERT; else txtStyle = TXT_STYLE_NORMAL; if (dspl_char_type != DSPL_TYPE_ASCII) txtStyle = txtStyle | TXT_STYLE_UNICODE; dspl_ScrText( in_X_signed,in_Y_signed,in_Text, txtStyle); // scrText_Unicode(in_X_signed,in_Y_signed, (USHORT*)in_Text); } #endif /* * if an external display simulation is used and switched on with the * EXT_DISPLAY config primitive - send a MMI_DISPLAY_REQ primitive. */ if (extDisplay) dspl_SendDisplayReq (in_X, in_Y, in_Text); return DRV_OK; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_TextOut | +--------------------------------------------------------------------+ PURPOSE : This function is used to display a text at the given location in_X/in_Y using the defined attributes (in_Attrib) It calls dspl_ScrText to actually display the text GW 14/02/03 - SPR#1736 Modified code to call 'dspl_ScrText' to allow a border to be drawn round chinese characters. */ GLOBAL UBYTE dspl_TextOut(USHORT in_X, USHORT in_Y, UBYTE in_Attrib, char * in_Text) { UBYTE temp; int in_X_signed; int in_Y_signed; int txtStyle=0; char* op_str; /*MC SPR 1319*/ if (in_Text == NULL) return DRV_OK; /*MC end*/ op_str = in_Text; #if defined (WIN32) if (!scrEnabled) { LCD_WriteString (in_Y, in_X, (UBYTE *) in_Text); } else #endif { if (in_Attrib & DSPL_TXTATTR_SIGNED_COORDS) { in_X_signed = (SHORT)in_X; in_Y_signed = (SHORT)in_Y; } else { in_X_signed = in_X; in_Y_signed = in_Y; } /*Mc SPR 1526, we no longer check for current mode*/ if (in_Attrib & DSPL_TXTATTR_INVERS) txtStyle = TXT_STYLE_INVERT; else txtStyle = TXT_STYLE_NORMAL; if ((in_Attrib&DSPL_TXTATTR_UNICODE) || (in_Text[0] ==0x80)) { txtStyle = txtStyle | TXT_STYLE_UNICODE; if (op_str[0] ==0x80)//if unicode tag at beginning of string op_str = &op_str[2]; } if (displayData.DisplayType EQ DSPL_TYPE_CHARACTER) { /* the following is only accurate for a fixed-width font*/ if (txtStyle & TXT_STYLE_UNICODE) { in_X_signed = in_X_signed*12+2; in_Y_signed = in_Y_signed*12; } else { in_X_signed = in_X_signed*6+2; in_Y_signed = in_Y_signed*8; } } dspl_ScrText( in_X_signed,in_Y_signed,op_str, txtStyle); } /* * if an external display simulation is used and switched on with the * EXT_DISPLAY config primitive - send a MMI_DISPLAY_REQ primitive. */ if (extDisplay) dspl_SendDisplayReq (in_X, in_Y, in_Text); return DRV_OK; } /**/ /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_SetWorkShadow | +--------------------------------------------------------------------+ PURPOSE : This function is used to define the address of the shadow RAM for drawing operations. */ GLOBAL UBYTE dspl_SetWorkShadow (UBYTE * in_ShadowPtr) { return DSPL_FCT_NOTSUPPORTED; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_SetDisplayShadow | +--------------------------------------------------------------------+ PURPOSE : This function is used to define the address of the shadow RAM for displaying operations. */ GLOBAL UBYTE dspl_SetDisplayShadow (UBYTE * in_ShadowPtr) { return DSPL_FCT_NOTSUPPORTED; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6147) MODULE : SMI_WM | | STATE : code ROUTINE : dspl_SendDisplayReq | +--------------------------------------------------------------------+ PURPOSE : sends an MMI_DISPLAY_REQ primitive to write the text at position X,Y to PL. If the parameter text is NULL only the cursor position should change. If in this case the X and Y value is 0xffff the cursor will be hide. */ LOCAL void dspl_SendDisplayReq (USHORT x, USHORT y, char *text) { #ifdef NEW_FRAME T_QMSG Msg; T_VOID_STRUCT *prim; #endif USHORT sdu_len = (text NEQ NULL) ? strlen (text) : 0; PALLOC_SDU (mmi_display_req, MMI_DISPLAY_REQ, (USHORT)(sdu_len<<3)); mmi_display_req->c_x = x; mmi_display_req->c_y = y; if (text NEQ NULL) { /* * text output */ mmi_display_req->attrib.content = CON_TEXT; mmi_display_req->attrib.control = CTL_NORMAL; mmi_display_req->sdu.o_buf = 0; mmi_display_req->sdu.l_buf = (sdu_len<<3); memcpy (mmi_display_req->sdu.buf, text, sdu_len); } else { /* * change the cursor position */ mmi_display_req->attrib.content = CON_CURSOR; mmi_display_req->attrib.control = ((x EQ 0xffff) ? CTL_HIDDEN : CTL_NORMAL); mmi_display_req->sdu.o_buf = 0; mmi_display_req->sdu.l_buf = 0; } #if defined NEW_FRAME if ( hCommMMI == VSI_ERROR ) { mmi_handle = vsi_e_handle ( 0, "MMI" ); hCommMMI = vsi_c_open ( 0, "MMI" ); prim = vsi_c_pnew ( 100, 0x8000 FILE_LINE_MACRO ); strcpy ((char*)prim, "REDIRECT MMI 0000111000001010 PAN"); vsi_c_primitive ( mmi_handle, D2P(prim) ); } PSEND(hCommMMI,mmi_display_req); #else ext_primitive (D2P(mmi_display_req), "CST", "PAN", sizeof (T_PRIM_HEADER) + sizeof (T_MMI_DISPLAY_REQ) + sdu_len); PFREE (mmi_display_req); #endif } GLOBAL UBYTE dspl_DrawWin (USHORT px, USHORT py, USHORT sx, USHORT sy, int format, t_font_bitmap *bgdBmp) { USHORT x1,y1,x2,y2; int xOfs,yOfs; if (bgdBmp == NULL) { scrDrawFilledRect( px+3,py+3, sx, sy, 0x00010101 ); //shadow scrDrawFilledRect( px,py, sx, sy, dspl_GetBgdColour() ); scrRect( px-1,py-1, sx+1, sy+1); } else { xOfs = (sx-bgdBmp->width)/2; yOfs = (sy-bgdBmp->height)/2; dspl_GetWindow(&x1,&y1,&x2,&y2 ); switch (format) { case DSPL_WIN_NORMAL: dspl_show_bitmap(px, py, bgdBmp, SHOWBITMAP_NORMAL ); break; case DSPL_WIN_CENTRE: dspl_show_bitmap(px+xOfs, py+yOfs, bgdBmp, SHOWBITMAP_NORMAL ); break; case DSPL_WIN_CLIP: dspl_SetWindow(px,py,px+sx,px+sy ); dspl_show_bitmap(px, py, bgdBmp, SHOWBITMAP_NORMAL ); break; case DSPL_WIN_CENTRE_CLIP: dspl_SetWindow(px,py,px+sx,px+sy ); dspl_show_bitmap(px+xOfs, py+yOfs, bgdBmp, SHOWBITMAP_NORMAL ); break; case DSPL_WIN_TILE: dspl_SetWindow(px,py,px+sx,px+sy ); yOfs=0; while(yOfs < sy) { xOfs=0; while (xOfs < sx) { dspl_show_bitmap(px+xOfs, py+yOfs, bgdBmp, SHOWBITMAP_NORMAL ); xOfs=xOfs+bgdBmp->width; } yOfs=yOfs+bgdBmp->height; } break; } dspl_SetWindow(x1,y1,x2,y2 ); } /* switch (format) { case 0: default: break; }*/ return DRV_OK; } static int win_x1, win_x2, win_y1, win_y2; //Set-up area to be drawn in - limit window to the size of the screen //Inputs in_x1/y1 - first column/row that can be drawn on // in_x2/y2 - last column/row //NB:- inputs are the same as used to clear/draw rectangles BUT // values stored in win_x2/y2 are +1 to ensure values are treated the same as scrX/Y GLOBAL UBYTE dspl_SetWindow(USHORT in_X1, USHORT in_Y1, USHORT in_X2, USHORT in_Y2) { int sizeX,sizeY; scrSize (&sizeX, &sizeY); if (in_X1>0) win_x1 = in_X1; else win_x1 = 0; if (in_Y1>0) win_y1 = in_Y1; else win_y1 = 0; if (in_X2<sizeX) win_x2 = in_X2+1; else win_x2 = sizeX; if (in_Y2<sizeY) win_y2 = in_Y2+1; else win_y2 = sizeY; return DRV_OK; } GLOBAL UBYTE dspl_ResetWindow( void ) { win_x1 = 0; win_y1 = 0; scrSize (&win_x2, &win_y2); return DRV_OK; } GLOBAL UBYTE dspl_GetWindow(USHORT* x1,USHORT* y1,USHORT* x2,USHORT* y2 ) { *x1= win_x1; *x2= win_x2; *y1= win_y1; *y2= win_y2; return DRV_OK; } /******************************************************************* * * * PART II: Workaround for Graphical Displays * * * *******************************************************************/ //June 03, 2005 REF: GSM-ENH-31636 xpradipg //CRR 28825: xpradipg - 11 Feb 2005 #if (defined(DSAMPLE) || defined(ESAMPLE) || defined(ISAMPLE) || defined(CALLISTO)) /*GW 21/02/03 - There is an unused long word at the end of each line for the new drivers for some good reason I'm sure.*/ #ifdef DSAMPLE_COLOUR16 #define LCD_COL (R2D_WIDTH+1) /* display size+32 bits */ #else #define LCD_COL (R2D_WIDTH) /* display size */ #endif #define LCD_ROW (R2D_HEIGHT) #define HEADER_INFO (3) #define DISPLAY_SIZE (LCD_ROW*LCD_ROW_NUM_LWORDS) /* static char scratch [100]; *//* command buffer - does not support output of new display */ #ifndef DSAMPLE_LITE unsigned char bgdColourArray[LCD_COL*4]; #endif #endif #ifdef CSAMPLE #define LCD_COL 84 /* display size */ #define LCD_ROW 48 #define LCD_COL_NUM_LWORDS ((LCD_ROW+31)/32) /* col size in longwords */ #endif //CSAMPLE #ifdef BSAMPLE #define LCD_COL 84 /* display size */ #define LCD_COL_B ((LCD_COL+7)/8) /* row size in byte */ #define LCD_ROW 48 #define DISPL_DIV 4 #endif /* LCD_ROW_NUM_LWORDS - number of long words used to store a row of pixels BYTEPERPIXEL - number of bytes used to store apixel on-screen */ #define CHECK_LIMITS /*Add bounds checks to code */ /******************************************************************************* $Macro: DSPL_SET_BITCOLOUR $Description: This macro sets the colour of the bit at the provided long word address $Returns: None. $Arguments: x - x position of pixel (may be unused) j - 32 bit offset within array of the pixel to be set col - colour (in LCD format) of the pixel to be set txt - debug text for traces - used if 'j' is bounds checked first. *******************************************************************************/ /******************************************************************************* $Macro: DSPL_GET_LWORD $Description: This macro $Returns: The 32bit offset of the word containing the pixel $Arguments: px - x position of pixel py - y position of pixel *******************************************************************************/ /******************************************************************************* $Macro: DSPL_GET_BYTE $Description: This macro $Returns: The 8bit offset of the word containing the pixel $Arguments: px - x position of pixel py - y position of pixel *******************************************************************************/ /******************************************************************************* $Macro: DSPL_GET_BITCOLOUR $Description: This macro $Returns: The colour in LCD format of the RGB input $Arguments: col - 32 bit RGB colour value *******************************************************************************/ /******************************************************************************* $Macro: DSPL_SET_XYBIT_COLOUR $Description: This macro $Returns: None $Arguments: x,y - posiiton of pixel to be set col - 0 =clear bixel, anything else - set pixel txt - trace for debug (if position is out-of-range) *******************************************************************************/ #ifdef DSAMPLE_LITE #define LCD_ROW_NUM_LWORDS ((LCD_COL+31)/32) /* col size in longwords */ #define BYTEPERPIXEL (1/8 - unused) #ifdef CHECK_LIMITS #define DSPL_SET_BITCOLOUR(x,j,col,txt) \ {\ if (((j)>=0) && ((j)<DISPLAY_SIZE)) \ {\ int m_px = 1 << (x & 0x1F);\ if (col) picture_col[j] = picture_col[j] | (m_px);\ else picture_col[j] = picture_col[j] & (~m_px);\ }else {mmi_trace(txt);}\ } #define DSPL_SET_XYBIT_COLOUR(x,y,col,txt) \ {\ int m_px = 1 << (x & 0x1F);\ int word = DSPL_GET_LWORD(x,y);\ if (((word)>=0) && ((word)<DISPLAY_SIZE)) \ {\ if (col) word = word | m_px;\ else word = word & (~m_px);\ }\ } #else #define DSPL_SET_BITCOLOUR(x,j,col,txt) \ {\ int m_px = 1 << (x & 0x1F);\ if (col) picture_col[j] = picture_col[j] | (m_px);\ else picture_col[j] = picture_col[j] & (~m_px);\ } #define DSPL_SET_XYBIT_COLOUR(x,y,col,txt) \ {\ int m_px = 1 << (x & 0x1F);\ int word = DSPL_GET_LWORD(x,y);\ if (col) word = word | m_px;\ else word = word & (~m_px);\ } #endif #define DSPL_GET_LWORD(px,py) ((py)*LCD_ROW_NUM_LWORDS + ((px)/32)) #define DSPL_GET_BYTE(px,py) (((py)*4)*LCD_ROW_NUM_LWORDS + ((px)/8)) #define DSPL_GET_BITCOLOUR(col32) (not used!) #define DSPL_GET_PIXELCOLOUR(col32) (not used!) #endif //DSAMPLE_LITE #ifdef DSAMPLE_COLOUR32 #define LCD_ROW_NUM_LWORDS (LCD_COL) /* col size in longwords */ #define BYTEPERPIXEL 4 #ifdef CHECK_LIMITS //safe version-includes trace for errors #define DSPL_SET_BITCOLOUR(x,j,col,txt) {if (((j)>=0) && ((j)<DISPLAY_SIZE)) picture_col[j] = (col); else {mmi_trace(txt);}} #else #define DSPL_SET_BITCOLOUR(x,j,col,txt) {picture_col[j] = (col);}//faster version - no bounds check #endif #define DSPL_GET_LWORD(px,py) ((py)*LCD_ROW_NUM_LWORDS + (px)) #define DSPL_GET_BYTE(px,py) (((py)*4)*LCD_ROW_NUM_LWORDS + ((px)*4)) #define DSPL_GET_BITCOLOUR(col32) (~(((((col32) &0x00F80000) >> 8) | (((col32) &0x0000FC00) >> 5) | (((col32) &0x000000F8) >> 3)))) #define DSPL_GET_PIXELCOLOUR(col32) (((((col32)<<8) &0x00F80000) | (((col32)<<5) &0x0000FC00) | (((col32)<<3) &0x000000F8))) #endif #ifdef DSAMPLE_COLOUR16 // July 1, 2005 REF: CRR 32677 - xpradipg // the extra word padding is not required for the ISAMPLE AND CALLISTO #if (defined(ISAMPLE) || defined(CALLISTO)) #define LCD_ROW_NUM_LWORDS ((LCD_COL)/2) /* col size in longwords */ #else #define LCD_ROW_NUM_LWORDS ((LCD_COL+1)/2) /* col size in longwords */ #endif #define BYTEPERPIXEL 2 #ifdef PIXEL_0_IN_LSW #ifdef CHECK_LIMITS #define DSPL_SET_BITCOLOUR(x,j,col,txt) \ {\ if (((j)>=0) && ((j)<DISPLAY_SIZE)) \ { if ((x)&0x01)\ picture_col[j] = (picture_col[j] & 0xFFFF0000) | (col & 0x0000FFFF);\ else\ picture_col[j] = (picture_col[j] & 0x0000FFFF) | ((col <<16) & 0xFFFF0000);\ }else {mmi_trace(txt);}\ } #else #define DSPL_SET_BITCOLOUR(x,j,col,txt) \ { if ((x)&0x01)\ picture_col[j] = (picture_col[j] & 0xFFFF0000) | (col & 0x0000FFFF);\ else\ picture_col[j] = (picture_col[j] & 0x0000FFFF) | ((col <<16) & 0xFFFF0000);\ } #endif #else #ifdef CHECK_LIMITS #define DSPL_SET_BITCOLOUR(x,j,col,txt) \ {\ if (((j)>=0) && ((j)<DISPLAY_SIZE)) \ { if ((x)&0x01)\ picture_col[j] = (picture_col[j] & 0x0000FFFF) | ((col <<16) & 0xFFFF0000);\ else\ picture_col[j] = (picture_col[j] & 0xFFFF0000) | (col & 0x0000FFFF);\ }else {mmi_trace(txt);}\ } #else #define DSPL_SET_BITCOLOUR(x,j,col,txt) \ { if ((x)&0x01)\ picture_col[j] = (picture_col[j] & 0x0000FFFF) | ((col <<16) & 0xFFFF0000);\ else\ picture_col[j] = (picture_col[j] & 0xFFFF0000) | (col & 0x0000FFFF);\ } #endif #endif //GW Added () round 'px' in definition below #define DSPL_GET_LWORD(px,py) ((py)*LCD_ROW_NUM_LWORDS + ((px)/2)) #define DSPL_GET_BYTE(px,py) (((py)*4)*LCD_ROW_NUM_LWORDS + ((px)*2)) // July 1, 2005 REF: CRR 32677 - xpradipg // the value is not negated here since the LCD driver expects without negation #if (defined(ISAMPLE) || defined(CALLISTO)) #define DSPL_GET_BITCOLOUR(col32) (((((col32) &0x00F80000) >> 8) | (((col32) &0x0000FC00) >> 5) | (((col32) &0x000000F8) >> 3))) #else #define DSPL_GET_BITCOLOUR(col32) (~(((((col32) &0x00F80000) >> 8) | (((col32) &0x0000FC00) >> 5) | (((col32) &0x000000F8) >> 3)))) #endif #define DSPL_GET_PIXELCOLOUR(col32) (((((col32)<<8) &0x00F80000) | (((col32)<<5) &0x0000FC00) | (((col32)<<3) &0x000000F8))) #endif // 3 words of header info for 'pictures' #ifdef DSAMPLE_LITE static UINT32* picture_bw = NULL;//Pointer to data in display. static UINT32* pictureCopy_bw= NULL;//Pointer to data in display. #endif//DSAMPLE_LITE #ifdef DSAMPLE_COLOUR static UINT32* picture_col = NULL;//Pointer to data in display. // Mar 30, 2005 REF: CRR 29986 xpradipg // removed the unused variable #ifndef FF_MMI_OPTIM static UINT32* pictureCopy_col= NULL;//Pointer to data in display. #endif #endif #ifdef CSAMPLE #define HEADER_INFO (3) #define DISPLAY_SIZE (LCD_COL*LCD_COL_NUM_LWORDS) static UINT32 display_bw [DISPLAY_SIZE+HEADER_INFO+10]; #ifdef USE_PLOT static UINT32 displayCopy_bw [DISPLAY_SIZE+HEADER_INFO+1]; /* copy to flag differences */ #endif static UINT32* picture_bw=NULL;//Pointer to data in display. static UINT32* pictureCopy_bw= NULL;//Pointer to data in display. /* static char scratch [100]; */ /* command buffer - does not support output of new display */ #endif //CSAMPLE #ifdef BSAMPLE static UBYTE displayScr [LCD_ROW][LCD_COL_B]; /* display buffer */ static UBYTE displayCopy [LCD_ROW][LCD_COL_B]; /* copy to flag differences */ /* static char scratch [LCD_ROW*LCD_COL_B*2+100]; */ /* command buffer */ #endif //BSAMPLE static int mobEnabled = 1; /* mobile simulation disabled */ extern int mfwExtOut (char *cmd); /* forward to ext. display */ UBYTE lcd_output_ready = TRUE; UBYTE lcd_output_needed = FALSE; #define scrHlen 18 static const char *scrHeader = "CONFIG MFWMOB SCR "; static int scrX, scrY; /* display size */ #if defined (WIN32) static int mtkEnabled = 0; /* MMI Toolkit */ #endif static int internal = 0; /* internal use only */ static int xIndex; /* data transfer index */ //accessible from outside e.g 3th application MMS void scrPoint (int px, int py, int col); /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6103) MODULE : DRV_DSPL | | STATE : code ROUTINE : dspl_BitBlt | +--------------------------------------------------------------------+ PURPOSE : This function is used to display a bitmap at the specified location using the raster operation provided. The bitmap format MUST be the same as the display and cannot contain any transparent colours If the bitmap does not cover the entire screen area, the rest of the area is drawn in the background colour provided. */ #ifdef DSAMPLE_COLOUR void fastCopyBitmap(int startX, int startY, // start position of bitmap int bmpSx, int bmpSy, //size of bitmap char* srcBitmap, int posX, int posY, // start of area to be copied into int sx, int sy, // size of area to be copied into U32 bgd_col, int bmpFormat) { char * image; int image_sx,image_x; int bgd_sx_left; int bgd_sx_right; int i,y; char *screen = (char*)picture_col; U32 bgdColour; if (posX < win_x1) { sx = sx - (win_x1-posX); posX = win_x1; } if (posX+sx >win_x2) { sx = win_x2 - posX; } if (posY < win_y1) { sy = sy - (win_y1-posY); posY = win_y1; } if (posY+sy >win_y2) { sy = win_y2 - posY; } { char trc[80]; sprintf(trc,"%d,%d,%d,%d,%d,%d",sx,sy,win_x1,win_y1,win_x2,win_y2); mmi_trace(trc); } #ifdef DSAMPLE_COLOUR32 if (bmpFormat != BMP_FORMAT_16BIT_LCD_COLOUR) #endif #ifdef DSAMPLE_COLOUR16 if (bmpFormat != BMP_FORMAT_16BIT_LCD_COMPRESSED_COLOUR) #endif { int maxY; //Either display as much of the image as possible or as much as will fit. if (bmpSy > sy) maxY = sy; else maxY = bmpSy; dspl_Clear(posX,posY,(U16)(posX+sx-1),(U16)(posY+sy-1)); dspl_BitBlt2((short) posX,(short)posY,(USHORT)bmpSx,(USHORT)maxY, (void *)srcBitmap,0, bmpFormat); return; } bgdColour = DSPL_GET_BITCOLOUR(bgd_col); bgdColourArray[0] = (bgdColour & 0x000000FF); bgdColourArray[1] = (bgdColour & 0x0000FF00) >>8; bgdColourArray[2] = (bgdColour & 0x00FF0000) >>16; bgdColourArray[3] = (bgdColour & 0xFF000000) >>24; for (i=BYTEPERPIXEL;i<LCD_COL*BYTEPERPIXEL;i++) bgdColourArray[i] = bgdColourArray[i-BYTEPERPIXEL]; bgd_sx_left = (startX- posX); if (srcBitmap) { image_x = posX - startX; image_sx = bmpSx; if (image_x < 0) { image_x = 0; } else image_sx = image_sx - image_x; } else { image_sx = 0; image_x = 0; } if (bgd_sx_left <0) bgd_sx_left=0; if ((image_sx + bgd_sx_left) > sx) { image_sx = sx - bgd_sx_left; bgd_sx_right = 0; } else { bgd_sx_right = sx-(image_sx+bgd_sx_left); } if (bgd_sx_right <0) bgd_sx_right=0; bgd_sx_right = bgd_sx_right*BYTEPERPIXEL; bgd_sx_left = bgd_sx_left*BYTEPERPIXEL; if (image_sx > 0) image_sx = image_sx*BYTEPERPIXEL; else image_sx = 0; if (image_x > 0) image_x = image_x*BYTEPERPIXEL; else image_x = 0; if (posY+sy > LCD_ROW) sy = LCD_ROW - posY; for (y=posY; y<posY+sy; y++) { int yOfs = DSPL_GET_BYTE(posX,y); if ((yOfs >=0) && (yOfs<DISPLAY_SIZE*4)) { if (((srcBitmap) && (y>startY) && (y <bmpSy+startY) && (image_sx >0))) { image = &srcBitmap[(y-startY)*bmpSx*BYTEPERPIXEL]; if (bgd_sx_left >0) memcpy(&screen[yOfs],&bgdColourArray[0],bgd_sx_left); memcpy(&screen[yOfs+bgd_sx_left],&image[image_x],image_sx); if (bgd_sx_right >0) memcpy(&screen[yOfs+bgd_sx_left+image_sx],&bgdColourArray[0],bgd_sx_right); } else { memcpy(&screen[yOfs],&bgdColourArray[0],sx*BYTEPERPIXEL); } } } } #else void fastCopyBitmap(int startX, int startY, // start position of bitmap int bmpSx, int bmpSy, //size of bitmap char* srcBitmap, int posX, int posY, // start of area to be copied into int sx, int sy, // size of area to be copied into U32 bgd_col, int bmpFormat) { //Fast copy is currently only required for colour bitmaps } #endif /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrMobUpdate | +--------------------------------------------------------------------+ PURPOSE : Shadow display to mobile simulation */ void scrMobUpdate (void) { #if defined (WIN32) USHORT x,y; USHORT i; USHORT z; if (mtkEnabled) { USHORT sdu_len; switch (mtkEnabled) { case 1: // ASAMPLE z= LCD_ROW; sdu_len = 13 * z; // (100 * z Pixels); { PALLOC_SDU (mmi_display_req, MMI_DISPLAY_REQ, (USHORT)(sdu_len<<3)); { mmi_display_req->c_x = LCD_COL; mmi_display_req->c_y = z; i=0; for (y=0;y<z;y++) for (x=0; x < 13; x++) mmi_display_req->sdu.buf[i++] = displayScr[y][x]; } TRACE_EVENT ("Send Display Content"); #if defined NEW_FRAME { { T_QMSG Message; Message.MsgType = MSG_PRIMITIVE; Message.Msg.Primitive.Prim = D2P(mmi_display_req); Message.Msg.Primitive.PrimLen = sizeof (T_MMI_DISPLAY_REQ) + LCD_COL_B*z; #ifdef MEMORY_SUPERVISION vsi_c_send (VSI_CALLER hCommL1 ,&Message, __FILE__, __LINE__); #else vsi_c_send (VSI_CALLER hCommL1 ,&Message); #endif } } #else // vsi_c_send (VSI_CALLER hCommL1, D2P(mmi_display_req), sizeof (T_MMI_DISPLAY_REQ) + LCD_COL_B*z); #endif } break; case 2: // another target with other dimensions { char buf[40]; sprintf (buf, "LCD NEEDED %d READY %d", lcd_output_needed, lcd_output_ready); TRACE_EVENT (buf); } lcd_output_needed = TRUE; if (lcd_output_ready) { lcd_output_needed = FALSE; lcd_output_ready = FALSE; sdu_len = 14 * 16 + 20; #if (LCD_ROW >= 64) { PALLOC_SDU (mmi_display_req, MMI_DISPLAY_REQ, sdu_len<<3); mmi_display_req->c_x = LCD_COL; mmi_display_req->c_y = 16; mmi_display_req->attrib.content = 3; i=0; for (y=48;y<64;y++) for (x=0; x < 13; x++) mmi_display_req->sdu.buf[i++] = displayScr[y][x]; #if defined NEW_FRAME { T_QMSG Message; Message.MsgType = MSG_PRIMITIVE; Message.Msg.Primitive.Prim = D2P(mmi_display_req); Message.Msg.Primitive.PrimLen = sizeof (T_MMI_DISPLAY_REQ) + 14*16+20; #ifdef MEMORY_SUPERVISION vsi_c_send (VSI_CALLER hCommL1 ,&Message, __FILE__, __LINE__); #else vsi_c_send (VSI_CALLER hCommL1 ,&Message); #endif } #else vsi_c_send (VSI_CALLER hCommL1, D2P(mmi_display_req), sizeof (T_MMI_DISPLAY_REQ) + 14*16+20); #endif } #endif #if (LCD_ROW >= 48) { PALLOC_SDU (mmi_display_req, MMI_DISPLAY_REQ, (USHORT)(sdu_len<<3)); mmi_display_req->c_x = LCD_COL; mmi_display_req->c_y = 16; mmi_display_req->attrib.content = 2; i=0; for (y=32;y<48;y++) for (x=0; x < 13; x++) mmi_display_req->sdu.buf[i++] = displayScr[y][x]; #if defined NEW_FRAME { T_QMSG Message; Message.MsgType = MSG_PRIMITIVE; Message.Msg.Primitive.Prim = D2P(mmi_display_req); Message.Msg.Primitive.PrimLen = sizeof (T_MMI_DISPLAY_REQ) + 14*16+20; #ifdef MEMORY_SUPERVISION vsi_c_send (VSI_CALLER hCommL1 ,&Message, __FILE__, __LINE__); #else vsi_c_send (VSI_CALLER hCommL1 ,&Message); #endif } #else vsi_c_send (VSI_CALLER hCommL1, D2P(mmi_display_req), sizeof (T_MMI_DISPLAY_REQ) + 14*16+20); #endif } #endif { PALLOC_SDU (mmi_display_req, MMI_DISPLAY_REQ, (USHORT)(sdu_len<<3)); mmi_display_req->c_x = LCD_COL; mmi_display_req->c_y = 16; mmi_display_req->attrib.content = 1; i=0; for (y=16;y<32;y++) for (x=0; x < 13; x++) mmi_display_req->sdu.buf[i++] = displayScr[y][x]; #if defined NEW_FRAME { T_QMSG Message; Message.MsgType = MSG_PRIMITIVE; Message.Msg.Primitive.Prim = D2P(mmi_display_req); Message.Msg.Primitive.PrimLen = sizeof (T_MMI_DISPLAY_REQ) + 14*16+20; #ifdef MEMORY_SUPERVISION vsi_c_send (VSI_CALLER hCommL1 ,&Message, __FILE__, __LINE__); #else vsi_c_send (VSI_CALLER hCommL1 ,&Message); #endif } #else vsi_c_send (VSI_CALLER hCommL1, D2P(mmi_display_req), sizeof (T_MMI_DISPLAY_REQ) + 14*16+20); #endif } { PALLOC_SDU (mmi_display_req, MMI_DISPLAY_REQ, (USHORT)(sdu_len<<3)); mmi_display_req->c_x = LCD_COL; mmi_display_req->c_y = 16; mmi_display_req->attrib.content = 0; i=0; for (y=0;y<16;y++) for (x=0; x < 13; x++) mmi_display_req->sdu.buf[i++] = displayScr[y][x]; #if defined NEW_FRAME { T_QMSG Message; Message.MsgType = MSG_PRIMITIVE; Message.Msg.Primitive.Prim = D2P(mmi_display_req); Message.Msg.Primitive.PrimLen = sizeof (T_MMI_DISPLAY_REQ) + 14*16+20; #ifdef MEMORY_SUPERVISION vsi_c_send (VSI_CALLER hCommL1 ,&Message, __FILE__, __LINE__); #else vsi_c_send (VSI_CALLER hCommL1 ,&Message); #endif } #else vsi_c_send (VSI_CALLER hCommL1, D2P(mmi_display_req), sizeof (T_MMI_DISPLAY_REQ) + 14*16+20); #endif } TRACE_EVENT ("Send Display Content"); } break; } } #endif #ifdef BSAMPLE if (mobEnabled) { /* ## scratch is not required and function mfwExtOut is ## not doing anything sprintf(scratch,"%s%s %d",scrHeader,"disp",LCD_COL_B); xIndex = 0; mfwExtOut(scratch); */ } #endif } int dspl_GetContrastColour( int ipCol) { switch (ipCol & 0x00808080) { case 0x000000: return (0x00FFFFFF); case 0x000080: return (0x00FFFF00); case 0x008000: return (0x00FF00FF); case 0x008080: return (0x00FF0000); case 0x800000: return (0x0000FFFF); case 0x800080: return (0x0000FF00); case 0x808000: return (0x000000FF); case 0x808080: return (0x00000000); default: return (0x00808080); } return (0x00808080); } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrLCDUpdate | +--------------------------------------------------------------------+ PURPOSE : Shadow display to LCD */ //GW Procedure/data supplied by new TI Driver V5.3.1 #ifdef R2D_ENABLED static T_R2D_SHAPE_PTR scrDisplayRect = NULL; //rectangle defined as shape of the display static T_R2D_GC_PTR scrPicPtr = NULL; //Pointer to gc with picture in it (b+w and col) static T_RVF_MB_ID mb_id; //ID of memory bank void r2d_refresh(void); int riv_err; extern T_R2D_GC_PTR r2d_g_lcd_gc; #endif // R2D_ENABLED static int picInit = 0; //Have we set up the mb id etc yet ? //Initialises data required for bolck copy of a 'picture' void scrRivPictureClear(void) { #ifdef CSAMPLE memset(display_bw,0,sizeof(display_bw)); #ifdef USE_PLOT memset(displayCopy_bw,0,sizeof(displayCopy_bw)); pictureCopy_bw = &displayCopy_bw[3]; //start of input data #endif display_bw[0] = LCD_COL; display_bw[1] = LCD_ROW; display_bw[2] = DISPLAY_SIZE; picture_bw = &display_bw[3]; //start of input data #endif #ifdef DSAMPLE_COLOUR #ifdef USEBUFFER display_colour[0] = LCD_COL; display_colour[1] = LCD_ROW; display_colour[2] = DISPLAY_SIZE; picture_col = &display_colour[3]; //start of input data #else picture_col = r2d_get_pixmap(r2d_g_lcd_gc); #endif { U32 lWord,bitCol; int j,y; //GW When clearing screen - do not allow transparent background colours! int bgdCol = dspl_GetBgdColour(); int fgdCol = dspl_GetFgdColour(); if (((bgdCol & 0x00F0F0F0) == (fgdCol & 0x00F0F0F0)) || ((bgdCol & 0xFF000000) == TRANSPARENT_32BIT_COLOUR)) { /*Foreground and background colours are the same (or near enough) */ /* or background colour is transparent */ /*Select a colour that will contrast with the current foreground colour */ bgdCol = dspl_GetContrastColour(fgdCol); } bitCol = (DSPL_GET_BITCOLOUR(bgdCol)) & 0x00FFFFFF; #ifdef DSAMPLE_COLOUR32 bgdColourArray[0] = (bitCol & 0x000000FF); bgdColourArray[1] = (bitCol & 0x0000FF00) >>8; bgdColourArray[2] = (bitCol & 0x00FF0000) >>16; bgdColourArray[3] = (bitCol & 0xFF000000) >>24; for (j=4;j<LCD_COL*4;j++) bgdColourArray[j] = bgdColourArray[j-4]; for (y=0; y<LCD_ROW; y++) { int yOfs = (y*LCD_ROW_NUM_LWORDS); memcpy(&picture_col[yOfs] ,bgdColourArray,LCD_COL*4); } #endif #ifdef DSAMPLE_COLOUR16 bgdColourArray[0] = (bitCol & 0x000000FF); bgdColourArray[1] = (bitCol & 0x0000FF00) >>8; for (j=2;j<LCD_COL*2;j++) bgdColourArray[j] = bgdColourArray[j-2]; for (y=0; y<LCD_ROW; y++) { int yOfs = (y*LCD_ROW_NUM_LWORDS); memcpy(&picture_col[yOfs] ,bgdColourArray,LCD_COL*2); } #endif } #endif #ifdef DSAMPLE_LITE picture_bw = r2d_get_pixmap(r2d_g_lcd_gc); memset(picture_bw,0,DISPLAY_SIZE*4); #endif } void scrRivPictureInit( void ) { static int err = -1; T_RVF_MB_NAME mb_name; T_RVF_MB_PARAM mb_param; //Ensure data is only created once. #ifdef R2D_ENABLED if (picInit != 0) return; picInit = 1; //int underway. scrRivPictureClear(); #endif #ifdef CSAMPLE strcpy(mb_name, "FRED"); mb_param.size = 256; mb_param.watermark = 128; riv_err = rvf_create_mb( mb_name, mb_param, &mb_id); if (riv_err == 0) { scrPicPtr = r2d_new_picture_context(mb_id, display_bw,R2D_LCD_KIND); scrDisplayRect = r2d_new_rectangle(mb_id,0,0,LCD_COL-1,LCD_ROW-1); } else { scrPicPtr = NULL; scrDisplayRect = NULL; } #endif #ifdef DSAMPLE_COLOUR #ifdef USEBUFFER strcpy(mb_name, "FRED"); mb_param.size = 256; mb_param.watermark = 128; err = rvf_create_mb( mb_name, mb_param, &mb_id); if (err == 0) { scrPicPtr = r2d_new_picture_context(mb_id, display_colourPtr,R2D_FULL_KIND);// R2D_LCD_KIND); scrDisplayRect = r2d_new_rectangle(mb_id,0,0,LCD_COL+1,LCD_ROW+1); } else #endif { scrPicPtr = NULL; scrDisplayRect = NULL; } #endif } //GW Change the display to #ifdef DSAMPLE_COLOUR #ifdef DSAMPLE_COLOUR32 #define TOP_BITS_SET 0xC618 #endif #ifdef DSAMPLE_COLOUR16 #define TOP_BITS_SET 0xC618C618 #endif #endif /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (6147) MODULE : SMI_WM | | STATE : code ROUTINE : scrUnfocusDisplay | +--------------------------------------------------------------------+ PURPOSE : Causes the entire display to appear much darker, allowing the pop-up dialog to be more clearly the focus especially the softkeys. GW #2294 23/07/03 - Created */ void scrUnfocusDisplay(void) { #ifndef _SIMULATION_ // Turn off this BMI Schnickschnack ... int x,y; UINT32 *picPtr; #ifndef DSAMPLE_COLOUR UINT32 mask; #endif #ifdef DSAMPLE_COLOUR picPtr = picture_col; #else picPtr = picture_bw; #endif if (picPtr != NULL) { for (y=0;y<LCD_ROW;y++) { #ifndef DSAMPLE_COLOUR if (y & 0x01) mask = 0xAAAAAAAA; else mask = 0x55555555; #endif for (x=0;x<LCD_ROW_NUM_LWORDS;x++) { #ifdef DSAMPLE_COLOUR //We Want to reduce colour by 50% (shift left) and set top bits to bits to 0 //Since picture colours are inverted, set top bits. //Also, colouris very bright - reduce by 75% if ((*picPtr & TOP_BITS_SET) != TOP_BITS_SET) *picPtr = ((*picPtr) >> 2) | TOP_BITS_SET; #else //B+W display - blank every second pixel *picPtr = (*picPtr) & mask; #endif picPtr++; } } } #endif /* _SIMULATION_ */ } //Set colour (only when different from last time) void scrSetR2DFgdCol(UINT32 col) { U16 opCol_a,opCol_r,opCol_g,opCol_b; static UINT32 oldCol = 0xFFFFFFFF; if (col != oldCol) { #ifdef DSAMPLE_COLOUR opCol_a = 0xFF; // ((col & 0x0000FF00) >> 16); opCol_r = ((col & 0x0000F800) >> 8); opCol_g = ((col & 0x000007E0) >> 3); opCol_b = ((col & 0x0000001F) << 3); #else opCol_a = 0xFF; // ((col & 0x0000FF00) >> 16); opCol_r = ((col & 0x000000E0) ); opCol_g = ((col & 0x0000001C) << 3); opCol_b = ((col & 0x00000003) << 6); if (opCol_r == 0) opCol_r = 0x80; if (opCol_g == 0) opCol_g = 0x40; #endif #ifdef R2D_ENABLED r2d_set_foreground_color_with_argb(r2d_g_lcd_gc, opCol_a, opCol_r, opCol_g, opCol_b ); oldCol = col; #endif } } //Set colour (only when different from last time) void scrSetR2DBgdCol(UINT32 col) { U16 opCol_a,opCol_r,opCol_g,opCol_b; static UINT32 oldCol = 0xFFFFFFFF; if (col != oldCol) { #ifdef DSAMPLE_COLOUR opCol_a = 0xFF; // ((col & 0x0000FF00) >> 16); opCol_r = ((col & 0x0000F800) >> 8); opCol_g = ((col & 0x000007E0) >> 3); opCol_b = ((col & 0x0000001F) << 3); #else opCol_a = 0xFF; // ((col & 0x0000FF00) >> 16); opCol_r = ((col & 0x000000E0) ); opCol_g = ((col & 0x0000001C) << 3); opCol_b = ((col & 0x00000003) << 6); if (opCol_r == 0) opCol_r = 0x80; if (opCol_g == 0) opCol_g = 0x40; #endif #ifdef R2D_ENABLED r2d_set_background_color_with_argb(r2d_g_lcd_gc, opCol_a, opCol_r, opCol_g, opCol_b ); oldCol = col; #endif } } //GW Procedure/data supplied by new TI Driver V5.3.1 //length of array (32bit words) to hold a copy of the screen (maybe) #ifdef R2D_ENABLED extern T_R2D_GC_PTR r2d_g_lcd_gc; #endif /* */ void scrPlotR2DPoint(U32 col, INT16 x, INT16 y) { #ifdef R2D_ENABLED static U32 fCol=0xFFFFFFFF; static U32 bCol=0xFFFFFFFF; static U32 flip=0; if (fCol==col) { scrSetR2DFgdCol(col ); r2d_draw_point(r2d_g_lcd_gc,x,y); } else if (bCol == col) { scrSetR2DBgdCol(col ); r2d_erase_point(r2d_g_lcd_gc,x,y); } else if (flip) { flip = 0; scrSetR2DBgdCol(col ); r2d_erase_point(r2d_g_lcd_gc,x,y); bCol = col; } else { flip = 1; scrSetR2DFgdCol(col ); r2d_draw_point(r2d_g_lcd_gc,x,y); fCol = col; } #endif } #ifdef BSAMPLE void scrLCDUpdate (void) { #ifdef USE_PLOT int nPlots=0; int row,rowstart; int kstart,kend,k; UBYTE *bcopy; int i,j; UBYTE m; UBYTE *bm; #else int i; #endif #if defined (WIN32_SIM) return; #endif if (!scrEnabled) return; #ifdef USE_PLOT bm = &displayScr[0][0]; bcopy = &displayCopy[0][0]; m = 0x80; for (j = 0; j < LCD_ROW; j++) { for (k = 0; k < (LCD_COL+7)/8; k++) { //Only plot data if it has changed since last time if (*bm != *bcopy) { m = 0x80; kstart = k*8; kend = k*8+8; if (kend>LCD_COL) kend = LCD_COL; for (i = kstart; i < kend; i++) { #ifdef R2D_ENABLED if ((*bm) & m) r2d_draw_point(r2d_g_lcd_gc,i,j); else r2d_erase_point(r2d_g_lcd_gc,j,i); #endif m >>= 1; } *bcopy = *bm;//Update value } bm++; bcopy++; } } #else //* work around limitations of TI driver ! * for (i = 0; i < LCD_ROW; i++) { displayScr[i][LCD_COL_B-1] &= 0xF0; displayScr[i][LCD_COL_B-1] |= (UBYTE) ((displayScr[i][6] >> 2) & 0x0F); } LCD_PixBlt(0,0,LCD_COL_B*8,8,(char*)&displayScr[0][0]); LCD_PixBlt(0,8,LCD_COL_B*8,8,(char*)(&(displayScr[8][0]))); LCD_PixBlt(0,16,LCD_COL_B*8,8,(char*)(&(displayScr[16][0]))); LCD_PixBlt(0,24,LCD_COL_B*8,8,(char*)(&(displayScr[24][0]))); #if (!CUST)//JVJE #if (CUST==1) LCD_PixBlt(0,32,LCD_COL_B*8,8,(char*)(&(displayScr[32][0]))); LCD_PixBlt(0,40,LCD_COL_B*8,8,(char*)(&(displayScr[40][0]))); #endif #endif } #endif #ifdef CSAMPLE void scrLCDUpdate (void) { int kstart,kend,k; int row,rowstart; int i,j; INT16 x1,y1; UINT32 m; UINT32 *bm; UINT32 *bcopy; static UINT32 col=0; int count; int nPlots=0; #if defined (WIN32_SIM) return; #endif if (!scrEnabled) return; #ifdef USE_PLOT bm = picture_bw; bcopy = pictureCopy_bw; for (j = 0; j < DISPLAY_SIZE; j++) { if (*bm != *bcopy) { //Only plot data if it has changed since last time m = 0x80000000; x1 = j / LCD_COL_NUM_LWORDS; y1 = j % LCD_COL_NUM_LWORDS; y1 = y1 << 5; y1 = (y1 + 16); x1 = (scrX-1)-x1; kstart = y1; kend = y1+32; for (i = kstart; i < kend; i++) { nPlots++; #ifdef R2D_ENABLED if ((*bm) & m) r2d_draw_point(r2d_g_lcd_gc,x1,(i%64)); else r2d_erase_point(r2d_g_lcd_gc,x1,(i%64)); #endif m >>= 1; } *bcopy = *bm;//Update value } bm++; bcopy++; if (nPlots > MAX_NUMBER_PLOTS) return; } #else if (scrPicPtr != NULL) { #ifdef R2D_ENABLED r2d_fast_blit(scrPicPtr,r2d_g_lcd_gc); #endif vsi_t_sleep(VSI_CALLER (20)); } #endif //old/new } #endif //CSAMPLE //June 03, 2005 REF: GSM-ENH-31636 xpradipg //CRR 28825: xpradipg - 11 Feb 2005 #if (defined(DSAMPLE) || defined(ESAMPLE) || defined(ISAMPLE) || defined(CALLISTO))// changes for flag cleanup and addition for ISAMPLE void scrLCDUpdate (void) { #if defined (WIN32_SIM) return; #endif if (!scrEnabled) return; #ifdef R2D_ENABLED r2d_flush(); #endif } #endif//D-sample /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrMobCommand | +--------------------------------------------------------------------+ PURPOSE : Command string from mobile simulation */ void scrMobCommand (char *s) { #ifdef BSAMPLE char *p; unsigned char *q; int i; char scratch [LCD_ROW*LCD_COL_B*2+100]; /* command buffer */ if (strstr(s,"ena") == s) { mobEnabled = 1; return; } if (strstr(s,"dis") == s) { mobEnabled = 0; return; } if (strstr(s,"ok") == s) { if (xIndex < 0) return; strcpy(scratch,scrHeader); if (xIndex >= sizeof(displayScr)) { strcat(scratch,"done"); mfwExtOut(scratch); return; } strcat(scratch,"data "); p = scratch + strlen(scratch); sprintf(p,"%04d %04d ",xIndex,LCD_COL_B*LCD_ROW/DISPL_DIV); p = scratch + strlen(scratch); q = (UBYTE *) displayScr; for (i = 0; i < LCD_COL_B * LCD_ROW / DISPL_DIV; i++) { sprintf(p,"%02x",q[xIndex++]); p += 2; } *p = '\0'; mfwExtOut(scratch); return; } #endif } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrInit | +--------------------------------------------------------------------+ PURPOSE : initialize screen driver */ void scrInit (void) { LCD_SetPower(); /* ES!! */ LCD_Reset(); LCD_Enable(1); dspl_InitColour (); #ifdef LSCREEN font_initFont(1); #else font_initFont(0); #endif #ifdef BSAMPLE memset(displayScr,0,sizeof(displayScr)); memset(displayCopy,0,sizeof(displayCopy)); #else scrRivPictureInit(); #endif #ifdef R2D_ENABLED r2d_erase( r2d_g_lcd_gc ); #endif mobEnabled = 0; scrEnabled = 1; internal = 0; scrX = LCD_COL; scrY = LCD_ROW; xIndex = -1; displayData.DisplayType = DSPL_TYPE_GRAPHIC; //GW Set display window to full screen dspl_ResetWindow(); } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrExit | +--------------------------------------------------------------------+ PURPOSE : finalize screen driver */ void scrExit (void) { LCD_Enable(0); mobEnabled = 0; scrEnabled = 0; xIndex = -1; } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrUpdate | +--------------------------------------------------------------------+ PURPOSE : set screen update mode GW 18/09/01 clear text invert flag whenever display is enabled/disabled. */ //GW mmi_trace is a call to the MMI to provide timings for MMI updates - //REMOVE FROM FINAL BUILD (if I forget!) int scrUpdate (int onOff) { int ena = scrEnabled; txtInvert = 0; //clear text invert flag whenever display is enabled/disabled. scrEnabled = onOff; if (scrEnabled) { #ifdef MMI_TRACE mmi_trace("scrupdate() enable start"); #endif scrLCDUpdate(); scrMobUpdate(); #ifdef MMI_TRACE mmi_trace("scrupdate() enable end"); #endif } else { #ifdef MMI_TRACE mmi_trace("scrupdate() disabled"); #endif } return ena; } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrSize | +--------------------------------------------------------------------+ PURPOSE : retrieve display size */ void scrSize (int *x, int *y) { *x = scrX; *y = scrY; } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrOnOff | +--------------------------------------------------------------------+ PURPOSE : switch display On/Off */ void scrOnOff (int on) { //kk to be checked /* ## scratch is not required and function mfwExtOut is ## not doing anything sprintf(scratch,"%sscrOnOff:%d",scrHeader,on); mfwExtOut(scratch); */ } #if (!CUST)//JVJE #if (CUST==1) /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrLight | +--------------------------------------------------------------------+ PURPOSE : switch display backlight On/Off */ void scrLight (int on) { //kk to be checked /* ## scratch is not required and function mfwExtOut is ## not doing anything sprintf(scratch,"%sscrLight:%d",scrHeader,on); mfwExtOut(scratch); */ } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrClear | +--------------------------------------------------------------------+ PURPOSE : clear display */ void scrClear (void) { #ifdef BSAMPLE memset(displayScr,0,sizeof(displayScr)); #else scrRivPictureClear(); #endif if (scrEnabled) { LCD_Clear(); /* TI driver function */ scrMobUpdate(); /* update mobile simulation */ } } #endif //CUST==1 /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrClearRect | +--------------------------------------------------------------------+ PURPOSE : clear display area */ #ifdef DSAMPLE_LITE void scrDrawFilledRect (int px, int py, int sx, int sy, U32 col) { int i,j; U32 opCol; int word; //Limit rectangle to the size of the screen. if ((px >= scrX) || (py >= scrY)) return; if ((col& 0xFF000000) == TRANSPARENT_32BIT_COLOUR) return; //Background colour is transparent //Allow -ve sizes but change data round if (sx <0) { px = px+sx; sx = -sx; } if (sy <0) { py = py+sy; sy = -sy; } //Limit rectangle to size of window if (px<win_x1) { sx = sx - win_x1; px = win_x1; } if (py<win_y1) { sy = sy - win_y1; py = win_y1; } if (px+sx >=win_x2) sx = win_x2 - px-1; if (py+sy >=win_y2) sy = win_y2 - py-1; if ((sx <= 0) || (sy<=0)) return;//cannot draw zero width rectangle. opCol = col; { U32 maskL, maskR; int skipBits,startWord,endWord; maskL = 0xFFFFFFFF; skipBits = px & 0x1F; maskL = maskL << skipBits; startWord = px >> 5; maskR = 0xFFFFFFFF; skipBits = (px+sx) & 0x1F; maskR = ~(maskR << skipBits); endWord = (px+sx) >> 5; if (startWord == endWord) { maskL = maskL & maskR; maskR = maskL; } if (col == 0) { //Set bgd colour to Black (0) for (j = py; j < py + sy; j++) { word = DSPL_GET_LWORD(px,j); picture_bw[word] = picture_bw[word] & (~maskL); word++; for (i = startWord+1; i < endWord; i++) { picture_bw[word] = 0; word++; } word = DSPL_GET_LWORD(px+sx,j); picture_bw[word] = picture_bw[word] & (~maskR); } } else { //Set bgd colour to White (1) for (j = py; j < py + sy; j++) { word = DSPL_GET_LWORD(px,j); picture_bw[word] = picture_bw[word] | (maskL); word++; for (i = startWord+1; i < endWord; i++) { picture_bw[word] = 0xFFFFFFFF; word++; } word = DSPL_GET_LWORD(px+sx,j); picture_bw[word] = picture_bw[word] | (maskR); } } } } #endif #ifdef DSAMPLE_COLOUR void scrDrawFilledRect (int px, int py, int sx, int sy, U32 col) { int i,j; U32 opCol; char* screen; //Limit rectangle to the size of the screen. if ((px >= scrX) || (py >= scrY)) return; if ((col& 0xFF000000) == TRANSPARENT_32BIT_COLOUR) return; //Background colour is transparent //Allow -ve sizes but change data round if (sx <0) { px = px+sx; sx = -sx; } if (sy <0) { py = py+sy; sy = -sy; } //Limit rectangle to size of window if (px<win_x1) { sx = sx - win_x1; px = win_x1; } if (py<win_y1) { sy = sy - win_y1; py = win_y1; } if (px+sx > win_x2) sx = win_x2 - px; if (py+sy > win_y2) sy = win_y2 - py; if ((sx <= 0) || (sy<=0)) return;//cannot draw zero width rectangle. opCol = col; //GW Fix - invert colour #ifdef USE_PLOT for (j = py; j < py + sy; j++) { for (i = px; i < px+sx; i++) scrPoint(i,j,opCol); } #else { U32 lWord,bgdColour; int y; screen = (char*)picture_col; bgdColour = DSPL_GET_BITCOLOUR(col); bgdColourArray[0] = (bgdColour & 0x000000FF); bgdColourArray[1] = (bgdColour & 0x0000FF00) >>8; bgdColourArray[2] = (bgdColour & 0x00FF0000) >>16; bgdColourArray[3] = (bgdColour & 0xFF000000) >>24; for (i=BYTEPERPIXEL;i<sx*BYTEPERPIXEL;i++) bgdColourArray[i] = bgdColourArray[i-BYTEPERPIXEL]; for (y=py; y<py+sy; y++) { // int yOfs = (y*LCD_COL+px); int yOfs = DSPL_GET_BYTE(px,y); memcpy(&screen[yOfs] ,bgdColourArray,sx*BYTEPERPIXEL); } } #endif//use plot } #endif #ifdef BSAMPLE void scrDrawFilledRect (int px, int py, int sx, int sy, U32 col) { scrClearRect (px, py, sx, sy); } #endif #ifdef CSAMPLE void scrDrawFilledRect (int px, int py, int sx, int sy, U32 col) { scrClearRect (px, py, sx, sy); } #endif void scrClearRect (int px, int py, int sx, int sy) { #ifdef BSAMPLE int i,j; int x1, x2; UBYTE m1, m2; #endif #ifdef CSAMPLE int x1; int i,j; int y1s, y2s; int y1f, y2f; U32 m1s,m2s; U32 m1f,m2f; int y1, y2; U32 m1,m2; #endif if (px < 0 || py < 0 || px >= scrX || py >= scrY || sx < 0 || sy < 0) return; if (px + sx > scrX) sx = scrX - px; if (py + sy > scrY) sy = scrY - py; //Limit rectangle to size of window if (px<win_x1) { sx = sx - win_x1; px = win_x1; } if (py<win_y1) { sy = sy - win_y1; py = win_y1; } if (px+sx >win_x2) sx = win_x2 - px; if (py+sy >win_y2) sy = win_y2 - py; if ((sx <= 0) || (sy<=0)) return;//cannot draw zero width rectangle. #ifdef BSAMPLE x1 = px / 8; /* first x offset */ x2 = (px + sx) / 8; /* last x offset */ m1 = m2 = 0xff; m1 = (UBYTE) ~(m1 >> (px & 7)); /* left mask */ m2 = (UBYTE) (m2 >> ((px + sx) & 7)); /* right mask */ if (x1 == x2) m1 = m2 = m1 | m2; /* combined masks */ for (j = py; j < py + sy; j++) { displayScr[j][x1] &= m1; for (i = x1 + 1; i < x2; i++) displayScr[j][i] = '\0'; displayScr[j][x2] &= m2; } #endif #ifdef CSAMPLE for (i=0;i<sx;i++) for (j=0;j<sy;j++) scrPoint(px+i,py+j,0); #endif //June 03, 2005 REF: GSM-ENH-31636 xpradipg //CRR 28825: xpradipg - 11 Feb 2005 #if (defined(DSAMPLE) || defined(ESAMPLE) || defined(ISAMPLE) || defined(CALLISTO)) //clean up of flag and addition for ISAMPLE scrDrawFilledRect ( px, py, sx, sy, dspl_GetBgdColour()); #endif } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrText_Unicode | +--------------------------------------------------------------------+ PURPOSE : draw text */ void scrText_Unicode (int x, int y, USHORT *txt) { UBYTE current_width=0; USHORT current_code,first_byte_code,second_byte_code; t_font_bitmap* current_bitmap,*error_bitmap; if ( y > scrY) return; while ((*txt) && (x <= scrX)) { current_code = (USHORT)((*txt)<<8)+(USHORT)((*txt)>>8);/*The USHORT is inverted, therefore we have to apply this simple change*/ current_bitmap = get_bitmap(current_code); if (!current_bitmap) /*ASCII codes will be represented*/ { first_byte_code = (USHORT)((*txt)&0xFF); error_bitmap = get_bitmap(first_byte_code); if (error_bitmap) { dspl_show_bitmap(x,y,error_bitmap,SHOWBITMAP_INVERT); x += error_bitmap->width; } second_byte_code = (USHORT)((*txt)>>8); error_bitmap = get_bitmap(second_byte_code); if (error_bitmap) { dspl_show_bitmap(x,y,error_bitmap,SHOWBITMAP_INVERT); x += error_bitmap->width; } } else { dspl_show_bitmap(x,y,current_bitmap,SHOWBITMAP_NORMAL); x += current_bitmap->width; } txt++; } } #ifndef DSAMPLE_COLOUR //Should work for DSAMPLE_LITE void dspl_show_bitmap(int x,int y,t_font_bitmap* current_bitmap,U32 attr ) { USHORT i, j,a,b; int bmpWidthBytes; bmpWidthBytes = (current_bitmap->width + 0x07) >> 3; for (i = 0; i < current_bitmap->height; i++) for (j = 0; j < current_bitmap->width; j++) { a = (j&(0x07)); b = i*(bmpWidthBytes)+((j&0xF8)>>3); if ((attr & SHOWBITMAP_SCALE_2x4) == 0) { if ((attr & SHOWBITMAP_NORMAL_MASK) == SHOWBITMAP_NORMAL) scrPoint(x+j,y+i,current_bitmap->bitmap[b]&(0x80>>a)); else scrPoint(x+j,y+i,((UBYTE)~(current_bitmap->bitmap[b]))&(0x80>>a)); } else { int x1,y1; int px = (current_bitmap->bitmap[b]&(0x80>>a)); for (x1 = x+j*2;x1 < x+j*2+2; x1++) for (y1 = y+i*4; y1<y+i*4+4; y1++) scrPoint(x1,y1,px); } } } #endif #ifdef DSAMPLE_COLOUR void dspl_show_bitmap(int x,int y,t_font_bitmap* current_bitmap,U32 attr ) { int i, j; int bmpByte; // which byte in bitmap we are looking at UBYTE bmpMask; // which bit in the (b+w) bitmap we are looking at UBYTE bitSet; // is the bit set or clear. U32 bitCol; // colour of bit in a colour bitmap U32 fCol,bCol, col;/*MC SPR 1526*/ int step; int lWord; if (current_bitmap==NULL) return; switch (current_bitmap->format) { case BMP_FORMAT_BW_UNPACKED: case BMP_FORMAT_BW_PACKED: //b+w bitmap - deal with both packed and unpacked. bmpMask = 0x80; bmpByte = 0; if (attr & SHOWBITMAP_INVERT) //invert { fCol = dspl_GetBgdColour(); bCol = dspl_GetFgdColour(); } else { fCol = dspl_GetFgdColour(); bCol = dspl_GetBgdColour(); } if (fCol==bCol) { fCol = 0x000000FF; bCol =0x00FFFF00; } for (i = 0; i < current_bitmap->height; i++) { for (j = 0; j < current_bitmap->width; j++) { /* a = (j&(0x07)); b = i*((current_bitmap->bitmapSize)/(current_bitmap->height))+((j&0xF8)>>3); bitSet = current_bitmap->bitmap[b]&(0x80>>a);*/ bitSet = current_bitmap->bitmap[bmpByte]&(bmpMask); /*MC SPR 1526*/ if (bitSet) col = fCol; else col = bCol; if (col!=TRANSPARENT_32BIT_COLOUR)/*if colour transparent, don't draw point*/ { scrPoint(x+j,y+i,col); } /*MC 1526 end*/ if (bmpMask <= 1) { bmpMask = 0x80; bmpByte++; } else bmpMask = bmpMask >>1; } // If we have an unpacked bitmaps and we are not already on a new byte, we move to a new byte if ((current_bitmap->format == BMP_FORMAT_BW_UNPACKED) && (bmpMask != 0x80)) { bmpMask = 0x80; bmpByte++; } } break; case BMP_FORMAT_256_COLOUR: //bitmap is 256 colour bitmap - ignore 'attr' bmpByte = 0; for (i = 0; i < current_bitmap->height; i++) { for (j = 0; j < current_bitmap->width; j++) { UINT32 col; UINT32 colR,colG,colB; col = current_bitmap->bitmap[bmpByte]; if (col!=TRANSPARENT_256_COL) { bitCol = (((col &0xE0) <<16) | ((col &0x1C) <<11) | ((col &0x03) << 6));/**/ //assume 16 bit colour scrPoint(x+j, y+i,bitCol); } bmpByte = bmpByte+1; //move to next byte } } break; case BMP_FORMAT_32BIT_COLOUR: //bitmap is a 32 bit colour bitmap - ignore 'attr' bmpByte = 0; for (i = 0; i < current_bitmap->height; i++) { for (j = 0; j < current_bitmap->width; j++) { //32 bit bitmap - data is in bytes //bmpByte = (i*current_bitmap->width+j)*4; bitCol = ((current_bitmap->bitmap[bmpByte] <<24) | (current_bitmap->bitmap[bmpByte+1] <<16) | (current_bitmap->bitmap[bmpByte+2] <<8) | (current_bitmap->bitmap[bmpByte+3])); if ((bitCol & 0xFF000000)!=TRANSPARENT_32BIT_COLOUR) scrPoint(x+j,y+i,bitCol); bmpByte = bmpByte+4; //move to next 32bit word } } break; case BMP_FORMAT_16BIT_LCD_COLOUR: //32 bits only first 2 bytes used case BMP_FORMAT_16BIT_LCD_COMPRESSED_COLOUR: //16 bits bmpByte = 0; if (current_bitmap->format == BMP_FORMAT_16BIT_LCD_COMPRESSED_COLOUR) step = 2; else step = 4; for (i = 0; i < current_bitmap->height; i++) { for (j = 0; j < current_bitmap->width; j++) { //32 bit bitmap - data is in bytes //bmpByte = (i*current_bitmap->width+j)*4; bitCol = ((current_bitmap->bitmap[bmpByte+1] <<8) | (current_bitmap->bitmap[bmpByte])); if ((bitCol & 0x0000FFFF)!=TRANSPARENT_16BIT_COL) { lWord = DSPL_GET_LWORD(x+j,y+i); // July 1, 2005 REF: CRR 32677 - xpradipg // The data present of all 16bit images are in the negated format hence we // renegate to get it in the right format #if (defined(ISAMPLE) ||defined(CALLISTO)) bitCol = ~bitCol; #endif DSPL_SET_BITCOLOUR(x+j,lWord,bitCol,"dsplShowbitmap"); } bmpByte = bmpByte+step; //move to next 32/16bit word } } break; default: //Unknown format break; } } #endif #define NO_COLOUR 0xFF123456 /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : dspl_setBorderWidth | +--------------------------------------------------------------------+ PURPOSE : sets current border width GW 10/02/03 SPR#1721 - Created */ static int txtBorder=0; int dspl_setBorderWidth(int borderSize) { int oldBorder; oldBorder = txtBorder; if ((borderSize >=0) && (borderSize <=4)) txtBorder = borderSize; return (oldBorder); } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : dspl_getBorderWidth | +--------------------------------------------------------------------+ PURPOSE : returns current border width GW 10/02/03 SPR#1721 - Created */ int dspl_getBorderWidth(void) { return(txtBorder); } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrCharBorderOutput | +--------------------------------------------------------------------+ PURPOSE : draw text with a border GW 10/02/03 SPR#1721 - Created */ void scrCharBorderOutput(t_font_bitmap* chrBmp, unsigned int fgdCol,unsigned int bgdCol,unsigned int borderCol, int bWidth, int px,int py ) { int x,y,i; int line[10]; int ofs; int bgdLine; int col; int emask,pmask; int init_emask = (0x01 << (28+bWidth)); int init_pmask = (0x01 << (28+bWidth)); /* */ for (i=0;i<10;i++) line[i] = 0; //trace("col=",fgdCol, bgdCol,borderCol,0x13); //set up border mask for (i=1;i<bWidth*2;i++) { init_emask = init_emask | (init_pmask >> i) | (init_pmask << i); } //trace("masks=",init_emask,init_pmask,0,0x12); for (y=-bWidth;y<chrBmp->height+bWidth;y++) { //trace("y,ht,bWidth",y,chrBmp->height,bWidth, 0x03); for (i=0;i<bWidth*2;i++) line[i]=line[i+1]; line[bWidth*2] =0; if (y+bWidth<chrBmp->height) { //work out where we want to display background bgdLine = 0x0FFFFFF0; bgdLine = bgdLine & (bgdLine << (24-chrBmp->width)); //Assume bitmaps are unpacked switch((chrBmp->width+7) & (0xF8)) { case 0x00: //no data break; case 0x08: // 1 byte/char ofs = y+bWidth; line[bWidth*2] = ((unsigned int)chrBmp->bitmap[ofs]) << 20; break; case 0x10: // 2 bytes/char ofs = (y+bWidth)*2; line[bWidth*2] = (((unsigned int)chrBmp->bitmap[ofs]) << 20) | (((unsigned int)chrBmp->bitmap[ofs+1]) << 12) ; break; case 0x18: // 3 bytes/char ofs = (y+bWidth)*3; line[bWidth*2] = (((unsigned int)chrBmp->bitmap[ofs]) << 20) | (((unsigned int)chrBmp->bitmap[ofs+1]) << 12) | (((unsigned int)chrBmp->bitmap[ofs+2]) << 4) ; break; default:// unable to handle bitmaps > 24 pixels wide //output checkerboard pattern as an error if (y &0x01) line[bWidth*2] = 0x0CCCCCC0; else line[bWidth*2] = 0x05555550; break; } } else { line[bWidth*2] = 0x00000000; bgdLine = 0x00; } //trace("line=",line[0],line[1], line[2], 0x13); emask = init_emask; // if any of the 3 pixels are set - erase point pmask = init_pmask; // only when pixel is set - plot point. for (x=-bWidth;x<chrBmp->width+bWidth;x++) { col = NO_COLOUR; if (line[bWidth] & pmask) { //pixel is in fgd colour col = fgdCol; } else { for (i=0;i<bWidth*2+1;i++) { if (line[i] & emask) col = borderCol; } if ((bgdLine & pmask) && (col == NO_COLOUR)) { col = bgdCol; } } if ((col != NO_COLOUR) && (col != TRANSPARENT_32BIT_COLOUR)) scrPoint(px+x,py+y,col); emask = emask>>1; pmask = pmask>>1; // trace("masks=",emask,pmask,col,0x13); } } } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrFastCharOutput | +--------------------------------------------------------------------+ PURPOSE : draw text avoiding using scrPoint GW 10/02/03 SPR#1736 - Created */ #ifdef DSAMPLE_COLOUR void scrFastCharOutput(t_font_bitmap* chrBmp, unsigned int fColconv,unsigned int bColconv, int x,int y ) { int fHeight = dspl_GetFontHeight(); int ofs = chrBmp->height - fHeight; int width = chrBmp->width; int i,j,k = 0; int sx,sy,ex,ey,lWord; int bitSet; UBYTE mask; int ofsj,nbytes; unsigned int col; //ensure that the data is never wiritten 'off-screen' if (x+width > win_x2) ex = win_x2-x; else ex = width; if (y+fHeight > win_y2) ey = win_y2-y; else ey = fHeight; if (x < win_x1) sx = win_x1-x; else sx = 0; if (y < win_y1) sy = win_y1-y; else sy = 0; nbytes = (width+7) >>3; ofs = ofs + sy; for (i=sy;i<ey;i++) { mask = 0x80 >> (sx & 0x07); ofsj = sx >> 3; for (j=sx;j<ex;j++) { //Have we data for the bitmap ?. If not, output a blank line. if (ofs >=0) bitSet = chrBmp->bitmap[ofs*nbytes+ofsj]&(mask); else bitSet = 0; if (bitSet) col = fColconv; else col = bColconv; if (col!=TRANSPARENT_32BIT_COLOUR) { lWord = DSPL_GET_LWORD(j+x,i+y); DSPL_SET_BITCOLOUR(j+x,lWord,col,"scrFastCharOutput"); } mask = mask >> 1; if (mask==0) { ofsj++; mask = 0x80; } } ofs++; } } #endif /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrCharOutput | +--------------------------------------------------------------------+ PURPOSE : draw text GW 10/02/03 SPR#1736 - Created */ void scrCharOutput(t_font_bitmap* chrBmp, unsigned int fCol,unsigned int bCol, int x,int y, int wChar, int hChar ) { int fHeight = dspl_GetFontHeight(); int ofs = chrBmp->height - fHeight; int width = chrBmp->width; int i,j,k = 0; int bitSet; UBYTE mask; int ofsj,nbytes; unsigned int col; int shiftj; ofs = chrBmp->height - fHeight; width = chrBmp->width; k = 0; for (i=0;i<fHeight;i++) { k = 0; nbytes = (width+7) >>3; for (j=0;j<width;j++) { shiftj= j & 0x07; ofsj = j >> 3; //Have we data for the bitmap ?. If not, output a blank line. if (ofs >=0) bitSet = chrBmp->bitmap[ofs*nbytes+ofsj]&(0x80>>shiftj); else bitSet = 0; if (bitSet) col = fCol; else col = bCol; if (col!=TRANSPARENT_32BIT_COLOUR) { if (!hChar) scrPoint(k+x,i+y,col); else { scrPoint(k+x,i*2+y,col); scrPoint(k+x,i*2+1+y,col); } if (wChar) { if ((j>=1) && (j<=wChar)) { //for j=1,2,3 - plot 2 pixels k++; if (!hChar) scrPoint(k+x,i+y,col); else { scrPoint(k+x,i*2+y,col); scrPoint(k+x,i*2+1+y,col); } } } } k++; } ofs++; } } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : dspl_ScrText | +--------------------------------------------------------------------+ PURPOSE : draw a line of ascii/unicode text GW 18/09/01 - Made invert flag local to file not procedure GW 10/02/03 SPR#1721 Added code to call separate procedure if a border is required. Removed existing 'border' code. GW 14/02/03 SPR#1736 - Split code into separate procedures Modified error display code to output ascii characters of the code if no matching bitmap is found. */ void dspl_ScrText (int x, int y, char *txt, int style) { int nChar = 0; int i, j, k; t_font_bitmap* chrBmp; t_font_bitmap* errBmp[2] = {NULL,NULL}; int str1, str2; int border = 0; int shadow = 0; int fHeight; int wChar,hChar,shadowHt; unsigned int fCol,bCol,borderCol,shadowCol,fColconv,bColconv; unsigned int col; int startX; USHORT code; startX = x; shadowCol = 0; borderCol = 0; border = dspl_getBorderWidth(); //default to wide chars (for the moment) if (style & TXT_STYLE_WIDECHAR) wChar = 3; else wChar = 0; if (style & TXT_STYLE_HIGHCHAR) hChar = 1; else hChar = 0; //Set-up default colours fCol = dspl_GetFgdColour(); bCol = dspl_GetBgdColour(); switch (style & TXT_STYLE_MASK) { case TXT_STYLE_NORMAL: //Normal default: break; case TXT_STYLE_INVERT: //Invert fCol = dspl_GetBgdColour(); bCol = dspl_GetFgdColour(); break; case TXT_STYLE_HIGHLIGHT: //highlight - colour background of selected item in differently. bCol = dspl_GetHighlightColour(); break; case TXT_STYLE_BORDER: // 1 pixelborder if (border==0) border = 1; break; case TXT_STYLE_2PIXEL_BORDER: // 2 pixelborder if (border==0) border = 2; break; case TXT_STYLE_3PIXEL_BORDER: // 3 pixelborder if (border==0) border = 3; break; case TXT_STYLE_4PIXEL_BORDER: // 4 pixelborder if (border==0) border = 4; break; case TXT_STYLE_SHADOW1: //shadow shadow = 1; break; case TXT_STYLE_SHADOW2: //deeper shadow shadow = 2; break; } if (fCol==bCol) { fCol = 0x00FF0000; bCol = 0x0000FFFF; } if (border) { borderCol = dspl_GetBorderColour(); if (borderCol == fCol) { //A border colour the same as the text colour - get a contrasting colour borderCol = dspl_GetContrastColour(fCol); } } else borderCol = 0; if (shadow) shadowCol = dspl_GetShadowColour(); else shadowCol = 0; // SH - modified because it doesn't allow text to start off the screen // GW - allow text to start off-screen but finish if completely off-screen if (y > scrY) return; if (txt ==NULL) return; fHeight = dspl_GetFontHeight(); if (hChar) shadowHt = fHeight*2; else shadowHt = fHeight; //For faster operation - precalculate colours #ifdef DSAMPLE_COLOUR if (fCol!=TRANSPARENT_32BIT_COLOUR) fColconv = DSPL_GET_BITCOLOUR(fCol); else fColconv = fCol; if (bCol!=TRANSPARENT_32BIT_COLOUR) bColconv = DSPL_GET_BITCOLOUR(bCol); else bColconv = bCol; #endif code = 0xFFFF; while ((code !=0) &&(x <= scrX)) { nChar++; /*mc SPR 1319*/ if (style &TXT_STYLE_UNICODE) { str1 = *txt; str2 = *(txt+1); code = ((str1<<8)&0xFF00) | (str2&0x00ff); } else/*mc end*/ { str1 = *txt; str2 = 0x00; /*SPR 1508, convert ASCII char to unicode before drawing it*/ code = translation_ascii_2_unicode[*txt]; } if (code != 0) { chrBmp = get_bitmap(code); if (chrBmp == NULL) { errBmp[0] = get_bitmap(str1); errBmp[1] = get_bitmap(str2); } #ifdef MMI_TRACE { char bfr[40]; if ((chrBmp==NULL) || (chrBmp->code==0xFFFF)) { sprintf(bfr,"Undefined bitmap for 0x%04X",code); mmi_trace(bfr); } } #endif } else //end of string reached chrBmp =NULL; if (chrBmp != NULL) { if (border) { scrCharBorderOutput(chrBmp,fCol,bCol,borderCol,border,x,y); } #ifdef DSAMPLE_COLOUR else if ((!hChar) && (!wChar)) { //GW 28/11/02 - for speed, don't use 'scrPoint' //NB Code is only correct for a D-sample scrFastCharOutput(chrBmp,fColconv,bColconv,x,y); } #endif //DSAMPLE_COLOUR else { scrCharOutput(chrBmp,fCol,bCol,x,y,wChar,hChar); } x = x + chrBmp->width + wChar; //add 3 for 'wide' chars //If there is a pixel border between chars at the moment - x = x+border; } else if (code!=0) { //We have no bitmap - display ascii equivalent for (i=0;i<2;i++) { if (errBmp[i]!= NULL) { scrCharOutput(errBmp[i],fCol,bCol,x,y,wChar,hChar); x = x + errBmp[i]->width + wChar; errBmp[i] = NULL; } } } /*MC SPR 1319*/ if (style &TXT_STYLE_UNICODE) txt+=2; else /*mc end*/ txt++; } if (shadow) { for (i=0;i<shadowHt;i++) { for (k=0;k<shadow;k++) scrPoint(x+k,i+y+k,shadowCol); } for (j=startX;j<x;j++) { for (k=0;k<shadow;k++) scrPoint(j+1+k,shadowHt+y+k, shadowCol); } } #ifdef MMI_TRACE { char bfr[40]; sprintf(bfr,"Nchr=%d (%d,%d)",nChar,x,y); mmi_trace(bfr); } #endif } void scrText (int x, int y, char *txt) { //Display non-inverted text dspl_ScrText (x,y, txt, TXT_STYLE_NORMAL); } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrText_Invert_Unicode| +--------------------------------------------------------------------+ PURPOSE : draw text inverted */ void scrText_Invert_Unicode (int x, int y, USHORT *txt) { UBYTE current_width=0; USHORT current_code,first_byte_code,second_byte_code; t_font_bitmap* current_bitmap,*error_bitmap; if (x < 0 || y < 0 || y + 12 > scrY) return; while ((*txt) && (x + current_width <= scrX)) { current_code = (USHORT)((*txt)<<8)+(USHORT)((*txt)>>8);/*The USHORT is inverted, therefore we have to apply this simple change*/ current_bitmap = get_bitmap(current_code); if (!current_bitmap) /*ASCII codes will be represented*/ { first_byte_code = (USHORT)((*txt)&0xFF); error_bitmap = get_bitmap(first_byte_code); if (error_bitmap) { dspl_show_bitmap(x,y,error_bitmap,SHOWBITMAP_INVERT); x += error_bitmap->width; } second_byte_code = (USHORT)((*txt)>>8); error_bitmap = get_bitmap(second_byte_code); if (error_bitmap) { dspl_show_bitmap(x,y,error_bitmap,SHOWBITMAP_INVERT); x += error_bitmap->width; } } else { dspl_show_bitmap(x,y,current_bitmap,SHOWBITMAP_INVERT); x += current_bitmap->width; } txt++; } } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrText_Invert | +--------------------------------------------------------------------+ PURPOSE : draw text inverted */ void scrText_Invert (int x, int y, char *txt) { //Display inverted text dspl_ScrText (x,y, txt, TXT_STYLE_INVERT); } EXTERN UBYTE dspl_str_length(char * str) { UBYTE count=0; USHORT* current; if (dspl_get_char_type() == DSPL_TYPE_ASCII) return (strlen(str)); else { current = (USHORT*) str; while (*current) { count++; current++; } return count; } } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrLine | +--------------------------------------------------------------------+ PURPOSE : draw line */ void scrLine (int x1, int y1, int x2, int y2) { int x, y, dx, dy, c1, c2, err, swap = 0; U32 fCol; if (x1 < 0 || x1 >= scrX || x2 < 0 || x2 >= scrX || y1 < 0 || y1 >= scrY || y2 < 0 || y2 >= scrY) return; fCol = dspl_GetFgdColour(); dx = x2 - x1; dy = y2 - y1; if (((dx < 0) ? -dx : dx) < ((dy < 0) ? -dy : dy)) { swap = 1; /* take the long way */ x = x1; x1 = y1; y1 = x; x = x2; x2 = y2; y2 = x; } if (x1 > x2) { x = x1; x1 = x2; x2 = x; /* always move to the right */ y = y1; y1 = y2; y2 = y; } dx = x2 - x1; dy = y2 - y1; c1 = dy * 2; dy = 1; if (c1 < 0) { c1 = -c1; dy = -1; } err = c1 - dx; c2 = err - dx; x = x1; y = y1; while (x <= x2) { scrPoint(swap?y:x,swap?x:y,fCol); x++; if (err < 0) err += c1; else { y += dy; err += c2; } } if (internal) return; } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrRect | +--------------------------------------------------------------------+ PURPOSE : draw rectangle */ void scrRect (int px, int py, int sx, int sy) { internal = 1; scrLine(px,py,px+sx,py); scrLine(px,py+sy,px+sx,py+sy); scrLine(px,py,px,py+sy); internal = 0; scrLine(px+sx,py,px+sx,py+sy); } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrFntSelect | +--------------------------------------------------------------------+ PURPOSE : select the current font */ int scrFntSelect (int font) { return 1; /* always OK */ } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrFntHeight | +--------------------------------------------------------------------+ PURPOSE : get height of current font */ int scrFntHeight (void) { #ifdef LSCREEN return 16; #endif if (dspl_char_type == DSPL_TYPE_ASCII) return 8; else return 12; } //Really get information about // (1) how many chars we can have on a line // (2) how many pixels are in a string //GW SPR#1721 - Include a border in the calculations int scrGetRealLength(char *str, int* totChar, int* totPixel) { int nChar=0; int nPixel=0; int maxChar,maxPixel; t_font_bitmap* bmp; int strEnd; USHORT str16,str1,str2; UBYTE current_display_char_type = dspl_char_type;/*mc SPR 1319*/ int border; //Calculate extra pixels allowed for the border border = dspl_getBorderWidth(); if (*totChar<=0) //assume full str required. maxChar = 256; //stop after 256 chars else maxChar = *totChar; //stop after 256 chars if (*totPixel<=0)// assume no limit to len - limit at 2x screen maxPixel = 2*scrX; else maxPixel = *totPixel; strEnd = FALSE; /*MC SPR 1319, char type is unicode if unicode tag*/ if(str[0] == 0x80) { current_display_char_type = DSPL_TYPE_UNICODE; str+=2; /*ignore first char SPR 1442*/ nChar+=2;/*MC*/ } else /*SPR 1526, assume if no unicode tag, we're in ASCII*/ current_display_char_type = DSPL_TYPE_ASCII; /*MC 1526, end*/ while (!strEnd) { if (current_display_char_type == DSPL_TYPE_ASCII) { str16 = *str; str++; } else { str1 = *str; str++; str2 = *str; str++; str16 = ((str1 << 8) & 0xFF00) + (str2 & 0x00FF);/*MC, fixed bitmask 1319*/ } if (str16 == 0) { //reached end of string. strEnd = TRUE; bmp = NULL; } else bmp = get_bitmap(str16); if (bmp!= NULL) { if (nPixel +bmp->width < maxPixel) { nPixel = nPixel + bmp->width+border; if (current_display_char_type == DSPL_TYPE_ASCII) nChar++; else nChar+=2; if (nChar >= maxChar) strEnd = TRUE; } else strEnd=TRUE; } } *totChar = nChar; *totPixel = nPixel; return (nPixel); } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrFntGetFit | +--------------------------------------------------------------------+ PURPOSE : number of string chars that fit into the line */ int scrFntGetFit (char *tp, int lineWidth) { int totChar = 0; // scrGetRealLength(tp, &totChar, &lineWidth); // return (totChar); if (dspl_char_type == DSPL_TYPE_ASCII) return (lineWidth /6); else return (lineWidth / 12); } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrFntGetLen | +--------------------------------------------------------------------+ PURPOSE : number of pixel used by first n string chars */ int scrFntGetLen(char *tp, int nChars) { int lineWidth = 0; int count=0; if (dspl_char_type == DSPL_TYPE_ASCII) return (nChars * 6); else { USHORT* temp = (USHORT*)tp; while (*temp) { UBYTE first_byte = (UBYTE)(*temp); if (first_byte) count+=12; else count+=6; temp++; } return count; } } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrBmpDraw | +--------------------------------------------------------------------+ PURPOSE : draw bitmap */ int scrBmpDraw (int px, int py, int sx, int sy, int ix, char *bm, int mode) { int i, j; unsigned char m; if (px < 0 || px >= scrX || py < 0 || py >= scrY || sx < 0 || sy < 0) return 0; if (px + sx > scrX) sx = scrX - px; if (py + sy > scrY) sy = scrY - py; m = 0x80; bm += (sx * sy * ix) / 8; for (j = 0; j < sy; j++) { for (i = 0; i < sx; i++) { scrPoint(px+i,py+j,*bm & m); m >>= 1; if (!m) { m = 0x80; bm++; } } if (m != 0x80) { m = 0x80; bm++; } } return 0; } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrCurType | +--------------------------------------------------------------------+ PURPOSE : set cursor type (0 = no cursor) */ void scrCurType (int type) { } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrCursor | +--------------------------------------------------------------------+ PURPOSE : set cursor at specified position */ void scrCursor (int x, int y) { scrLine(x,y+7,x+5,y+7); } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : ti1_scr | | STATE : code ROUTINE : scrPoint | +--------------------------------------------------------------------+ PURPOSE : draw point */ //Return colour of pixel at point (px,py) or zero if not on screen. static int getScrPoint (int px, int py) { #ifdef BSAMPLE unsigned char m = 0x80; #endif //BSAMPLE #ifdef CSAMPLE U32 m2; #endif //CSAMPLE int x1,y1; int lWord; // index for colour word U32 opWord; //olour word U32 op_col; U32 picCol; if (px < 0 || py < 0 || px >= scrX || py >= scrY) return (0); #ifdef BSAMPLE m >>= px & 7; // mask px >>= 3; // x offset if (displayScr[py][px] & m) return (0x00FFFFFF); else return (0x00000000); #endif //BSAMPLE #ifdef CSAMPLE //Display plots data from Right to Left // - reverse x-coordinate //Also display seems to be 16 pixels down the screen - //plot points at y=(y-16) mod 64 x1 = (scrX-1)-px; y1 = (py+48) & 63; //(py-16) ; //Display is in columns for TI drivers m2 = 0x80000000; m2 = m2 >> (y1 & 31); //shift m2 by 0-31 y1 = y1 >> 5; // 32bits/word return (picture_bw[lWord] & m2); #endif //CSAMPLE #ifdef DSAMPLE_COLOUR //i/p colour is 32 bit - reduce to 16 x1 = px; y1 = py; lWord = y1*LCD_ROW_NUM_LWORDS + x1; //GW invert pic bits opWord = ~picture_col[lWord]; //Change from 16(8) bits to 32(24) bits #ifdef DSAMPLE_COLOUR32 opWord = opWord & 0x0000FFFF; #endif //DSAMPLE_COLOUR32 #ifdef DSAMPLE_COLOUR16 #ifdef PIXEL_0_IN_LSW if (lWord & 0x01) opWord = ((opWord >>16) & 0x0000FFFF); else opWord = ((opWord ) & 0x0000FFFF); #else if (lWord & 0x01) opWord = ((opWord ) & 0x0000FFFF); else opWord = ((opWord >>16) & 0x0000FFFF); #endif #endif //DSAMPLE_COLOUR16 return(DSPL_GET_PIXELCOLOUR(opWord)); #endif //DSAMPLE_COLOUR #ifdef DSAMPLE_LITE //i/p colour is 32 bit - reduce to 16 { int xmask; x1 = px; y1 = py; lWord = DSPL_GET_LWORD(x1,y1); //y1*LCD_ROW_NUM_LWORDS + x1 >> 5; xmask = 0x01 << (x1 & 0x1F); //GW invert pic bits if (picture_bw[lWord] & xmask) opWord = 0x00FFFFFF; else opWord = 0x00000000; //Change from 16(8) bits to 32(24) bits } return (opWord); #endif //DSAMPLE_LITE } static int checkPixelColour(int px, int py, U32 col) { U32 currCol; currCol = getScrPoint (px, py); if ((currCol & 0x00F8FCF8) == (col & 0x00F8FCF8))//16bit colour return (1); //colours match else return (0); //colours are different } unsigned int translucence(unsigned int ipCol,unsigned int picCol) { int trans1,trans2; U32 col_red1,col_green1,col_blue1; U32 col_red2,col_green2,col_blue2; U32 rmerge,gmerge,bmerge; U32 opCol; //0xFF=transparent (col=picCol) //0x00=solid (col=ipCol) trans1 = (ipCol >>24) & 0xFF; trans2 = 255-trans1; if (trans1 == 0x00) return (ipCol); else if (trans1 == 0xFF) return (picCol); //Read in colour from 24 bits col_red1 = (ipCol & 0x00FF0000) >> 8; col_green1 = (ipCol & 0x0000FF00) >> 8; col_blue1 = (ipCol & 0x000000FF); //Read in colour from 8 bits col_red2 = (picCol & 0x00FF0000) >> 8; col_green2 = (picCol & 0x0000FF00) >> 8; col_blue2 = (picCol & 0x000000FF); //red = 0x0000xx00, green = 0x000000xx, blue = 0x000000xx (256x higher than it should be) //Round values up // rmerge = (col_red1 *trans1+col_red2 *trans2+0x0FFFF) & 0x00FF0000; // gmerge = (col_green1*trans1+col_green2*trans2+0x000FF) & 0x0000FF00; // bmerge =((col_blue1 *trans1+col_blue2 *trans2+0x000FF) >> 8)& 0x000000FF; rmerge = (col_red1 *trans2+col_red2 *trans1+0x1F0000) & 0x00FF0000; gmerge = (col_green1*trans2+col_green2*trans1+0x001000) & 0x0000FF00; bmerge =((col_blue1 *trans2+col_blue2 *trans1+0x001000) >> 8)& 0x000000FF; opCol = rmerge|gmerge|bmerge; return (opCol); } #ifdef BSAMPLE static void scrPoint (int px, int py, int col) { unsigned char m = 0x80; //GW Do not plot if outside of the defined window if (px < win_x1 || py < win_y1 || px >= win_x2 || py >= win_y2) return; m >>= px & 7; // mask px >>= 3; // x offset if (col) displayScr[py][px] |= m; else displayScr[py][px] &= (UBYTE) ~m; } #endif //BSAMPLE #ifdef CSAMPLE static void scrPoint (int px, int py, int col) { U32 m2; int x1,y1; int lWord; // index for colour word if (px < win_x1 || py < win_y1 || px >= win_x2 || py >= win_y2) return; //Display plots data from Right to Left // - reverse x-coordinate //Also display seems to be 16 pixels down the screen - //plot points at y=(y-16) mod 64 x1 = (scrX-1)-px; y1 = (py+48) & 63; //(py-16) ; //Display is in columns for TI drivers m2 = 0x80000000; m2 = m2 >> (y1 & 31); //shift m2 by 0-31 y1 = y1 >> 5; // 32bits/word lWord = x1*LCD_COL_NUM_LWORDS+y1; if (col) picture_bw[lWord] |= m2; else picture_bw[lWord] &= (U32)(~m2); } #endif //CSAMPLE #ifdef DSAMPLE_COLOUR void scrPoint (int px, int py, int col) { int lWord; // index for colour word U32 bitCol; //i/p colour is 32 bit if (px < win_x1 || py < win_y1 || px >= win_x2 || py >= win_y2) return; lWord = DSPL_GET_LWORD(px,py); bitCol = DSPL_GET_BITCOLOUR(col); DSPL_SET_BITCOLOUR(px,lWord,bitCol,"plot"); } #endif //DSAMPLE_COLOUR #ifdef DSAMPLE_LITE void scrPoint (int px, int py, int col) { int m_px; int word ; //i/p colour is 32 bit if (px < win_x1 || py < win_y1 || px >= win_x2 || py >= win_y2) return; m_px = 1 << (px & 0x1F); word = DSPL_GET_LWORD(px,py); if (col) picture_bw[word] = picture_bw[word] | m_px; else picture_bw[word] = picture_bw[word] & (~m_px); } #endif //DSAMPLE_LITE /******************************************************************* * * * PART III: LCD Simulation for Windows * * * *******************************************************************/ #if defined (WIN32) #define LCDE_COL 20 #define LCDE_ROW 4 static int screensize_x = 16; static int screensize_y = 4; #define NULL_TERM '\0' /* string termination */ static CHAR lcd_screen [LCDE_ROW+2][LCDE_COL+3]; static CHAR cursor_line[LCDE_COL+3]; static int lcd_cursX, lcd_cursY, lcd_enabled = FALSE; LOCAL void LCD_Refresh (void) { int i; CHAR buf[100]; for (i=0; i<screensize_y+2; i++) { sprintf (buf, "~LCD~%s", &lcd_screen[i][0]); #if defined NEW_FRAME vsi_o_ttrace (0, 0xffff, buf); #else #endif if (lcd_cursY+1 EQ i) { cursor_line[lcd_cursX+1] = '^'; sprintf (buf, "~LCD~%s", cursor_line); #if defined NEW_FRAME vsi_o_ttrace (0, 0xffff, buf); #else #endif cursor_line[lcd_cursX+1] = ' '; } else { if (i < screensize_y+1) { sprintf (buf, "~LCD~%s", cursor_line); #if defined NEW_FRAME vsi_o_ttrace (0, 0xffff, buf); #else #endif } } } } GLOBAL void LCD_Enable (int on) { lcd_enabled = (on EQ 1); } GLOBAL void LCD_Clear (void) { int r, c; if (lcd_enabled) { lcd_cursX = lcd_cursY = 0; for (r=1; r<screensize_y+1; r++) for (c=1; c<screensize_x+1; c++) lcd_screen[r][c] = ' '; LCD_Refresh (); } } GLOBAL void LCD_Reset (void) { int r, c, i; memset (cursor_line, ' ', screensize_x+3); cursor_line[0] = cursor_line[screensize_x+1] = '|'; cursor_line[screensize_x+2] = NULL_TERM; for (r=1; r < screensize_y+1; r++) { lcd_screen[r][0] = '|'; lcd_screen[r][screensize_x+1] = '|'; } for (c=1; c < screensize_x+1; c++) { lcd_screen[0][c] = '-'; lcd_screen[screensize_y+1][c] = '-'; } lcd_screen[0][0] = '+'; lcd_screen[screensize_y+1][0] = '+'; lcd_screen[0][screensize_x+1] = '+'; lcd_screen[screensize_y+1][screensize_x+1] = '+'; for (i=0; i<screensize_y+2; i++) lcd_screen [i][screensize_x+2] = NULL_TERM; lcd_enabled = TRUE; LCD_Clear (); lcd_enabled = FALSE; } GLOBAL void LCD_WriteString (int row, int col, CHAR *s) { if (s == NULL) { TRACE_EVENT("LCD_WriteString got NULL Pointer as Text"); return; } if (lcd_enabled) { int len = strlen (s); if (row < screensize_y AND col < screensize_x) { if ((col + len) > screensize_x) { /* clip the string */ s[(len = screensize_x-col)] = NULL_TERM; } memcpy (&lcd_screen[row+1][col+1], s, len); LCD_Refresh (); } } } GLOBAL void LCD_Cursor (int row, int col) { if (lcd_enabled) { if (row < screensize_y AND col < screensize_x) { lcd_cursY = row; lcd_cursX = col; LCD_Refresh (); } } } GLOBAL void LCD_SetPower (void) { } GLOBAL void LCD_PixBlt (int x, int y, int w, int h, char *bmp) { } /* * Stimulation of the lcd driver */ GLOBAL void lcd_test (UBYTE mode) { TRACE_EVENT ("Display Redirection activated"); mtkEnabled = mode; scrInit(); if (mtkEnabled EQ 2) { scrY = 64; } } #endif /* WIN32 */ #endif /* MMI != 0 */