Custom CheckBox drawable wird nicht richtig dargestellt

kukuk

kukuk

App-Anbieter (kostenlos)
29
Hallo, ich habe einen eignene Checkbox Selector erstellt, jedoch werden die Drawables im Betrieb nicht richtig dargestellt und der untere Teil wird abgeschnitten. Hat jemand eine Ahnung wie ich das korrigieren kann?

Bilder-Upload - Kostenlos Fotos hochladen und ins Netz stellen

Code:
<CheckBox
                        android:id="@+id/checkBox1"
                        android:layout_width="wrap_content"
                        android:layout_height="wrap_content"
                      
                        android:layout_marginTop="10dp"
                        android:gravity="center"
                        android:textColor="#dcdcdc"
                        android:button="@drawable/checkbox_selector"
                        
                        android:text="Einstellungen speichern" />



<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:state_checked="true" android:drawable="@drawable/white_color_box_with_tick" />
    <item android:state_checked="false" android:drawable="@drawable/white_color_box_without_tick" />
</selector>
 
Moin Moin, du Layoutkünstler :)

Ich vermute mal , dein "Holder" baut mist , nachvollziehen kann ich es auf anhieb nicht.

Ich lehne mich mal aus dem Fenster und präsentire dir , wie ich es löse .
Ich habe auch meine Apps mit teilweise bis zu 5 unterschiedlichen (wählbaren) Layouts im EInsatz und ärgerte mich ständig über
die verschiedenen Auflösungen /Grössen usw und wollte einen Button dahin haben , wo er auch hinsoll ..

Ich gehe folgendermaßen vor :

Zuerst habe ich mir eine Routine gebastelt, die mir die Infos des Displays im zusammenhang des background liefert
Das Background-Image erstelle ich immer schön homogen mit ein paar netten Schattierungen Full-HD und
sichere es in /res/drawable-nodpi (wichtig , sonst gibt es performance-Probleme)

Code:
  ACTIVITY.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);

     DisplayMetrics metrics = new DisplayMetrics();
     WindowManager wm = (WindowManager) getSystemService(WINDOW_SERVICE);
     wm.getDefaultDisplay().getMetrics(metrics);
     float yInches = metrics.heightPixels/metrics.ydpi;
     float xInches = metrics.widthPixels/metrics.xdpi;

     Globals.LAYOUT_HEIGHT =  metrics.heightPixels;
     Globals.LAYOUT_WIDTH  =  metrics.widthPixels;
     Globals.LAYOUT_INCH   = (float)Math.sqrt(xInches*xInches + yInches*yInches);


     //  Fitting-Faktor von Background - Image berechnen
     final BitmapFactory.Options options = new BitmapFactory.Options();
     options.inJustDecodeBounds = true;
     BitmapFactory.decodeResource(getResources(), [drawable_id_meines_backgrounds],options);
     int real_bitmap_width = options.outWidth;
     int real_bitmap_height = options.outWidth;
     Globals.LAYOUT_ZOOM_X = ((float)Globals.LAYOUT_WIDTH  / (float) real_bitmap_width)  ;
     Globals.LAYOUT_ZOOM_Y = ((float)Globals.LAYOUT_HEIGHT / (float) real_bitmap_height) ;




Nächster Schritt :
Man möchte ein Element immer im Verhältnis zum Display in der gleichen Größe zum
Display erstellen / anzeigen lassen, ohne x verschiedene Layouts erstellen zu müssen.
Ausserdem umgehe ich damit die Berechnung von Android - ich kann manchmal wirklich nicht nachvollziehen, was die da machen.

Bsp : Ein Layoutbackground hat Gitterlinien und man möchte die Knöpfe immer auf den
Schnittpunkten sitzen haben - egal was für ein Device .

Ich nehme nach meiner obigen Berechnung immer an, dass die Breite / Höhe des Displays jeweils 0.0 - 1.0 ist.
Möchte man also ein Element in der Mitte platzieren, so wäre das 0.5

Bsp:
Code:
int breite = 150;
int position_X = 0.2F;
int position_Y = 0.32F;

ImageButton b_close        = (ImageButton) findViewById(R.id.image_button_close_slider);

