// StrokeLine
BRect
Painter::StrokeLine(BPoint a, BPoint b, const pattern& p)
{
_Transform(&a);
_Transform(&b);
BRect touched(a, b);
// first, try an optimized version
float penSize = _Transform(fPenSize);
if (penSize == 1.0 &&
(fDrawingMode == B_OP_COPY || fDrawingMode == B_OP_OVER)) {
pattern pat = *fPatternHandler->GetR5Pattern();
if (pat == B_SOLID_HIGH &&
StraightLine(a, b, fPatternHandler->HighColor().GetColor32())) {
SetPenLocation(b);
return _Clipped(touched);
} else if (pat == B_SOLID_LOW &&
StraightLine(a, b, fPatternHandler->LowColor().GetColor32())) {
SetPenLocation(b);
return _Clipped(touched);
}
}
agg::path_storage path;
path.move_to(a.x, a.y);
path.line_to(b.x, b.y);
touched = _StrokePath(path, p);
SetPenLocation(b);
return _Clipped(touched);
}
// StrokeRect
void
Painter::StrokeRect(const BRect& r, const rgb_color& c) const
{
StraightLine(BPoint(r.left, r.top),
BPoint(r.right - 1, r.top), c);
StraightLine(BPoint(r.right, r.top),
BPoint(r.right, r.bottom - 1), c);
StraightLine(BPoint(r.right, r.bottom),
BPoint(r.left + 1, r.bottom), c);
StraightLine(BPoint(r.left, r.bottom),
BPoint(r.left, r.top + 1), c);
}
static instruction *FoldAbsolute( instruction *ins ) {
/*********************************************************
See below.
*/
instruction *new_ins;
opcnt num_operands;
name *result;
tn fold;
type_def *tipe;
type_def *left_tipe;
type_def *rite_tipe;
type_def *fold_tipe;
pointer left;
pointer rite;
name *tmp;
name *new_const;
float_handle value;
tipe = ClassType( ins->type_class );
left_tipe = ClassType( _OpClass( ins ) );
num_operands = OpcodeNumOperands( ins );
left = NULL;
rite = NULL;
if( num_operands != 0 ) {
left = TName( ins->operands[0], left_tipe );
if( num_operands > 1 ) {
if( ins->operands[1]->n.type_class == XX ) {
rite_tipe = tipe;
} else {
rite_tipe = ClassType( ins->operands[1]->n.type_class );
}
rite = TName( ins->operands[1], rite_tipe );
}
}
fold = NULL;
switch( ins->head.opcode ) {
case OP_ADD:
fold = FoldPlus( left, rite, tipe );
break;
case OP_SUB:
fold = FoldMinus( left, rite, tipe );
break;
case OP_MUL:
fold = FoldTimes( left, rite, tipe );
break;
case OP_DIV:
fold = FoldDiv( left, rite, tipe );
break;
case OP_MOD:
fold = FoldMod( left, rite, tipe );
break;
case OP_AND:
fold = FoldAnd( left, rite, tipe );
break;
case OP_OR:
fold = FoldOr( left, rite, tipe );
break;
case OP_XOR:
fold = FoldXor( left, rite, tipe );
break;
case OP_RSHIFT:
fold = FoldRShift( left, rite, tipe );
break;
case OP_LSHIFT:
fold = FoldLShift( left, rite, tipe );
break;
case OP_NEGATE:
fold = FoldUMinus( left, tipe );
break;
case OP_COMPLEMENT:
fold = Fold1sComp( left, tipe );
break;
case OP_CONVERT:
// look out for CNV PT U2 t1 type instructions; if sizeof( PT ) is greater
// than sizeof( U2 ), we don't want to fold or we'll screw up based pointers
if( IsTrickyPointerConv( ins ) )
return( NULL );
// fall through!
case OP_ROUND:
fold = FoldCnvRnd( (cg_op)ins->head.opcode, left, tipe );
break;
case OP_CMP_EQUAL:
case OP_CMP_NOT_EQUAL:
case OP_CMP_GREATER:
case OP_CMP_LESS_EQUAL:
case OP_CMP_LESS:
case OP_CMP_GREATER_EQUAL:
if( ActiveCompare( ins ) ) {
fold = FoldCompare( (cg_op)ins->head.opcode, left, rite, tipe );
if( fold != NULL ) {
return( StraightLine( ins, fold, true ) );
}
}
break;
case OP_BIT_TEST_TRUE:
if( ActiveCompare( ins ) ) {
fold = FoldAnd( left, rite, tipe );
if( fold != NULL ) {
return( StraightLine( ins, fold, true ) );
}
}
break;
case OP_BIT_TEST_FALSE:
if( ActiveCompare( ins ) ) {
fold = FoldAnd( left, rite, tipe );
if( fold != NULL ) {
return( StraightLine( ins, fold, false ) );
}
}
break;
default:
fold = NULL;
break;
}
if( fold != NULL ) {
fold_tipe = fold->tipe;
result = TGetName( fold );
if( result != NULL && !NeedConvert( fold_tipe, tipe ) ) {
ins->table = NULL;
// look out for scary DIV U4 EDX:EAX, c1 -> t1 type instructions
if( result->n.class != N_CONSTANT &&
result->n.size != TypeClassSize[ins->type_class] )
return( NULL );
// look out for scary MUL U4 EDX:EAX, c1 -> t1 type instructions
if( result->n.class != N_CONSTANT &&
ins->result->n.size != TypeClassSize[ins->type_class] )
return( NULL );
new_ins = MakeMove( result, ins->result, ins->type_class );
SetCSEBits( ins, new_ins );
DupSeg( ins, new_ins );
ReplIns( ins, new_ins );
return( new_ins );
}
