// Draw the progress bar (if any) on the screen. Does not flip pages.
// Should only be called with updateMutex locked.
void ScreenRecoveryUI::draw_progress_locked()
{
if (currentIcon == ERROR) return;
if (currentIcon == INSTALLING_UPDATE || currentIcon == ERASING) {
draw_install_overlay_locked(installingFrame);
}
if (progressBarType != EMPTY) {
int iconHeight = gr_get_height(backgroundIcon[INSTALLING_UPDATE]);
int width = gr_get_width(progressBarEmpty);
int height = gr_get_height(progressBarEmpty);
int dx = (gr_fb_width() - width)/2;
#if 0 //wschen 2012-07-11
int dy = (3*gr_fb_height() + iconHeight - 2*height)/4;
#else
int dy = (gr_fb_height() - 8 * height)/4;
#endif
// Erase behind the progress bar (in case this was a progress-only update)
gr_color(0, 0, 0, 255);
gr_fill(dx, dy, width, height);
if (progressBarType == DETERMINATE) {
float p = progressScopeStart + progress * progressScopeSize;
int pos = (int) (p * width);
if (rtl_locale) {
// Fill the progress bar from right to left.
if (pos > 0) {
gr_blit(progressBarFill, width-pos, 0, pos, height, dx+width-pos, dy);
}
if (pos < width-1) {
gr_blit(progressBarEmpty, 0, 0, width-pos, height, dx, dy);
}
} else {
// Fill the progress bar from left to right.
if (pos > 0) {
gr_blit(progressBarFill, 0, 0, pos, height, dx, dy);
}
if (pos < width-1) {
gr_blit(progressBarEmpty, pos, 0, width-pos, height, dx+pos, dy);
}
}
}
if (progressBarType == INDETERMINATE) {
static int frame = 0;
gr_blit(progressBarIndeterminate[frame], 0, 0, width, height, dx, dy);
// in RTL locales, we run the animation backwards, which
// makes the spinner spin the other way.
if (rtl_locale) {
frame = (frame + indeterminate_frames - 1) % indeterminate_frames;
} else {
frame = (frame + 1) % indeterminate_frames;
}
}
}
}
// Draw the progress bar (if any) on the screen. Does not flip pages.
// Should only be called with gUpdateMutex locked.
static void draw_progress_locked()
{
if (gProgressBarType == PROGRESSBAR_TYPE_NONE) return;
int iconHeight = gr_get_height(gBackgroundIcon[BACKGROUND_ICON_INSTALLING]);
int width = gr_get_width(gProgressBarEmpty);
int height = gr_get_height(gProgressBarEmpty);
int dx = (gr_fb_width() - width)/2;
int dy = (3*gr_fb_height() + iconHeight - 2*height)/4;
// Erase behind the progress bar (in case this was a progress-only update)
gr_color(0, 0, 0, 255);
gr_fill(dx, dy, width, height);
if (gProgressBarType == PROGRESSBAR_TYPE_NORMAL) {
float progress = gProgressScopeStart + gProgress * gProgressScopeSize;
int pos = (int) (progress * width);
if (pos > 0) {
gr_blit(gProgressBarFill, 0, 0, pos, height, dx, dy);
}
if (pos < width-1) {
gr_blit(gProgressBarEmpty, pos, 0, width-pos, height, dx+pos, dy);
}
}
if (gProgressBarType == PROGRESSBAR_TYPE_INDETERMINATE) {
static int frame = 0;
gr_blit(gProgressBarIndeterminate[frame], 0, 0, width, height, dx, dy);
frame = (frame + 1) % PROGRESSBAR_INDETERMINATE_STATES;
}
}
int GUICheckbox::Render(void)
{
if (!isConditionTrue())
{
mRendered = false;
return 0;
}
int ret = 0;
int lastState = 0;
DataManager::GetValue(mVarName, lastState);
if (lastState)
{
if (mChecked && mChecked->GetResource())
gr_blit(mChecked->GetResource(), 0, 0, mCheckW, mCheckH, mRenderX, mRenderY);
}
else
{
if (mUnchecked && mUnchecked->GetResource())
gr_blit(mUnchecked->GetResource(), 0, 0, mCheckW, mCheckH, mRenderX, mRenderY);
}
if (mLabel)
ret = mLabel->Render();
mLastState = lastState;
mRendered = true;
return ret;
}
// Clear the screen and draw the currently selected background icon (if any).
// Should only be called with gUpdateMutex locked.
static void draw_background_locked(int icon)
{
gPagesIdentical = 0;
// gr_color(0, 0, 0, 255);
// gr_fill(0, 0, gr_fb_width(), gr_fb_height());
{
int bw = gr_get_width(gBackground);
int bh = gr_get_height(gBackground);
int bx = 0;
int by = 0;
for (by = 0; by < gr_fb_height(); by += bh) {
for (bx = 0; bx < gr_fb_width(); bx += bw) {
gr_blit(gBackground, 0, 0, bw, bh, bx, by);
}
}
}
if (icon) {
gr_surface surface = gBackgroundIcon[icon];
int iconWidth = gr_get_width(surface);
int iconHeight = gr_get_height(surface);
int iconX = (gr_fb_width() - iconWidth) / 2;
int iconY = (gr_fb_height() - iconHeight) / 2;
gr_blit(surface, 0, 0, iconWidth, iconHeight, iconX, iconY);
if (icon == BACKGROUND_ICON_INSTALLING) {
draw_install_overlay_locked(gInstallingFrame);
}
}
}
int GUISlider::Render(void)
{
if(!isConditionTrue())
return 0;
if (!sSlider || !sSlider->GetResource())
return -1;
// Draw the slider
gr_blit(sSlider->GetResource(), 0, 0, mRenderW, mRenderH, mRenderX, mRenderY);
// Draw the used
if (sSliderUsed && sSliderUsed->GetResource() && sCurTouchX > mRenderX)
gr_blit(sSliderUsed->GetResource(), 0, 0, sCurTouchX - mRenderX, mRenderH, mRenderX, mRenderY);
// Draw the touch icon
if (sTouch && sTouch->GetResource())
gr_blit(sTouch->GetResource(), 0, 0, sTouchW, sTouchH, sCurTouchX, (mRenderY + ((mRenderH - sTouchH) / 2)));
if (sSliderLabel) {
int ret = sSliderLabel->Render();
if (ret < 0) return ret;
}
sUpdate = 0;
return 0;
}
int GUIFileSelector::Render(void)
{
// First step, fill background
gr_color(mBackgroundColor.red, mBackgroundColor.green, mBackgroundColor.blue, 255);
gr_fill(mRenderX, mRenderY, mRenderW, mRenderH);
// Next, render the background resource (if it exists)
if (mBackground && mBackground->GetResource())
{
mBackgroundX = mRenderX + ((mRenderW - mBackgroundW) / 2);
mBackgroundY = mRenderY + ((mRenderH - mBackgroundH) / 2);
gr_blit(mBackground->GetResource(), 0, 0, mBackgroundW, mBackgroundH, mBackgroundX, mBackgroundY);
}
// Now, we need the lines (icon + text)
gr_color(mFontColor.red, mFontColor.green, mFontColor.blue, mFontColor.alpha);
// This tells us how many lines we can actually render
int lines = mRenderH / (mLineHeight + mLineSpacing);
int line;
int folderSize = mShowFolders ? mFolderList.size() : 0;
int fileSize = mShowFiles ? mFileList.size() : 0;
if (folderSize + fileSize < lines) lines = folderSize + fileSize;
void* fontResource = NULL;
if (mFont) fontResource = mFont->GetResource();
int yPos = mRenderY + (mLineSpacing / 2);
for (line = 0; line < lines; line++)
{
Resource* icon;
std::string label;
if (line + mStart < folderSize)
{
icon = mFolderIcon;
label = mFolderList.at(line + mStart).fileName;
}
else
{
icon = mFileIcon;
label = mFileList.at((line + mStart) - folderSize).fileName;
}
if (icon && icon->GetResource())
{
gr_blit(icon->GetResource(), 0, 0, mIconWidth, mIconHeight, mRenderX, yPos);
}
gr_textEx(mRenderX + mIconWidth + 5, yPos, label.c_str(), fontResource);
// Move the yPos
yPos += mLineHeight + mLineSpacing;
}
mUpdate = 0;
return 0;
}
int GUIProgressBar::RenderInternal(void)
{
if (!mEmptyBar || !mEmptyBar->GetResource())
return -1;
if (!mFullBar || !mFullBar->GetResource())
return -1;
gr_blit(mEmptyBar->GetResource(), 0, 0, mRenderW, mRenderH, mRenderX, mRenderY);
gr_blit(mFullBar->GetResource(), 0, 0, mLastPos, mRenderH, mRenderX, mRenderY);
return 0;
}
// Draw the progress bar (if any) on the screen. Does not flip pages.
// Should only be called with updateMutex locked.
void ScreenRecoveryUI::draw_progress_locked()
{
if (currentIcon == ERROR) return;
if (currentIcon == INSTALLING_UPDATE || currentIcon == ERASING) {
gr_surface icon = installation[installingFrame];
gr_blit(icon, 0, 0, gr_get_width(icon), gr_get_height(icon), iconX, iconY);
}
if (progressBarType != EMPTY) {
int iconHeight = gr_get_height(backgroundIcon[INSTALLING_UPDATE]);
int width = gr_get_width(progressBarEmpty);
int height = gr_get_height(progressBarEmpty);
int dx = (gr_fb_width() - width)/2;
#if 0 //wschen 2012-07-11
int dy = (3*gr_fb_height() + iconHeight - 2*height)/4;
#else
int dy = (gr_fb_height() - 8 * height)/4;
#endif
// Erase behind the progress bar (in case this was a progress-only update)
gr_color(0, 0, 0, 255);
gr_fill(dx, dy, width, height);
if (progressBarType == DETERMINATE) {
float p = progressScopeStart + progress * progressScopeSize;
int pos = (int) (p * width);
if (rtl_locale) {
// Fill the progress bar from right to left.
if (pos > 0) {
gr_blit(progressBarFill, width-pos, 0, pos, height, dx+width-pos, dy);
}
if (pos < width-1) {
gr_blit(progressBarEmpty, 0, 0, width-pos, height, dx, dy);
}
} else {
// Fill the progress bar from left to right.
if (pos > 0) {
gr_blit(progressBarFill, 0, 0, pos, height, dx, dy);
}
if (pos < width-1) {
gr_blit(progressBarEmpty, pos, 0, width-pos, height, dx+pos, dy);
}
}
}
}
}
// Clear the screen and draw the currently selected background icon (if any).
// Should only be called with updateMutex locked.
void ScreenRecoveryUI::draw_background_locked(Icon icon)
{
pagesIdentical = false;
gr_color(0, 0, 0, 255);
gr_clear();
if (icon) {
gr_surface surface = backgroundIcon[icon];
if (icon == INSTALLING_UPDATE || icon == ERASING) {
surface = installation[installingFrame];
}
gr_surface text_surface = backgroundText[icon];
int iconWidth = gr_get_width(surface);
int iconHeight = gr_get_height(surface);
int textWidth = gr_get_width(text_surface);
int textHeight = gr_get_height(text_surface);
int stageHeight = gr_get_height(stageMarkerEmpty);
int sh = (max_stage >= 0) ? stageHeight : 0;
iconX = (gr_fb_width() - iconWidth) / 2;
iconY = (gr_fb_height() - (iconHeight+textHeight+40+sh)) / 2;
// MStar Android Patch Begin
// Add textHeight + 40 + sh may cause iconY value be negative number
if (iconY < 0) {
iconY = 0;
}
// MStar Android Patch End
int textX = (gr_fb_width() - textWidth) / 2;
int textY = ((gr_fb_height() - (iconHeight+textHeight+40+sh)) / 2) + iconHeight + 40;
gr_blit(surface, 0, 0, iconWidth, iconHeight, iconX, iconY);
if (stageHeight > 0) {
int sw = gr_get_width(stageMarkerEmpty);
int x = (gr_fb_width() - max_stage * gr_get_width(stageMarkerEmpty)) / 2;
int y = iconY + iconHeight + 20;
for (int i = 0; i < max_stage; ++i) {
gr_blit((i < stage) ? stageMarkerFill : stageMarkerEmpty,
0, 0, sw, stageHeight, x, y);
x += sw;
}
}
gr_color(255, 255, 255, 255);
gr_texticon(textX, textY, text_surface);
}
}
void mouse_draw( INSTANCE * i, REGION * clip )
{
int r ;
REGION region;
r = GLOINT32( libmouse, MOUSEREGION ) ;
if ( r < 0 || r > 31 ) r = 0 ;
region = regions[r];
if ( clip ) region_union( ®ion, clip );
if ( GLOINT32( libmouse, MOUSEANGLE ) || GLOINT32( libmouse, MOUSESIZE ) != 100 )
gr_rotated_blit(
0,
®ion,
GLOINT32( libmouse, MOUSEX ),
GLOINT32( libmouse, MOUSEY ),
GLODWORD( libmouse, MOUSEFLAGS ),
GLOINT32( libmouse, MOUSEANGLE ),
GLOINT32( libmouse, MOUSESIZE ),
GLOINT32( libmouse, MOUSESIZE ),
mouse_map ) ;
else
gr_blit(
0,
®ion,
GLOINT32( libmouse, MOUSEX ),
GLOINT32( libmouse, MOUSEY ),
GLODWORD( libmouse, MOUSEFLAGS ),
mouse_map ) ;
mouse_map->modified = 0;
}
int GUIConsole::RenderSlideout(void)
{
if (!mSlideoutImage || !mSlideoutImage->GetResource()) return -1;
gr_blit(mSlideoutImage->GetResource(), 0, 0, mSlideoutW, mSlideoutH, mSlideoutX, mSlideoutY);
return 0;
}
// MStar Android Patch Begin
// Draw the title bitmaps on the top of panel.
// Should only be called with gUpdateMutex locked.
void ScreenRecoveryUI::draw_top_title_locked()
{
gr_surface titleASurface = titleNotPowerOff;
int titleAWidth = gr_get_width(titleASurface);
int titleAHeight = gr_get_height(titleASurface);
int titleAX = (gr_fb_width() - titleAWidth) / 2;
int titleAY = 50;
gr_blit(titleASurface, 0, 0, titleAWidth, titleAHeight, titleAX, titleAY);
gr_surface titleBSurface = titleNotUnplug;
int titleBWidth = gr_get_width(titleBSurface);
int titleBHeight = gr_get_height(titleBSurface);
int titleBX = (gr_fb_width() - titleBWidth) / 2;
int titleBY = titleAY + titleAHeight;
gr_blit(titleBSurface, 0, 0, titleBWidth, titleBHeight, titleBX, titleBY);
}
int GUIButton::Render(void)
{
if (!isConditionTrue())
{
mRendered = false;
return 0;
}
int ret = 0;
if (mButtonImg) ret = mButtonImg->Render();
if (ret < 0) return ret;
if (hasFill) {
gr_color(mFillColor.red, mFillColor.green, mFillColor.blue, mFillColor.alpha);
gr_fill(mRenderX, mRenderY, mRenderW, mRenderH);
}
if (mButtonIcon && mButtonIcon->GetResource())
gr_blit(mButtonIcon->GetResource(), 0, 0, mIconW, mIconH, mIconX, mIconY);
if (mButtonLabel) {
int w, h;
mButtonLabel->GetCurrentBounds(w, h);
if (w != mTextW) {
mTextW = w;
}
ret = mButtonLabel->Render();
if (ret < 0) return ret;
}
if (renderHighlight && hasHighlightColor) {
gr_color(mHighlightColor.red, mHighlightColor.green, mHighlightColor.blue, mHighlightColor.alpha);
gr_fill(mRenderX, mRenderY, mRenderW, mRenderH);
}
mRendered = true;
return ret;
}
int GUIButton::Update(void)
{
if (!isConditionTrue()) return (mRendered ? 2 : 0);
if (!mRendered) return 2;
int ret = 0, ret2 = 0;
if (mButtonImg) ret = mButtonImg->Update();
if (ret < 0) return ret;
if (ret == 0)
{
if (mButtonLabel) {
ret2 = mButtonLabel->Update();
if (ret2 < 0) return ret2;
if (ret2 > ret) ret = ret2;
}
}
else if (ret == 1)
{
// The button re-rendered, so everyone else is a render
if (mButtonIcon && mButtonIcon->GetResource())
gr_blit(mButtonIcon->GetResource(), 0, 0, mIconW, mIconH, mIconX, mIconY);
if (mButtonLabel) ret = mButtonLabel->Render();
if (ret < 0) return ret;
ret = 1;
}
else
{
// Aparently, the button needs a background update
ret = 2;
}
return ret;
}
// Clear the screen and draw the currently selected background icon (if any).
// Should only be called with updateMutex locked.
void ScreenRecoveryUI::draw_background_locked(Icon icon)
{
pagesIdentical = false;
gr_color(0, 0, 0, 255);
gr_fill(0, 0, gr_fb_width(), gr_fb_height());
if (icon) {
gr_surface surface = backgroundIcon[icon];
gr_surface text_surface = backgroundText[icon];
int iconWidth = gr_get_width(surface);
int iconHeight = gr_get_height(surface);
int textWidth = gr_get_width(text_surface);
int textHeight = gr_get_height(text_surface);
int iconX = (gr_fb_width() - iconWidth) / 2;
int iconY = (gr_fb_height() - (iconHeight+textHeight+40)) / 2;
int textX = (gr_fb_width() - textWidth) / 2;
int textY = ((gr_fb_height() - (iconHeight+textHeight+40)) / 2) + iconHeight + 40;
gr_blit(surface, 0, 0, iconWidth, iconHeight, iconX, iconY);
if (icon == INSTALLING_UPDATE || icon == ERASING) {
draw_install_overlay_locked(installingFrame);
}
gr_color(255, 255, 255, 255);
gr_texticon(textX, textY, text_surface);
}
}
// Clear the screen and draw the currently selected background icon (if any).
// Should only be called with updateMutex locked.
void ScreenRecoveryUI::draw_background_locked() {
pagesIdentical = false;
gr_color(0, 0, 0, 255);
gr_clear();
if (currentIcon != NONE) {
if (max_stage != -1) {
int stage_height = gr_get_height(stageMarkerEmpty);
int stage_width = gr_get_width(stageMarkerEmpty);
int x = (gr_fb_width() - max_stage * gr_get_width(stageMarkerEmpty)) / 2;
int y = gr_fb_height() - stage_height;
for (int i = 0; i < max_stage; ++i) {
GRSurface* stage_surface = (i < stage) ? stageMarkerFill : stageMarkerEmpty;
gr_blit(stage_surface, 0, 0, stage_width, stage_height, x, y);
x += stage_width;
}
}
GRSurface* text_surface = GetCurrentText();
int text_x = (gr_fb_width() - gr_get_width(text_surface)) / 2;
int text_y = GetTextBaseline();
gr_color(255, 255, 255, 255);
gr_texticon(text_x, text_y, text_surface);
}
}
int GUIKeyboard::Render(void)
{
if (!isConditionTrue())
{
mRendered = false;
return 0;
}
int ret = 0;
if (keyboardImg[currentLayout - 1] && keyboardImg[currentLayout - 1]->GetResource())
gr_blit(keyboardImg[currentLayout - 1]->GetResource(), 0, 0, KeyboardWidth, KeyboardHeight, mRenderX, mRenderY);
if (hasHighlight && highlightRenderCount != 0) {
int boxheight, boxwidth, x;
if (rowY == 0)
boxheight = row_heights[currentLayout - 1][rowY];
else
boxheight = row_heights[currentLayout - 1][rowY] - row_heights[currentLayout - 1][rowY - 1];
if (colX == 0) {
x = mRenderX;
boxwidth = keyboard_keys[currentLayout - 1][rowY][colX].end_x;
} else {
x = mRenderX + keyboard_keys[currentLayout - 1][rowY][colX - 1].end_x;
boxwidth = keyboard_keys[currentLayout - 1][rowY][colX].end_x - keyboard_keys[currentLayout - 1][rowY][colX - 1].end_x;
}
gr_color(mHighlightColor.red, mHighlightColor.green, mHighlightColor.blue, mHighlightColor.alpha);
gr_fill(x, mRenderY + row_heights[currentLayout - 1][rowY - 1], boxwidth, boxheight);
if (highlightRenderCount > 0)
highlightRenderCount--;
} else
mRendered = true;
return ret;
}
// Draws the animation and progress bar (if any) on the screen.
// Does not flip pages.
// Should only be called with updateMutex locked.
void ScreenRecoveryUI::draw_foreground_locked() {
if (currentIcon != NONE) {
GRSurface* frame = GetCurrentFrame();
int frame_width = gr_get_width(frame);
int frame_height = gr_get_height(frame);
int frame_x = (gr_fb_width() - frame_width) / 2;
int frame_y = GetAnimationBaseline();
gr_blit(frame, 0, 0, frame_width, frame_height, frame_x, frame_y);
}
if (progressBarType != EMPTY) {
int width = gr_get_width(progressBarEmpty);
int height = gr_get_height(progressBarEmpty);
int progress_x = (gr_fb_width() - width)/2;
int progress_y = GetProgressBaseline();
// Erase behind the progress bar (in case this was a progress-only update)
gr_color(0, 0, 0, 255);
gr_fill(progress_x, progress_y, width, height);
if (progressBarType == DETERMINATE) {
float p = progressScopeStart + progress * progressScopeSize;
int pos = (int) (p * width);
if (rtl_locale) {
// Fill the progress bar from right to left.
if (pos > 0) {
gr_blit(progressBarFill, width-pos, 0, pos, height,
progress_x+width-pos, progress_y);
}
if (pos < width-1) {
gr_blit(progressBarEmpty, 0, 0, width-pos, height, progress_x, progress_y);
}
} else {
// Fill the progress bar from left to right.
if (pos > 0) {
gr_blit(progressBarFill, 0, 0, pos, height, progress_x, progress_y);
}
if (pos < width-1) {
gr_blit(progressBarEmpty, pos, 0, width-pos, height,
progress_x+pos, progress_y);
}
}
}
}
}
// Clear the screen and draw the currently selected background icon (if any).
// Should only be called with updateMutex locked.
void ScreenRecoveryUI::draw_background_locked(Icon icon)
{
pagesIdentical = false;
SetColor(TEXT_FILL);
gr_clear();
if (icon) {
gr_surface surface = backgroundIcon[icon];
if (icon == INSTALLING_UPDATE || icon == ERASING) {
surface = installation[installingFrame];
}
gr_surface text_surface = backgroundText[icon];
int iconWidth = gr_get_width(surface);
int iconHeight = gr_get_height(surface);
int textWidth = gr_get_width(text_surface);
int textHeight = gr_get_height(text_surface);
int stageHeight = gr_get_height(stageMarkerEmpty);
int availableHeight = icon == INSTALLING_UPDATE && !DialogShowing() && show_text
? 3 * gr_fb_height() / 4 : gr_fb_height();
int sh = (max_stage >= 0) ? stageHeight : 0;
iconX = (gr_fb_width() - iconWidth) / 2;
iconY = (availableHeight - (iconHeight+textHeight+40+sh)) / 2;
int textX = (gr_fb_width() - textWidth) / 2;
int textY = ((availableHeight - (iconHeight+textHeight+40+sh)) / 2) + iconHeight + 40;
gr_blit(surface, 0, 0, iconWidth, iconHeight, iconX, iconY);
if (stageHeight > 0) {
int sw = gr_get_width(stageMarkerEmpty);
int x = (gr_fb_width() - max_stage * gr_get_width(stageMarkerEmpty)) / 2;
int y = iconY + iconHeight + 20;
for (int i = 0; i < max_stage; ++i) {
gr_blit((i < stage) ? stageMarkerFill : stageMarkerEmpty,
0, 0, sw, stageHeight, x, y);
x += sw;
}
}
LOGV("textX=%d textY=%d iconX=%d iconY=%d", textX, textY, iconX, iconY);
SetColor(MENU);
gr_texticon(textX, textY, text_surface);
}
}
int GUIKeyboard::Render(void)
{
if (!isConditionTrue())
{
mRendered = false;
return 0;
}
Layout& lay = layouts[currentLayout - 1];
if (lay.keyboardImg && lay.keyboardImg->GetResource())
gr_blit(lay.keyboardImg->GetResource(), 0, 0, KeyboardWidth, KeyboardHeight, mRenderX, mRenderY);
// Draw highlight for capslock
if (hasCapsHighlight && lay.is_caps && CapsLockOn) {
gr_color(mCapsHighlightColor.red, mCapsHighlightColor.green, mCapsHighlightColor.blue, mCapsHighlightColor.alpha);
for (int indexy=0; indexy<MAX_KEYBOARD_ROWS; indexy++) {
for (int indexx=0; indexx<MAX_KEYBOARD_KEYS; indexx++) {
if ((int)lay.keys[indexy][indexx].key == KEYBOARD_LAYOUT && (int)lay.keys[indexy][indexx].layout == lay.revert_layout) {
int boxheight, boxwidth, x;
if (indexy == 0)
boxheight = lay.row_end_y[indexy];
else
boxheight = lay.row_end_y[indexy] - lay.row_end_y[indexy - 1];
if (indexx == 0) {
x = mRenderX;
boxwidth = lay.keys[indexy][indexx].end_x;
} else {
x = mRenderX + lay.keys[indexy][indexx - 1].end_x;
boxwidth = lay.keys[indexy][indexx].end_x - lay.keys[indexy][indexx - 1].end_x;
}
gr_fill(x, mRenderY + lay.row_end_y[indexy - 1], boxwidth, boxheight);
}
}
}
}
if (hasHighlight && highlightRenderCount != 0) {
int boxheight, boxwidth, x;
if (rowY == 0)
boxheight = lay.row_end_y[rowY];
else
boxheight = lay.row_end_y[rowY] - lay.row_end_y[rowY - 1];
if (colX == 0) {
x = mRenderX;
boxwidth = lay.keys[rowY][colX].end_x;
} else {
x = mRenderX + lay.keys[rowY][colX - 1].end_x;
boxwidth = lay.keys[rowY][colX].end_x - lay.keys[rowY][colX - 1].end_x;
}
gr_color(mHighlightColor.red, mHighlightColor.green, mHighlightColor.blue, mHighlightColor.alpha);
gr_fill(x, mRenderY + lay.row_end_y[rowY - 1], boxwidth, boxheight);
if (highlightRenderCount > 0)
highlightRenderCount--;
} else
mRendered = true;
return 0;
}
// Draw the given frame over the installation overlay animation. The
// background is not cleared or draw with the base icon first; we
// assume that the frame already contains some other frame of the
// animation. Does nothing if no overlay animation is defined.
// Should only be called with updateMutex locked.
void ScreenRecoveryUI::draw_install_overlay_locked(int frame) {
if (installationOverlay == NULL || overlay_offset_x < 0) return;
gr_surface surface = installationOverlay[frame];
int iconWidth = gr_get_width(surface);
int iconHeight = gr_get_height(surface);
gr_blit(surface, 0, 0, iconWidth, iconHeight,
overlay_offset_x, overlay_offset_y);
}
// Draw the virtual keys on the screen. Does not flip pages.
// Should only be called with gUpdateMutex locked.
static void draw_virtualkeys_locked()
{
//gr_surface surface = gVirtualKeys;
//virtualkey_w = gr_get_width(surface);
//virtualkey_h = gr_get_height(surface);
int iconX = (gr_fb_width() - virtualkey_w) / 2;
int iconY = (gr_fb_height() - virtualkey_h);
if (virtualkey_pressed) {
//clear virtual key area alpha.
//gr_color(0, 0, 0, 255);
//gr_fill(0, iconY, gr_fb_width(), gr_fb_height());
//draw virtual key area background.
gr_blit(gBackground, 0, 0, virtualkey_w, virtualkey_h, 0, iconY);
}
//draw virtual key.
gr_blit(gVirtualKeys, 0, 0, virtualkey_w, virtualkey_h, iconX, iconY);
}
// Draw the virtual keys on the screen. Does not flip pages.
// Should only be called with gUpdateMutex locked.
static void draw_virtualkeys_locked()
{
gr_surface surface = gVirtualKeys;
int iconWidth = gr_get_width(surface);
int iconHeight = gr_get_height(surface);
int iconX = (gr_fb_width() - iconWidth) / 2;
int iconY = (gr_fb_height() - iconHeight);
gr_blit(surface, 0, 0, iconWidth, iconHeight, iconX, iconY);
}
// Draw the given frame over the installation overlay animation. The
// background is not cleared or draw with the base icon first; we
// assume that the frame already contains some other frame of the
// animation. Does nothing if no overlay animation is defined.
// Should only be called with gUpdateMutex locked.
static void draw_install_overlay_locked(int frame) {
if (gInstallationOverlay == NULL) return;
gr_surface surface = gInstallationOverlay[frame];
int iconWidth = gr_get_width(surface);
int iconHeight = gr_get_height(surface);
gr_blit(surface, 0, 0, iconWidth, iconHeight,
ui_parameters.install_overlay_offset_x,
ui_parameters.install_overlay_offset_y);
}
int ScreenRecoveryUI::draw_header_icon()
{
gr_surface surface = headerIcon;
int iw = header_width;
int ih = header_height;
int ix = (gr_fb_width() - iw) / 2;
int iy = 0;
gr_blit(surface, 0, 0, iw, ih, ix, iy);
return ih;
}
// Draw the title bitmaps to show the tip message.
// Should only be called with gUpdateMutex locked.
void ScreenRecoveryUI::draw_tip_title_locked(Tip tip)
{
if (tip) {
gr_surface tipSurface = tipTitle[tip];
int tipWidth = gr_get_width(tipSurface);
int tipHeight = gr_get_height(tipSurface);
int tipX = (gr_fb_width() - tipWidth) / 2;
int tipY = gr_fb_height() - tipHeight - 50;
gr_blit(tipSurface, 0, 0, tipWidth, tipHeight, tipX, tipY);
}
}
void draw_instance_at( INSTANCE * i, REGION * region, int x, int y, GRAPH * dest )
{
GRAPH * map ;
int16_t * blend_table = NULL ;
int flags ;
int scalex, scaley ;
int alpha ;
int blendop;
PALETTE * palette = NULL;
int paletteid;
map = instance_graph( i ) ;
if ( !map ) return ;
flags = ( LOCDWORD( librender, i, FLAGS ) ^ LOCDWORD( librender, i, XGRAPH_FLAGS ) );
if (( alpha = LOCDWORD( librender, i, ALPHA ) ) != 255 )
{
if ( alpha <= 0 ) return ;
else if ( alpha < 255 )
flags |= B_ALPHA | ( alpha << B_ALPHA_SHIFT );
}
scalex = LOCINT32( librender, i, GRAPHSIZEX );
scaley = LOCINT32( librender, i, GRAPHSIZEY );
if ( scalex == 100 && scaley == 100 ) scalex = scaley = LOCINT32( librender, i, GRAPHSIZE );
if (( blendop = LOCDWORD( librender, i, BLENDOP ) ) )
{
blend_table = map->blend_table;
map->blend_table = ( int16_t * ) blendop;
}
if (( paletteid = LOCDWORD( librender, i, PALETTEID ) ) )
{
palette = map->format->palette ;
map->format->palette = ( PALETTE * ) paletteid;
}
/* XGRAPH does not rotate destination graphic.
WARNING: don't remove "scalex != 100 || scaley != 100 ||" from begin the next condition */
if ( scalex != 100 || scaley != 100 || ( LOCINT32( librender, i, ANGLE ) && !LOCDWORD( librender, i, XGRAPH ) ) )
{
gr_rotated_blit( dest, region, x, y, flags, LOCDWORD( librender, i, XGRAPH ) ? 0 : LOCINT32( librender, i, ANGLE ), scalex, scaley, map ) ;
}
else
{
gr_blit( dest, region, x, y, flags, map ) ;
}
if ( paletteid ) map->format->palette = palette;
if ( blendop ) map->blend_table = blend_table;
}
void ScreenRecoveryUI::draw_exit_recovery_tip_title_locked(int exitRecoveryTip)
{
if ((exitRecoveryTip >= 0)&&(exitRecoveryTip<=14)) {
gr_surface exitRecoveryTipSurface = exitRecoveryTipTitle[exitRecoveryTip];
int tipWidth = gr_get_width(exitRecoveryTipSurface);
int tipHeight = gr_get_height(exitRecoveryTipSurface);
int tipX = (gr_fb_width() - tipWidth) / 2;
int tipY = (gr_fb_height() - tipHeight)/2;
gr_blit(exitRecoveryTipSurface, 0, 0, tipWidth, tipHeight, tipX, tipY);
}
}
// Draw the progress bar (if any) on the screen; does not flip pages
// Should only be called with gUpdateMutex locked and if ui_has_initialized is true
static void draw_progress_locked() {
if (gCurrentIcon == BACKGROUND_ICON_INSTALLING) {
// update the installation animation, if active
if (ui_parameters.installing_frames > 0)
ui_increment_frame();
draw_install_overlay_locked(gInstallingFrame);
}
if (gProgressBarType != PROGRESSBAR_TYPE_NONE) {
int iconHeight = gr_get_height(gBackgroundIcon[BACKGROUND_ICON_INSTALLING]);
int width = gr_get_width(gProgressBarEmpty);
int height = gr_get_height(gProgressBarEmpty);
int dx = (gr_fb_width() - width)/2;
int dy = (3*gr_fb_height() + iconHeight - 2*height)/4;
// Erase behind the progress bar (in case this was a progress-only update)
gr_color(0, 0, 0, 255);
gr_fill(dx, dy, width, height);
if (gProgressBarType == PROGRESSBAR_TYPE_NORMAL) {
float progress = gProgressScopeStart + gProgress * gProgressScopeSize;
int pos = (int) (progress * width);
if (pos > 0) {
gr_blit(gProgressBarFill, 0, 0, pos, height, dx, dy);
}
if (pos < width-1) {
gr_blit(gProgressBarEmpty, pos, 0, width-pos, height, dx+pos, dy);
}
}
if (gProgressBarType == PROGRESSBAR_TYPE_INDETERMINATE) {
static int frame = 0;
gr_blit(gProgressBarIndeterminate[frame], 0, 0, width, height, dx, dy);
frame = (frame + 1) % ui_parameters.indeterminate_frames;
}
}
gettimeofday(&lastprogupd, NULL);
}
// Draw the currently selected icon (if any) at given location.
// Should only be called with gUpdateMutex locked.
static void draw_icon_locked(gr_surface icon,int locX, int locY)
{
gPagesIdentical = 0;
if (icon) {
int iconWidth = gr_get_width(icon);
int iconHeight = gr_get_height(icon);
int iconX = locX - iconWidth / 2;
int iconY = locY - iconHeight / 2;
gr_blit(icon, 0, 0, iconWidth, iconHeight, iconX, iconY);
}
}
