lcd.c File Reference

---

Detailed Description

This module provides LCD support.

REVISION

• 10/09/2004 DeepB
  Initial creation.

Definition in file lcd.c.

#include "../SYSTEM/sys_hardware.h"
#include "../SYSTEM/sys_main.h"
#include "../MESSAGE/message.h"
#include "lcd.h"
#include "lcd_assert.h"

Include dependency graph for lcd.c:

Go to the source code of this file.

Functions
void	LCD_wrRect (const st_RECT *pRect, const unsigned short *pData)
	Function writes rectangle area display data into LCD image buffer.
void	LCD_scroll (const st_RECT *pRect, const st_BRUSH *pBrush, LCD_SCMODE mode, short pixelStep)
	Function scrolls contents inside the specified rectangle in given mode and step size.
void	LCD_refreshAll (void)
	Function refreshes the entire LCD display.
void	LCD_update (const st_RECT *pRect)
	Function updates the rectangle dispaly area to LCD.
void	LCD_refresh (const st_RECT *pRect)
	Function refreshes the rectangle display area immediately.
unsigned short *	LCD_rdRect (const st_RECT *pRect, unsigned short *pRdBuf)
	Function reads back rectangle area display data in LCD image buffer, together with LCD_wrRect(...), application can directly manipulate the image buffer data.
void	LCD_setCursor (short x, short y)
	Function sets the active LCD cursor.
void	LCD_printFld (const st_FIELD *pFld, st_LCDINFO *pInfo)
	Function prints out the specified rectangle area.
void	LCD_power (LCD_ONOFF power, unsigned int contrast)
	Function serves as the LCD task handle.
void	LCD_main (void)
	Function serves as the LCD task handle.
void	LCD__loadGraph (const st_POINT *pPnt, unsigned long graph)
	Function copies bitmap to the LCD mirror buffer at location specified by upper left corner coordinates.
void	LCD_graphSize (unsigned long graf, st_SIZE *size)
	Function returns the graph size.
void	LCD_invRect (const st_RECT *pRect)
	Function inverts the rectangle area.
void	LCD_drawRect (const st_RECT *pRect)
	Function draws a rectangle in current LCD frame.
void	LCD_setBrush (const st_BRUSH *brush)
	Function sets up the active LCD brush, if no brush is passed in, clear the LCD brush.
void	LCD_setPen (const st_PEN *pen)
	Function sets up the active LCD pen, if no pen is passed in, clear the LCD pen.
void	LCD_setFont (LCD_FONT font)
	Function sets the selected font and loads all the font controls.
void	LCD_setFrame (const st_RECT *frame)
	Function sets up the display frame control.
void	LCD_contrast (unsigned int contrast)
	Function controls the LCD contrast.
void	LCD__wrRect (const st_RECT *pRect, const unsigned short *pD)
	Function writes to the Mirror buffer the specified data positioned by the specified rectangle.
void	LCD__paintRect (const st_RECT *pRect, const st_BRUSH *pBrush)
	Function paints the specified rectangle using the specified brush.
unsigned short	LCD__loadData (unsigned short *pD, unsigned short bufLen, unsigned long dptr)
	Function loads LCD display data into internal display data buffer.
unsigned short	LCD__copyChar (unsigned short ch)
	Function copies bitmap in character buffer into the LCD mirror buffer at location specified by LCD cursor.
void	LCD__copyBmp (unsigned short *pBmp, const st_CURSOR *pCs, const st_SIZE *pSz)
	Function copies bitmap to specified location.
unsigned short	LCD__charWidth (unsigned short ch)
	Function returns width of the specified character.
Variables
BOOL	lcdOvlped
	GLOBAL DATA.

---

Function Documentation

unsigned short LCD__charWidth (  unsigned short  ch  )

