auto import from //depot/cupcake/@135843

1 files changed, 0 insertions, 954 deletions

diff --git a/core/java/android/app/Dialog.java b/core/java/android/app/Dialog.java
deleted file mode 100644
index b09a57fb27a5..000000000000
--- a/core/java/android/app/Dialog.java
+++ /dev/null
@@ -1,954 +0,0 @@
-/*
- * Copyright (C) 2006 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.app;
-
-import android.content.Context;
-import android.content.DialogInterface;
-import android.graphics.drawable.Drawable;
-import android.net.Uri;
-import android.os.Handler;
-import android.os.Message;
-import android.os.Bundle;
-import android.util.Config;
-import android.util.Log;
-import android.view.ContextMenu;
-import android.view.ContextThemeWrapper;
-import android.view.Gravity;
-import android.view.KeyEvent;
-import android.view.Menu;
-import android.view.MenuItem;
-import android.view.MotionEvent;
-import android.view.View;
-import android.view.ViewConfiguration;
-import android.view.ViewGroup;
-import android.view.LayoutInflater;
-import android.view.Window;
-import android.view.WindowManager;
-import android.view.ContextMenu.ContextMenuInfo;
-import android.view.View.OnCreateContextMenuListener;
-
-import com.android.internal.policy.PolicyManager;
-
-import java.lang.ref.WeakReference;
-
-/**
- * Base class for Dialogs.
- * 
- * <p>Note: Activities provide a facility to manage the creation, saving and
- * restoring of dialogs. See {@link Activity#onCreateDialog(int)},
- * {@link Activity#onPrepareDialog(int, Dialog)},
- * {@link Activity#showDialog(int)}, and {@link Activity#dismissDialog(int)}. If
- * these methods are used, {@link #getOwnerActivity()} will return the Activity
- * that managed this dialog.
- * 
- * <p>Often you will want to have a Dialog display on top of the current
- * input method, because there is no reason for it to accept text.  You can
- * do this by setting the {@link WindowManager.LayoutParams#FLAG_ALT_FOCUSABLE_IM
- * WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM} window flag (assuming
- * your Dialog takes input focus, as it the default) with the following code:
- * 
- * <pre>
- *     getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
- *             WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
- * </pre>
- */
-public class Dialog implements DialogInterface, Window.Callback,
-        KeyEvent.Callback, OnCreateContextMenuListener {
-    private static final String LOG_TAG = "Dialog";
-
-    private Activity mOwnerActivity;
-    
-    final Context mContext;
-    final WindowManager mWindowManager;
-    Window mWindow;
-    View mDecor;
-    /**
-     * This field should be made private, so it is hidden from the SDK.
-     * {@hide}
-     */
-    protected boolean mCancelable = true;
-    private Message mCancelMessage;
-    private Message mDismissMessage;
-
-    /**
-     * Whether to cancel the dialog when a touch is received outside of the
-     * window's bounds.
-     */
-    private boolean mCanceledOnTouchOutside = false;
-    
-    private OnKeyListener mOnKeyListener;
-
-    private boolean mCreated = false;
-    private boolean mShowing = false;
-
-    private final Thread mUiThread;
-    private final Handler mHandler = new Handler();
-
-    private final Runnable mDismissAction = new Runnable() {
-        public void run() {
-            dismissDialog();
-        }
-    };
-
-    /**
-     * Create a Dialog window that uses the default dialog frame style.
-     * 
-     * @param context The Context the Dialog is to run it.  In particular, it
-     *                uses the window manager and theme in this context to
-     *                present its UI.
-     */
-    public Dialog(Context context) {
-        this(context, 0);
-    }
-
-    /**
-     * Create a Dialog window that uses a custom dialog style.
-     * 
-     * @param context The Context in which the Dialog should run. In particular, it
-     *                uses the window manager and theme from this context to
-     *                present its UI.
-     * @param theme A style resource describing the theme to use for the 
-     * window. See <a href="{@docRoot}guide/topics/resources/available-resources.html#stylesandthemes">Style 
-     * and Theme Resources</a> for more information about defining and using 
-     * styles.  This theme is applied on top of the current theme in 
-     * <var>context</var>.  If 0, the default dialog theme will be used.
-     */
-    public Dialog(Context context, int theme) {
-        mContext = new ContextThemeWrapper(
-            context, theme == 0 ? com.android.internal.R.style.Theme_Dialog : theme);
-        mWindowManager = (WindowManager)context.getSystemService("window");
-        Window w = PolicyManager.makeNewWindow(mContext);
-        mWindow = w;
-        w.setCallback(this);
-        w.setWindowManager(mWindowManager, null, null);
-        w.setGravity(Gravity.CENTER);
-        mUiThread = Thread.currentThread();
-        mDismissCancelHandler = new DismissCancelHandler(this);
-    }
-
-    /**
-     * @deprecated
-     * @hide
-     */
-    @Deprecated
-    protected Dialog(Context context, boolean cancelable,
-            Message cancelCallback) {
-        this(context);
-        mCancelable = cancelable;
-        mCancelMessage = cancelCallback;
-    }
-
-    protected Dialog(Context context, boolean cancelable,
-            OnCancelListener cancelListener) {
-        this(context);
-        mCancelable = cancelable;
-        setOnCancelListener(cancelListener);
-    }
-
-    /**
-     * Retrieve the Context this Dialog is running in.
-     * 
-     * @return Context The Context that was supplied to the constructor.
-     */
-    public final Context getContext() {
-        return mContext;
-    }
-
-    /**
-     * Sets the Activity that owns this dialog. An example use: This Dialog will
-     * use the suggested volume control stream of the Activity.
-     * 
-     * @param activity The Activity that owns this dialog.
-     */
-    public final void setOwnerActivity(Activity activity) {
-        mOwnerActivity = activity;
-        
-        getWindow().setVolumeControlStream(mOwnerActivity.getVolumeControlStream());
-    }
-
-    /**
-     * Returns the Activity that owns this Dialog. For example, if
-     * {@link Activity#showDialog(int)} is used to show this Dialog, that
-     * Activity will be the owner (by default). Depending on how this dialog was
-     * created, this may return null.
-     * 
-     * @return The Activity that owns this Dialog.
-     */
-    public final Activity getOwnerActivity() {
-        return mOwnerActivity;
-    }
-    
-    /**
-     * @return Whether the dialog is currently showing.
-     */
-    public boolean isShowing() {
-        return mShowing;
-    }
-
-    /**
-     * Start the dialog and display it on screen.  The window is placed in the
-     * application layer and opaque.  Note that you should not override this
-     * method to do initialization when the dialog is shown, instead implement
-     * that in {@link #onStart}.
-     */
-    public void show() {
-        if (mShowing) {
-            if (Config.LOGV) Log.v(LOG_TAG,
-                    "[Dialog] start: already showing, ignore");
-            if (mDecor != null) mDecor.setVisibility(View.VISIBLE);
-            return;
-        }
-
-        if (!mCreated) {
-            dispatchOnCreate(null);
-        }
-
-        onStart();
-        mDecor = mWindow.getDecorView();
-        WindowManager.LayoutParams l = mWindow.getAttributes();
-        if ((l.softInputMode
-                & WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) == 0) {
-            WindowManager.LayoutParams nl = new WindowManager.LayoutParams();
-            nl.copyFrom(l);
-            nl.softInputMode |=
-                    WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION;
-            l = nl;
-        }
-        mWindowManager.addView(mDecor, l);
-        mShowing = true;
-    }
-    
-    /**
-     * Hide the dialog, but do not dismiss it.
-     */
-    public void hide() {
-        if (mDecor != null) mDecor.setVisibility(View.GONE);
-    }
-
-    /**
-     * Dismiss this dialog, removing it from the screen. This method can be
-     * invoked safely from any thread.  Note that you should not override this
-     * method to do cleanup when the dialog is dismissed, instead implement
-     * that in {@link #onStop}.
-     */
-    public void dismiss() {
-        if (Thread.currentThread() != mUiThread) {
-            mHandler.post(mDismissAction);
-        } else {
-            mDismissAction.run();
-        }
-    }
-
-    private void dismissDialog() {
-        if (mDecor == null) {
-            if (Config.LOGV) Log.v(LOG_TAG,
-                    "[Dialog] dismiss: already dismissed, ignore");
-            return;
-        }
-        if (!mShowing) {
-            if (Config.LOGV) Log.v(LOG_TAG,
-                    "[Dialog] dismiss: not showing, ignore");
-            return;
-        }
-
-        mWindowManager.removeView(mDecor);
-        mDecor = null;
-        mWindow.closeAllPanels();
-        onStop();
-        mShowing = false;
-        
-        sendDismissMessage();
-    }
-
-    private void sendDismissMessage() {
-        if (mDismissMessage != null) {
-            // Obtain a new message so this dialog can be re-used
-            Message.obtain(mDismissMessage).sendToTarget();
-        }
-    }
-    
-    // internal method to make sure mcreated is set properly without requiring
-    // users to call through to super in onCreate
-    void dispatchOnCreate(Bundle savedInstanceState) {
-        onCreate(savedInstanceState);
-        mCreated = true;
-    }
-
-    /**
-     * Similar to {@link Activity#onCreate}, you should initialized your dialog
-     * in this method, including calling {@link #setContentView}.
-     * @param savedInstanceState If this dialog is being reinitalized after a
-     *     the hosting activity was previously shut down, holds the result from
-     *     the most recent call to {@link #onSaveInstanceState}, or null if this
-     *     is the first time.
-     */
-    protected void onCreate(Bundle savedInstanceState) {
-    }
-
-    /**
-     * Called when the dialog is starting.
-     */
-    protected void onStart() {
-    }
-
-    /**
-     * Called to tell you that you're stopping.
-     */
-    protected void onStop() {
-    }
-
-    private static final String DIALOG_SHOWING_TAG = "android:dialogShowing";
-    private static final String DIALOG_HIERARCHY_TAG = "android:dialogHierarchy";
-
-    /**
-     * Saves the state of the dialog into a bundle.
-     *
-     * The default implementation saves the state of its view hierarchy, so you'll
-     * likely want to call through to super if you override this to save additional
-     * state.
-     * @return A bundle with the state of the dialog.
-     */
-    public Bundle onSaveInstanceState() {
-        Bundle bundle = new Bundle();
-        bundle.putBoolean(DIALOG_SHOWING_TAG, mShowing);
-        if (mCreated) {
-            bundle.putBundle(DIALOG_HIERARCHY_TAG, mWindow.saveHierarchyState());
-        }
-        return bundle;
-    }
-
-    /**
-     * Restore the state of the dialog from a previously saved bundle.
-     *
-     * The default implementation restores the state of the dialog's view
-     * hierarchy that was saved in the default implementation of {@link #onSaveInstanceState()},
-     * so be sure to call through to super when overriding unless you want to
-     * do all restoring of state yourself.
-     * @param savedInstanceState The state of the dialog previously saved by
-     *     {@link #onSaveInstanceState()}.
-     */
-    public void onRestoreInstanceState(Bundle savedInstanceState) {
-        final Bundle dialogHierarchyState = savedInstanceState.getBundle(DIALOG_HIERARCHY_TAG);
-        if (dialogHierarchyState == null) {
-            // dialog has never been shown, or onCreated, nothing to restore.
-            return;
-        }
-        dispatchOnCreate(savedInstanceState);
-        mWindow.restoreHierarchyState(dialogHierarchyState);
-        if (savedInstanceState.getBoolean(DIALOG_SHOWING_TAG)) {
-            show();
-        }
-    }
-
-    /**
-     * Retrieve the current Window for the activity.  This can be used to
-     * directly access parts of the Window API that are not available
-     * through Activity/Screen.
-     * 
-     * @return Window The current window, or null if the activity is not
-     *         visual.
-     */
-    public Window getWindow() {
-        return mWindow;
-    }
-
-    /**
-     * Call {@link android.view.Window#getCurrentFocus} on the
-     * Window if this Activity to return the currently focused view.
-     * 
-     * @return View The current View with focus or null.
-     * 
-     * @see #getWindow
-     * @see android.view.Window#getCurrentFocus
-     */
-    public View getCurrentFocus() {
-        return mWindow != null ? mWindow.getCurrentFocus() : null;
-    }
-
-    /**
-     * Finds a view that was identified by the id attribute from the XML that
-     * was processed in {@link #onStart}.
-     *
-     * @param id the identifier of the view to find
-     * @return The view if found or null otherwise.
-     */
-    public View findViewById(int id) {
-        return mWindow.findViewById(id);
-    }
-
-    /**
-     * Set the screen content from a layout resource.  The resource will be
-     * inflated, adding all top-level views to the screen.
-     * 
-     * @param layoutResID Resource ID to be inflated.
-     */
-    public void setContentView(int layoutResID) {
-        mWindow.setContentView(layoutResID);
-    }
-
-    /**
-     * Set the screen content to an explicit view.  This view is placed
-     * directly into the screen's view hierarchy.  It can itself be a complex
-     * view hierarhcy.
-     * 
-     * @param view The desired content to display.
-     */
-    public void setContentView(View view) {
-        mWindow.setContentView(view);
-    }
-
-    /**
-     * Set the screen content to an explicit view.  This view is placed
-     * directly into the screen's view hierarchy.  It can itself be a complex
-     * view hierarhcy.
-     * 
-     * @param view The desired content to display.
-     * @param params Layout parameters for the view.
-     */
-    public void setContentView(View view, ViewGroup.LayoutParams params) {
-        mWindow.setContentView(view, params);
-    }
-
-    /**
-     * Add an additional content view to the screen.  Added after any existing
-     * ones in the screen -- existing views are NOT removed.
-     * 
-     * @param view The desired content to display.
-     * @param params Layout parameters for the view.
-     */
-    public void addContentView(View view, ViewGroup.LayoutParams params) {
-        mWindow.addContentView(view, params);
-    }
-
-    /**
-     * Set the title text for this dialog's window.
-     * 
-     * @param title The new text to display in the title.
-     */
-    public void setTitle(CharSequence title) {
-        mWindow.setTitle(title);
-        mWindow.getAttributes().setTitle(title);
-    }
-
-    /**
-     * Set the title text for this dialog's window. The text is retrieved
-     * from the resources with the supplied identifier.
-     *
-     * @param titleId the title's text resource identifier
-     */
-    public void setTitle(int titleId) {
-        setTitle(mContext.getText(titleId));
-    }
-
-    /**
-     * A key was pressed down.
-     * 
-     * <p>If the focused view didn't want this event, this method is called.
-     *
-     * <p>The default implementation handles KEYCODE_BACK to close the
-     * dialog.
-     *
-     * @see #onKeyUp
-     * @see android.view.KeyEvent
-     */
-    public boolean onKeyDown(int keyCode, KeyEvent event) {
-        if (keyCode == KeyEvent.KEYCODE_BACK) {
-            if (mCancelable) {
-                cancel();
-            }
-            return true;
-        }
-
-        return false;
-    }
-
-    /**
-     * A key was released.
-     * 
-     * @see #onKeyDown
-     * @see KeyEvent
-     */
-    public boolean onKeyUp(int keyCode, KeyEvent event) {
-        return false;
-    }
-
-    /**
-     * Default implementation of {@link KeyEvent.Callback#onKeyMultiple(int, int, KeyEvent)
-     * KeyEvent.Callback.onKeyMultiple()}: always returns false (doesn't handle
-     * the event).
-     */
-    public boolean onKeyMultiple(int keyCode, int repeatCount, KeyEvent event) {
-        return false;
-    }
-    
-    /**
-     * Called when a touch screen event was not handled by any of the views
-     * under it. This is most useful to process touch events that happen outside
-     * of your window bounds, where there is no view to receive it.
-     * 
-     * @param event The touch screen event being processed.
-     * @return Return true if you have consumed the event, false if you haven't.
-     *         The default implementation will cancel the dialog when a touch
-     *         happens outside of the window bounds.
-     */
-    public boolean onTouchEvent(MotionEvent event) {
-        if (mCancelable && mCanceledOnTouchOutside && event.getAction() == MotionEvent.ACTION_DOWN
-                && isOutOfBounds(event)) {
-            cancel();
-            return true;
-        }
-        
-        return false;
-    }
-
-    private boolean isOutOfBounds(MotionEvent event) {
-        final int x = (int) event.getX();
-        final int y = (int) event.getY();
-        final int slop = ViewConfiguration.get(mContext).getScaledWindowTouchSlop();
-        final View decorView = getWindow().getDecorView();
-        return (x < -slop) || (y < -slop)
-                || (x > (decorView.getWidth()+slop))
-                || (y > (decorView.getHeight()+slop));
-    }
-    
-    /**
-     * Called when the trackball was moved and not handled by any of the
-     * views inside of the activity.  So, for example, if the trackball moves
-     * while focus is on a button, you will receive a call here because
-     * buttons do not normally do anything with trackball events.  The call
-     * here happens <em>before</em> trackball movements are converted to
-     * DPAD key events, which then get sent back to the view hierarchy, and
-     * will be processed at the point for things like focus navigation.
-     * 
-     * @param event The trackball event being processed.
-     * 
-     * @return Return true if you have consumed the event, false if you haven't.
-     * The default implementation always returns false.
-     */
-    public boolean onTrackballEvent(MotionEvent event) {
-        return false;
-    }
-    
-    public void onWindowAttributesChanged(WindowManager.LayoutParams params) {
-        if (mDecor != null) {
-            mWindowManager.updateViewLayout(mDecor, params);
-        }
-    }
-
-    public void onContentChanged() {
-    }
-    
-    public void onWindowFocusChanged(boolean hasFocus) {
-    }
-
-    /**
-     * Called to process key events.  You can override this to intercept all 
-     * key events before they are dispatched to the window.  Be sure to call 
-     * this implementation for key events that should be handled normally.
-     * 
-     * @param event The key event.
-     * 
-     * @return boolean Return true if this event was consumed.
-     */
-    public boolean dispatchKeyEvent(KeyEvent event) {
-        if ((mOnKeyListener != null) && (mOnKeyListener.onKey(this, event.getKeyCode(), event))) {
-            return true;
-        }
-        if (mWindow.superDispatchKeyEvent(event)) {
-            return true;
-        }
-        return event.dispatch(this);
-    }
-
-    /**
-     * Called to process touch screen events.  You can override this to
-     * intercept all touch screen events before they are dispatched to the
-     * window.  Be sure to call this implementation for touch screen events
-     * that should be handled normally.
-     * 
-     * @param ev The touch screen event.
-     * 
-     * @return boolean Return true if this event was consumed.
-     */
-    public boolean dispatchTouchEvent(MotionEvent ev) {
-        if (mWindow.superDispatchTouchEvent(ev)) {
-            return true;
-        }
-        return onTouchEvent(ev);
-    }
-    
-    /**
-     * Called to process trackball events.  You can override this to
-     * intercept all trackball events before they are dispatched to the
-     * window.  Be sure to call this implementation for trackball events
-     * that should be handled normally.
-     * 
-     * @param ev The trackball event.
-     * 
-     * @return boolean Return true if this event was consumed.
-     */
-    public boolean dispatchTrackballEvent(MotionEvent ev) {
-        if (mWindow.superDispatchTrackballEvent(ev)) {
-            return true;
-        }
-        return onTrackballEvent(ev);
-    }
-
-    /**
-     * @see Activity#onCreatePanelView(int)
-     */
-    public View onCreatePanelView(int featureId) {
-        return null;
-    }
-
-    /**
-     * @see Activity#onCreatePanelMenu(int, Menu)
-     */
-    public boolean onCreatePanelMenu(int featureId, Menu menu) {
-        if (featureId == Window.FEATURE_OPTIONS_PANEL) {
-            return onCreateOptionsMenu(menu);
-        }
-        
-        return false;
-    }
-
-    /**
-     * @see Activity#onPreparePanel(int, View, Menu)
-     */
-    public boolean onPreparePanel(int featureId, View view, Menu menu) {
-        if (featureId == Window.FEATURE_OPTIONS_PANEL && menu != null) {
-            boolean goforit = onPrepareOptionsMenu(menu);
-            return goforit && menu.hasVisibleItems();
-        }
-        return true;
-    }
-
-    /**
-     * @see Activity#onMenuOpened(int, Menu)
-     */
-    public boolean onMenuOpened(int featureId, Menu menu) {
-        return true;
-    }
-
-    /**
-     * @see Activity#onMenuItemSelected(int, MenuItem)
-     */
-    public boolean onMenuItemSelected(int featureId, MenuItem item) {
-        return false;
-    }
-
-    /**
-     * @see Activity#onPanelClosed(int, Menu)
-     */
-    public void onPanelClosed(int featureId, Menu menu) {
-    }
-
-    /**
-     * It is usually safe to proxy this call to the owner activity's
-     * {@link Activity#onCreateOptionsMenu(Menu)} if the client desires the same
-     * menu for this Dialog.
-     * 
-     * @see Activity#onCreateOptionsMenu(Menu)
-     * @see #getOwnerActivity()
-     */
-    public boolean onCreateOptionsMenu(Menu menu) {
-        return true;
-    }
-
-    /**
-     * It is usually safe to proxy this call to the owner activity's
-     * {@link Activity#onPrepareOptionsMenu(Menu)} if the client desires the
-     * same menu for this Dialog.
-     * 
-     * @see Activity#onPrepareOptionsMenu(Menu)
-     * @see #getOwnerActivity()
-     */
-    public boolean onPrepareOptionsMenu(Menu menu) {
-        return true;
-    }
-
-    /**
-     * @see Activity#onOptionsItemSelected(MenuItem)
-     */
-    public boolean onOptionsItemSelected(MenuItem item) {
-        return false;
-    }
-
-    /**
-     * @see Activity#onOptionsMenuClosed(Menu)
-     */
-    public void onOptionsMenuClosed(Menu menu) {
-    }
-
-    /**
-     * @see Activity#openOptionsMenu()
-     */
-    public void openOptionsMenu() {
-        mWindow.openPanel(Window.FEATURE_OPTIONS_PANEL, null);
-    }
-    
-    /**
-     * @see Activity#closeOptionsMenu()
-     */
-    public void closeOptionsMenu() {
-        mWindow.closePanel(Window.FEATURE_OPTIONS_PANEL);
-    }
-
-    /**
-     * @see Activity#onCreateContextMenu(ContextMenu, View, ContextMenuInfo)
-     */
-    public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
-    }
-
-    /**
-     * @see Activity#registerForContextMenu(View)
-     */
-    public void registerForContextMenu(View view) {
-        view.setOnCreateContextMenuListener(this);
-    }
-    
-    /**
-     * @see Activity#unregisterForContextMenu(View)
-     */
-    public void unregisterForContextMenu(View view) {
-        view.setOnCreateContextMenuListener(null);
-    }
-    
-    /**
-     * @see Activity#openContextMenu(View)
-     */
-    public void openContextMenu(View view) {
-        view.showContextMenu();
-    }
-
-    /**
-     * @see Activity#onContextItemSelected(MenuItem)
-     */
-    public boolean onContextItemSelected(MenuItem item) {
-        return false;
-    }
-    
-    /**
-     * @see Activity#onContextMenuClosed(Menu)
-     */
-    public void onContextMenuClosed(Menu menu) {
-    }
-    
-    /**
-     * This hook is called when the user signals the desire to start a search.
-     */
-    public boolean onSearchRequested() {
-        // not during dialogs, no.
-        return false;
-    }
-
-
-    /**
-     * Request that key events come to this dialog. Use this if your
-     * dialog has no views with focus, but the dialog still wants
-     * a chance to process key events.
-     * 
-     * @param get true if the dialog should receive key events, false otherwise
-     * @see android.view.Window#takeKeyEvents
-     */
-    public void takeKeyEvents(boolean get) {
-        mWindow.takeKeyEvents(get);
-    }
-
-    /**
-     * Enable extended window features.  This is a convenience for calling
-     * {@link android.view.Window#requestFeature getWindow().requestFeature()}.
-     * 
-     * @param featureId The desired feature as defined in
-     *                  {@link android.view.Window}.
-     * @return Returns true if the requested feature is supported and now
-     *         enabled.
-     * 
-     * @see android.view.Window#requestFeature
-     */
-    public final boolean requestWindowFeature(int featureId) {
-        return getWindow().requestFeature(featureId);
-    }
-
-    /**
-     * Convenience for calling
-     * {@link android.view.Window#setFeatureDrawableResource}.
-     */
-    public final void setFeatureDrawableResource(int featureId, int resId) {
-        getWindow().setFeatureDrawableResource(featureId, resId);
-    }
-
-    /**
-     * Convenience for calling
-     * {@link android.view.Window#setFeatureDrawableUri}.
-     */
-    public final void setFeatureDrawableUri(int featureId, Uri uri) {
-        getWindow().setFeatureDrawableUri(featureId, uri);
-    }
-
-    /**
-     * Convenience for calling
-     * {@link android.view.Window#setFeatureDrawable(int, Drawable)}.
-     */
-    public final void setFeatureDrawable(int featureId, Drawable drawable) {
-        getWindow().setFeatureDrawable(featureId, drawable);
-    }
-
-    /**
-     * Convenience for calling
-     * {@link android.view.Window#setFeatureDrawableAlpha}.
-     */
-    public final void setFeatureDrawableAlpha(int featureId, int alpha) {
-        getWindow().setFeatureDrawableAlpha(featureId, alpha);
-    }
-
-    public LayoutInflater getLayoutInflater() {
-        return getWindow().getLayoutInflater();
-    }
-
-    /**
-     * Sets whether this dialog is cancelable with the
-     * {@link KeyEvent#KEYCODE_BACK BACK} key.
-     */
-    public void setCancelable(boolean flag) {
-        mCancelable = flag;
-    }
-
-    /**
-     * Sets whether this dialog is canceled when touched outside the window's
-     * bounds. If setting to true, the dialog is set to be cancelable if not
-     * already set.
-     * 
-     * @param cancel Whether the dialog should be canceled when touched outside
-     *            the window.
-     */
-    public void setCanceledOnTouchOutside(boolean cancel) {
-        if (cancel && !mCancelable) {
-            mCancelable = true;
-        }
-        
-        mCanceledOnTouchOutside = cancel;
-    }
-    
-    /**
-     * Cancel the dialog.  This is essentially the same as calling {@link #dismiss()}, but it will
-     * also call your {@link DialogInterface.OnCancelListener} (if registered).
-     */
-    public void cancel() {
-        if (mCancelMessage != null) {
-            
-            // Obtain a new message so this dialog can be re-used
-            Message.obtain(mCancelMessage).sendToTarget();
-        }
-        dismiss();
-    }
-
-    /**
-     * Set a listener to be invoked when the dialog is canceled.
-     * <p>
-     * This will only be invoked when the dialog is canceled, if the creator
-     * needs to know when it is dismissed in general, use
-     * {@link #setOnDismissListener}.
-     * 
-     * @param listener The {@link DialogInterface.OnCancelListener} to use.
-     */
-    public void setOnCancelListener(final OnCancelListener listener) {
-        if (listener != null) {
-            mCancelMessage = mDismissCancelHandler.obtainMessage(CANCEL, listener);
-        } else {
-            mCancelMessage = null;
-        }
-    }
-
-    /**
-     * Set a message to be sent when the dialog is canceled.
-     * @param msg The msg to send when the dialog is canceled.
-     * @see #setOnCancelListener(android.content.DialogInterface.OnCancelListener)
-     */
-    public void setCancelMessage(final Message msg) {
-        mCancelMessage = msg;
-    }
-
-    /**
-     * Set a listener to be invoked when the dialog is dismissed.
-     * @param listener The {@link DialogInterface.OnDismissListener} to use.
-     */
-    public void setOnDismissListener(final OnDismissListener listener) {
-        if (listener != null) {
-            mDismissMessage = mDismissCancelHandler.obtainMessage(DISMISS, listener);
-        } else {
-            mDismissMessage = null;
-        }
-    }
-
-    /**
-     * Set a message to be sent when the dialog is dismissed.
-     * @param msg The msg to send when the dialog is dismissed.
-     */
-    public void setDismissMessage(final Message msg) {
-        mDismissMessage = msg;
-    }
-
-    /**
-     * By default, this will use the owner Activity's suggested stream type.
-     * 
-     * @see Activity#setVolumeControlStream(int)
-     * @see #setOwnerActivity(Activity)
-     */
-    public final void setVolumeControlStream(int streamType) {
-        getWindow().setVolumeControlStream(streamType);
-    }
-
-    /**
-     * @see Activity#getVolumeControlStream()
-     */
-    public final int getVolumeControlStream() {
-        return getWindow().getVolumeControlStream();
-    }
-    
-    /**
-     * Sets the callback that will be called if a key is dispatched to the dialog.
-     */
-    public void setOnKeyListener(final OnKeyListener onKeyListener) {
-        mOnKeyListener = onKeyListener;
-    }
-
-    private static final int DISMISS = 0x43;
-    private static final int CANCEL = 0x44;
-
-    private Handler mDismissCancelHandler;
-
-    private static final class DismissCancelHandler extends Handler {
-        private WeakReference<DialogInterface> mDialog;
-
-        public DismissCancelHandler(Dialog dialog) {
-            mDialog = new WeakReference<DialogInterface>(dialog);
-        }
-
-        @Override
-        public void handleMessage(Message msg) {
-            switch (msg.what) {
-                case DISMISS:
-                    ((OnDismissListener) msg.obj).onDismiss(mDialog.get());
-                    break;
-                case CANCEL:
-                    ((OnCancelListener) msg.obj).onCancel(mDialog.get());
-                    break;
-            }
-        }
-    }
-}