Domanda

Ho creato alcuni elementi personalizzati e voglio posizionarli a livello di codice nell'angolo in alto a destra ( n pixel dal bordo superiore e m pixel dal bordo destro) . Pertanto ho bisogno di ottenere la larghezza e l'altezza dello schermo e quindi impostare la posizione:

int px = screenWidth - m;
int py = screenHeight - n;

Come posso ottenere screenWidth e screenHeight nell'attività principale?

È stato utile?

Soluzione

Se vuoi le dimensioni di visualizzazione in pixel puoi usare getSize :

Display display = getWindowManager().getDefaultDisplay();
Point size = new Point();
display.getSize(size);
int width = size.x;
int height = size.y;

Se non ti trovi in ?? Attività puoi ottenere il Display predefinito tramite WINDOW_SERVICE :

WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
Display display = wm.getDefaultDisplay();

Se sei in un frammento e vuoi compierlo, usa solo Activity.WindowManager (in Xamarin.Android) o getActivity (). getWindowManager () (in java).

Prima dell'introduzione di getSize (nel livello API 13), è possibile utilizzare i metodi getWidth e getHeight che sono ora obsoleti:

Display display = getWindowManager().getDefaultDisplay(); 
int width = display.getWidth();  // deprecated
int height = display.getHeight();  // deprecated

Per il caso d'uso che stai descrivendo, tuttavia, un margine / riempimento nel layout sembra più appropriato.

Un altro modo è: DisplayMetrics

  

Una struttura che descrive informazioni generali su un display, come dimensioni, densità e ridimensionamento dei caratteri. Per accedere ai membri DisplayMetrics, inizializza un oggetto come questo:

DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);

Possiamo usare widthPixels per ottenere informazioni per:

  

" La larghezza assoluta del display in pixel. "

Esempio:

Log.d("ApplicationTagName", "Display width in px is " + metrics.widthPixels);

Altri suggerimenti

Un modo è:

Display display = getWindowManager().getDefaultDisplay(); 
int width = display.getWidth();
int height = display.getHeight();

È obsoleto e dovresti invece provare il seguente codice. Le prime due righe di codice forniscono gli oggetti DisplayMetrics . Questo oggetto contiene campi come heightPixels , widthPixels .

DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);

int height = metrics.heightPixels;
int width = metrics.widthPixels;

Potrebbe non rispondere alla tua domanda, ma potrebbe essere utile sapere (stavo cercando me stesso quando sono arrivato a questa domanda) che se hai bisogno della dimensione di una Vista ma il tuo codice viene eseguito quando il suo layout non è stato disposto ancora (ad esempio in onCreate () ) puoi impostare un ViewTreeObserver.OnGlobalLayoutListener con View.getViewTreeObserver (). addOnGlobalLayoutListener () e inserisci lì il codice pertinente che necessita della dimensione della vista. Il callback dell'ascoltatore verrà chiamato quando il layout sarà stato predisposto.

(risposta del 2012, potrebbe non essere aggiornata) Se si desidera supportare pre Honeycomb, è necessario inserire la compatibilità con le versioni precedenti prima dell'API 13. Qualcosa del tipo:

int measuredWidth = 0;
int measuredHeight = 0;
WindowManager w = getWindowManager();

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
    Point size = new Point();
    w.getDefaultDisplay().getSize(size);
    measuredWidth = size.x;
    measuredHeight = size.y;
} else {
    Display d = w.getDefaultDisplay();
    measuredWidth = d.getWidth();
    measuredHeight = d.getHeight();
}

Ovviamente i metodi obsoleti verranno eventualmente eliminati dagli SDK più recenti, ma mentre continuiamo a fare affidamento sulla maggior parte dei nostri utenti con Android 2.1, 2.2 e 2.3, questo è ciò che ci resta.

Ho provato tutte le possibili soluzioni "quot". senza successo e ho notato che "Dalvik Explorer" di Elliott Hughes " l'app mostra sempre la dimensione corretta su qualsiasi dispositivo Android / versione del sistema operativo. Ho finito per guardare il suo progetto open source che può essere trovato qui: https://code.google.com/p/enh/

Ecco tutto il codice rilevante:

WindowManager w = activity.getWindowManager();
Display d = w.getDefaultDisplay();
DisplayMetrics metrics = new DisplayMetrics();
d.getMetrics(metrics);
// since SDK_INT = 1;
widthPixels = metrics.widthPixels;
heightPixels = metrics.heightPixels;
try {
    // used when 17 > SDK_INT >= 14; includes window decorations (statusbar bar/menu bar)
    widthPixels = (Integer) Display.class.getMethod("getRawWidth").invoke(d);
    heightPixels = (Integer) Display.class.getMethod("getRawHeight").invoke(d);
} catch (Exception ignored) {
}
try {
    // used when SDK_INT >= 17; includes window decorations (statusbar bar/menu bar)
    Point realSize = new Point();
    Display.class.getMethod("getRealSize", Point.class).invoke(d, realSize);
    widthPixels = realSize.x;
    heightPixels = realSize.y;
} catch (Exception ignored) {
}

EDIT: versione leggermente migliorata (evita di generare eccezioni sulla versione del sistema operativo non supportata):

WindowManager w = activity.getWindowManager();
Display d = w.getDefaultDisplay();
DisplayMetrics metrics = new DisplayMetrics();
d.getMetrics(metrics);
// since SDK_INT = 1;
widthPixels = metrics.widthPixels;
heightPixels = metrics.heightPixels;
// includes window decorations (statusbar bar/menu bar)
if (Build.VERSION.SDK_INT >= 14 && Build.VERSION.SDK_INT < 17)
try {
    widthPixels = (Integer) Display.class.getMethod("getRawWidth").invoke(d);
    heightPixels = (Integer) Display.class.getMethod("getRawHeight").invoke(d);
} catch (Exception ignored) {
}
// includes window decorations (statusbar bar/menu bar)
if (Build.VERSION.SDK_INT >= 17)
try {
    Point realSize = new Point();
    Display.class.getMethod("getRealSize", Point.class).invoke(d, realSize);
    widthPixels = realSize.x;
    heightPixels = realSize.y;
} catch (Exception ignored) {
}

Modo più semplice:

 int screenHeight = getResources().getDisplayMetrics().heightPixels;
 int screenWidth = getResources().getDisplayMetrics().widthPixels; 

Per accedere all'altezza della barra di stato per dispositivi Android, preferiamo un modo programmatico per ottenerlo:

Codice di esempio

int resId = getResources().getIdentifier("status_bar_height", "dimen", "android");
if (resId > 0) {
    result = getResources().getDimensionPixelSize(resId);
}

La variabile risultato indica l'altezza nel pixel.

Per un accesso rapido

Inserisci qui la descrizione dell'immagine

Per ulteriori informazioni sull'altezza di barra del titolo , barra di navigazione e visualizzazione contenuto , si prega di guardare Dimensioni dello schermo del dispositivo Android .

Prima ottieni la vista (ad es. con findViewById () ) e poi puoi usare getWidth () sulla vista stessa.

Ho due funzioni, una per inviare il contesto e l'altra per ottenere altezza e larghezza in pixel:

public static int getWidth(Context mContext){
    int width=0;
    WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
    Display display = wm.getDefaultDisplay();
    if(Build.VERSION.SDK_INT>12){
        Point size = new Point();
        display.getSize(size);
        width = size.x;
    }
    else{
        width = display.getWidth();  // Deprecated
    }
    return width;
}

e

public static int getHeight(Context mContext){
    int height=0;
    WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
    Display display = wm.getDefaultDisplay();
    if(Build.VERSION.SDK_INT>12){
        Point size = new Point();
        display.getSize(size);
        height = size.y;
    }
    else{
        height = display.getHeight();  // Deprecated
    }
    return height;
}

Per il ridimensionamento dinamico tramite XML esiste un attributo chiamato " android: layout_weight "

L'esempio seguente, modificato dalla risposta di Synic su questa discussione , mostra un pulsante che occupa il 75% dello schermo (peso = .25) e una vista di testo che occupa il restante 25% dello schermo (peso = .75).

<LinearLayout android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal">

    <Button android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:layout_weight=".25"
        android:text="somebutton">

    <TextView android:layout_width="fill_parent"
        android:layout_height="Wrap_content"
        android:layout_weight=".75">
</LinearLayout>

Questo è il codice che uso per l'attività:

// `activity` is an instance of Activity class.
Display display = activity.getWindowManager().getDefaultDisplay();
Point screen = new Point();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
    display.getSize(screen);
} else {            
    screen.x = display.getWidth();
    screen.y = display.getHeight();
}

Sembra abbastanza pulito eppure, si prende cura della deprecazione.

Non è una soluzione molto migliore? DisplayMetrics viene fornito con tutto il necessario e funziona dall'API 1.

public void getScreenInfo(){
    DisplayMetrics metrics = new DisplayMetrics();
    getActivity().getWindowManager().getDefaultDisplay().getMetrics(metrics);

    heightPixels = metrics.heightPixels;
    widthPixels = metrics.widthPixels;
    density = metrics.density;
    densityDpi = metrics.densityDpi;
}

