gt:         if (dialog == null || !dialog.isShowing()) {
context: /*
   * Copyright (C) 2007 The Android Open Source Project
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package android.preference;
  
  import android.app.Dialog;
  import android.content.Context;
  import android.content.DialogInterface;
  import android.os.Bundle;
  import android.os.Parcel;
  import android.os.Parcelable;
  import android.text.TextUtils;
  import android.util.AttributeSet;
  import android.view.View;
  import android.widget.Adapter;
  import android.widget.AdapterView;
  import android.widget.ListAdapter;
  import android.widget.ListView;
  
  /**
   * Represents a top-level {@link Preference} that
   * is the root of a Preference hierarchy. A {@link PreferenceActivity}
   * points to an instance of this class to show the preferences. To instantiate
   * this class, use {@link PreferenceManager#createPreferenceScreen(Context)}.
   * <ul>
   * This class can appear in two places:
   * <li> When a {@link PreferenceActivity} points to this, it is used as the root
   * and is not shown (only the contained preferences are shown).
   * <li> When it appears inside another preference hierarchy, it is shown and
   * serves as the gateway to another screen of preferences (either by showing
   * another screen of preferences as a {@link Dialog} or via a
   * {@link Context#startActivity(android.content.Intent)} from the
   * {@link Preference#getIntent()}). The children of this {@link PreferenceScreen}
   * are NOT shown in the screen that this {@link PreferenceScreen} is shown in.
   * Instead, a separate screen will be shown when this preference is clicked.
   * </ul>
   * <p>Here's an example XML layout of a PreferenceScreen:</p>
   * <pre>
  &lt;PreferenceScreen
          xmlns:android="http://schemas.android.com/apk/res/android"
          android:key="first_preferencescreen"&gt;
      &lt;CheckBoxPreference
              android:key="wifi enabled"
              android:title="WiFi" /&gt;
      &lt;PreferenceScreen
              android:key="second_preferencescreen"
              android:title="WiFi settings"&gt;
          &lt;CheckBoxPreference
                  android:key="prefer wifi"
                  android:title="Prefer WiFi" /&gt;
          ... other preferences here ...
      &lt;/PreferenceScreen&gt;
  &lt;/PreferenceScreen&gt; </pre>
   * <p>
   * In this example, the "first_preferencescreen" will be used as the root of the
   * hierarchy and given to a {@link PreferenceActivity}. The first screen will
   * show preferences "WiFi" (which can be used to quickly enable/disable WiFi)
   * and "WiFi settings". The "WiFi settings" is the "second_preferencescreen" and when
   * clicked will show another screen of preferences such as "Prefer WiFi" (and
   * the other preferences that are children of the "second_preferencescreen" tag).
   * 
   * @see PreferenceCategory
   */
  public final class PreferenceScreen extends PreferenceGroup implements AdapterView.OnItemClickListener,
          DialogInterface.OnDismissListener {
  
      private ListAdapter mRootAdapter;
      
      private Dialog mDialog;
      
      /**
       * Do NOT use this constructor, use {@link PreferenceManager#createPreferenceScreen(Context)}.
       * @hide-
       */
      public PreferenceScreen(Context context, AttributeSet attrs) {
          super(context, attrs, com.android.internal.R.attr.preferenceScreenStyle);
      }
  
      /**
       * Returns an adapter that can be attached to a {@link PreferenceActivity}
       * to show the preferences contained in this {@link PreferenceScreen}.
       * <p>
       * This {@link PreferenceScreen} will NOT appear in the returned adapter, instead
       * it appears in the hierarchy above this {@link PreferenceScreen}.
       * <p>
       * This adapter's {@link Adapter#getItem(int)} should always return a
       * subclass of {@link Preference}.
       * 
       * @return An adapter that provides the {@link Preference} contained in this
       *         {@link PreferenceScreen}.
       */
      public ListAdapter getRootAdapter() {
          if (mRootAdapter == null) {
              mRootAdapter = onCreateRootAdapter();
          }
          
          return mRootAdapter;
      }
      
      /**
       * Creates the root adapter.
       * 
       * @return An adapter that contains the preferences contained in this {@link PreferenceScreen}.
       * @see #getRootAdapter()
       */
      protected ListAdapter onCreateRootAdapter() {
          return new PreferenceGroupAdapter(this);
      }
  
      /**
       * Binds a {@link ListView} to the preferences contained in this {@link PreferenceScreen} via
       * {@link #getRootAdapter()}. It also handles passing list item clicks to the corresponding
       * {@link Preference} contained by this {@link PreferenceScreen}.
       * 
       * @param listView The list view to attach to.
       */
      public void bind(ListView listView) {
          listView.setOnItemClickListener(this);
          listView.setAdapter(getRootAdapter());
          
          onAttachedToActivity();
      }
      
      @Override
      protected void onClick() {
          if (getIntent() != null || getPreferenceCount() == 0) {
              return;
          }
          
          showDialog(null);
      }
      
      private void showDialog(Bundle state) {
          Context context = getContext();
          ListView listView = new ListView(context);
          bind(listView);
  
          // Set the title bar if title is available, else no title bar
          final CharSequence title = getTitle();
          Dialog dialog = mDialog = new Dialog(context, TextUtils.isEmpty(title)
                  ? com.android.internal.R.style.Theme_NoTitleBar
                  : com.android.internal.R.style.Theme);
          dialog.setContentView(listView);
          if (!TextUtils.isEmpty(title)) {
              dialog.setTitle(title);
          }
          dialog.setOnDismissListener(this);
          if (state != null) {
              dialog.onRestoreInstanceState(state);
          }
  
          // Add the screen to the list of preferences screens opened as dialogs
          getPreferenceManager().addPreferencesScreen(dialog);
          
          dialog.show();
      }
      
      public void onDismiss(DialogInterface dialog) {
          mDialog = null;
          getPreferenceManager().removePreferencesScreen(dialog);
      }
      
      /**
       * Used to get a handle to the dialog. 
       * This is useful for cases where we want to manipulate the dialog
       * as we would with any other activity or view.
       */
      public Dialog getDialog() {
          return mDialog;
      }
  
      public void onItemClick(AdapterView parent, View view, int position, long id) {
          Object item = getRootAdapter().getItem(position);
          if (!(item instanceof Preference)) return;
          
          final Preference preference = (Preference) item; 
          preference.performClick(this);
      }
  
      @Override
      protected boolean isOnSameScreenAsChildren() {
          return false;
      }
      
      @Override
      protected Parcelable onSaveInstanceState() {
          final Parcelable superState = super.onSaveInstanceState();
          final Dialog dialog = mDialog;
  