[LG Optimus 3D] defcomg:
So i Looked into JB From LG it has same Values as ICS

package android.view;

import android.content.res.CompatibilityInfo;
import android.graphics.Point;
import android.graphics.Rect;
import android.os.*;
import android.util.DisplayMetrics;
import android.util.Slog;

// Referenced classes of package android.view:
// CompatibilityInfoHolder, IWindowManager

public class Display
{

static final boolean DEBUG_DISPLAY_SIZE = false;
public static final int DEFAULT_DISPLAY = 0;
static final String TAG = "Display";
private static boolean sInitialized = false;
private static final Object sStaticInit = new Object();
private static IWindowManager sWindowManager;
private final CompatibilityInfoHolder mCompatibilityInfo;
float mDensity;
private final int mDisplay;
float mDpiX;
float mDpiY;
private float mLastGetTime;
private int mMaximumTextureSize;
private Rect mMirroringRegion;
private int mPixelFormat;
private float mRefreshRate;
private final DisplayMetrics mTmpMetrics;
private final Point mTmpPoint;

Display(int i, CompatibilityInfoHolder compatibilityinfoholder)
{
mMirroringRegion = new Rect();
mTmpPoint = new Point();
mTmpMetrics = new DisplayMetrics();
synchronized (sStaticInit)
{
if (!sInitialized)
{
nativeClassInit();
sInitialized = true;
}
}
if (compatibilityinfoholder == null)
compatibilityinfoholder = new CompatibilityInfoHolder();
mCompatibilityInfo = compatibilityinfoholder;
mDisplay = i;
init(i);
return;
exception;
obj;
JVM INSTR monitorexit ;
throw exception;
}

public static Display createCompatibleDisplay(int i, CompatibilityInfoHolder compatibilityinfoholder)
{
return new Display(i, compatibilityinfoholder);
}

static native int getDisplayCount();

private Rect getMirroringRegion()
{
if (!SystemProperties.OMAP_ENHANCEMENT || mMirroringRegion.width() != 0) goto _L2; else goto _L1
_L1:
String as[];
mMirroringRegion.set(0, 0, 1280, 720);
as = SystemProperties.get("persist.hwc.mirroring.region", "").split(":");
if (as.length != 4) goto _L4; else goto _L3
_L3:
int i;
int j;
int k;
int l;
j = Integer.parseInt(as[0]);
i = Integer.parseInt(as[1]);
k = Integer.parseInt(as[2]);
l = Integer.parseInt(as[3]);
if (j >= k || i >= l)
throw new NumberFormatException();
goto _L5
_L4:
Slog.i("Display", (new StringBuilder()).append("Mirroring region is ").append(mMirroringRegion).toString());
_L2:
return mMirroringRegion;
_L5:
try
{
mMirroringRegion.set(j, i, k, l);
}
catch (NumberFormatException _ex) { }
if (true) goto _L4; else goto _L6
_L6:
}

private native int getRawHeightNative();

private native int getRawWidthNative();

private void getSizeInternal(Point point, boolean flag)
{
Object obj = getWindowManager();
if (obj == null) goto _L2; else goto _L1
_L1:
CompatibilityInfo compatibilityinfo;
((IWindowManager) (obj)).getDisplaySize(point);
if (!flag)
break MISSING_BLOCK_LABEL_145;
compatibilityinfo = mCompatibilityInfo.getIfNeeded();
if (compatibilityinfo == null)
break MISSING_BLOCK_LABEL_145;
obj = mTmpMetrics;
obj;
JVM INSTR monitorenter ;
mTmpMetrics.noncompatWidthPixels = point.x;
mTmpMetrics.noncompatHeightPixels = point.y;
mTmpMetrics.density = mDensity;
compatibilityinfo.applyToDisplayMetrics(mTmpMetrics);
point.x = mTmpMetrics.widthPixels;
point.y = mTmpMetrics.heightPixels;
break MISSING_BLOCK_LABEL_145;
RemoteException remoteexception;
remoteexception;
Slog.w("Display", "Unable to get display size", remoteexception);
break MISSING_BLOCK_LABEL_145;
_L2:
point.x = getRawWidth();
point.y = getRawHeight();
}

static IWindowManager getWindowManager()
{
Object obj = sStaticInit;
obj;
JVM INSTR monitorenter ;
if (sWindowManager == null)
sWindowManager = IWindowManager.Stub.asInterface(ServiceManager.getService("window"));
IWindowManager iwindowmanager = sWindowManager;
return iwindowmanager;
}

private native void init(int i);

private static native void nativeClassInit();

public int getDisplayId()
{
return mDisplay;
}

public int getDsdrExternalHeight()
{
return 0;
}

public int getDsdrExternalWidth()
{
return 0;
}

public int getDsdrStatus()
{
return -1;
}

public int getHeight()
{
Point point = mTmpPoint;
point;
JVM INSTR monitorenter ;
long l = SystemClock.uptimeMillis();
if ((float)l > 20F + mLastGetTime)
{
getSizeInternal(mTmpPoint, true);
mLastGetTime = l;
}
l = mTmpPoint.y;
return l;
}

public int getMaximumSizeDimension()
{
int i = getWindowManager().getMaximumSizeDimension();
i = i;
_L2:
return i;
RemoteException remoteexception;
remoteexception;
Slog.w("Display", "Unable to get display maximum size dimension", remoteexception);
remoteexception = 0;
if (true) goto _L2; else goto _L1
_L1:
}

public int getMaximumTextureSize()
{
int i;
if (!SystemProperties.OMAP_ENHANCEMENT)
i = -1;
else
i = mMaximumTextureSize;
return i;
}

public void getMetrics(DisplayMetrics displaymetrics)
{
synchronized (mTmpPoint)
{
getSizeInternal(mTmpPoint, false);
getMetricsWithSize(displaymetrics, mTmpPoint.x, mTmpPoint.y);
}
CompatibilityInfo compatibilityinfo = mCompatibilityInfo.getIfNeeded();
if (compatibilityinfo != null)
compatibilityinfo.applyToDisplayMetrics(displaymetrics);
return;
exception;
point;
JVM INSTR monitorexit ;
throw exception;
}

public void getMetricsWithSize(DisplayMetrics displaymetrics, int i, int j)
{
displaymetrics.densityDpi = (int)(0.5F + 160F * mDensity);
displaymetrics.widthPixels = i;
displaymetrics.noncompatWidthPixels = i;
displaymetrics.heightPixels = j;
displaymetrics.noncompatHeightPixels = j;
float f = mDensity;
displaymetrics.noncompatDensity = f;
displaymetrics.density = f;
f = displaymetrics.density;
displaymetrics.noncompatScaledDensity = f;
displaymetrics.scaledDensity = f;
f = mDpiX;
displaymetrics.noncompatXdpi = f;
displaymetrics.xdpi = f;
f = mDpiY;
displaymetrics.noncompatYdpi = f;
displaymetrics.ydpi = f;
}

public native int getOrientation();

public int getPixelFormat()
{
return mPixelFormat;
}

public int getRawExternalHeight()
{
int i;
if (!SystemProperties.OMAP_ENHANCEMENT)
i = 720;
else
i = getMirroringRegion().height();
return i;
}

public int getRawExternalWidth()
{
int i;
if (!SystemProperties.OMAP_ENHANCEMENT)
i = 1280;
else
i = getMirroringRegion().width();
return i;
}

public int getRawHeight()
{
return getRawHeightNative();
}

public int getRawWidth()
{
return getRawWidthNative();
}

public void getRealMetrics(DisplayMetrics displaymetrics)
{
Point point = mTmpPoint;
point;
JVM INSTR monitorenter ;
getRealSize(mTmpPoint);
getMetricsWithSize(displaymetrics, mTmpPoint.x, mTmpPoint.y);
return;
}

public void getRealSize(Point point)
{
try
{
IWindowManager iwindowmanager = getWindowManager();
if (iwindowmanager != null)
{
iwindowmanager.getRealDisplaySize(point);
} else
{
point.x = getRawWidth();
point.y = getRawHeight();
}
}
catch (RemoteException remoteexception)
{
Slog.w("Display", "Unable to get real display size", remoteexception);
}
}

public void getRectSize(Rect rect)
{
Point point = mTmpPoint;
point;
JVM INSTR monitorenter ;
getSizeInternal(mTmpPoint, true);
rect.set(0, 0, mTmpPoint.x, mTmpPoint.y);
return;
}

public float getRefreshRate()
{
return mRefreshRate;
}

public int getRotation()
{
return getOrientation();
}

public void getSize(Point point)
{
getSizeInternal(point, true);
}

public int getWidth()
{
Point point = mTmpPoint;
point;
JVM INSTR monitorenter ;
long l = SystemClock.uptimeMillis();
if ((float)l > 20F + mLastGetTime)
{
getSizeInternal(mTmpPoint, true);
mLastGetTime = l;
}
l = mTmpPoint.x;
return l;
}

}

if (!SystemProperties.OMAP_ENHANCEMENT || mMirroringRegion.width() != 0) goto _L2; else goto _L1
_L1:
String as[];
mMirroringRegion.set(0, 0, 1280, 720);
as = SystemProperties.get("[COLOR="Red"]persist.hwc.mirroring.region[/COLOR]", "").split(":");
if (as.length != 4) goto _L4; else goto _L3