Prepares to add primitives with the specified tint and transform. This configures
{@link #stableAttrs} with all of the attributes that are the same for every vertex.
964696
public void prepare (int tint, AffineTransform xf) {
    prepare(tint, xf.m00, xf.m01, xf.m10, xf.m11, xf.tx, xf.ty);
  }
1061598
private void init(Context context, AttributeSet attrs) {

        initAttributes(context, attrs);
        initPaintObjects();
        initDimensions();
        initPadding();
        initFloatingLabelAnimator();
        initOnItemSelectedListener();
        setMinimumHeight(getPaddingTop() + getPaddingBottom() + minContentHeight);
        //Erase the drawable selector not to be affected by new size (extra paddings)
        setBackgroundResource(R.drawable.my_background);

    }
1130821
public static void tint(View view, Tint tint) {
        final ColorStateList color = tint.getColor(view.getContext());

        if (view instanceof ImageView) {
            tint(((ImageView) view).getDrawable(), color);
        } else if (view instanceof TextView) {
            TextView text = (TextView) view;
            Drawable[] comp = text.getCompoundDrawables();
            for (int i = 0; i < comp.length; i++) {
                if (comp[i] != null) {
                    comp[i] = tint(comp[i], color);
                }
            }
            text.setCompoundDrawablesWithIntrinsicBounds(comp[0], comp[1], comp[2], comp[3]);
        } else {
            throw new IllegalArgumentException("Unsupported view type");
        }
    }
597091
@Override
    protected boolean prepare(final Context2D context, final Attributes attr, final double alpha)
    {
        final Point2DArray points = attr.getControlPoints();

        if ((points != null) && (points.size() == 3))
        {
            context.beginPath();

            final Point2D p0 = points.get(0);

            final Point2D p1 = points.get(1);

            final Point2D p2 = points.get(2);

            context.moveTo(p0.getX(), p0.getY());

            context.quadraticCurveTo(p1.getX(), p1.getY(), p2.getX(), p2.getY());

            return true;
        }
        return false;
    }
369088
def _add_attrs(self):
        ''''''
        for attr in self.template_attrs:
            attr_value = self._get_template_attr(attr)

            if not attr_value:
                continue

            attr, attr_value = self._transform_key_value(
                attr,
                attr_value,
                self.attr_map
            )
            self.templ_dict[attr] = attr_value
1245623
protected void prepare(GuiRenderer renderer, float x, float y, float z, FontOptions options)
	{
		renderer.next(GL11.GL_QUADS);

		Minecraft.getMinecraft().getTextureManager().bindTexture(textureRl);
		GL11.glPushMatrix();
		GL11.glTranslatef(x, y, 0);

		zIndex = z;
	}
205567
public void addQuad (int tint, AffineTransform xf,
                       float left, float top, float right, float bottom,
                       float sl, float st, float sr, float sb) {
    addQuad(tint, xf.m00, xf.m01, xf.m10, xf.m11, xf.tx, xf.ty,
            left, top, right, bottom, sl, st, sr, sb);
  }
377353
public void addQuad (Texture tex, int tint, AffineTransform xf,
                       float x, float y, float w, float h) {
    setTexture(tex);
    float sr = tex.config.repeatX ? w/tex.displayWidth : 1;
    float sb = tex.config.repeatY ? h/tex.displayHeight : 1;
    addQuad(tint, xf, x, y, x+w, y+h, 0, 0, sr, sb);
  }
148677
public static void addExcludedAttrs(String... attrs) {
		if (attrs != null) {
			for (String attr : attrs) {
				excludedAttrs.add(attr);
			}
		}
	}
252937
function( gl, v, renderer ) {

			var n = v.length,
				units = allocTexUnits( renderer, n );

			gl.uniform1iv( this.addr, units );

			for ( var i = 0; i !== n; ++ i ) {

				renderer.setTextureCube( v[ i ] || emptyCubeTexture, units[ i ] );

			}

		}
497722
@Override
    protected boolean prepare(final Context2D context, final Attributes attr, final double alpha)
    {
        final double r = attr.getRadius();

        if (r > 0)
        {
            context.beginPath();

            context.arc(0, 0, r, attr.getStartAngle(), attr.getEndAngle(), attr.isCounterClockwise());

            return true;
        }
        return false;
    }
1370337
function( gl, v, renderer ) {

			var unit = renderer.allocTextureUnit();
			gl.uniform1i( this.addr, unit );
			renderer.setTexture2D( v || emptyTexture, unit );

		}
477790
private void initializeNoxViewConfig(Context context, AttributeSet attrs, int defStyleAttr,
      int defStyleRes) {
    noxConfig = new NoxConfig();
    TypedArray attributes = context.getTheme()
        .obtainStyledAttributes(attrs, R.styleable.nox, defStyleAttr, defStyleRes);
    initializeNoxItemSize(attributes);
    initializeNoxItemMargin(attributes);
    initializeNoxItemPlaceholder(attributes);
    initializeShapeConfig(attributes);
    initializeTransformationConfig(attributes);
    attributes.recycle();
  }
61334
def add_outermost_primitives(gc) #:nodoc:
      add_transform_primitives(gc)
      gc.push
      add_viewbox_primitives(@width, @height, gc)
      add_style_primitives(gc)
      @content.each { |element| element.add_primitives(gc) }
      gc.pop
      self
    end
698538
protected void setupTransformNatural(Rectangle2D modelBounds) {
        double zoom = rendererModel.getParameter(ZoomFactor.class).getValue();
        this.fontManager.setFontForZoom(zoom);
        this.setup();
    }
1364363
protected void initWithWrapperType() {
     // =========== wrapper type ==============
        transformers.put(Boolean.class, new Transformer() {
            @Override
            public SFSDataWrapper transform(Object value) {
                return new SFSDataWrapper(SFSDataType.BOOL, value);
            }
        });
        transformers.put(Byte.class, new Transformer() {
            @Override
            public SFSDataWrapper transform(Object value) {
                return new SFSDataWrapper(SFSDataType.BYTE, value);
            }
        });
        transformers.put(Character.class, new Transformer() {
            @Override
            public SFSDataWrapper transform(Object value) {
                return new SFSDataWrapper(SFSDataType.BYTE, (byte)((Character)value).charValue());
            }
        });
        transformers.put(Double.class, new Transformer() {
            @Override
            public SFSDataWrapper transform(Object value) {
                return new SFSDataWrapper(SFSDataType.DOUBLE, value);
            }
        });
        transformers.put(Float.class, new Transformer() {
            @Override
            public SFSDataWrapper transform(Object value) {
                return new SFSDataWrapper(SFSDataType.FLOAT, value);
            }
        });
        transformers.put(Integer.class, new Transformer() {
            @Override
            public SFSDataWrapper transform(Object value) {
                return new SFSDataWrapper(SFSDataType.INT, value);
            }
        });
        transformers.put(Long.class, new Transformer() {
            @Override
            public SFSDataWrapper transform(Object value) {
                return new SFSDataWrapper(SFSDataType.LONG, value);
            }
        });
        transformers.put(Short.class, new Transformer() {
            @Override
            public SFSDataWrapper transform(Object value) {
                return new SFSDataWrapper(SFSDataType.SHORT, value);
            }
        });
    }
725949
@Override
    protected boolean prepare(final Context2D context, final Attributes attr, final double alpha)
    {
        if (m_list.size() < 1)
        {
            if (false == parse(attr))
            {
                return false;
            }
        }
        if (m_list.size() < 1)
        {
            return false;
        }
        context.path(m_list);

        return true;
    }