int is_to_switch(struct aps_controller *aps) {
enum brq_code w_brq = get_brq_for_me(aps, WEST);
enum brq_code e_brq = get_brq_for_me(aps, EAST);
enum brq_code hi_brq = get_highest_brq(aps);
if (RMAX(w_brq, e_brq) != NR && RMAX(w_brq, e_brq) != RR && (is_coexist_brq(RMAX(w_brq, e_brq), hi_brq))) {
return 1;
}
return 0;
}
/* conversion of YCbCr to RGB
used by video_calc_palette (internal palette) (not used by CRT emu)
*/
static void video_convert_renderer_to_rgb_gamma(video_ycbcr_color_t *src, float sat,
float bri, float con, float gam, float tin,
palette_entry_t *dst, int video)
{
float rf, bf, gf;
double factor;
int r, g, b;
video_ycbcr_color_t tmp;
/* DBG(("video_convert_renderer_to_rgb_gamma")); */
tmp.cb = src->cb;
tmp.cr = src->cr;
tmp.y = src->y;
if (video) {
tmp.cr += tin; /* apply tint */
/* apply saturation */
tmp.cb *= sat;
tmp.cr *= sat;
video_convert_ycbcr_to_rgb(&tmp, &r, &g, &b);
} else {
/* FIXME: tint for ntsc */
tmp.cr += tin; /* apply tint */
/* apply saturation */
tmp.cb *= sat;
tmp.cr *= sat;
video_convert_yiq_to_rgb(&tmp, &r, &g, &b);
}
/* do gamma correction */
factor = pow(255.0f, 1.0f - gam);
rf = video_gamma((float)r, factor, gam, bri, con);
gf = video_gamma((float)g, factor, gam, bri, con);
bf = video_gamma((float)b, factor, gam, bri, con);
/* convert to int and clip to 8 bit boundaries */
r = (int)rf;
g = (int)gf;
b = (int)bf;
dst->dither = 0;
dst->red = (BYTE)RMAX(r,255);
dst->green = (BYTE)RMAX(g,255);
dst->blue = (BYTE)RMAX(b,255);
dst->name = NULL;
}
int is_to_pass(struct aps_controller *aps) {
enum brq_code w_brq = get_brq_for_me(aps, WEST);
enum brq_code e_brq = get_brq_for_me(aps, EAST);
enum brq_code hi_brq = get_highest_brq(aps);
if (NR != RMAX(w_brq, e_brq) && is_coexist_brq(RMAX(w_brq, e_brq), hi_brq))
return 0;
if (RMAX(w_brq, e_brq) < hi_brq)
return 1;
if (NR == RMAX(w_brq, e_brq)) {
if (!is_default_kbytes(&DRV_KBYTES(WEST)) && !is_kbyte_for_me(aps, WEST))
return 1;
if (!is_default_kbytes(&DRV_KBYTES(EAST)) && !is_kbyte_for_me(aps, EAST))
return 1;
}
return 0;
}
RRect RLineCache::flush(class IRichCompositor* compositor)
{
RRect line_rect;
// no element yet, need not flush!
element_list_t* line = getCachedElements();
if ( line->size() == 0 )
return line_rect;
// line mark
std::vector<element_list_t::iterator> line_marks;
std::vector<short> line_widths;
RRect zone = compositor->getMetricsState()->zone;
bool wrapline = m_rWrapLine;
// line width auto growth
if ( zone.size.w == 0 )
wrapline = false;
RMetricsState* mstate = compositor->getMetricsState();
RPos pen;
RRect temp_linerect;
short base_line_pos_y = 0;
element_list_t::iterator inner_start_it = line->begin();
line_marks.push_back(line->begin()); // push first line start
for ( element_list_t::iterator it = line->begin(); it != line->end(); it++ )
{
RMetrics* metrics = (*it)->getMetrics();
// prev composit event
(*it)->onCachedCompositBegin(this, pen);
// calculate baseline offset
short baseline_correct = 0;
if ( (*it)->needBaselineCorrect() )
{
baseline_correct = m_rBaselinePos;
}
// first element
if ( pen.x == 0 )
{
pen.x -= metrics->rect.min_x();
}
// set position
(*it)->setLocalPositionX(pen.x);
(*it)->setLocalPositionY(pen.y + baseline_correct);
RRect rect = metrics->rect;
rect.pos.x += pen.x;
rect.pos.y += baseline_correct;
temp_linerect.extend(rect);
// process wrapline
element_list_t::iterator next_it = it + 1;
if ( next_it == line->end() || // last element
(*next_it)->isNewlineBefore() || // line-break before next element
(*it)->isNewlineFollow() || // line-break after this element
( wrapline && pen.x != 0 // wrap line
&& pen.x + metrics->advance.x + (*next_it)->getMetrics()->rect.pos.x + (*next_it)->getMetrics()->rect.size.w + getPadding()*2 > zone.size.w
&& (*next_it)->canLinewrap() ) )
{
// correct out of bound correct
short y2correct = -temp_linerect.max_y();
for ( element_list_t::iterator inner_it = inner_start_it; inner_it != next_it; inner_it++ )
{
RPos pos = (*inner_it)->getLocalPosition();
(*inner_it)->setLocalPositionY(pos.y + y2correct);
(*inner_it)->setLocalPositionX(pos.x /*+ x2correct*/);
}
temp_linerect.pos.y = pen.y;
line_rect.extend(temp_linerect);
pen.y -= (temp_linerect.size.h + getSpacing());
pen.x = 0;
// push next line start
line_marks.push_back(next_it);
line_widths.push_back(temp_linerect.size.w);
inner_start_it = next_it;
temp_linerect = RRect();
}
else
{
pen.x += metrics->advance.x;
}
// post composit event
(*it)->onCachedCompositEnd(this, pen);
}
short align_correct_x = 0;
size_t line_mark_idx = 0;
if ( getHAlign() == e_align_left )
line_rect.size.w += getPadding() * 2;
else
line_rect.size.w = RMAX(zone.size.w, line_rect.size.w + getPadding() * 2); // auto rect
for ( element_list_t::iterator it = line->begin(); it != line->end(); it++ )
{
// prev composit event
(*it)->onCachedCompositBegin(this, pen);
if ( it == line_marks[line_mark_idx] )
{
short lwidth = line_widths[line_mark_idx];
// x correct
switch ( getHAlign() )
{
case e_align_left:
align_correct_x = getPadding();
break;
case e_align_center:
align_correct_x = ( line_rect.size.w - lwidth ) / 2;
break;
case e_align_right:
align_correct_x = line_rect.size.w - lwidth - getPadding();
break;
}
line_mark_idx++; // until next line
}
RPos pos = (*it)->getLocalPosition();
(*it)->setLocalPositionX(mstate->pen_x + pos.x + align_correct_x);
(*it)->setLocalPositionY(mstate->pen_y + pos.y);
// post composit event
(*it)->onCachedCompositEnd(this, pen);
}
line_rect.pos.y = mstate->pen_y;
// advance pen position
mstate->pen_y -= (line_rect.size.h + getSpacing());
mstate->pen_x = 0;
clear();
return line_rect;
}
RRect RHTMLTableCache::flush(class IRichCompositor* compositor)
{
RRect table_rect;
if ( m_rCached.empty())
{
return table_rect;
}
// table content size
std::vector<short> row_heights;
std::vector<short> col_widths;
std::vector<bool> width_set;
short max_row_width = 0;
short max_row_height = 0;
for ( element_list_t::iterator it = m_rCached.begin(); it != m_rCached.end(); it++ )
{
REleHTMLRow* row = dynamic_cast<REleHTMLRow*>(*it);
if ( !row )
{
CCLog("[CCRich] Table cache can only accept 'REleHTMLRow' element!");
continue;
}
short current_row_height = 0;
std::vector<class REleHTMLCell*>& cells = row->getCells();
for ( size_t i = 0; i < cells.size(); i++ )
{
CCAssert(i <= col_widths.size(), "");
if ( i == col_widths.size() )
{
col_widths.push_back(cells[i]->getMetrics()->rect.size.w + getPadding() * 2);
width_set.push_back(cells[i]->isWidthSet());
}
else
{
if (width_set[i])
{
if (cells[i]->isWidthSet())
{
col_widths[i] = RMAX(col_widths[i], cells[i]->getMetrics()->rect.size.w + getPadding() * 2);
}
else
{
// do nothing
}
}
else
{
if (cells[i]->isWidthSet())
{
col_widths[i] = cells[i]->getMetrics()->rect.size.w + getPadding() * 2;
width_set[i] = true;
}
else
{
// do nothing use the first row default width
//col_widths[i] = RMIN(col_widths[i], cells[i]->getMetrics()->rect.size.w + getPadding() * 2);
}
}
}
current_row_height = RMAX(current_row_height, cells[i]->getMetrics()->rect.size.h);
}
current_row_height += getPadding() * 2;
row_heights.push_back(current_row_height);
table_rect.size.h += current_row_height;
}
// max width
for ( size_t i = 0; i < col_widths.size(); i++ )
{
table_rect.size.w += col_widths[i];
}
// set content metrics
short spacing = getSpacing();
short pen_x = 0;
short pen_y = -m_rTable->m_rBorder;
size_t row_idx = 0;
for ( element_list_t::iterator it = m_rCached.begin(); it != m_rCached.end(); it++ )
{
REleHTMLRow* row = dynamic_cast<REleHTMLRow*>(*it);
if ( !row )
{
CCLog("[CCRich] Table cache can only accept 'REleHTMLRow' element!");
continue;
}
pen_x = m_rTable->m_rBorder;
// set row metrics
row->setLocalPositionX(pen_x);
row->setLocalPositionY(pen_y);
RMetrics* row_metrics = row->getMetrics();
row_metrics->rect.size.h = row_heights[row_idx];
row_metrics->rect.size.w = table_rect.size.w + spacing * (col_widths.size() - 1);
// process cells in row
short cell_pen_x = 0;
std::vector<class REleHTMLCell*>& cells = row->getCells();
for ( size_t i = 0; i < cells.size(); i++ )
{
cells[i]->setLocalPositionX(cell_pen_x);
cells[i]->setLocalPositionY(0);
RMetrics* cell_metrics = cells[i]->getMetrics();
cell_metrics->rect.size.w = col_widths[i];
cell_metrics->rect.size.h = row_heights[row_idx];
recompositCell(cells[i]);
cell_pen_x += col_widths[i];
cell_pen_x += spacing;
}
pen_y -= row_heights[row_idx];
pen_y -= spacing;
row_idx++;
}
table_rect.size.h += m_rTable->m_rBorder * 2 + spacing * (row_heights.size() - 1);
table_rect.size.w += m_rTable->m_rBorder * 2 + spacing * (col_widths.size() - 1);
m_rCached.clear();
return table_rect;
}
enum brq_code get_local_brq(struct aps_controller *aps, enum side side) {
assert(WEST == EXT_CMD_SIDE || EAST == EXT_CMD_SIDE);
return EXT_CMD_SIDE == side ? RMAX(get_ext_brq(aps), get_dq_brq(aps, side)) : get_dq_brq(aps, side);
}
enum brq_code get_highest_brq(struct aps_controller *aps) {
return RMAX(get_highest_brq_on_side(aps, WEST), get_highest_brq_on_side(aps, EAST));
}
