diff --git a/src/com/android/settings/DataUsageSummary.java b/src/com/android/settings/DataUsageSummary.java
index 87ce772..417c525 100644
--- a/src/com/android/settings/DataUsageSummary.java
+++ b/src/com/android/settings/DataUsageSummary.java
@@ -64,7 +64,9 @@
 import android.content.pm.PackageManager.NameNotFoundException;
 import android.content.res.Resources;
 import android.graphics.Color;
+import android.graphics.drawable.ColorDrawable;
 import android.graphics.drawable.Drawable;
+import android.graphics.drawable.InsetDrawable;
 import android.net.ConnectivityManager;
 import android.net.INetworkPolicyManager;
 import android.net.INetworkStatsService;
@@ -120,6 +122,8 @@
 import android.widget.TextView;
 
 import com.android.internal.telephony.Phone;
+import com.android.settings.drawable.InsetBoundsDrawable;
+import com.android.settings.drawable.DrawableWrapper;
 import com.android.settings.net.NetworkPolicyEditor;
 import com.android.settings.net.SummaryForAllUidLoader;
 import com.android.settings.widget.ChartDataUsageView;
@@ -275,7 +279,12 @@
         mListView = (ListView) view.findViewById(android.R.id.list);
 
         // adjust padding around tabwidget as needed
-        prepareCustomPreferencesList(container, view, mListView);
+        prepareCustomPreferencesList(container, view, mListView, true);
+
+        // inset selector and divider drawables
+        final int insetSide = view.getResources().getDimensionPixelOffset(
+                com.android.internal.R.dimen.preference_fragment_padding_side);
+        insetListViewDrawables(mListView, insetSide);
 
         mTabHost.setup();
         mTabHost.setOnTabChangedListener(mTabListener);
@@ -1391,7 +1400,7 @@
         public View getView(int position, View convertView, ViewGroup parent) {
             if (convertView == null) {
                 convertView = LayoutInflater.from(parent.getContext()).inflate(
-                        R.layout.app_percentage_item, parent, false);
+                        R.layout.data_usage_item, parent, false);
             }
 
             final Context context = parent.getContext();
@@ -1913,6 +1922,24 @@
     }
 
     /**
+     * Inset both selector and divider {@link Drawable} on the given
+     * {@link ListView} by the requested dimensions.
+     */
+    private static void insetListViewDrawables(ListView view, int insetSide) {
+        final Drawable selector = view.getSelector();
+        final Drawable divider = view.getDivider();
+
+        // fully unregister these drawables so callbacks can be maintained after
+        // wrapping below.
+        final Drawable stub = new ColorDrawable(Color.TRANSPARENT);
+        view.setSelector(stub);
+        view.setDivider(stub);
+
+        view.setSelector(new InsetBoundsDrawable(selector, insetSide));
+        view.setDivider(new InsetBoundsDrawable(divider, insetSide));
+    }
+
+    /**
      * Set {@link android.R.id#title} for a preference view inflated with
      * {@link #inflatePreference(LayoutInflater, ViewGroup, View)}.
      */
diff --git a/src/com/android/settings/Utils.java b/src/com/android/settings/Utils.java
index 2d2b654..20a34a3 100644
--- a/src/com/android/settings/Utils.java
+++ b/src/com/android/settings/Utils.java
@@ -377,7 +377,8 @@
      * when outside scrollbars are requested. Usually used to display
      * {@link ListView} and {@link TabWidget} with correct padding.
      */
-    public static void prepareCustomPreferencesList(ViewGroup parent, View child, ListView list) {
+    public static void prepareCustomPreferencesList(
+            ViewGroup parent, View child, ListView list, boolean ignoreSidePadding) {
         final boolean movePadding = list.getScrollBarStyle() == View.SCROLLBARS_OUTSIDE_OVERLAY;
         if (movePadding && parent instanceof PreferenceFrameLayout) {
             ((PreferenceFrameLayout.LayoutParams) child.getLayoutParams()).removeBorders = true;
@@ -387,7 +388,9 @@
                     com.android.internal.R.dimen.preference_fragment_padding_side);
             final int paddingBottom = res.getDimensionPixelSize(
                     com.android.internal.R.dimen.preference_fragment_padding_bottom);
-            list.setPadding(paddingSide, 0, paddingSide, paddingBottom);
+
+            final int effectivePaddingSide = ignoreSidePadding ? 0 : paddingBottom;
+            list.setPadding(effectivePaddingSide, 0, effectivePaddingSide, paddingBottom);
         }
     }
 }