Function returns width of the specified character. Parameters: ch  the specified character. Returns: width of the specified character. Definition at line 2043 of file lcd.c. References st_LCD::chAddr, st_LCD::font, st_FONT::tabAddr, and st_FONT::tabLen. Referenced by LCD__copyChar(), and LCD_printFld(). { unsigned short width; LCD_assert((ch&0xff00)==0, LCD__CHARWIDTH); // Table upper boundary check. // Table low boundary assumed to be 0. if ( ch > Lcd.font.tabLen ) { ch = 0x20; // Always print out a SPACE char if invalid char detected. } /* Read and form address of character ch */ GEN_readXdata((unsigned long)(Lcd.font.tabAddr + 2 + ch*2), (USHORT*)&Lcd.chAddr, 2); /* Get the width of the character */ GEN_readXdata((unsigned long)Lcd.chAddr, &width, 1); return ( width&0x00FF ); }

void LCD__copyBmp (  unsigned short *  pBmp, const st_CURSOR *  pCs, const st_SIZE *  pSz )

Function copies bitmap to specified location. Also a boundary check will be carried out per to the active LCD frame, thus bitmap data can possibly be modified during function call. Parameters: pBmp  bitmap data pointer. pCs  bitmap cursor position. pSz  bitmap size. Definition at line 1942 of file lcd.c. References st_RECT::br, st_LCD::frame, LCD__wrRect(), st_RECT::ul, st_POINT::x, and st_POINT::y. Referenced by LCD__copyChar(), and LCD__loadGraph(). { unsigned short csX = pCs->x; unsigned short csY = pCs->y; unsigned short szX = pSz->x; unsigned short szY = pSz->y; st_RECT rect; unsigned short rshift; unsigned short lshift; unsigned short hoffset; unsigned short colNum; unsigned short wordPerClm = (szY-1)/16+1; unsigned short * pD; unsigned short * pS; unsigned short * pT; unsigned short ii, jj, kk; LCD_assert((unsigned int)pBmp, LCD__COPYBMP); // Check display boundarys. if( (csX > Lcd.frame.br.x) || (csY > Lcd.frame.br.y) || ( (csX + szX - 1) < Lcd.frame.ul.x) || ( (csY + szY - 1) < Lcd.frame.ul.y) ) return; // Check upper left X. if( csX < Lcd.frame.ul.x ) { rect.ul.x = Lcd.frame.ul.x; hoffset = (Lcd.frame.ul.x - csX) * wordPerClm; } else { rect.ul.x = csX; hoffset = 0; } // Check upper left Y. if( csY < Lcd.frame.ul.y ) { rect.ul.y = 0; lshift = Lcd.frame.ul.y - csY; } else { rect.ul.y = csY; lshift = 0; } // Check bottom right X. if( csX + szX - 1 > Lcd.frame.br.x ) { rect.br.x = Lcd.frame.br.x; } else { rect.br.x = csX + szX - 1; } // Check bottom right Y. if((csY + szY - 1) > Lcd.frame.br.y) { rect.br.y = Lcd.frame.br.y; // Shif buffer if necessary. colNum = rect.br.x-rect.ul.x+1; pS = pBmp + hoffset + lshift/16; pD = pBmp; lshift = lshift%16; rshift = 16 - lshift; jj = (rect.br.y-rect.ul.y)/16; for( ii = 0; ii < colNum; ii++ ) { pT = pS; for( kk = 0; kk <= jj; kk++ ) { *pD = *pS++<<lshift; *pD++ |= *pS>>rshift; } pS = pT + wordPerClm; } } else { rect.br.y = csY + szY - 1; } LCD__wrRect(&rect, pBmp); }

Here is the call graph for this function:

unsigned short LCD__copyChar (  unsigned short  ch  )

Function copies bitmap in character buffer into the LCD mirror buffer at location specified by LCD cursor. Also a boundary check will be carried out per to the active LCD frame. Parameters: ch  character to be copied. Returns: character width in pixel. Definition at line 1910 of file lcd.c. References st_LCD::chAddr, st_LCD::cs, st_LCD::font, st_FONT::h, LCD__charWidth(), and LCD__copyBmp(). Referenced by LCD_printFld(). { st_SIZE sz; unsigned short width; LCD_assert((ch&0xff00)==0, LCD__COPYCHAR); width = LCD__charWidth(ch); if(0 == width) return; // Read in the font bitmap data. GEN_readXdata((unsigned long)Lcd.chAddr+1, LCD_chBuf, ((Lcd.font.h-1)/16+1)*width); sz.x = width; sz.y = Lcd.font.h; LCD__copyBmp(LCD_chBuf, &Lcd.cs, &sz); return width; }

Here is the call graph for this function:

unsigned short LCD__loadData (  unsigned short *  pD, unsigned short  bufLen, unsigned long  dptr )

Function loads LCD display data into internal display data buffer. Parameters: pD  Internal display data buffer. bufLen  maximum data buffer length. dptr  Original display data pointer. Returns: Number of data words read. Definition at line 1865 of file lcd.c. Referenced by LCD_printFld(), MENU__listMenuAction(), and MENU__playMenuAction(). { unsigned short count; unsigned short ii; unsigned short * pS; // Check to unpack if necessary. // !!!NOTE!!! // This algorithm will not work when language other than English // is used. In that case we'll need to add font check here as well. // LCD_assert((unsigned int)((unsigned long)pD&dptr), LCD__LOADDATA); count = GEN_readXstr(dptr, pD, bufLen); LCD_assert(count<=bufLen, LCD__LOADDATA2); if( (*pD) & 0xFF00 ) { count = (count>bufLen/2)? bufLen/2 : count; pS = pD+count-1; pD = pD+count*2-1; /* unpack string. */ ii = count; while(ii--) { *pD-- = *pS&0x0ff; *pD-- = *pS-->>8; } count <<= 1; } return count; }

void LCD__loadGraph (  const st_POINT *  pPnt, unsigned long  graph )

Function copies bitmap to the LCD mirror buffer at location specified by upper left corner coordinates. Also a boundary check will be carried out per to the active LCD frame. pGraph data format, +------+--------------------------------------------------------------+ | Word | | |Offset| Description. | +------+--------------------------------------------------------------+ | 0 | Size in pixels in X direction. | +------+--------------------------------------------------------------+ | 1 | Size in pixels in Y direction. | +------+--------------------------------------------------------------+ | 2 | Reserved. | +------+--------------------------------------------------------------+ | 3 | Data length in words. | +------+--------------------------------------------------------------+ | 4 | Bit map data. | +------+--------------------------------------------------------------+ | ... | | +------+--------------------------------------------------------------+ | N | Bit map data. | +------+--------------------------------------------------------------+ Parameters: pPnt  upper left point. graph  graph data pointer. Definition at line 1353 of file lcd.c. References LCD__copyBmp(), and SYS_die(). Referenced by LCD_printFld(). { st_SIZE sz; unsigned short tmp; unsigned short* pD; LCD_assert(graph != 0, LCD__LOADGRAPH); GEN_readXdata(graph++, (USHORT*)&sz.x, 1); GEN_readXdata(graph++, (USHORT*)&sz.y, 1); graph++; GEN_readXdata(graph++, &tmp, 1); if(0 == tmp) return; #ifndef LCD_USEXDATA if( (pD = (unsigned short *)malloc(tmp) ) == NULL ) #else if( (pD = (unsigned short *)nalloc(tmp) ) == NULL ) #endif { SYS_die(LCD__LOADGRAPH); } GEN_readXdata(graph, pD, tmp); LCD__copyBmp(pD, pPnt, &sz); #ifndef LCD_USEXDATA free(pD); #else nfree(pD); #endif }

Here is the call graph for this function:

void LCD__paintRect (  const st_RECT *  pRect, const st_BRUSH *  pBrush )

Function paints the specified rectangle using the specified brush. Function does not do rectangle validity check, it is the caller's responsibility to make sure rectangle is valid. Parameters: pRect  rectangle data object pointer. pBrush  brush data object pointer. Definition at line 1760 of file lcd.c. References st_LCD::brush, and st_BRUSH::clr. Referenced by LCD_drawRect(), and LCD_scroll(). { unsigned short pattern; unsigned short * pBuf; unsigned short * pTmp; unsigned short clmWords; unsigned short clmNum; unsigned short stmask, endmask; unsigned short preshift, nextshift; unsigned short ii, jj; unsigned short ulX, ulY, brX, brY; LCD_assertRect(*pRect, LCD__PAINTRECT); if(pBrush == NULL) pBrush = &Lcd.brush; pattern = (pBrush->clr)? 0xFFFF : 0; pBuf = LCD_mbuf; ulX = pRect->ul.x; ulY = pRect->ul.y; brX = pRect->br.x; brY = pRect->br.y; // Calculate the start word. pBuf += ulX*8 + ulY/16; // Generate start word bit mask. // preshift = pRect->ul.y%16; preshift = ulY&0x0F; nextshift = 16 - preshift; stmask = _sbit_mask[preshift]; // Generate the end word bit mask. endmask = _ebit_mask[(brY&0x0F) + 1]; // Calculate total words per column. clmWords = ((brY - ulY + preshift) >> 4 ) + 1; // Calculate total column numbers. clmNum = brX - ulX + 1; // If column does not cross word boundary. if(clmWords == 1) { endmask |= stmask; stmask = (pattern&_sbit_mask[brY-ulY+1])>>preshift; // Write buffer. for(ii = 0; ii < clmNum; ii++ ) { *pBuf &= endmask; *pBuf |= stmask; pBuf += 8; } return; } pTmp = pBuf; // Write buffer while column crosses word boundary. // Process the start word. for(ii = 0; ii < clmNum; ii++ ) { *pBuf &= stmask; *pBuf |= (pattern>>preshift); pBuf += 8; } // Process the whole column word if any. for(jj = 0; jj < clmWords - 2; jj++) { pBuf = ++pTmp; stmask = (pattern<<nextshift)|(pattern>>preshift); for(ii = 0; ii < clmNum; ii++ ) { *pBuf = stmask; pBuf += 8; } } // Process the end word. pBuf = pTmp + 1; stmask = ((pattern<<nextshift)|(pattern>>preshift))&(~endmask); for(ii = 0; ii < clmNum; ii++ ) { *pBuf &= endmask; *pBuf |= stmask; pBuf += 8; } }

void LCD__wrRect (  const st_RECT *  pRect, const unsigned short *  pD )

Function writes to the Mirror buffer the specified data positioned by the specified rectangle. The upper half buffer corresponds to the significant bit of the gray scaled LCD pixel. It is the caller's responsibility to make sure rectangle always drops in valid display area. It is also the caller's responsibility to make sure pData points to valid data. Parameters: pRect  rectangle data object pointer. pD  rectangle data pointer. Definition at line 1645 of file lcd.c. References st_RECT::ul, st_POINT::x, and st_POINT::y. Referenced by LCD__copyBmp(), and LCD_wrRect(). { unsigned short * pBuf; unsigned short * pTmp; const unsigned short * pDtmp; unsigned short dptrOffset; unsigned short clmWords; unsigned short clmNum; unsigned short stmask, endmask, rvsendmask; unsigned short preshift, nextshift; unsigned short ii, jj, tmp; unsigned short ulX, ulY, brX, brY; LCD_assertRect(*pRect, LCD__WRRECT); LCD_assert((unsigned short)pD, LCD__WRRECT2); pBuf = LCD_mbuf; ulX = pRect->ul.x; ulY = pRect->ul.y; brX = pRect->br.x; brY = pRect->br.y; // Calculate the start word. pBuf += ulX*8 + ulY/16; // Generate start word bit mask. // preshift = pRect->ul.y%16; preshift = ulY&0x0F; nextshift = 16 - preshift; stmask = _sbit_mask[preshift]; // Generate the end word bit mask. endmask = _ebit_mask[(brY&0x0F) + 1]; rvsendmask = ~endmask; // Calculate total words per column. clmWords = ((brY - ulY + preshift) >> 4 ) + 1; // Calculate total column numbers. clmNum = brX - ulX + 1; // If column does not cross word boundary. if(clmWords == 1) { endmask |= stmask; stmask = _sbit_mask[brY-ulY+1]; /* Write buffer. */ for(ii = 0; ii < clmNum; ii++ ) { *pBuf &= endmask; *pBuf |= (((*pD++)&stmask)>>preshift); pBuf += 8; } return; } dptrOffset = ((brY-ulY) >> 4) + 1; pTmp = pBuf; pDtmp = pD; // Write buffer while column crosses word boundary. // Process the start word. for(ii = 0; ii < clmNum; ii++ ) { *pBuf &= stmask; *pBuf |= (*pD>>preshift); pBuf += 8; pD += dptrOffset; } pD = pDtmp; // Process the whole column word if any. for(jj = 0; jj < clmWords - 2; jj++) { pBuf = ++pTmp; for(ii = 0; ii < clmNum; ii++ ) { *pBuf = (*pD++)<<nextshift; *pBuf |= ((*pD) >> preshift); pBuf += 8; pD += dptrOffset-1; } pD = ++pDtmp; } // Process the end word. pBuf = pTmp + 1; for(ii = 0; ii < clmNum; ii++ ) { *pBuf &= endmask; tmp = (*pD++)<<nextshift; tmp |= ( (*pD) >> preshift); tmp &= rvsendmask; *pBuf |= tmp; pBuf += 8; pD += dptrOffset-1; } }

void LCD_contrast (  unsigned int  contrast  )

Function controls the LCD contrast. Parameters: contrast  LCD contrast value to be set. Definition at line 1621 of file lcd.c. Referenced by MENU__setContrast(). { unsigned int temp; /* Read to clear port to send LCD commands. */ temp = RS_CTRL; asm(" nop"); LCD_ACCESS = LCD_CMD__VOLUME_REGISTER; LCD_ACCESS = contrast + LCD_CONTRAST_OFFSET; }

void LCD_drawRect (  const st_RECT *  pRect  )

Function draws a rectangle in current LCD frame. Parameters: pRect  Rectangle to be drawn. Definition at line 1498 of file lcd.c. References st_RECT::br, st_LCD::brush, st_PEN::clr, st_BRUSH::clr, LCD__paintRect(), st_LCD::pen, st_PEN::sz, st_RECT::ul, st_POINT::x, and st_POINT::y. Referenced by MENU__create(), MENU__createDjMenu(), MENU__createListMenu(), MENU__createMsgBox(), MENU__createMyfiGainMenu(), MENU__createShadow(), MENU__createVolumeMenu(), MENU__listMenuAction(), MENU__myfiChannelControl(), MENU__myfiGainControl(), MENU__playMenuAction(), MENU__sbarInit(), MENU__vbarInit(), MENU__volumeControl(), MENU__XIMaction(), MENU_create(), MENU_statusBar(), and MENU_update(). { st_RECT rect; st_BRUSH brush; unsigned short ulX, ulY, brX, brY; ulX = pRect->ul.x; ulY = pRect->ul.y; brX = pRect->br.x; brY = pRect->br.y; LCD_assertRect(*pRect, LCD_DRAWRECT); if(Lcd.pen.clr != 0) { brush.clr = Lcd.pen.clr; LCD__paintRect(pRect, &brush); // Check if pen is too large. if( ((brX-ulX) <= Lcd.pen.sz.x)||((brY-ulY) <= Lcd.pen.sz.y) ) return; } rect.ul.x = ulX+Lcd.pen.sz.x; rect.ul.y = ulY+Lcd.pen.sz.y; rect.br.x = brX-Lcd.pen.sz.x; rect.br.y = brY-Lcd.pen.sz.y; LCD__paintRect(&rect, &Lcd.brush); }

Here is the call graph for this function:

void LCD_graphSize (  unsigned long  graf, st_SIZE *  size )

Function returns the graph size. Parameters: graf  Graph data pointer. size  Size buffer. Definition at line 1396 of file lcd.c. Referenced by MENU__createListMenu(), and MENU__listMenuAction(). { GEN_readXdata(graf++, (USHORT*)(&size->x), 1); GEN_readXdata(graf++, (USHORT*)(&size->y), 1); }

void LCD_invRect (  const st_RECT *  pRect  )

Function inverts the rectangle area. Parameters: pRect  rectangle data object pointer. Definition at line 1408 of file lcd.c. Referenced by MENU__createDateTimeMenu(), MENU__createListMenu(), MENU__createMsgBox(), MENU__listMenuAction(), MENU__msgBoxAction(), MENU__XIMaction(), MENU_statusBar(), and MENU_update(). { unsigned short * pBuf; unsigned short * pTmp; unsigned short clmWords; unsigned short clmNum; unsigned short stmask, endmask, rvsendmask; unsigned short preshift; unsigned short ii, jj, tmp; unsigned short ulX, ulY, brX, brY; pBuf = LCD_mbuf; ulX = pRect->ul.x; ulY = pRect->ul.y; brX = pRect->br.x; brY = pRect->br.y; // Calculate the start word. pBuf += ulX*8 + ulY/16; // Generate start word bit mask. // preshift = pRect->ul.y%16; preshift = ulY&0x0F; stmask = _sbit_mask[preshift]; // Generate the end word bit mask. endmask = _ebit_mask[(brY&0x0F) + 1]; rvsendmask = ~endmask; // Calculate total words per column. clmWords = ((brY - ulY + preshift) >> 4 ) + 1; // Calculate total column numbers. clmNum = brX - ulX + 1; // If column does not cross word boundary. if(clmWords == 1) { endmask |= stmask; stmask = ~endmask; /* Write buffer. */ for(ii = 0; ii < clmNum; ii++ ) { *pBuf = (*pBuf&endmask)|((~(*pBuf))&stmask); pBuf += 8; } return; } pTmp = pBuf; // Write buffer while column crosses word boundary. // Process the start word. tmp = ~stmask; for(ii = 0; ii < clmNum; ii++ ) { *pBuf = (*pBuf&stmask)|((~(*pBuf))&tmp); pBuf += 8; } // Process the whole column word if any. for(jj = 0; jj < clmWords - 2; jj++) { pBuf = ++pTmp; for(ii = 0; ii < clmNum; ii++ ) { *pBuf = ~(*pBuf); pBuf += 8; } } // Process the end word. pBuf = pTmp + 1; for(ii = 0; ii < clmNum; ii++ ) { *pBuf = (*pBuf&endmask)|((~(*pBuf))&rvsendmask); pBuf += 8; } }

void LCD_power (  LCD_ONOFF  power, unsigned int  contrast )

Function serves as the LCD task handle. Parameters: power  LCD power state, ON or OFF. contrast  LCD power up contrast value. user application setup begin * user LCD power setup begin * Definition at line 1131 of file lcd.c. References st_RECT::br, GEN_zeroOut(), LCD_refresh(), st_RECT::ul, st_POINT::x, and st_POINT::y. Referenced by SYS_die(), and UI_PSF_sleep(). { unsigned short temp; unsigned short counter; st_RECT rect; LCD_NOTOVLPED(); if ( power == LCD_POWER_ON ) { // Read to clear port. temp = RS_CTRL; asm(" nop"); LCD_ACCESS = LCD_CMD__SETPD_DUTY_RATIO; LCD_ACCESS = 0x80; LCD_ACCESS = LCD_CMD__ADC|ADC_REVERSE_DSP; LCD_ACCESS = LCD_CMD__SHL|SHL_NORMAL; LCD_ACCESS = LCD_CMD__COM0; LCD_ACCESS = 0; LCD_ACCESS = LCD_CMD__OSCILLATOR; LCD_ACCESS = LCD_CMD__DC_DC|DC_DC_4; LCD_ACCESS = LCD_CMD__REGULATOR_RESISTOR|6; LCD_ACCESS = LCD_CMD__VOLUME_REGISTER; LCD_ACCESS = contrast + LCD_CONTRAST_OFFSET; LCD_ACCESS = LCD_CMD__BIAS|BIAS_9; LCD_ACCESS = LCD_CMD__FRC_PWM_MODE | FRC_4 | PWM_9; // White mode LCD_ACCESS = LCD_CMD__GRAYSCALE_MODE|GRAY_SCALE_MODE_0; LCD_ACCESS = 0x00; LCD_ACCESS = LCD_CMD__GRAYSCALE_MODE|GRAY_SCALE_MODE_1; LCD_ACCESS = 0x00; LCD_ACCESS = LCD_CMD__GRAYSCALE_MODE|GRAY_SCALE_MODE_2; LCD_ACCESS = 0x33; //LCD_ACCESS = 0x00; LCD_ACCESS = LCD_CMD__GRAYSCALE_MODE|GRAY_SCALE_MODE_3; LCD_ACCESS = 0x33; //LCD_ACCESS = 0x00; LCD_ACCESS = LCD_CMD__GRAYSCALE_MODE|GRAY_SCALE_MODE_4; LCD_ACCESS = 0x66; //LCD_ACCESS = 0x00; LCD_ACCESS = LCD_CMD__GRAYSCALE_MODE|GRAY_SCALE_MODE_5; LCD_ACCESS = 0x66; //LCD_ACCESS = 0x00; LCD_ACCESS = LCD_CMD__GRAYSCALE_MODE|GRAY_SCALE_MODE_6; LCD_ACCESS = 0x99; LCD_ACCESS = LCD_CMD__GRAYSCALE_MODE|GRAY_SCALE_MODE_7; LCD_ACCESS = 0x99; LCD_ACCESS = LCD_CMD__POWER_CONTROL|POWER_CONTROL_ALL_ON; asm( " nop"); // end of LCD power on setup. // wait for the initialization done counter = 0; do { temp = LCD_ACCESS; counter++; }while( (temp & 0x80) && (counter != 0x7FFF) ); /* Refresh the cleared display buffer. */ GEN_zeroOut((UINT16*)LCD_mbuf, LCD_MIRROR_BUF_SZ); rect.ul.x = rect.ul.y = 0; rect.br.x = LCD_XMAX; rect.br.y = LCD_YMAX; LCD_refresh(&rect); LCD_ACCESS = LCD_CMD__DISPLAY | DISPLAY_ON; LCD_ACCESS = LCD_CMD__ENTIRE_DISPLAY | ENTIRE_DISPLAY_OFF; } else if( power == LCD_POWER_OFF) { temp = RS_CTRL; LCD_ACCESS = LCD_CMD__ENTIRE_DISPLAY | ENTIRE_DISPLAY_OFF; LCD_ACCESS = LCD_CMD__DISPLAY | DISPLAY_OFF; asm(" nop"); LCD_ACCESS = LCD_CMD__RESET; asm(" nop"); LCD_ACCESS = LCD_CMD__POWER_CONTROL|POWER_CONTROL_ALL_OFF; asm(" nop"); } }

Here is the call graph for this function:

void LCD_printFld (  const st_FIELD *  pFld, st_LCDINFO *  pInfo )

Function prints out the specified rectangle area. Parameters: pFld  output field data object pointer. pInfo  output information associated, if NULL, no info generated. Definition at line 732 of file lcd.c. References st_LINEINFO::chNum, st_LCD::chsp, st_LCD::cs, st_LCD::font, st_LCD::frame, st_FONT::h, LCD__charWidth(), LCD__copyChar(), LCD__loadData(), LCD__loadGraph(), LCD_FONT, LCD_setCursor(), LCD_setFont(), st_LINEFIFO::lninfo, st_LINEINFO::moreCh, st_LINEINFO::pC, st_LINEINFO::ul, st_POINT::x, st_POINT::y, and st_LINEFIFO::Yoffset. Referenced by MENU__create(), MENU__createDbRecordInfoMenu(), MENU__createDjMenu(), MENU__createListMenu(), MENU__createMsgBox(), MENU__createMyfiChannelMenu(), MENU__createMyfiGainMenu(), MENU__createPlayMenu(), MENU__createPresetMenu(), MENU__createPropertiesMenu(), MENU__createSynclogMenu(), MENU__createVolumeMenu(), MENU__listMenuAction(), MENU__myfiChannelControl(), MENU__playMenuAction(), MENU_statusBar(), and MENU_update(). { unsigned short num, ii, w, chars=0; unsigned short Yoffset; unsigned short * pC; st_LINEINFO * pLnInfo; st_CURSOR cs; LCD_assert((unsigned short)pFld, LCD_PRINTFLD); LCD_assertRect(pFld->rc, LCD_PRINTFLD2); if( pFld->dptr == 0 ) return; Lcd.frame = pFld->rc; if( !(pFld->attr&FLD_ATTR_CURSOR) ) LCD_setCursor(pFld->rc.ul.x, pFld->rc.ul.y); if( pFld->attr&FLD_ATTR_TXTFLD ) { LCD_setFont((LCD_FONT)(pFld->attr&FLD_ATTR_TXTFONT)); LCD__loadData(LCD_dbuf, LCD_STR_DATABUF_SZ, pFld->dptr); LCD__lnfifo(pFld, pInfo); pLnInfo = &LCD_lnfifo.lninfo[0]; Yoffset = LCD_lnfifo.Yoffset; while( num = pLnInfo->chNum ) { LCD_setCursor(pLnInfo->ul.x, pLnInfo->ul.y+Yoffset); pC = pLnInfo->pC; for(ii = 0; ii < num; ii++) { w = LCD__copyChar(*pC++); if(w) Lcd.cs.x += (w + Lcd.chsp); } if( Lcd.cs.y+Lcd.font.h-1 <= pFld->rc.br.y ) { chars += num; cs.x = Lcd.cs.x; cs.y = Lcd.cs.y; } if(pLnInfo->moreCh) { w = LCD__copyChar(pLnInfo->moreCh); if(w) Lcd.cs.x += (w + Lcd.chsp); } pLnInfo++; } /* Setup print info. */ if(pInfo) { if(chars == 0) { chars = num; cs.x = Lcd.cs.x; cs.y = Lcd.cs.y; } else { pC = LCD_lnfifo.lninfo[0].pC+chars; while(cs.x > pFld->rc.br.x) { chars--; pC--; cs.x = cs.x-LCD__charWidth(*pC)-Lcd.chsp; } } pInfo->num = chars; pInfo->cs = cs; } } else LCD__loadGraph(&Lcd.cs, pFld->dptr); }

Here is the call graph for this function:

unsigned short* LCD_rdRect (  const st_RECT *  pRect, unsigned short *  pRdBuf )

Function reads back rectangle area display data in LCD image buffer, together with LCD_wrRect(...), application can directly manipulate the image buffer data. Parameters: pRect  Rectangle read. pRdBuf  Display data pointer if not NULL. (if NULL, function will automatically allocate buffer.) Returns: Display data pointer. Definition at line 644 of file lcd.c. References SYS_die(), st_POINT::x, and st_POINT::y. Referenced by MENU__preserve(), MENU__restore(), and MENU_create(). { unsigned short * pD; unsigned short * pT; unsigned short * pBuf; unsigned short * pTmp; unsigned short len; unsigned short clmNum, clmWords; unsigned short preshift, nextshift; unsigned short ulX, ulY, brX, brY; LCD_assertRect(*pRect, LCD_RDRECT); ulX = pRect->ul.x; ulY = pRect->ul.y; brX = pRect->br.x; brY = pRect->br.y; // Calculate the start word. pBuf = LCD_mbuf+ulX*8 + ulY/16; preshift = ulY&0x0F; nextshift = 16 - preshift; // Calculate total words per column. clmWords = ((brY-ulY)>>4) + 1; // Calculate total column numbers. clmNum = brX-ulX+1; len = clmNum*clmWords; if(pRdBuf == NULL) { #ifndef LCD_USEXDATA pD = (unsigned short *)malloc(len+1); #else pD = (unsigned short *)nalloc(len+1); #endif if( NULL == pD ) SYS_die(LCD_RDRECT); } else pD = pRdBuf; *pD = len; pT = pD+1; // Read buffer while column crosses word boundary. for(ulX = 0; ulX < clmNum; ulX++ ) { pTmp = pBuf; for(ulY = 0; ulY < clmWords; ulY++) { *pT = *pBuf<<preshift; pBuf++; *pT |= *pBuf>>(nextshift); pT++; } pBuf = pTmp+8; } return pD; }

Here is the call graph for this function:

void LCD_refresh (  const st_RECT *  pRect  )

Function refreshes the rectangle display area immediately. Parameters: pRect  points to specified rectangle display area. Definition at line 423 of file lcd.c. References st_RECT::br, st_RECT::ul, st_POINT::x, and st_POINT::y. Referenced by LCD_main(), LCD_power(), and LCD_refreshAll(). { LCD_assertRect(*pRect, LCD_REFRESH); #ifdef LCD_GRAYSCALED_OVLP if(TRUE == lcdOvlped) { if(pRect->ul.x) LCD__refresh(pRect, 1); else { if(0 == pRect->ul.y) { st_RECT rect; LCD_assertRect(lcdOvlpRc, LCD_REFRESH2); rect.ul.x = pRect->ul.x; rect.ul.y = pRect->ul.y; rect.br.x = pRect->br.x; rect.br.y = lcdOvlpRc.ul.y-1; LCD__refresh(&rect, 2); rect.ul.x = pRect->ul.x; rect.ul.y = lcdOvlpRc.ul.y; rect.br.x = lcdOvlpRc.ul.x-1; rect.br.y = lcdOvlpRc.br.y; LCD__refresh(&rect, 2); rect.ul.x = lcdOvlpRc.br.x+1; rect.ul.y = lcdOvlpRc.ul.y; rect.br.x = pRect->br.x; rect.br.y = lcdOvlpRc.br.y; LCD__refresh(&rect, 2); rect.ul.x = pRect->ul.x; rect.ul.y = lcdOvlpRc.br.y+1; rect.br.x = pRect->br.x; rect.br.y = pRect->br.y; LCD__refresh(&rect, 3); LCD__refresh(&lcdOvlpRc, 1); } else LCD__refresh(pRect, 0); } } else LCD__refresh(pRect, 0); #else LCD__refresh(pRect, 0); #endif }

void LCD_scroll (  const st_RECT *  pRect, const st_BRUSH *  pBrush, LCD_SCMODE  mode, short  pixelStep )

Function scrolls contents inside the specified rectangle in given mode and step size. If brush is specified, the background will be painted to fill the area left by scrolling. NOTE: operation is not affected by active LCD frame. Parameters: pRect  points to specified rectangle. pBrush  points to specified brush. mode  scroll mode specifier. pixelStep  step size in pixel. Definition at line 137 of file lcd.c. References st_RECT::br, st_BRUSH::clr, LCD__paintRect(), LCD_SCMODE, SC_CIRH, SC_CIRV, SC_HORZ, SC_VERT, st_RECT::ul, st_POINT::x, and st_POINT::y. Referenced by MENU__listMenuAction(). { short step; unsigned short * pBuf; unsigned short * pTmp; unsigned short * pS; unsigned short clmWords; unsigned short clmNum; unsigned short stmask, endmask; unsigned short wdoffset; unsigned short ii, jj; unsigned short ulX, ulY, brX, brY; st_RECT rect; st_BRUSH brush; LCD_assertRect(*pRect, LCD_SCROLL); if( 0 == pixelStep ) return; if(pBrush == NULL) { brush.clr = 0; pBrush = &brush; } ulX = pRect->ul.x; ulY = pRect->ul.y; brX = pRect->br.x; brY = pRect->br.y; // Generate start word bit mask. // preshift = pRect->ul.y%16; ii = ulY&0x0F; stmask = _sbit_mask[ii]; // Calculate total words per column. clmWords = ((brY - ulY + ii) >> 4 ) + 1; // Generate the end word bit mask. jj = (brY&0x0F)+1; endmask = _ebit_mask[jj]; // Calculate total column numbers. clmNum = brX - ulX + 1; step = ( 0>pixelStep)? -pixelStep: pixelStep; switch(mode) { case SC_HORZ: rect.ul.y = ulY; rect.br.y = brY; if( step >= clmNum ) { LCD__paintRect(pRect, pBrush); return; } clmNum -= step; if( 0 > pixelStep ) // scroll right { step = -8; rect.ul.x = ulX; rect.br.x = ulX-pixelStep-1; pBuf = LCD_mbuf + brX*8 + ulY/16; } else // scroll left. { step = 8; rect.ul.x = brX-pixelStep+1; rect.br.x = brX; pBuf = LCD_mbuf + ulX*8 + ulY/16; } pTmp = pBuf; pixelStep *= 8; // Reversed start mask. ulX = ~stmask; // Process the start word. for(ii = 0; ii < clmNum; ii++ ) { *pBuf &= stmask; *pBuf |= (*(pBuf+pixelStep)&ulX); pBuf += step; } // Process the whole column word if any. for(jj = 0; jj < clmWords - 2; jj++) { pBuf = ++pTmp; for(ii = 0; ii < clmNum; ii++ ) { *pBuf = *(pBuf+pixelStep); pBuf += step; } } if( 1 < clmWords ) { // Process the end word. pBuf = pTmp+1; ulX = ~endmask; for(ii = 0; ii < clmNum; ii++ ) { *pBuf &= endmask; *pBuf |= ((*(pBuf+pixelStep))&ulX); pBuf += step; } } break; case SC_VERT: rect.ul.x = ulX; rect.br.x = brX; if( step >= brY-ulY+1 ) { LCD__paintRect(pRect, pBrush); return; } if( 0 > pixelStep ) // scroll down { rect.ul.y = ulY; rect.br.y = ulY-pixelStep-1; pBuf = LCD_mbuf + ulX*8 + brY/16; if( 1 == clmWords ) { endmask |= stmask; ulX =~endmask; for(ii = 0; ii < clmNum; ii++ ) { *pBuf = (((*pBuf&ulX)>>step)&ulX)|(*pBuf&endmask); pBuf += 8; } break; } // Column cross words. wdoffset = step/16; clmWords -= 2+wdoffset-1; step &= 0x0f; ulY = 16-step; pTmp = pBuf; ulX = ~endmask; pixelStep = ~stmask; // reversed start mask. for(ii = 0; ii < clmNum; ii++ ) { pBuf = pTmp; pS = pBuf-wdoffset; // Process end word. *pBuf = (*pBuf&endmask)|(((*pS>>step)|(*(pS-1)<<ulY))&ulX); pBuf--; pS--; // Process the whole column word if any. for(jj = 1; jj < clmWords; jj++) { *pBuf = *pS>>step; *pBuf |= *(pS-1)<<ulY; pBuf--; pS--; } // Process the start word. *pBuf = ((*pS&pixelStep)>>step)|(*pS&stmask); pTmp += 8; } } else // scroll up. { rect.ul.y = brY-pixelStep+1; rect.br.y = brY; pBuf = LCD_mbuf + ulX*8 + ulY/16; if( 1 == clmWords ) { endmask |= stmask; ulX =~endmask; for(ii = 0; ii < clmNum; ii++ ) { *pBuf = (((*pBuf&ulX)<<step)&ulX)|(*pBuf&endmask); pBuf += 8; } break; } // Column cross words. wdoffset = step/16; clmWords -= 2+wdoffset-1; step &= 0x0f; ulY = 16-step; pTmp = pBuf; ulX = ~endmask; pixelStep = ~stmask; // reversed start mask. for(ii = 0; ii < clmNum; ii++ ) { pBuf = pTmp; pS = pBuf+wdoffset; // Process start word. *pBuf = (*pBuf&stmask)|(((*pS<<step)|(*(pS+1)>>ulY))&pixelStep); pBuf++; pS++; // Process the whole column word if any. for(jj = 1; jj < clmWords; jj++) { *pBuf = *pS<<step; *pBuf |= *(pS+1)>>ulY; pBuf++; pS++; } // Process the end word. *pBuf = ((*pS&ulX)<<step)|(*pS&endmask); pTmp += 8; } } break; case SC_CIRH: case SC_CIRV: default: break; } LCD__paintRect(&rect, pBrush); }

Here is the call graph for this function:

void LCD_setBrush (  const st_BRUSH *  brush  )

Function sets up the active LCD brush, if no brush is passed in, clear the LCD brush. Parameters: brush  Brush object pointer. Definition at line 1533 of file lcd.c. References st_LCD::brush, and st_BRUSH::clr. Referenced by MENU__create(), MENU__createDjMenu(), MENU__createListMenu(), MENU__createMsgBox(), MENU__createMyfiGainMenu(), MENU__createShadow(), MENU__createVolumeMenu(), MENU__listMenuAction(), MENU__myfiChannelControl(), MENU__myfiGainControl(), MENU__playMenuAction(), MENU__sbarInit(), MENU__vbarInit(), MENU__volumeControl(), MENU__XIMaction(), MENU_create(), MENU_statusBar(), MENU_update(), and SYS_die(). { if(brush) { memcpy(&Lcd.brush, brush, sizeof(st_BRUSH)); } else { /* If NULL brush, clear brush. */ Lcd.brush.clr = 0; } }

void LCD_setCursor (  short  x, short  y )

Function sets the active LCD cursor. Parameters: x  position in x-axis. y  position in y-axis. Definition at line 716 of file lcd.c. References st_LCD::cs. Referenced by LCD_printFld(). { Lcd.cs.x = x; Lcd.cs.y = y; }

void LCD_setFont (  LCD_FONT  font  )

Function sets the selected font and loads all the font controls. Parameters: font  Font specifier. Definition at line 1578 of file lcd.c. References st_LCD::chsp, st_LCD::font, FONT_NULL, st_LCD::fontID, st_FONT::gray, st_FONT::h, st_LCD::lnsp, st_LCD::pChbuf, st_FONT::tabAddr, st_FONT::tabLen, and st_FONT::w. Referenced by LCD_printFld(), and SYS_die(). { unsigned short temp[6]; if(FONT_NULL == font) return; Lcd.fontID = font; // Get the start address of fontX table and height of the font. GEN_readXdata((unsigned long)FONT_TABLES + (unsigned short)font*6, &temp[0], 6); Lcd.font.tabAddr = ((unsigned long)temp[0]<<16) | (unsigned long)temp[1]; GEN_readXdata((unsigned long)Lcd.font.tabAddr, &Lcd.font.tabLen, 1); // Load character height, width, gray level, character space, line space. Lcd.font.h = temp[2]; Lcd.font.w = temp[3]; Lcd.chsp = temp[4]; Lcd.lnsp = temp[5]; Lcd.font.gray = 3; Lcd.pChbuf = &LCD_chBuf[0]; }

void LCD_setFrame (  const st_RECT *  frame  )

Function sets up the display frame control. Parameters: frame  Definition at line 1610 of file lcd.c. References st_LCD::frame. Referenced by MENU__createListMenu(), MENU__listMenuAction(), and MENU_statusBar(). { Lcd.frame = *frame; }

void LCD_setPen (  const st_PEN *  pen  )

Function sets up the active LCD pen, if no pen is passed in, clear the LCD pen. Parameters: pen  Pen object pointer. Definition at line 1555 of file lcd.c. References st_PEN::clr, st_LCD::pen, st_PEN::shp, and st_PEN::sz. Referenced by MENU__createDjMenu(), MENU__createMsgBox(), MENU__createShadow(), MENU__listMenuAction(), MENU__myfiChannelControl(), MENU__myfiGainControl(), MENU__playMenuAction(), MENU__sbarInit(), MENU__vbarInit(), MENU__volumeControl(), MENU__XIMaction(), MENU_create(), MENU_statusBar(), MENU_update(), and SYS_die(). { if(pen) { memcpy(&Lcd.pen, pen, sizeof(st_PEN)); } else { /* If NULL pen, clear all parameters. */ Lcd.pen.clr = 0; Lcd.pen.shp = 0; Lcd.pen.sz.x = 0; Lcd.pen.sz.y = 0; } }

void LCD_update (  const st_RECT *  pRect  )

Function updates the rectangle dispaly area to LCD. Parameters: pRect  points to specified rectangle display area. Definition at line 403 of file lcd.c. { LCD_assertRect(*pRect, LCD_UPDATE); if(SYS_NOTASSERTED()) { mMSG_send( lcdMsgQ, LCD_MSG_ID, ((pRect->ul.x<<8)&0x0ff00)|pRect->ul.y, ((pRect->br.x<<8)&0x0ff00)|pRect->br.y, 0); } }

void LCD_wrRect (  const st_RECT *  pRect, const unsigned short *  pData )

Function writes rectangle area display data into LCD image buffer. together with LCD_rdRect(...), application can directly manipulate the image buffer data. NOTE: this function does not do any frame boundary check. Parameters: pRect  Rectangle written. pData  Display data pointer. Definition at line 102 of file lcd.c. References st_RECT::br, st_LCD::frame, LCD__wrRect(), st_RECT::ul, st_POINT::x, and st_POINT::y. Referenced by MENU__preserve(), MENU__restore(), and MENU_action(). { st_RECT frame; LCD_assertRect(*pRect, LCD_WRRECT); LCD_assert( (unsigned int)pData, LCD_WRRECT2); frame = Lcd.frame; Lcd.frame.ul.x = Lcd.frame.ul.y = 0; Lcd.frame.br.x = LCD_XMAX; Lcd.frame.br.y = LCD_YMAX; LCD__wrRect(pRect, pData+1); Lcd.frame = frame; }

Here is the call graph for this function:

---