Puoi anche ottenere la visualizzazione effettiva (compresi i decori dello schermo, come la barra di stato o la barra di navigazione del software) utilizzando getRealMetrics , ma funziona solo su 17+.

Mi manca qualcosa?

Sto solo aggiungendo alla risposta di Francesco. L'altro osservatore che è più adatto, se si desidera scoprire la posizione nella finestra o la posizione nella schermata è ViewTreeObserver.OnPreDrawListener ()

Questo può anche essere usato per trovare altri attributi di una vista che è per lo più sconosciuta al momento onCreate () ad es. la posizione di scorrimento, la posizione in scala.

Trova larghezza e altezza dello schermo:

width = getWindowManager().getDefaultDisplay().getWidth();
height = getWindowManager().getDefaultDisplay().getHeight();

Usando questo, possiamo ottenere l'ultimo e sopra SDK 13.

// New width and height
int version = android.os.Build.VERSION.SDK_INT;
Log.i("", " name == "+ version);
Display display = getWindowManager().getDefaultDisplay();
int width;
if (version >= 13) {
    Point size = new Point();
    display.getSize(size);
    width = size.x;
    Log.i("width", "if =>" +width);
}
else {
    width = display.getWidth();
    Log.i("width", "else =>" +width);
}

Utilizzo del seguente codice in Attività.

DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int height = metrics.heightPixels;
int wwidth = metrics.widthPixels;
DisplayMetrics dimension = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dimension);
int w = dimension.widthPixels;
int h = dimension.heightPixels;

Ho scoperto che questo ha funzionato.

Rect dim = new Rect();
getWindowVisibleDisplayFrame(dim);

Devo dire che se non sei in Activity , ma in View (o hai una variabile di View nel tuo ambito) , non è necessario utilizzare WINDOW_SERVICE . Quindi puoi utilizzare almeno due modi.

Per prima cosa:

DisplayMetrics dm = yourView.getContext().getResources().getDisplayMetrics();

Secondo:

DisplayMetrics dm = new DisplayMetrics();
yourView.getDisplay().getMetrics(dm);

Tutti questi metodi che chiamiamo qui non sono deprecati.

public class AndroidScreenActivity extends Activity {

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        DisplayMetrics dm = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(dm);
        String str_ScreenSize = "The Android Screen is: "
                                   + dm.widthPixels
                                   + " x "
                                   + dm.heightPixels;

        TextView mScreenSize = (TextView) findViewById(R.id.strScreenSize);
        mScreenSize.setText(str_ScreenSize);
    }
}

Per ottenere le dimensioni dello schermo usare metrices di visualizzazione

DisplayMetrics displayMetrics = new DisplayMetrics();
if (context != null) 
      WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
      Display defaultDisplay = windowManager.getDefaultDisplay();
      defaultDisplay.getRealMetrics(displayMetrics);
    }

Ottieni l'altezza e la larghezza in pixel

int width  =displayMetrics.widthPixels;
int height =displayMetrics.heightPixels;

Questa non è una risposta per l'OP, poiché voleva le dimensioni del display in pixel reali. Volevo le dimensioni in "pixel indipendenti dal dispositivo" e mettere insieme le risposte da qui https://stackoverflow.com/a/ 17880012/253938 e qui https://stackoverflow.com/a/6656774/253938 ho trovato in questo modo:

    DisplayMetrics displayMetrics = Resources.getSystem().getDisplayMetrics();
    int dpHeight = (int)(displayMetrics.heightPixels / displayMetrics.density + 0.5);
    int dpWidth = (int)(displayMetrics.widthPixels / displayMetrics.density + 0.5);

Esiste un modo non deprecato per farlo utilizzando DisplayMetrics (API 1), che evita il disordine try / catch:

 // initialize the DisplayMetrics object
 DisplayMetrics deviceDisplayMetrics = new DisplayMetrics();

 // populate the DisplayMetrics object with the display characteristics
 getWindowManager().getDefaultDisplay().getMetrics(deviceDisplayMetrics);

 // get the width and height
 screenWidth = deviceDisplayMetrics.widthPixels;
 screenHeight = deviceDisplayMetrics.heightPixels;

Vorrei racchiudere il codice getSize in questo modo:

@SuppressLint("NewApi")
public static Point getScreenSize(Activity a) {
    Point size = new Point();
    Display d = a.getWindowManager().getDefaultDisplay();
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
        d.getSize(size);
    } else {
        size.x = d.getWidth();
        size.y = d.getHeight();
    }
    return size;
}