diff --git a/src/com/android/settings/applications/ManageApplications.java b/src/com/android/settings/applications/ManageApplications.java
index d4abfa8..4157e8a 100644
--- a/src/com/android/settings/applications/ManageApplications.java
+++ b/src/com/android/settings/applications/ManageApplications.java
@@ -646,7 +646,7 @@
         tabHost.setOnTabChangedListener(this);
 
         // adjust padding around tabwidget as needed
-        prepareCustomPreferencesList(container, mTabHost, mListView);
+        prepareCustomPreferencesList(container, mTabHost, mListView, false);
 
         return mTabHost;
     }
diff --git a/src/com/android/settings/drawable/DrawableWrapper.java b/src/com/android/settings/drawable/DrawableWrapper.java
new file mode 100644
index 0000000..0ac4f7c
--- /dev/null
+++ b/src/com/android/settings/drawable/DrawableWrapper.java
@@ -0,0 +1,162 @@
+/*
+ * Copyright (C) 2011 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 com.android.settings.drawable;
+
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.Rect;
+import android.graphics.Region;
+import android.graphics.drawable.Drawable;
+import android.view.View;
+
+import com.android.internal.util.Preconditions;
+
+/**
+ * Base wrapper that delegates all calls to another {@link Drawable}. The
+ * wrapped {@link Drawable} <em>must</em> be fully released from any
+ * {@link View} before wrapping, otherwise internal {@link Drawable.Callback}
+ * may be dropped.
+ */
+public class DrawableWrapper extends Drawable implements Drawable.Callback {
+    private final Drawable mDrawable;
+
+    public DrawableWrapper(Drawable drawable) {
+        mDrawable = Preconditions.checkNotNull(drawable);
+        mDrawable.setCallback(this);
+    }
+
+    @Override
+    public void draw(Canvas canvas) {
+        mDrawable.draw(canvas);
+    }
+
+    @Override
+    public void setBounds(int left, int top, int right, int bottom) {
+        super.setBounds(left, top, right, bottom);
+        mDrawable.setBounds(left, top, right, bottom);
+    }
+
+    @Override
+    public void setChangingConfigurations(int configs) {
+        mDrawable.setChangingConfigurations(configs);
+    }
+
+    @Override
+    public int getChangingConfigurations() {
+        return mDrawable.getChangingConfigurations();
+    }
+
+    @Override
+    public void setDither(boolean dither) {
+        mDrawable.setDither(dither);
+    }
+
+    @Override
+    public void setFilterBitmap(boolean filter) {
+        mDrawable.setFilterBitmap(filter);
+    }
+
+    @Override
+    public void setAlpha(int alpha) {
+        mDrawable.setAlpha(alpha);
+    }
+
+    @Override
+    public void setColorFilter(ColorFilter cf) {
+        mDrawable.setColorFilter(cf);
+    }
+
+    @Override
+    public boolean isStateful() {
+        return mDrawable.isStateful();
+    }
+
+    @Override
+    public boolean setState(final int[] stateSet) {
+        return mDrawable.setState(stateSet);
+    }
+
+    @Override
+    public int[] getState() {
+        return mDrawable.getState();
+    }
+
+    @Override
+    public void jumpToCurrentState() {
+        mDrawable.jumpToCurrentState();
+    }
+
+    @Override
+    public Drawable getCurrent() {
+        return mDrawable.getCurrent();
+    }
+
+    @Override
+    public boolean setVisible(boolean visible, boolean restart) {
+        return super.setVisible(visible, restart) || mDrawable.setVisible(visible, restart);
+    }
+
+    @Override
+    public int getOpacity() {
+        return mDrawable.getOpacity();
+    }
+
+    @Override
+    public Region getTransparentRegion() {
+        return mDrawable.getTransparentRegion();
+    }
+
+    @Override
+    public int getIntrinsicWidth() {
+        return mDrawable.getIntrinsicWidth();
+    }
+
+    @Override
+    public int getIntrinsicHeight() {
+        return mDrawable.getIntrinsicHeight();
+    }
+
+    @Override
+    public int getMinimumWidth() {
+        return mDrawable.getMinimumWidth();
+    }
+
+    @Override
+    public int getMinimumHeight() {
+        return mDrawable.getMinimumHeight();
+    }
+
+    @Override
+    public boolean getPadding(Rect padding) {
+        return mDrawable.getPadding(padding);
+    }
+
+    /** {@inheritDoc} */
+    public void invalidateDrawable(Drawable who) {
+        invalidateSelf();
+    }
+
+    /** {@inheritDoc} */
+    public void scheduleDrawable(Drawable who, Runnable what, long when) {
+        scheduleSelf(what, when);
+    }
+
+    /** {@inheritDoc} */
+    public void unscheduleDrawable(Drawable who, Runnable what) {
+        unscheduleSelf(what);
+    }
+}
diff --git a/src/com/android/settings/drawable/InsetBoundsDrawable.java b/src/com/android/settings/drawable/InsetBoundsDrawable.java
new file mode 100644
index 0000000..50ef9f3
--- /dev/null
+++ b/src/com/android/settings/drawable/InsetBoundsDrawable.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2011 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 com.android.settings.drawable;
+
+import android.graphics.drawable.Drawable;
+
+/**
+ * Wrapper around another {@link Drawable} that insets requested bounds by a
+ * specific amount.
+ */
+public class InsetBoundsDrawable extends DrawableWrapper {
+    private final int mInsetBoundsSides;
+
+    public InsetBoundsDrawable(Drawable drawable, int insetBoundsSides) {
+        super(drawable);
+        mInsetBoundsSides = insetBoundsSides;
+    }
+
+    @Override
+    public void setBounds(int left, int top, int right, int bottom) {
+        super.setBounds(left + mInsetBoundsSides, top, right - mInsetBoundsSides, bottom);
+    }
+}
diff --git a/src/com/android/settings/widget/ChartDataUsageView.java b/src/com/android/settings/widget/ChartDataUsageView.java
index cad2ed8..cb9c8d7 100644
--- a/src/com/android/settings/widget/ChartDataUsageView.java
+++ b/src/com/android/settings/widget/ChartDataUsageView.java
@@ -496,32 +496,32 @@
         public long buildLabel(Resources res, SpannableStringBuilder builder, long value) {
 
             final CharSequence unit;
-            float result = value;
-            long labelValue = 1;
-            if (result <= 100 * MB_IN_BYTES) {
+            final long unitFactor;
+            if (value <= 100 * MB_IN_BYTES) {
                 unit = res.getText(com.android.internal.R.string.megabyteShort);
-                result /= MB_IN_BYTES;
-                labelValue = MB_IN_BYTES;
+                unitFactor = MB_IN_BYTES;
             } else {
                 unit = res.getText(com.android.internal.R.string.gigabyteShort);
-                result /= GB_IN_BYTES;
-                labelValue = GB_IN_BYTES;
+                unitFactor = GB_IN_BYTES;
             }
 
+            final double result = (double) value / unitFactor;
+            final double resultRounded;
             final CharSequence size;
             if (result < 10) {
                 size = String.format("%.1f", result);
+                resultRounded = (unitFactor * Math.round(result * 10)) / 10;
             } else {
                 size = String.format("%.0f", result);
+                resultRounded = unitFactor * Math.round(result);
             }
-            labelValue *= Float.parseFloat(size.toString());
 
             final int[] sizeBounds = findOrCreateSpan(builder, sSpanSize, "^1");
             builder.replace(sizeBounds[0], sizeBounds[1], size);
             final int[] unitBounds = findOrCreateSpan(builder, sSpanUnit, "^2");
             builder.replace(unitBounds[0], unitBounds[1], unit);
 
-            return labelValue;
+            return (long) resultRounded;
         }
 
         /** {@inheritDoc} */
diff --git a/src/com/android/settings/widget/ChartSweepView.java b/src/com/android/settings/widget/ChartSweepView.java
index 33e90c8..7b6d887 100644
--- a/src/com/android/settings/widget/ChartSweepView.java
+++ b/src/com/android/settings/widget/ChartSweepView.java
@@ -45,11 +45,13 @@
 
     private static final boolean DRAW_OUTLINE = false;
 
+    // TODO: clean up all the various padding/offset/margins
+
     private Drawable mSweep;
     private Rect mSweepPadding = new Rect();
 
     /** Offset of content inside this view. */
-    private Point mContentOffset = new Point();
+    private Rect mContentOffset = new Rect();
     /** Offset of {@link #mSweep} inside this view. */
     private Point mSweepOffset = new Point();
 
@@ -229,6 +231,8 @@
         if (mLabelTemplate != null && mAxis != null) {
             mLabelValue = mAxis.buildLabel(getResources(), mLabelTemplate, mValue);
             invalidate();
+        } else {
+            mLabelValue = mValue;
         }
     }
 
