Increment/Decrement View für euch

Hi Leute da jetzt ein paar Stunden in ne eigene View investiert habe, da ich die schon öfters gebraucht hätte, will ich die mal Veröffentlichen, falls jemad die auch gebrauchen kann...



Falls wer Verbesserungsvorschläge hat meinetwegen, aber Rumgemäckere über den Code könnt ihr euch sparen...
z.B. hab ich nicht umgesetzt, dass es weiter zählt wenn man länger auf einem Button bleibt, da es für mich nicht notwendig ist, falls wer das machen weil oder weiß wie dass leicht geht gerne...
Falls wer noch was extra braucht kann ers sich ja noch programmieren...

Aja und Layoutparams sollte man immer setzen, mit ner fixen höhe, damit er alles passend berechnen kann...

Falls (was ich fast nicht glaube^^) irgendwer verwendet, gerne aber vergiss nicht mich in den Credits zu erwähnen =D

Grafiken der Buttons für alle Auflösungen:
http://www.file-upload.net/download-3705355/RaufRunter_Graphics.zip.html

sry Leute aber mag die Codeansicht nicht:

import android.content.Context;
import android.graphics.Color;
import android.graphics.drawable.Drawable;
import android.os.Handler;
import android.util.TypedValue;
import android.view.Gravity;
import android.view.View;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.TextView;

/*
* Von Leo Knoll
* LDK-Productions
*
* View zum erhöhen und verringern einer Zahl
*/

public class RaufRunter extends LinearLayout{
private Button butRauf;
private Button butRunter;
private TextView txtCount;
private Drawable dRauf;
private Drawable dRaufprr;
private Drawable dRaufprrrt;
private Drawable dRunter;
private Drawable dRunterPrr;
private Drawable dRunterPrrrt;

private int nummer = 0;
private int min = 0;
private int max = 9;
private Handler raufHandler = new Handler();
private Handler runterHandler = new Handler();
private Runnable raufRunnable = new Runnable() {
public void run() {
butRauf.setBackgroundDrawable(dRauf);
}
};
private Runnable runterRunnable = new Runnable() {
public void run() {
butRunter.setBackgroundDrawable(dRunter);
}
};

//restart gibt an, ob er zum min springen soll wenn er das max überschritten hat und umgekehrt!
private Boolean restart = true;

public RaufRunter(Context context) {
super(context);
initRaufRunter(context);

}

public RaufRunter(Context context, int min, int max) {
super(context);
this.min = min;
this.max = max;
initRaufRunter(context);
}

public RaufRunter(Context context, boolean restart) {
super(context);
this.restart = restart;
initRaufRunter(context);
}

public RaufRunter(Context context, int min, int max, boolean restart) {
super(context);
this.min = min;
this.max = max;
this.restart = restart;
initRaufRunter(context);
}

private void initRaufRunter(Context context){
super.setOrientation(LinearLayout.HORIZONTAL);
super.setOrientation(Gravity.CENTER);
super.setBaselineAligned(false);
butRauf = new Button(context);
butRunter = new Button(context);
txtCount = new TextView(context);
dRauf = context.getResources().getDrawable(R.drawable.pfeilrauf);
dRunter = context.getResources().getDrawable(R.drawable.pfeilrunter);
dRaufprr = context.getResources().getDrawable(R.drawable.pfeilraufprr);
dRunterPrr = context.getResources().getDrawable(R.drawable.pfeilrunterprr);
dRaufprrrt = context.getResources().getDrawable(R.drawable.pfeilraufprrrt);
dRunterPrrrt = context.getResources().getDrawable(R.drawable.pfeilrunterprrrt);
LinearLayout myContainer = new LinearLayout(context);

butRauf.setBackgroundDrawable(dRauf);
butRunter.setBackgroundDrawable(dRunter);
setNumber(nummer);
txtCount.setTextColor(Color.BLACK);
butRauf.setText("");
butRunter.setText("");

butRauf.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
nummer++;
if(nummer > max && restart){
nummer = min;
butRauf.setBackgroundDrawable(dRaufprrrt);
}else if(nummer > max){
nummer = max;
butRauf.setBackgroundDrawable(dRaufprrrt);
}else{
butRauf.setBackgroundDrawable(dRaufprr);
}

setNumberText();
raufHandler.postDelayed(raufRunnable , 60);
}
});
butRunter.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
nummer--;
if(nummer < min && restart){
nummer = max;
butRunter.setBackgroundDrawable(dRunterPrrrt);
}else if(nummer < min){
nummer = min;
butRunter.setBackgroundDrawable(dRunterPrrrt);
}else{
butRunter.setBackgroundDrawable(dRunterPrr);
}

setNumberText();
runterHandler.postDelayed(runterRunnable , 60);
}
});
LayoutParams lp = new LinearLayout.LayoutParams(android.widget.LinearLayout.LayoutParams.FILL_PARENT, android.widget.LinearLayout.LayoutParams.FILL_PARENT, 1);
butRauf.setLayoutParams(lp);
butRunter.setLayoutParams(lp);
txtCount.setLayoutParams(lp);
txtCount.setTextSize(50);

txtCount.setGravity(Gravity.CENTER);

myContainer.setOrientation(LinearLayout.HORIZONTAL);
myContainer.setGravity(Gravity.CENTER);
myContainer.setLayoutParams(lp);
myContainer.setBaselineAligned(false);

