精华内容
下载资源
问答
  • windows字体详解能够获得文字每一部分的高宽值,屏幕分辨率,屏幕物理尺寸毫米数,文字所占像素数TEXTMETRIC
  • 很早我就研究在WM6.5上获得屏幕物理尺寸,但一直没有成功。后来又想要在Android上有所突破,不过在今天之前得到的尺寸都不准确。虽然很多人认为没必要这么较真,因为貌似很多情况下用不到。不过我就当这是一件很有...

    大家帮忙喽!

    博主参加2014博客之星活动,大家帮忙投票啦!猛击这里


    通过程序去了解硬件情况是一件十分有意思的事情。很早我就研究在WM6.5上获得屏幕物理尺寸,但一直没有成功。后来又想要在Android上有所突破,不过在今天之前得到的尺寸都不准确。虽然很多人认为没必要这么较真,因为貌似很多情况下用不到。不过我就当这是一件很有挑战性的事,一定要做到。对,就是这么任性。


    源码中android.view包下的Display类提供了很多方法供程序员获得显示相关的信息,通过此类让我们开启了解设备屏幕之旅吧。

    一、分辨率

    需要注意的原来经常使用的getHeight()与getWidth()已经不推荐使用了,建议使用getSize()来替代。
    此方法原型如下:
        public void getSize(Point outSize) {
            synchronized (this) {
                updateDisplayInfoLocked();
                mDisplayInfo.getAppMetrics(mTempMetrics, mDisplayAdjustments);
                outSize.x = mTempMetrics.widthPixels;
                outSize.y = mTempMetrics.heightPixels;
            }
        }
    参数是一个返回参数,用以返回分辨率的Point,这个Point也比较简单,我们只需要关注x和y这两个成员就可以了。
    用法如下:
        private void getDisplayInfomation() {
            Point point = new Point();
            getWindowManager().getDefaultDisplay().getSize(point);
            Log.d(TAG,"the screen size is "+point.toString());
        }
    结果如下:
    D/MainActivity﹕ the screen size is Point(800, 1280)

    此外Display又提供了一个getRealSize方法,原型如下:
        public void getRealSize(Point outSize) {
            synchronized (this) {
                updateDisplayInfoLocked();
                outSize.x = mDisplayInfo.logicalWidth;
                outSize.y = mDisplayInfo.logicalHeight;
            }
        }

    从两个方法的实现上看是有区别的,但是在通常情况下二者的返回值相同。那么差异究竟在哪里,下面做一些实验来验证一下。
    首先,我将Acitvity设置不同的theme,比如:
    android:theme="@android:style/Theme.Black.NoTitleBar.Fullscreen"
    android:theme="@android:style/Theme.NoTitleBar.Fullscreen"
    结果还是相同的。

    接下来将我的Activity父类变成ActionBarActivity,如下:
    public class MainActivity extends ActionBarActivity
    期望ActionBar会占用一些屏幕,并在程序中动态设置Listview的Item中的图片大小。在机缘巧合之下,
    结果验证了在这种情况下,getSize返回的结果变了。
    代码如下:
        private void getDisplayInfomation() {
            Point point = new Point();
            getWindowManager().getDefaultDisplay().getSize(point);
            Log.d(TAG,"the screen size is "+point.toString());
            getWindowManager().getDefaultDisplay().getRealSize(point);
            Log.d(TAG,"the screen real size is "+point.toString());
        }

    Log如下:
    D/MainActivity﹕ the screen size is Point(800, 1202)
    D/MainActivity﹕ the screen real size is Point(800, 1280)

    如果你不能够轻易复现也不用急,保险起见,为了得到相对正确的信息还是使用getRealSize()吧。

    二、屏幕尺寸

    设备的物理屏幕尺寸。与几年前不同,目前的手机屏幕已经大到一只手握不下了。标配早已经到了5寸屏时代。
    所谓屏幕尺寸指的是屏幕对角线的长度,单位是英寸。
    然而不同的屏幕尺寸是可以采用相同的分辨率的,而它们之间的区别在与密度(density)不同。
    下面先介绍一下密度的概念,DPI、PPI,最后讲解一下如何根据获得的Display信息去求出屏幕尺寸。这是一个困扰我很久的问题了。

    三、屏幕密度

    屏幕密度与DPI这个概念紧密相连,DPI全拼是dots-per-inch,即每英寸的点数。也就是说,密度越大,每英寸内容纳的点数就越多。
    android.util包下有个DisplayMetrics类可以获得密度相关的信息。
    最重要的是densityDpi这个成员,它有如下几个常用值:
    DENSITY_LOW = 120
    DENSITY_MEDIUM = 160  //默认值
    DENSITY_TV = 213      //TV专用
    DENSITY_HIGH = 240
    DENSITY_XHIGH = 320
    DENSITY_400 = 400
    DENSITY_XXHIGH = 480
    DENSITY_XXXHIGH = 640

    举例如下:
        private void getDensity() {
            DisplayMetrics displayMetrics = getResources().getDisplayMetrics();
            Log.d(TAG,"Density is "+displayMetrics.density+" densityDpi is "+displayMetrics.densityDpi+" height: "+displayMetrics.heightPixels+
                " width: "+displayMetrics.widthPixels);
        }

    Log如下:
    the screen size is Point(1600, 2438)
    the screen real size is Point(1600, 2560)
    Density is 2.0 densityDpi is 320 height: 2438 width: 1600

    有了这些信息,我们是不是就可以计算屏幕尺寸了呢?
    首先求得对角线长,单位为像素。
    然后用其除以密度(densityDpi)就得出对角线的长度了。
    代码如下:
        private void getScreenSizeOfDevice() {
            DisplayMetrics dm = getResources().getDisplayMetrics();
            int width=dm.widthPixels;
            int height=dm.heightPixels;
            double x = Math.pow(width,2);
            double y = Math.pow(height,2);
            double diagonal = Math.sqrt(x+y);
    
            int dens=dm.densityDpi;
            double screenInches = diagonal/(double)dens;
            Log.d(TAG,"The screenInches "+screenInches);
        }

    Log如下:

    01-13 16:35:03.026  16601-16601/com.linc.listviewanimation D/MainActivity﹕ the screen size is Point(1600, 2438)
    01-13 16:35:03.026  16601-16601/com.linc.listviewanimation D/MainActivity﹕ the screen real size is Point(1600, 2560)
    01-13 16:35:03.026  16601-16601/com.linc.listviewanimation D/MainActivity﹕ Density is 2.0 densityDpi is 320 height: 2438 width: 1600 xdpi 338.666 ydpi 338.666
    01-13 16:35:03.026  16601-16601/com.linc.listviewanimation D/MainActivity﹕ The screenInches 9.112922229586951

    如Log所见,使用heightPixels得出的值是2483而不是正确的2560.从而使结果9.11反倒跟真实屏幕尺寸很接近。下面用正确的height再算一遍。
    01-13 16:39:05.476  17249-17249/com.linc.listviewanimation D/MainActivity﹕ the screen size is Point(1600, 2560)
    01-13 16:39:05.476  17249-17249/com.linc.listviewanimation D/MainActivity﹕ the screen real size is Point(1600, 2560)
    01-13 16:39:05.476  17249-17249/com.linc.listviewanimation D/MainActivity﹕ Density is 2.0 densityDpi is 320 height: 2560 width: 1600 xdpi 338.666 ydpi 338.666
    01-13 16:39:05.476  17249-17249/com.linc.listviewanimation D/MainActivity﹕ The screenInches 9.433981132056605
    结果是9.43英寸,而真实值是8.91.如果再换一个设备,那么值差的更多。说明上面的计算是错误的。
    那么错在哪里呢?densityDpi是每英寸的点数(dots-per-inch)是打印机常用单位(因而也被称为打印分辨率),而不是每英寸的像素数。下面引出PPI这个概念。

    四、PPI

    Pixels per inch,这才是我要的每英寸的像素数(也被称为图像的采样率)。有了这个值,那么根据上面的公式就可以求导出屏幕的物理尺寸了。
    还好DisplayMetrics有两个成员是xdpi和ydpi,对其描述是:
    //The exact physical pixels per inch of the screen in the X/Y dimension.
    屏幕X/Y轴上真正的物理PPI。
    Yes!Got it!
    为了保证获得正确的分辨率,我还是使用getRealSize去获得屏幕宽和高像素。所以,经过修改,代码如下:
        private void getScreenSizeOfDevice2() {
            Point point = new Point();
            getWindowManager().getDefaultDisplay().getRealSize(point);
            DisplayMetrics dm = getResources().getDisplayMetrics();
            double x = Math.pow(point.x/ dm.xdpi, 2);
            double y = Math.pow(point.y / dm.ydpi, 2);
            double screenInches = Math.sqrt(x + y);
            Log.d(TAG, "Screen inches : " + screenInches);
        }
    Log is as follows:
    01-13 16:58:50.142  17249-17249/com.linc.listviewanimation D/MainActivity﹕ Screen inches : 8.914015757534717

    五、DIP

    注意不要与上面的DPI混淆,这个DIP是Density Independent Pixel,直译为密度无关的像素。
    我们在布局文件中使用的dp/dip就是它。官方推荐使用dp是因为它会根据你设备的密度算出对应的像素。
    公式为:pixel = dip*density

    需要注意的是,我们在Java代码中对控件设置宽高是不可以设置单位的,而其自带的单位是像素。所以如果动态修改控件大小时,
    我们的任务就来了,那就是将像素转换为dp。
    实例代码如下:
        //pixel = dip*density;
        private int convertDpToPixel(int dp) {
            DisplayMetrics displayMetrics = mContext.getResources().getDisplayMetrics();
            return (int)(dp*displayMetrics.density);
        }
    
        private int convertPixelToDp(int pixel) {
            DisplayMetrics displayMetrics = mContext.getResources().getDisplayMetrics();
            return (int)(pixel/displayMetrics.density);
        } 

    参考:

    http://stackoverflow.com/questions/19155559/how-to-get-android-device-screen-size

    展开全文
  • 二、QML获取桌面屏幕大小: (1)、引入声明文件 import QtQuick.Window 2.2 (2)、获取方法 (2.1)、通过全局对象Screen获取客户区的矩形(上图中的蓝框): 根据Screen对象的属性desktopAvailableWidth和...
    QDesktopWidget *mydesk = QApplication::desktop();
    mydesk-> widthMM(); mydesk->heightMM();
    
    mydesk->physicalDpiX(); mydesk->physicalDpiY();
    
    double Winches = (double)mydesk.width() / (double)mydesk.physicalDpiX();
    double Hinches = (double)mydesk.Height() / (double)mydesk.physicalDpiY();

    下面是新用法,和实际结果一致

        QRect rec = QGuiApplication::screens().at(0)->geometry();
    
        int h1 = rec.height();
        int h2 = rec.width();
    
        QSizeF rec1=QGuiApplication::screens().at(0)->physicalSize();
        qreal ww= rec1.rwidth();
        qreal hh=rec1.rheight();
    
    
        qreal dpi=QGuiApplication::screens().at(0)->logicalDotsPerInch();
        dpi=QGuiApplication::screens().at(0)->logicalDotsPerInchX();
        dpi=QGuiApplication::screens().at(0)->logicalDotsPerInchY();
        dpi=QGuiApplication::screens().at(0)->physicalDotsPerInch();
        dpi=QGuiApplication::screens().at(0)->physicalDotsPerInchX();
        dpi=QGuiApplication::screens().at(0)->physicalDotsPerInchY();

     

    一、Qt/C++获取桌面屏幕大小:
        (1)、包含头文件
        #include <QApplication>
        #include <QDesktopWidget>
        (2)、获取方法
        首先需要调用:
    QDesktopWidget* desktopWidget = QApplication::desktop();
        得到桌面对象的指针,然后调用如下两个函数分别获取桌面客户区大小和整个桌面的大小。
        (2.1)、调用如下方法得到客户区的矩形(上图中的蓝框):
        QRect clientRect = desktopWidget->availableGeometry();
        根据方法 clientRect.width() 和 clientRect.height() 就可以获取桌面客户区的宽和高的大小。
        例如:如果屏幕的分辨率为1366*768,则以上获取的宽为1366,高为728.可见其去除了任务栏的高度。
        (2.2)、调用如下方法可得到整个桌面的矩形(上图中的红框):
        QRect applicationRect = desktopWidget->screenGeometry();
        根据方法 applicationRect.width() 和 applicationRect.height() 就可以获取整个桌面的宽和高的大小。
        例如:如果屏幕的分辨率为1366*768,则以上获取的宽为1366,高为768。可见其包括了任务栏的高度。

    二、QML获取桌面屏幕大小:
    (1)、引入声明文件
    import QtQuick.Window 2.2
    (2)、获取方法
    (2.1)、通过全局对象Screen获取客户区的矩形(上图中的蓝框):
    根据Screen对象的属性desktopAvailableWidth和desktopAvailableHeight,即Screen.desktopAvailableWidth和
    Screen.desktopAvailableHeight即可得到桌面客户区的宽和高的大小。
    例如:如果屏幕的分辨率为1366*768,则以上获取的宽为1366,高为728.可见其去除了任务栏的高度。
    (2.2)、通过全局对象Screen获取整个桌面矩形(上图中的红框):
    根据Screen对象的属性width和height,即Screen.width和
    Screen.height即可得到桌面客户区的宽和高的大小。

    例如:如果屏幕的分辨率为1366*768,则以上获取的宽为1366,高为768。可见其包括了任务栏的高度。

     

     

     

     

     

    展开全文
  • 这样可以计算屏幕物理尺寸 宽 = width/xdpi 高 = height/ydpi 但是现在比较疑惑的是,为什么通过这个公式算出来的值不正确?是手机厂商写入的参数是错误的吗? 比如我现在手里有两台手机: 联想A388t 5寸屏: width...

    https://segmentfault.com/q/1010000002794179

    通过android提供的接口,我们可以获取到如下的信息:
    int densityDpi = mContext.getResources().getDisplayMetrics().densityDpi;
    float scaledDensity = mContext.getResources().getDisplayMetrics().scaledDensity;
    float density = mContext.getResources().getDisplayMetrics().density;
    float xdpi = mContext.getResources().getDisplayMetrics().xdpi;
    float ydpi = mContext.getResources().getDisplayMetrics().ydpi;
    int width = mContext.getResources().getDisplayMetrics().widthPixels;
    int height = mContext.getResources().getDisplayMetrics().heightPixels;

    这样可以计算屏幕的物理尺寸
    宽 = width/xdpi
    高 = height/ydpi

    但是现在比较疑惑的是,为什么通过这个公式算出来的值不正确?是手机厂商写入的参数是错误的吗?

    比如我现在手里有两台手机:
    联想A388t 5寸屏:
    width=480,height=854,densityDpi=240,density=1.5,xdpi=239.05882,ydpi=241.01778

    小米1 4寸屏: width=480,height=854,densityDpi=240,density=1.5,xdpi=254.0,ydpi=271.145

    这两台手机的分辨率一样,dpi一样,density一样,可为什么一个是4寸屏,一个是5寸屏

    google,baidu后无解,还请大拿解惑,谢谢

    转载于:https://www.cnblogs.com/jukan/p/6425368.html

    展开全文
  • 有了这个值,那么根据上面的公式就可以求导出屏幕物理尺寸了。 还好DisplayMetrics有两个成员是xdpi和ydpi,对其描述是: [java]   view plain   copy   //The exact ...

    一、分辨率

    需要注意的原来经常使用的getHeight()与getWidth()已经不推荐使用了,建议使用getSize()来替代。
    此方法原型如下:
    [java]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. public void getSize(Point outSize) {  
    2.     synchronized (this) {  
    3.         updateDisplayInfoLocked();  
    4.         mDisplayInfo.getAppMetrics(mTempMetrics, mDisplayAdjustments);  
    5.         outSize.x = mTempMetrics.widthPixels;  
    6.         outSize.y = mTempMetrics.heightPixels;  
    7.     }  
    8. }  
    参数是一个返回参数,用以返回分辨率的Point,这个Point也比较简单,我们只需要关注x和y这两个成员就可以了。
    用法如下:
    [java]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. private void getDisplayInfomation() {  
    2.     Point point = new Point();  
    3.     getWindowManager().getDefaultDisplay().getSize(point);  
    4.     Log.d(TAG,"the screen size is "+point.toString());  
    5. }  
    结果如下:
    [plain]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. D/MainActivity﹕ the screen size is Point(800, 1280)  

    此外Display又提供了一个getRealSize方法,原型如下:
    [java]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. public void getRealSize(Point outSize) {  
    2.     synchronized (this) {  
    3.         updateDisplayInfoLocked();  
    4.         outSize.x = mDisplayInfo.logicalWidth;  
    5.         outSize.y = mDisplayInfo.logicalHeight;  
    6.     }  
    7. }  

    从两个方法的实现上看是有区别的,但是在通常情况下二者的返回值相同。那么差异究竟在哪里,下面做一些实验来验证一下。
    首先,我将Acitvity设置不同的theme,比如:
    [html]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. android:theme="@android:style/Theme.Black.NoTitleBar.Fullscreen"  
    2. android:theme="@android:style/Theme.NoTitleBar.Fullscreen"  
    结果还是相同的。

    接下来将我的Activity父类变成ActionBarActivity,如下:
    public class MainActivity extends ActionBarActivity
    期望ActionBar会占用一些屏幕,并在程序中动态设置Listview的Item中的图片大小。在机缘巧合之下,
    结果验证了在这种情况下,getSize返回的结果变了。
    代码如下:
    [java]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. private void getDisplayInfomation() {  
    2.     Point point = new Point();  
    3.     getWindowManager().getDefaultDisplay().getSize(point);  
    4.     Log.d(TAG,"the screen size is "+point.toString());  
    5.     getWindowManager().getDefaultDisplay().getRealSize(point);  
    6.     Log.d(TAG,"the screen real size is "+point.toString());  
    7. }  

    Log如下:
    [plain]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. D/MainActivity﹕ the screen size is Point(800, 1202)  
    2. D/MainActivity﹕ the screen real size is Point(800, 1280)  

    如果你不能够轻易复现也不用急,保险起见,为了得到相对正确的信息还是使用getRealSize()吧。

    二、屏幕尺寸

    设备的物理屏幕尺寸。与几年前不同,目前的手机屏幕已经大到一只手握不下了。标配早已经到了5寸屏时代。
    所谓屏幕尺寸指的是屏幕对角线的长度,单位是英寸。
    然而不同的屏幕尺寸是可以采用相同的分辨率的,而它们之间的区别在与密度(density)不同。
    下面先介绍一下密度的概念,DPI、PPI,最后讲解一下如何根据获得的Display信息去求出屏幕尺寸。这是一个困扰我很久的问题了。

    三、屏幕密度

    屏幕密度与DPI这个概念紧密相连,DPI全拼是dots-per-inch,即每英寸的点数。也就是说,密度越大,每英寸内容纳的点数就越多。
    android.util包下有个DisplayMetrics类可以获得密度相关的信息。
    最重要的是densityDpi这个成员,它有如下几个常用值:
    [java]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. DENSITY_LOW = 120  
    2. DENSITY_MEDIUM = 160  //默认值  
    3. DENSITY_TV = 213      //TV专用  
    4. DENSITY_HIGH = 240  
    5. DENSITY_XHIGH = 320  
    6. DENSITY_400 = 400  
    7. DENSITY_XXHIGH = 480  
    8. DENSITY_XXXHIGH = 640  

    举例如下:
    [java]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. private void getDensity() {  
    2.     DisplayMetrics displayMetrics = getResources().getDisplayMetrics();  
    3.     Log.d(TAG,"Density is "+displayMetrics.density+" densityDpi is "+displayMetrics.densityDpi+" height: "+displayMetrics.heightPixels+  
    4.         " width: "+displayMetrics.widthPixels);  
    5. }  

    Log如下:
    [plain]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. the screen size is Point(1600, 2438)  
    2. the screen real size is Point(1600, 2560)  
    3. Density is 2.0 densityDpi is 320 height: 2438 width: 1600  

    有了这些信息,我们是不是就可以计算屏幕尺寸了呢?
    首先求得对角线长,单位为像素。
    然后用其除以密度(densityDpi)就得出对角线的长度了。
    代码如下:
    [java]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. private void getScreenSizeOfDevice() {  
    2.     DisplayMetrics dm = getResources().getDisplayMetrics();  
    3.     int width=dm.widthPixels;  
    4.     int height=dm.heightPixels;  
    5.     double x = Math.pow(width,2);  
    6.     double y = Math.pow(height,2);  
    7.     double diagonal = Math.sqrt(x+y);  
    8.   
    9.     int dens=dm.densityDpi;  
    10.     double screenInches = diagonal/(double)dens;  
    11.     Log.d(TAG,"The screenInches "+screenInches);  
    12. }  

    Log如下:

    [plain]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. 01-13 16:35:03.026  16601-16601/com.linc.listviewanimation D/MainActivity﹕ the screen size is Point(1600, 2438)  
    2. 01-13 16:35:03.026  16601-16601/com.linc.listviewanimation D/MainActivity﹕ the screen real size is Point(1600, 2560)  
    3. 01-13 16:35:03.026  16601-16601/com.linc.listviewanimation D/MainActivity﹕ Density is 2.0 densityDpi is 320 height: 2438 width: 1600 xdpi 338.666 ydpi 338.666  
    4. 01-13 16:35:03.026  16601-16601/com.linc.listviewanimation D/MainActivity﹕ The screenInches 9.112922229586951  

    如Log所见,使用heightPixels得出的值是2483而不是正确的2560.从而使结果9.11反倒跟真实屏幕尺寸很接近。下面用正确的height再算一遍。
    [plain]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. 01-13 16:39:05.476  17249-17249/com.linc.listviewanimation D/MainActivity﹕ the screen size is Point(1600, 2560)  
    2. 01-13 16:39:05.476  17249-17249/com.linc.listviewanimation D/MainActivity﹕ the screen real size is Point(1600, 2560)  
    3. 01-13 16:39:05.476  17249-17249/com.linc.listviewanimation D/MainActivity﹕ Density is 2.0 densityDpi is 320 height: 2560 width: 1600 xdpi 338.666 ydpi 338.666  
    4. 01-13 16:39:05.476  17249-17249/com.linc.listviewanimation D/MainActivity﹕ The screenInches 9.433981132056605  
    结果是9.43英寸,而真实值是8.91.如果再换一个设备,那么值差的更多。说明上面的计算是错误的。
    那么错在哪里呢?densityDpi是每英寸的点数(dots-per-inch)是打印机常用单位(因而也被称为打印分辨率),而不是每英寸的像素数。下面引出PPI这个概念。

    四、PPI

    Pixels per inch,这才是我要的每英寸的像素数(也被称为图像的采样率)。有了这个值,那么根据上面的公式就可以求导出屏幕的物理尺寸了。
    还好DisplayMetrics有两个成员是xdpi和ydpi,对其描述是:
    [java]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. //The exact physical pixels per inch of the screen in the X/Y dimension.  
    屏幕X/Y轴上真正的物理PPI。
    Yes!Got it!
    为了保证获得正确的分辨率,我还是使用getRealSize去获得屏幕宽和高像素。所以,经过修改,代码如下:
    [java]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. private void getScreenSizeOfDevice2() {  
    2.     Point point = new Point();  
    3.     getWindowManager().getDefaultDisplay().getRealSize(point);  
    4.     DisplayMetrics dm = getResources().getDisplayMetrics();  
    5.     double x = Math.pow(point.x/ dm.xdpi, 2);  
    6.     double y = Math.pow(point.y / dm.ydpi, 2);  
    7.     double screenInches = Math.sqrt(x + y);  
    8.     Log.d(TAG, "Screen inches : " + screenInches);  
    9. }  
    Log is as follows:
    [plain]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. 01-13 16:58:50.142  17249-17249/com.linc.listviewanimation D/MainActivity﹕ Screen inches : 8.914015757534717  

    五、DIP

    注意不要与上面的DPI混淆,这个DIP是Density Independent Pixel,直译为密度无关的像素。
    我们在布局文件中使用的dp/dip就是它。官方推荐使用dp是因为它会根据你设备的密度算出对应的像素。
    公式为:pixel = dip*density

    需要注意的是,我们在Java代码中对控件设置宽高是不可以设置单位的,而其自带的单位是像素。所以如果动态修改控件大小时,
    我们的任务就来了,那就是将像素转换为dp。
    实例代码如下:
    [java]  view plain  copy
      在CODE上查看代码片 派生到我的代码片
    1. //pixel = dip*density;  
    2. private int convertDpToPixel(int dp) {  
    3.     DisplayMetrics displayMetrics = mContext.getResources().getDisplayMetrics();  
    4.     return (int)(dp*displayMetrics.density);  
    5. }  
    6.   
    7. private int convertPixelToDp(int pixel) {  
    8.     DisplayMetrics displayMetrics = mContext.getResources().getDisplayMetrics();  
    9.     return (int)(pixel/displayMetrics.density);  
    10. }   

    参考:

    http://stackoverflow.com/questions/19155559/how-to-get-android-device-screen-size

    展开全文
  • 很早我就研究在WM6.5上获得屏幕物理尺寸,但一直没有成功。后来又想要在Android上有所突破,不过在今天之前得到的尺寸都不准确。虽然很多人认为没必要这么较真,因为貌似很多情况下用不到。不过我就当这是一件很有...
  • DPI:dots-per-inch,每英寸的像素数量,也就是说,密度越大,每英寸内容纳的点数就越多。这个值是设备自己决定并写死的。 计算方法:获取到屏幕的分辨率:point.x和point.y,再取出屏幕的DPI(每英寸的...即屏幕尺寸
  • Android中获取屏幕物理尺寸的方法

    千次阅读 2015-09-30 11:11:44
    第一种方法//获取屏幕宽度 int screenWidth = ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getWidth();//获取屏幕高度 int screenHeight = ((WindowManager) context....
  • android获取屏幕物理尺寸

    万次阅读 2017-08-23 17:52:17
    * @ 获取当前手机屏幕尺寸 */ public static float getPingMuSize(Context mContext) { int densityDpi = mContext.getResources().getDisplayMetrics().densityDpi; float scaledDensity = mContext.getResou
  • android 获取屏幕物理尺寸

    千次阅读 2018-07-04 15:49:21
    计算方法:获取到屏幕的分辨率:point.x和point.y,再取出屏幕的DPI(每英寸的像素数量),计算... * 得到屏幕物理尺寸,由于该尺寸是在出厂时,厂商写死的,所以仅供参考 * 计算方法:获取到屏幕的分辨率:point...
  • iPhone 各屏幕尺寸及解析

    万次阅读 2019-06-24 17:23:35
    屏幕物理尺寸 屏幕密度 开发尺寸 像素尺寸 倍图 4/4s 3.5 inch 326 ppi 320*480 pt 640*960 px @2x 5/5S/5c/SE 4.0 inch 326 ppi 320*568 pt 640*1136 px @2x 6/6S/7/8 4.7 inch ...
  • 最近在做一个项目,需要获取电脑屏幕PPI,网上好多都是人云亦云,花了蛮多时间的,深感不易!记录一下结果,希望对后来者有所帮助。 PPI 和 DPI PPI (Pixels Per Inch) : 即每一英寸长度上有多少个像...
  • Java 获取屏幕尺寸

    千次阅读 2019-07-23 09:44:56
    Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize(); double width = screenSize.getWidth();...// 屏幕物理大小还需要知道屏幕的dpi 意思是说一英寸多少个象素 double dpi = T...
  • //获取显示器物理尺寸(cm) public virtual SizeF GetMonitorPhysicalSize(string monitorPnpDevId) { byte[] edid = GetMonitorEdid(monitorPnpDevId); if (edid.Length ) return SizeF.Empty; return new ...
  • Qt:获取屏幕物理长度和宽度(CM)

    千次阅读 2017-01-11 17:16:55
    Qt有提供接口,获取屏幕的分辨率和DPI,那么通过这些接口的组合,我们就可以算出来屏幕物理高宽了代码如下:QGuiApplication app( argc, argv );QScreen *primaryScreen = app.primaryScreen(); qDebug() (cm):" ...
  • 大家都知道移动端设备屏幕尺寸非常多,碎片化严重。尤其是Android,你会听到很多种分辨率:480×800, 480×854, 540×960, 720×1280, 1080×1920,而且还有传说中的2K屏、4K、5k等。近年来iPhone的碎片化也加剧了:...
  • 通常大家在表示电脑、电视、手机等电子产品的屏幕大小时会使用英寸这一长度单位来描述。要注意的一点时,英寸在描述电脑、电视、手机等电子产品的屏幕大小时是指屏幕的对角线长度。  英寸(inch,缩写为in.)在荷兰...
  • 屏幕尺寸:对角线的长度(厘米) 屏幕分辨率:横纵向上物理像素的个数(物理像素) 物理像素:分辨率,是屏幕成像的最小单位 css像素:是web开发者使用的最小单位 一个css像素最终一定会转成物理像素去屏幕上呈像 一...
  • 原理:由EnumDisplayDevices获取当前显示器的DISPLAY_DEVICE数据,取其中的DeviceID进行解析,获取Model和Driver,然后在注册表SYSTEM\\CurrentControlSet\\Enum\\DISPLAY\\中匹配到键值,取得其中的EDID数据。
  • 什么是分辨率 我们把一个个像素点当成小格子,...很明显,显示相同尺寸屏幕,肯定是点越多,显示的越精细,效果越好。 那图中这些像素点是什么呢?其实就是物理像素。 什么是物理像素 物理像素(physical ...
  • window 下获取显示器物理尺寸

    千次阅读 2010-09-26 09:04:00
    HDC = ::GetDC(NULL);int DpiW=::GetDeviceCaps(hScreenDC ,LOGPIXELSX); int DpiH=::GetDeviceCaps(hScreenDC ,LOGPIXELSY); int m_Width = GetSystemMetrics( SM_CXSCREEN ); int m_Highth = ...
  • Android7.1 RK3288修改屏幕物理分辨率 Physical Size以及rk3288 修改hdmi分辨率后整个布局都会改变,很不协调的问题 一、通过 shell 命令 wm size 查看到 Physical Size (物理尺寸) 1080x2246 ,将初始化的这个...
  • Flutter获取屏幕相关尺寸

    千次阅读 2019-08-06 14:32:11
    class Screen { static double get width { MediaQueryData mediaQuery = MediaQueryData.fromWindow(ui.window); return mediaQuery.size.width; } static double get height { MediaQueryData ...
  • 每英寸有多少个像素,称为ppi(pixel per inch)。我们可以简单算算,iPhone 4是640 x 960像素,对角线就是1154像素,除以3.5英寸,应该是330...因此iPhone 4的屏幕叫作Retina显示屏。Retina在英文中,是视网膜的意思。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 30,006
精华内容 12,002
关键字:

屏幕物理尺寸