Comment faire une boîte de dialogue d'alerte remplir 90% de la taille de l'écran?
Je peux très bien créer et afficher une boîte de dialogue d'alerte personnalisée, mais malgré cela, j'ai Android:layout_width/height="fill_parent" dans la boîte de dialogue XML, il est seulement aussi gros que le contenu.
Ce que je veux, c'est un dialogue qui remplisse la totalité de l'écran, à l'exception peut-être d'un remplissage de 20 pixels . Ensuite, l'image faisant partie du dialogue s'étendra automatiquement à la taille de la boîte de dialogue avec fill_parent.
Selon Dianne Hackborn, développeur de la plate-forme Android, dans this post de groupe de discussion, Dialogs a défini la largeur et la hauteur de la présentation de niveau supérieur de la fenêtre sur WRAP_CONTENT. Pour agrandir le dialogue, vous pouvez définir ces paramètres sur MATCH_PARENT.
Code de démonstration:
AlertDialog.Builder adb = new AlertDialog.Builder(this);
Dialog d = adb.setView(new View(this)).create();
// (That new View is just there to have something inside the dialog that can grow big enough to cover the whole screen.)
WindowManager.LayoutParams lp = new WindowManager.LayoutParams();
lp.copyFrom(d.getWindow().getAttributes());
lp.width = WindowManager.LayoutParams.MATCH_PARENT;
lp.height = WindowManager.LayoutParams.MATCH_PARENT;
d.show();
d.getWindow().setAttributes(lp);
Notez que les attributs sont définis après l'affichage de la boîte de dialogue. Le système est méticuleux sur le moment où ils sont définis. (Je suppose que le moteur de présentation doit les définir la première fois que la boîte de dialogue est affichée, ou quelque chose du genre.)
Il serait préférable de le faire en étendant Theme.Dialog, vous n’auriez alors pas à jouer au jeu de devinettes pour savoir quand appeler setAttributes. (Même s’il est un peu plus difficile de faire en sorte que le dialogue adopte automatiquement un thème clair ou sombre, ou le thème Honeycomb Holo. Cela peut être fait selon http://developer.Android.com/guide/topics/ui/ themes.html # SelectATheme )
Essayez d’encapsuler votre structure de dialogue personnalisée dans RelativeLayout au lieu de LinearLayout. Cela a fonctionné pour moi.
La spécification de FILL_PARENT dans la fenêtre de dialogue, comme d’autres l’a suggéré, n’a pas fonctionné pour moi (sous Android 4.0.4), car elle a simplement allongé l’arrière-plan de la boîte de dialogue noire pour remplir tout l’écran.
Ce qui fonctionne bien consiste à utiliser la valeur d'affichage minimale, mais en l'indiquant dans le code, de sorte que la boîte de dialogue occupe 90% de l'écran.
Alors:
Activity activity = ...;
AlertDialog dialog = ...;
// retrieve display dimensions
Rect displayRectangle = new Rect();
Window window = activity.getWindow();
window.getDecorView().getWindowVisibleDisplayFrame(displayRectangle);
// inflate and adjust layout
LayoutInflater inflater = (LayoutInflater)activity.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
View layout = inflater.inflate(R.layout.your_dialog_layout, null);
layout.setMinimumWidth((int)(displayRectangle.width() * 0.9f));
layout.setMinimumHeight((int)(displayRectangle.height() * 0.9f));
dialog.setView(layout);
En général, seul le réglage de la largeur devrait suffire dans la plupart des cas.
Définissez Android:minWidth et Android:minHeight dans votre vue personnalisée xml. Ceux-ci peuvent forcer l'alerte à ne pas simplement envelopper la taille du contenu. Utiliser une vue comme celle-ci devrait le faire:
<LinearLayout
xmlns:Android="http://schemas.Android.com/apk/res/Android"
Android:layout_width="fill_parent"
Android:layout_height="fill_parent"
Android:minWidth="300dp"
Android:minHeight="400dp">
<ImageView
Android:layout_width="fill_parent"
Android:layout_height="fill_parent"
Android:background="@drawable/icon"/>
</LinearLayout>
dialog.getWindow().setLayout(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT);
Encore plus simple, faites ceci:
int width = (int)(getResources().getDisplayMetrics().widthPixels*0.90);
int height = (int)(getResources().getDisplayMetrics().heightPixels*0.90);
alertDialog.getWindow().setLayout(width, height);
Toutes les autres réponses ici ont du sens, mais cela ne répond pas à ce dont Fabian a besoin. Voici une solution de la mienne. Ce n'est peut-être pas la solution parfaite, mais cela fonctionne pour moi. Il affiche une boîte de dialogue en plein écran mais vous pouvez spécifier un remplissage en haut, en bas, à gauche ou à droite.
Commencez par mettre ceci dans votre res/values / styles.xml:
<style name="CustomDialog" parent="@Android:style/Theme.Dialog">
<item name="Android:windowIsTranslucent">true</item>
<item name="Android:windowBackground">@color/Black0Percent</item>
<item name="Android:paddingTop">20dp</item>
<item name="Android:windowContentOverlay">@null</item>
<item name="Android:windowNoTitle">true</item>
<item name="Android:backgroundDimEnabled">false</item>
<item name="Android:windowIsFloating">false</item>
</style>
Comme vous pouvez le voir, j'ai là-bas Android: paddingTop = 20dp est fondamentalement ce dont vous avez besoin. Le Android: windowBackground = @ color/Black0Percent est simplement un code de couleur déclaré sur mon color.xml
res/values / color.xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
<color name="Black0Percent">#00000000</color>
</resources>
Ce code couleur sert uniquement de mannequin pour remplacer l’arrière-plan de fenêtre par défaut du dialogue par une couleur de transparence de 0%.
Ensuite, construisez la présentation de dialogue personnalisée res/layout/dialog.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
Android:id="@+id/dialoglayout"
Android:layout_width="match_parent"
Android:background="@drawable/DesiredImageBackground"
Android:layout_height="match_parent"
Android:orientation="vertical" >
<EditText
Android:id="@+id/edittext1"
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:singleLine="true"
Android:textSize="18dp" />
<Button
Android:id="@+id/button1"
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:text="Dummy Button"
Android:textSize="18dp" />
</LinearLayout>
Enfin, voici notre boîte de dialogue qui définit une vue personnalisée qui utilise notre fichier dialog.xml:
Dialog customDialog;
LayoutInflater inflater = (LayoutInflater) getLayoutInflater();
View customView = inflater.inflate(R.layout.dialog, null);
// Build the dialog
customDialog = new Dialog(this, R.style.CustomDialog);
customDialog.setContentView(customView);
customDialog.show();
Conclusion: J'ai essayé de remplacer le thème de la boîte de dialogue dans le fichier styles.xml nommé CustomDialog. Il remplace la disposition de la fenêtre Boîte de dialogue et me permet de définir un remplissage et de modifier l'opacité de l'arrière-plan. Ce n'est peut-être pas la solution parfaite, mais j'espère que cela vous aidera .. :)
Vous pouvez utiliser un pourcentage pour la largeur de la fenêtre de dialogue (JUST).
Regardez cet exemple de Holo Theme:
<style name="Theme.Holo.Dialog.NoActionBar.MinWidth">
<item name="Android:windowMinWidthMajor">@Android:dimen/dialog_min_width_major</item>
<item name="Android:windowMinWidthMinor">@Android:dimen/dialog_min_width_minor</item>
</style>
<!-- The platform's desired minimum size for a dialog's width when it
is along the major axis (that is the screen is landscape). This may
be either a fraction or a dimension. -->
<item type="dimen" name="dialog_min_width_major">65%</item>
Tout ce que vous avez à faire est d’étendre ce thème et de changer les valeurs de "majeur" et "mineur" à 90% au lieu de 65%.
Cordialement.
Ce qui suit a bien fonctionné pour moi:
<style name="MyAlertDialogTheme" parent="Base.Theme.AppCompat.Light.Dialog.Alert">
<item name="windowFixedWidthMajor">90%</item>
<item name="windowFixedWidthMinor">90%</item>
</style>
(note: windowMinWidthMajor/Minor comme suggéré dans les réponses précédentes ne faisait pas l'affaire. Mes dialogues changeaient constamment de taille en fonction du contenu)
et alors:
AlertDialog.Builder builder = new AlertDialog.Builder(getActivity(), R.style.MyAlertDialogTheme);
Solution avec calcul effectif à 90%:
@Override public void onStart() {
Dialog dialog = getDialog();
if (dialog != null) {
dialog.getWindow()
.setLayout((int) (getScreenWidth(getActivity()) * .9), ViewGroup.LayoutParams.MATCH_PARENT);
}
}
où getScreenWidth(Activity activity) est défini comme suit (le mieux est placé dans une classe Utils):
public static int getScreenWidth(Activity activity) {
Point size = new Point();
activity.getWindowManager().getDefaultDisplay().getSize(size);
return size.x;
}
Eh bien, vous devez définir la hauteur et la largeur de votre dialogue avant de le montrer (dialog.show ())
alors, fais quelque chose comme ça:
dialog.getWindow().setLayout(width, height);
//then
dialog.show()
De loin le moyen le plus simple auquel je puisse penser -
Si votre boîte de dialogue est constituée d’un LinearLayout vertical, ajoutez simplement une vue factice "Remplissage en hauteur" occupant toute la hauteur de l’écran.
Par exemple -
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
Android:orientation="vertical"
Android:layout_width="match_parent"
Android:layout_height="match_parent"
Android:weightSum="1">
<EditText
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:id="@+id/editSearch" />
<ListView
Android:layout_width="match_parent"
Android:layout_height="match_parent"
Android:id="@+id/listView"/>
<!-- this is a dummy view that will make sure the dialog is highest -->
<View
Android:layout_width="match_parent"
Android:layout_height="match_parent"
Android:layout_weight="1"/>
</LinearLayout>
Notez le Android:weightSum="1" dans les attributs de LinearLayout et le Android:layout_weight="1" dans les attributs de la vue factice.
Après avoir initialisé votre objet de dialogue et défini la vue du contenu. Faites cela et profitez-en.
(dans le cas où je mets 90% en largeur et 70% en hauteur car largeur 90% sera au dessus de la barre d'outils)
DisplayMetrics displaymetrics = new DisplayMetrics();
getActivity().getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
int width = (int) ((int)displaymetrics.widthPixels * 0.9);
int height = (int) ((int)displaymetrics.heightPixels * 0.7);
d.getWindow().setLayout(width,height);
d.show();
Eh bien, vous devez définir la hauteur et la largeur de votre dialogue avant de le montrer (dialog.show ())
alors, fais quelque chose comme ça:
dialog.getWindow().setLayout(width, height);
//then
dialog.show()
Obtenir ce code, je l'ai fait quelques modifications:
dialog.getWindow().setLayout((int)(MapGeaGtaxiActivity.this.getWindow().peekDecorView().getWidth()*0.9),(int) (MapGeaGtaxiActivity.this.getWindow().peekDecorView().getHeight()*0.9));
cependant, la taille de la boîte de dialogue peut changer lorsque l'appareil change de position. Vous devez peut-être gérer vous-même lorsque les métriques changent . PD: peekDecorView, implique que la présentation en activité est correctement initialisée, sinon vous pouvez
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int height = metrics.heightPixels;
int wwidth = metrics.widthPixels;
afin d'obtenir la taille de l'écran
Ma réponse est basée sur celle de koma, mais elle ne nécessite pas de remplacer onStart mais uniquement onCreateView, qui est presque toujours remplacée par défaut lorsque vous créez de nouveaux fragments.
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
View v = inflater.inflate(R.layout.your_fragment_layout, container);
Rect displayRectangle = new Rect();
Window window = getDialog().getWindow();
window.getDecorView().getWindowVisibleDisplayFrame(displayRectangle);
v.setMinimumWidth((int)(displayRectangle.width() * 0.9f));
v.setMinimumHeight((int)(displayRectangle.height() * 0.9f));
return v;
}
Je l'ai testé sur Android 5.0.1.
Obtenir la largeur de l'appareil:
public static int getWidth(Context context) {
DisplayMetrics displayMetrics = new DisplayMetrics();
WindowManager windowmanager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
windowmanager.getDefaultDisplay().getMetrics(displayMetrics);
return displayMetrics.widthPixels;
}
puis utiliser cela pour faire le dialogue 90% de l'appareil,
Dialog filterDialog = new Dialog(context, R.style.searchsdk_FilterDialog);
filterDialog.setContentView(R.layout.searchsdk_filter_popup);
initFilterDialog(filterDialog);
filterDialog.setCancelable(true);
filterDialog.getWindow().setLayout(((getWidth(context) / 100) * 90), LinearLayout.LayoutParams.MATCH_PARENT);
filterDialog.getWindow().setGravity(Gravity.END);
filterDialog.show();
...
AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
Dialog d = builder.create(); //create Dialog
d.show(); //first show
DisplayMetrics metrics = new DisplayMetrics(); //get metrics of screen
getActivity().getWindowManager().getDefaultDisplay().getMetrics(metrics);
int height = (int) (metrics.heightPixels*0.9); //set height to 90% of total
int width = (int) (metrics.widthPixels*0.9); //set width to 90% of total
d.getWindow().setLayout(width, height); //set layout
public static WindowManager.LayoutParams setDialogLayoutParams(Activity activity, Dialog dialog)
{
try
{
Display display = activity.getWindowManager().getDefaultDisplay();
Point screenSize = new Point();
display.getSize(screenSize);
int width = screenSize.x;
WindowManager.LayoutParams layoutParams = new WindowManager.LayoutParams();
layoutParams.copyFrom(dialog.getWindow().getAttributes());
layoutParams.width = (int) (width - (width * 0.07) );
layoutParams.height = WindowManager.LayoutParams.WRAP_CONTENT;
return layoutParams;
}
catch (Exception e)
{
e.printStackTrace();
return null;
}
}
Voici ma variante pour la largeur du dialogue personnalisé:
DisplayMetrics displaymetrics = new DisplayMetrics();
mActivity.getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
int width = (int) (displaymetrics.widthPixels * (ThemeHelper.isPortrait(mContext) ? 0.95 : 0.65));
WindowManager.LayoutParams params = getWindow().getAttributes();
params.width = width;
getWindow().setAttributes(params);
En fonction de l'orientation du périphérique (ThemeHelper.isPortrait(mContext)), la largeur de la boîte de dialogue sera donc de 95% (en mode portrait) ou de 65% (en mode paysage). C'est un peu plus que l'auteur a demandé mais cela pourrait être utile à quelqu'un.
Vous devez créer une classe qui s'étend de Dialog et mettre ce code dans votre méthode onCreate(Bundle savedInstanceState).
Pour la hauteur de la boîte de dialogue, le code devrait être similaire à celui-ci.
Au-dessus, beaucoup de réponses sont bonnes mais aucune n’a fonctionné pleinement pour moi. J'ai donc combiné la réponse de @ nmr et obtenu celle-ci.
final Dialog d = new Dialog(getActivity());
// d.getWindow().setBackgroundDrawable(R.color.action_bar_bg);
d.requestWindowFeature(Window.FEATURE_NO_TITLE);
d.setContentView(R.layout.dialog_box_shipment_detail);
WindowManager wm = (WindowManager) getActivity().getSystemService(Context.WINDOW_SERVICE); // for activity use context instead of getActivity()
Display display = wm.getDefaultDisplay(); // getting the screen size of device
Point size = new Point();
display.getSize(size);
int width = size.x - 20; // Set your heights
int height = size.y - 80; // set your widths
WindowManager.LayoutParams lp = new WindowManager.LayoutParams();
lp.copyFrom(d.getWindow().getAttributes());
lp.width = width;
lp.height = height;
d.getWindow().setAttributes(lp);
d.show();
vous devez utiliser un style @ style.xml tel que CustomDialog pour afficher la boîte de dialogue personnalisable.
<style name="CustomDialog" parent="@Android:style/Theme.DeviceDefault.Light.Dialog">
<item name="Android:windowIsTranslucent">true</item>
<item name="Android:windowBackground">@color/colorWhite</item>
<item name="Android:editTextColor">@color/colorBlack</item>
<item name="Android:windowContentOverlay">@null</item>
<item name="Android:windowNoTitle">true</item>
<item name="Android:backgroundDimEnabled">true</item>
<item name="Android:windowIsFloating">true</item>
<item name="Android:windowSoftInputMode">stateUnspecified|adjustPan</item>
</style>
et utiliser ce style dans Activity.Java comme ceci
Dialog dialog= new Dialog(Activity.this, R.style.CustomDialog);
dialog.requestWindowFeature(Window.FEATURE_NO_TITLE);
dialog.setContentView(R.layout.custom_dialog);
et votre fichier custom_dialog.xml devrait se trouver dans votre répertoire de disposition
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
Android:orientation="vertical"
Android:layout_width="match_parent"
Android:layout_height="match_parent"
Android:paddingLeft="10dp"
Android:paddingRight="10dp">
<TextView
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:text=""
Android:textSize="20dp"
Android:id="@+id/tittle_text_view"
Android:textColor="@color/colorBlack"
Android:layout_marginTop="20dp"
Android:layout_marginLeft="10dp"/>
<LinearLayout
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:orientation="horizontal"
Android:layout_marginLeft="20dp"
Android:layout_marginBottom="10dp"
Android:layout_marginTop="20dp"
Android:layout_marginRight="20dp">
<EditText
Android:id="@+id/edit_text_first"
Android:layout_width="50dp"
Android:layout_height="match_parent"
Android:hint="0"
Android:inputType="number" />
<TextView
Android:id="@+id/text_view_first"
Android:layout_width="wrap_content"
Android:layout_height="match_parent"
Android:layout_marginLeft="5dp"
Android:gravity="center"/>
<EditText
Android:id="@+id/edit_text_second"
Android:layout_width="50dp"
Android:layout_height="match_parent"
Android:hint="0"
Android:layout_marginLeft="5dp"
Android:inputType="number" />
<TextView
Android:id="@+id/text_view_second"
Android:layout_width="wrap_content"
Android:layout_height="match_parent"
Android:layout_marginLeft="5dp"
Android:gravity="center"/>
</LinearLayout>
</LinearLayout>
Voici une réponse courte qui a fonctionné pour moi (Testé sur API 8 et API 19).
Dialog mDialog;
View mDialogView;
...
// Get height
int height = mDialog.getWindow()
.getWindowManager().getDefaultDisplay()
.getHeight();
// Set your desired padding (here 90%)
int padding = height - (int)(height*0.9f);
// Apply it to the Dialog
mDialogView.setPadding(
// padding left
0,
// padding top (90%)
padding,
// padding right
0,
// padding bottom (90%)
padding);