myContainer.addView(butRauf);
myContainer.addView(txtCount);
myContainer.addView(butRunter);
super.addView(myContainer);
}

private void setNumberText(){
txtCount.setText(String.valueOf(nummer));
}


/**
* @param setzt eine neue Nummer. Ob die neue Nummer Min oder Max Wert überschreitet wird nicht beachtet!
*/
public void setNumber(int number){
this.nummer = number;
setNumberText();
}

/**
* @return gibt die derzeitige Nummer zurück
*/
public int getNumber(){
return this.nummer;
}

public int getMin() {
return min;
}

public void setMin(int min) {
this.min = min;
if(min > nummer)
setNumber(min);
try {
LayoutParams params = new LayoutParams(super.getLayoutParams());
this.setLayoutParams(params);
} catch (Exception e) {
}
}

public int getMax() {
return max;
}

public void setMax(int max) {
this.max = max;
if(max < nummer)
setNumber(max);
try {
LayoutParams params = new LayoutParams(super.getLayoutParams());
this.setLayoutParams(params);
} catch (Exception e) {
}
}

private int getTxtCountBreite(int paramsWidth){
int nummerSize = String.valueOf(max).length();
int numNegSize = String.valueOf(min).length();
int width = nummerSize * paramsWidth/6;
if(numNegSize > nummerSize){
width = numNegSize * paramsWidth/6;
}else if(nummerSize == 1){
width *= 1.5;
}
return width;
}

public void setLayoutParams(LayoutParams params){
super.setLayoutParams(params);

if((2*params.height + getTxtCountBreite(params.height*3)) > params.width && !(params.width == android.widget.LinearLayout.LayoutParams.FILL_PARENT)
&& !(params.width == android.widget.LinearLayout.LayoutParams.WRAP_CONTENT)){
int nummerSize = String.valueOf(max).length();
int numNegSize = String.valueOf(min).length();
Double x = 0.0;

if(numNegSize > nummerSize){
x = params.width/(2 + (nummerSize+1)/2.D);
}else if(nummerSize == 1){
x = params.width*4/11.D;
}else{
x = params.width/(2 + nummerSize/2.D);
}
int y = (int) (params.width -2*x);
butRauf.setLayoutParams(new LinearLayout.LayoutParams(x.intValue(), x.intValue()));
butRunter.setLayoutParams(new LinearLayout.LayoutParams(x.intValue(), x.intValue()));
txtCount.setLayoutParams(new LinearLayout.LayoutParams(y, x.intValue()));
txtCount.setTextSize(TypedValue.COMPLEX_UNIT_PX, x.intValue()*5/6);
}else{
butRauf.setLayoutParams(new LinearLayout.LayoutParams(params.height, params.height));
butRunter.setLayoutParams(new LinearLayout.LayoutParams(params.height, params.height));
txtCount.setLayoutParams(new LinearLayout.LayoutParams(getTxtCountBreite(params.height*3), params.height));
txtCount.setTextSize(TypedValue.COMPLEX_UNIT_PX, params.height*5/6);
}
}

/**
* @return Drawable für den Increment-Button
*/
public Drawable getDrawableRauf() {
return dRauf;
}

/**
* @param setzt Drawable für den Increment-Button
*/
public void setDrawableRauf(Drawable rauf) {
dRauf = rauf;
butRauf.setBackgroundDrawable(dRauf);
}

/**
* @return Drawable für den gedrückten Increment-Button
*/
public Drawable getDrawableRaufPress() {
return dRaufprr;
}

/**
* @param setzt Drawable für den gedrückten Increment-Button
*/
public void setDrawableRaufPress(Drawable raufpress) {
dRaufprr = raufpress;
}

/**
* @return Drawable für den Decrement-Button
*/
public Drawable getDrawableRunter() {
return dRunter;
}

/**
* @param setzt Drawable für den Decrement-Button
*/
public void setDrawableRunter(Drawable runter) {
dRunter = runter;
butRunter.setBackgroundDrawable(dRunter);
}

/**
* @return Drawable für den gedrückten Increment-Button
*/
public Drawable getDrawableRunterPress() {
return dRunterPrr;
}

/**
* @param setzt Drawable für den gedrückten Decrement-Button
*/
public void setDrawableRunterPress(Drawable runterpress) {
dRunterPrr = runterpress;
}

/**
* @param setzt Drawable für den gedrückten Decrement-Button wenn dieser max oder min überschreitet
*/
public void setDrawableRunterPressExtrem(Drawable runterpressExtrem) {
dRunterPrrrt = runterpressExtrem;
}

/**
* @return Drawable für den gedrückten Increment-Button wenn dieser max oder min überschreitet
*/
public Drawable getDrawableRunterPressExtrem() {
return dRunterPrrrt;
}

/**
* @return returns restart. Restart gibt an, ob er zum min springen soll wenn er das max überschritten hat und umgekehrt!
*/
public Boolean getRestart() {
return restart;
}

/**
* @param setzt restart. Restart gibt an, ob er zum min springen soll wenn er das max überschritten hat und umgekehrt!
*/
public void setRestart(Boolean restart) {
this.restart = restart;
}

/**
* @param setzt die Farbe für die Zahl
*/
public void setTextColor(int color){
this.txtCount.setTextColor(color);
}

}