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)); }