@@ -333,9 +337,9 @@
                 // only start tracking when in sweet spot
                 final boolean accept;
                 if (mFollowAxis == VERTICAL) {
-                    accept = event.getX() > getWidth() - (mSweepPadding.right * 3);
+                    accept = event.getX() > getWidth() - (mSweepPadding.right * 8);
                 } else {
-                    accept = event.getY() > getHeight() - (mSweepPadding.bottom * 3);
+                    accept = event.getY() > getHeight() - (mSweepPadding.bottom * 8);
                 }
 
                 final MotionEvent eventInParent = event.copy();
@@ -392,6 +396,7 @@
             }
             case MotionEvent.ACTION_UP: {
                 mTracking = null;
+                mValue = mLabelValue;
                 dispatchOnSweep(true);
                 setTranslationX(0);
                 setTranslationY(0);
@@ -534,23 +539,30 @@
             mMargins.bottom = mSweepPadding.bottom;
         }
 
-        mContentOffset.x = 0;
-        mContentOffset.y = 0;
+        mContentOffset.set(0, 0, 0, 0);
 
         // make touch target area larger
+        final int widthBefore = getMeasuredWidth();
+        final int heightBefore = getMeasuredHeight();
         if (mFollowAxis == HORIZONTAL) {
-            final int widthBefore = getMeasuredWidth();
             final int widthAfter = widthBefore * 3;
-            setMeasuredDimension(widthAfter, getMeasuredHeight());
-            mContentOffset.offset((widthAfter - widthBefore) / 2, 0);
+            setMeasuredDimension(widthAfter, heightBefore);
+            mContentOffset.left = (widthAfter - widthBefore) / 2;
+
+            final int offset = mSweepPadding.bottom * 2;
+            mContentOffset.bottom -= offset;
+            mMargins.bottom += offset;
         } else {
-            final int heightBefore = getMeasuredHeight();
             final int heightAfter = heightBefore * 3;
-            setMeasuredDimension(getMeasuredWidth(), heightAfter);
+            setMeasuredDimension(widthBefore, heightAfter);
             mContentOffset.offset(0, (heightAfter - heightBefore) / 2);
+
+            final int offset = mSweepPadding.right * 2;
+            mContentOffset.right -= offset;
+            mMargins.right += offset;
         }
 