android.view.ViewGroup.LayoutParams b_close_params = b_close.getLayoutParams();;
int button_size_real      = (int) ((float) breite * (float)  Globals.LAYOUT_ZOOM_X);
int button_size_middle    = (button_size_real/2);
b_close_params.width  = b_close_params.height = button_size_real; b_close.setLayoutParams(b_close_params);
b_close.setX((int) ((position_X) * Globals.LAYOUT_WIDTH) - button_size_middle);
b_close.setY((int) (position_Y) * Globals.LAYOUT_HEIGHT) - button_size_middle);

Und Voila, egal welche abstruse Auflösung dein Display hat , der Knopf sieht im verhältnis immer gleich aus und ist auch immer im Verhältnis an der gleichen stelle plaziert



Noch einfacher kann man es sich mit eigenen klassen machen - hier z.b. ein Imagebutton
(Ich persönlich verabscheue Spaghetti-Sourcecodes a la Basic)

Code:
public class ExtendedImageButton extends ImageButton
{
   public static final  float CENTER = -9999.12345F;

    public static Context con;

    public ExtendedImageButton(Context context)
    {
        super(context);
        con = context;

        // TODO Auto-generated constructor stub
    }

    public ImageButton create (float x,float y,int size,int resource,int id)
    {
        ImageButton b_button = new ImageButton(con);
        b_button.setImageResource(resource);

        RelativeLayout.LayoutParams i_back = new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.WRAP_CONTENT, RelativeLayout.LayoutParams.WRAP_CONTENT);
        int button_size_real      = (int) ((float) size * (float)  Globals.LAYOUT_ZOOM_X);
        int button_size_middle    = (button_size_real/2); i_back.width  = i_back.height = button_size_real;
        b_button.setLayoutParams(i_back);

        b_button.setScaleType(ScaleType.CENTER);
        b_button.setAdjustViewBounds(true);
        b_button.setBackgroundColor(Color.TRANSPARENT);
        b_button.bringToFront();
        b_button.setVisibility(View.VISIBLE);

        b_button.setTag(id);
        b_button.setId (id);
     

        if (x == CENTER)
        {
          b_button.setX((Globals.LAYOUT_WIDTH / 2) - button_size_middle);
        }
        else
        {
         b_button.setX((int) (x * Globals.LAYOUT_WIDTH));
        }

        if (y == CENTER)
        {
         b_button.setY((Globals.LAYOUT_HEIGHT / 2) - button_size_middle);
        }
        else
        {
          b_button.setY((int) (y * Globals.LAYOUT_HEIGHT));
        }
        return b_button;

    }


Der Aufruf zu dieser Klasse :

Code:
int SIze_of_Button = 250;

//  größere  elemente z.b. auf kleinen Displays -------    (Damit der Finger auch was trifft)
if (Globals.LAYOUT_INCH < 6.5F) Size_of_Button = 400;


ImageButton  b_next = new ExtendedImageButton(this).create(0.04F, 0.75F, Size_of_Button, R.drawable.media_next, BUTTON_NEXT);
            b_next.setOnClickListener(onButtonPressed);



Dieses Verfahren kann man bei Belieben auf nahezu alle Views anwenden - dem eigenen Spieltrieb
sind dazu keine Grenzen gesetzt.


P.S Bei Buttons erstelle ich meine Grafiken immer zentriert in einem quadratischen Png - rundrum transparent zur Mittelpunktberechnung
(Erleichtert mir das Leben)

P.S2. Sollten Einige bei der präsentierten Lösung die Stirn runzeln - ich komme halt aus der Core C++ ecke :)


lg
Stefan
 
Zuletzt bearbeitet:
  • Danke
Reaktionen: kukuk
Ich danke dir für deine ausführliche Antwort.
Ich habe jetzt bei meinem Spinner das marginTop="10" entfernt und schon wird es richtig dargestellt.......
 

Ähnliche Themen

M
  • MikelKatzengreis
Antworten
10
Aufrufe
231
swa00
swa00
S
Antworten
7
Aufrufe
1.164
swa00
swa00
W
  • whazza
Antworten
0
Aufrufe
714
whazza
W
Zurück
Oben Unten