Puoi ottenere la dimensione altezza usando:

getResources().getDisplayMetrics().heightPixels;

e la larghezza utilizzando

getResources().getDisplayMetrics().widthPixels; 

Per chi cerca dimensione dello schermo utilizzabile senza Barra di stato e Barra delle azioni (anche grazie alla risposta di Swapnil):

DisplayMetrics dm = getResources().getDisplayMetrics();
float screen_w = dm.widthPixels;
float screen_h = dm.heightPixels;

int resId = getResources().getIdentifier("status_bar_height", "dimen", "android");
if (resId > 0) {
    screen_h -= getResources().getDimensionPixelSize(resId);
}

TypedValue typedValue = new TypedValue();
if(getTheme().resolveAttribute(android.R.attr.actionBarSize, typedValue, true)){
    screen_h -= getResources().getDimensionPixelSize(typedValue.resourceId);
}

Prima carica il file XML e poi scrivi questo codice:

setContentView(R.layout.main);      
Display display = getWindowManager().getDefaultDisplay();
final int width = (display.getWidth());
final int height = (display.getHeight());

Mostra larghezza e altezza in base alla risoluzione dello schermo.

Segui i metodi seguenti:

public static int getWidthScreen(Context context) {
    return getDisplayMetrics(context).widthPixels;
}

public static int getHeightScreen(Context context) {
    return getDisplayMetrics(context).heightPixels;
}

private static DisplayMetrics getDisplayMetrics(Context context) {
    DisplayMetrics displayMetrics = new DisplayMetrics();
    WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
    wm.getDefaultDisplay().getMetrics(displayMetrics);
    return displayMetrics;
}

Ci sono momenti in cui è necessario conoscere le dimensioni precise dello spazio disponibile per un layout in onCreate di un'attività. Dopo qualche pensiero ho scoperto questo modo di farlo.

public class MainActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        startActivityForResult(new Intent(this, Measure.class), 1);
        // Return without setting the layout, that will be done in onActivityResult.
    }

    @Override
    protected void onActivityResult (int requestCode, int resultCode, Intent data) {
        // Probably can never happen, but just in case.
        if (resultCode == RESULT_CANCELED) {
            finish();
            return;
        }
        int width = data.getIntExtra("Width", -1);
        // Width is now set to the precise available width, and a layout can now be created.            ...
    }
}

public final class Measure extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
       // Create a LinearLayout with a MeasureFrameLayout in it.
        // Just putting a subclass of LinearLayout in works fine, but to future proof things, I do it this way.
        LinearLayout linearLayout = new LinearLayout(this);
        LinearLayout.LayoutParams matchParent = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.MATCH_PARENT);
        MeasureFrameLayout measureFrameLayout = new MeasureFrameLayout(this);
        measureFrameLayout.setLayoutParams(matchParent);
        linearLayout.addView(measureFrameLayout);
        this.addContentView(linearLayout, matchParent);
        // measureFrameLayout will now request this second activity to finish, sending back the width.
    }

    class MeasureFrameLayout extends FrameLayout {
        boolean finished = false;
        public MeasureFrameLayout(Context context) {
            super(context);
        }

        @SuppressLint("DrawAllocation")
        @Override
        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
            super.onMeasure(widthMeasureSpec, heightMeasureSpec);
            if (finished) {
                return;
            }
            finished = true;
            // Send the width back as the result.
            Intent data = new Intent().putExtra("Width", MeasureSpec.getSize(widthMeasureSpec));
            Measure.this.setResult(Activity.RESULT_OK, data);
            // Tell this activity to finish, so the result is passed back.
            Measure.this.finish();
        }
    }
}

Se per qualche motivo non vuoi aggiungere un'altra attività al manifest di Android, puoi farlo in questo modo:

public class MainActivity extends Activity {
    static Activity measuringActivity;

    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        Bundle extras = getIntent().getExtras();
        if (extras == null) {
            extras = new Bundle();
        }
        int width = extras.getInt("Width", -2);
        if (width == -2) {
            // First time in, just start another copy of this activity.
            extras.putInt("Width", -1);
            startActivityForResult(new Intent(this, MainActivity.class).putExtras(extras), 1);
            // Return without setting the layout, that will be done in onActivityResult.
            return;
        }
        if (width == -1) {
            // Second time in, here is where the measurement takes place.
            // Create a LinearLayout with a MeasureFrameLayout in it.
            // Just putting a subclass of LinearLayout in works fine, but to future proof things, I do it this way.
            LinearLayout linearLayout = new LinearLayout(measuringActivity = this);
            LinearLayout.LayoutParams matchParent = new LinearLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
            MeasureFrameLayout measureFrameLayout = new MeasureFrameLayout(this);
            measureFrameLayout.setLayoutParams(matchParent);
            linearLayout.addView(measureFrameLayout);
            this.addContentView(linearLayout, matchParent);
            // measureFrameLayout will now request this second activity to finish, sending back the width.
        }
    }

    @Override
    protected void onActivityResult (int requestCode, int resultCode, Intent data) {
        // Probably can never happen, but just in case.
        if (resultCode == RESULT_CANCELED) {
            finish();
            return;
        }
        int width = data.getIntExtra("Width", -3);
        // Width is now set to the precise available width, and a layout can now be created. 
        ...
    }

class MeasureFrameLayout extends FrameLayout {
    boolean finished = false;
    public MeasureFrameLayout(Context context) {
        super(context);
    }

    @SuppressLint("DrawAllocation")
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        if (finished) {
            return;
        }
        finished = true;
        // Send the width back as the result.
        Intent data = new Intent().putExtra("Width", MeasureSpec.getSize(widthMeasureSpec));
        MainActivity.measuringActivity.setResult(Activity.RESULT_OK, data);
        // Tell the (second) activity to finish.
        MainActivity.measuringActivity.finish();
    }
}    

Se non si desidera il sovraccarico di WindowManager, Punti o Display, è possibile acquisire gli attributi di altezza e larghezza dell'elemento Visualizza più in alto nel proprio XML, purché la sua altezza e larghezza siano impostate su match_parent. (Questo è vero fino a quando il layout occupa l'intero schermo.)

Ad esempio, se il tuo XML inizia con qualcosa del genere:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/entireLayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

Quindi findViewById (R.id.entireLayout) .getWidth () restituirà la larghezza dello schermo e findViewById (R.id.entireLayout) .getHeight () restituirà l'altezza dello schermo.

Ho un'attività splash screen con LinearLayout come vista di root che ha match_parent per la sua larghezza e amp; altezza. Questo è il codice nel metodo onCreate () di quell'attività. Uso queste misure in tutte le altre attività dell'app.

int displayWidth = getRawDisplayWidthPreHoneycomb();
int rawDisplayHeight = getRawDisplayHeightPreHoneycomb();
int usableDisplayHeight = rawDisplayHeight - getStatusBarHeight();
pf.setScreenParameters(displayWidth, usableDisplayHeight);

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
    LinearLayout myView = (LinearLayout) findViewById(R.id.splash_view);
    myView.addOnLayoutChangeListener(new OnLayoutChangeListener() {
        @Override
        public void onLayoutChange(View v, int left, int top, int right, int bottom, int oldLeft, int oldTop, int oldRight, int oldBottom) {
            if (left == 0 && top == 0 && right == 0 && bottom == 0) {
                return;
            }
            int displayWidth = Math.min(right, bottom);
            int usableDisplayHeight = Math.max(right, bottom);
            pf.setScreenParameters(displayWidth, usableDisplayHeight);
        }
    });
}

Ecco le implementazioni per i metodi che vedi vengono chiamati sopra:

private int getRawDisplayWidthPreHoneycomb() {
    WindowManager windowManager = getWindowManager();
    Display display = windowManager.getDefaultDisplay();
    DisplayMetrics displayMetrics = new DisplayMetrics();
    display.getMetrics(displayMetrics);

    int widthPixels = displayMetrics.widthPixels;
    int heightPixels = displayMetrics.heightPixels;

    return Math.min(widthPixels, heightPixels);
}

private int getRawDisplayHeightPreHoneycomb() {
    WindowManager w = getWindowManager();
    Display d = w.getDefaultDisplay();
    DisplayMetrics metrics = new DisplayMetrics();
    d.getMetrics(metrics);

    int widthPixels = metrics.widthPixels;
    int heightPixels = metrics.heightPixels;

    return Math.max(widthPixels, heightPixels);
}

public int getStatusBarHeight() {
    int statusBarHeight = 0;

    int resourceId = getResources().getIdentifier("status_bar_height", "dimen", "android");
    if (resourceId > 0) {
        statusBarHeight = getResources().getDimensionPixelSize(resourceId);
    }

    return statusBarHeight;
}

Ciò comporta l'altezza e la larghezza del display utilizzabile, escluso qualsiasi tipo di barra (barra di stato, barra di navigazione), per tutte le versioni API e diversi tipi di dispositivi (telefoni e tablet).

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top