-        mSweepOffset.offset(mContentOffset.x, mContentOffset.y);
+        mSweepOffset.offset(mContentOffset.left, mContentOffset.top);
         mMargins.offset(-mSweepOffset.x, -mSweepOffset.y);
     }
 
@@ -592,7 +604,7 @@
         if (isEnabled() && mLabelLayout != null) {
             final int count = canvas.save();
             {
-                canvas.translate(mContentOffset.x, mContentOffset.y + labelOffset);
+                canvas.translate(mContentOffset.left, mContentOffset.top + labelOffset);
                 mLabelLayout.draw(canvas);
             }
             canvas.restoreToCount(count);
@@ -602,18 +614,18 @@
         }
 
         if (mFollowAxis == VERTICAL) {
-            mSweep.setBounds(labelSize, mSweepOffset.y, width,
+            mSweep.setBounds(labelSize, mSweepOffset.y, width + mContentOffset.right,
                     mSweepOffset.y + mSweep.getIntrinsicHeight());
         } else {
-            mSweep.setBounds(mSweepOffset.x, labelSize,
-                    mSweepOffset.x + mSweep.getIntrinsicWidth(), height);
+            mSweep.setBounds(mSweepOffset.x, labelSize, mSweepOffset.x + mSweep.getIntrinsicWidth(),
+                    height + mContentOffset.bottom);
         }
 
         mSweep.draw(canvas);
     }
 
     public static float getLabelTop(ChartSweepView view) {
-        return view.getY() + view.mContentOffset.y;
+        return view.getY() + view.mContentOffset.top;
     }
 
     public static float getLabelBottom(ChartSweepView view) {