DM界面库DPI改造之路（和图片拉伸防锯齿）

已于 2022-06-08 02:12:10 修改
阅读量873 收藏 1
点赞数
分类专栏： DM 文章标签： ui windows编程 c++ 个人开发
于 2022-06-08 00:47:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liaozhilong88/article/details/125175142
版权

DM界面库简介：
DM是Dui Magic的简称，是一套基于商业化标准的开源directui界面框架，不仅能提供完善的项目管理方案、详细的文档框架，也可轻松协助完成可视化界面设计，其核心库的稳定性已在内部多个大型商化项目中通过验证。界面库开始编写于2014年，2015年年中基本完成主框架代码的编写，之后不断完善和维护，代码主程笔者的前同事hgy413，他曾经是YY游戏运营中心的windows C++桌面客户端的资深架构师，笔者曾经也是该库的深度开发及维护者，我们曾努力致力把DM打造成全网最好的windows界面库。
原博客地址：REDM-开源的商业化DirectUI库_花熊的博客-CSDN博客

引言：

在高分辨率的屏幕上（比如当下主流的笔记本），我们通常会设置windows的显示缩放进行比例拉伸，这样可以避免程序的显示过小而看不清，不方便操作：
                                    

但是程序界面经过系统拉伸之后，无论是界面上的图片和文字因为经过系统拉伸，而显得模糊，而对于那些对界面显示分辨率有较高要求（比如分辨率的游戏）的用户，是不想程序被系统进行拉伸的，这种情况下，我们只需要通过调用系统API：SetProcessDpiAwareness(PROCESS_PER_MONITOR_DPI_AWARE);来设置dpi，这种情况下，表明程序拒绝被系统进行拉伸，我们看看这两种情况下的效果对比：

  • 上面左边的图是被系统进行2.5倍拉伸的效果，界面显示被放大，用户方便操作，但是缺点是界面的图片和字体比较模糊。
  • 上面右边的图是拒绝被系统进行拉伸的效果，界面显示没有经过放大，但是界面的字体和图片没有经过拉伸，显示是清晰的，但是缺点就是界面显示比较小，非常不方便用户进行操作。

 引入主题：

界面的DPI改造就是把上面的右图窗口大小进行2.5倍拉伸，达到左图的效果，这样窗口的显示既满足了界面显示清晰，又达到了方便用户操作的目的。

怎么实现呢（可能会遇到的挑战）：

  1. 把窗口大小进行等比例拉伸，即窗口在创建的时候进行倍率拉伸：

  2. 上图右图，界面经过倍率拉伸之后以及控件坐标和字体大小进行简单的转换之后，窗口大小跟左边一致了，但是依然有很多的问题需要解决，比如：

    一.

    上面右图是经过DPI改造后，但是里面的tablayout布局对子控件还没进行布局处理，控件位置和大小没有做倍率拉伸处理，所以显示上跟原布局会有问题。布局分了好几种布局，比如描点布局、水平布局、垂直布局、spliter布局等，这些都要找到合适的地方进行对坐标和控件大小进行处理。
    二.

    上面右图是经过DPI改造后，里面的listctrl控件跟左边的item高度跟原高度不相同，这些控件布局以及控件宽高都需要做调整。DM里面的控件很多，这些控件可能都需要做相应的转换和处理。
  3. ...
     

 如何调整（部分调整的代码展示）：

  1. 处理窗口创建时候的宽高：

    如上图，在加载xml的时候，就对创建窗口的初始宽高进行DPI等比例拉伸处理
  2. 控件坐标转换：

  3. 字体大小的调整：

  4. 子窗口控件宽高转换：

  5. ......

     

 DPI改造之后效果对比：

好了，经过改造，从图1到图2再到图3，我们几乎以及改造的几乎一样了，基本完成了DPI的改造工作。图3比图1字体上看清晰很多。

 但经过对比，发现，DPI改造之后的图像经过拉伸之后，出现了明显的锯齿状。这也是需要解决的另一个问题，就是图片拉伸防锯齿功能。

 

图片拉伸防锯齿功能：

这里引入了一种图片拉伸填充算法，原理就是在图片拉伸的时候通过图像算法，填充图片因为拉伸而缺失的像素，达到“羽化”的效果。

打开图片拉伸防锯齿功能：

图片拉伸防锯齿功能不是默认带的，需要手动开启，开启方法就是在CMake之前勾选USE_XGRAPHIC32选项，然后重新生成工程，重新编译工程即可。

重新生成工程之后，工程会自动加入xGraphic32图像算法代码以及SmoothBmp注册替换画布插件代码：

 打开图片拉伸防锯齿功能之后（可能是截图工具限制，截图可能看起来效果不明显）：

 经过改造，图片拉伸的锯齿得到了明显的改善。

好了，到了这里，就基本完成了DPI功能的改造了，如果开启DPI功能，建议也开启图片拉伸防锯齿功能，图片拉伸防锯齿算法比较消耗CPU，但笔者已经对此做了缓存上的优化，不影响效率，可放心使用。

附录：

1.因为DPI功能改造刚改造不久，后续才会将代码合入主线，目前可以在我的代码仓库上进行下载：
DM: REDM是一套基于商业化标准的开源directui界面框架，不仅能提供完善的项目管理方案、详细的文档框架，也可轻松协助完成可视化界面设计，其核心库的稳定性已在内部多个大型商化项目中通过验证。

2.这里截取一段自己写的代码作为参考：
 

//-------------------------------------------------------
// Copyright (c) DuiMagic
// All rights reserved.
// 
// File Name: DMDPIHelper.h 
// File Des: DPI转换工具类
/* Use  Des:
	DMApp theApp(hInstance);
	DMDPIHelper::EnableHIDPI(true); // 程序高清支持 SetProcessDpiAwareness
	DMDPIHelper::getSingleton().SetDPIAdaptFlag(true); // 设置dpi标志
	DPISCALE_X(10);  // 传右值 结果返回经过乘积
	DPISCALE_X(i);   // 传变量 不会改变i的值 等价：DPISCALE_X_T<int>(i);
	DPISCALE_X_T<int&>(i); // 传引用 会改变i的值
	DPISCALE_X(&i);  // 传指针 会改变i的值 等价：DPISCALE_X_T<int*>(&i);
	DPIUNSCALE_X(10);
	DPISCALE_X_T<int>(20);

	CSize size(10, 20);
	CRect rect(10, 20, 30, 40);
	CSize rtSize = DPISCALE_OBJ(size);  // 传CSize对象 不会改变size的值
	CRect rtRect = DPISCALE_OBJ(rect);  // 传CRect对象 不会改变rect的值
	CSize rtSize2 = DPISCALE_OBJ_T<CSize&>(size); // 传CSize引用 会改变size的值
	CSize rtSize3 = DPISCALE_OBJ_T<CSize*>(&size); // 传CSize指针 会改变size的值
	DPIUNSCALE_OBJ(size); // 传CSize对象 不会改变size的值 等价：DPIUNSCALE_OBJ_T<CSize>(rect);
	DPIUNSCALE_OBJ(rect); // 传CRect对象 不会改变rect的值 等价：DPIUNSCALE_OBJ_T<CRect>(rect);
	DPIUNSCALE_OBJ_T<CRect&>(rect);  // 传CSize引用 会改变size的值
	DPIUNSCALE_OBJ_T<CRect*>(&rect); // 传CSize指针 会改变size的值
*/
// File Summary: 
// Cur Version: 1.0
// Author:
// Create Data:
// History:
// 		<Author>	<Time>		<Version>	  <Des>
//      zeron		2022-5-7	1.0			
//-------------------------------------------------------
#pragma once

#define DPISCALE_X(val)		DMDPIHelper::getSingleton().DpiScaleX<decltype(val)>(val)
#define DPISCALE_X_T		DMDPIHelper::getSingleton().DpiScaleX
#define DPIUNSCALE_X(val)	DMDPIHelper::getSingleton().DpiUnScaleX<decltype(val)>(val)
#define DPIUNSCALE_X_T		DMDPIHelper::getSingleton().DpiUnScaleX

#define DPISCALE_Y(val)		DMDPIHelper::getSingleton().DpiScaleY<decltype(val)>(val)
#define DPISCALE_Y_T		DMDPIHelper::getSingleton().DpiScaleY
#define DPIUNSCALE_Y(val)	DMDPIHelper::getSingleton().DpiUnScaleY<decltype(val)>(val)
#define DPIUNSCALE_Y_T		DMDPIHelper::getSingleton().DpiUnScaleY

#define DPISCALE_OBJ(val)	DMDPIHelper::getSingleton().DpiScaleObj<decltype(val)>(val)
#define DPISCALE_OBJ_T		DMDPIHelper::getSingleton().DpiScaleObj
#define DPIUNSCALE_OBJ(val) DMDPIHelper::getSingleton().DpiUnScaleObj<decltype(val)>(val)
#define DPIUNSCALE_OBJ_T	DMDPIHelper::getSingleton().DpiUnScaleObj

#define ISDPISCALED  DMDPIHelper::getSingleton().IsNeededScale()
#define DPIEXTENDX(X) (ISDPISCALED ? X : 0)
#define DPISCALEXVAL DMDPIHelper::getSingleton().GetDPIScaleX()
#define DPISCALEYVAL DMDPIHelper::getSingleton().GetDPIScaleY()
#define CHECK_DPIXY(val) if (DMDPIHelper::getSingleton().GetDPIX() == 96 && DMDPIHelper::getSingleton().GetDPIY() == 96) { return val; }
#define CHECK_DPIX(val) if (DMDPIHelper::getSingleton().GetDPIX() == 96) { return val; }
#define CHECK_DPIY(val) if (DMDPIHelper::getSingleton().GetDPIY() == 96) { return val; }

namespace DM
{
	/// <summary>
	///		DPI转换工具类
	/// </summary>
	class DM_EXPORT DMDPIHelper:public DMSingletonT<DMDPIHelper>
	{
	public:
		DMDPIHelper();
		static void EnableHIDPI(bool enable = true);

		void SetDPIAdaptFlag(bool bDPIAdaptFlag, bool bEnableHIDPI = true);
		bool GetDPIAdaptFlag();

		// Get screen DPI.
		int GetDPIX();
		int GetDPIY();

		// Get windows real screen DPI.
		int GetRealDPIX();
		int GetRealDPIY();

		// Get DPI Scale.
		float GetDPIScaleX();
		float GetDPIScaleY();

		//---------------------------------------------------
		// Function Des: 参数类型类别说明
		//---------------------------------------------------
		template <typename T>
		struct TupleTraits
		{
			typedef T ValueType;
			typedef T& RefType;
			typedef const T& ParamType;
		};

		template <typename T>
		struct TupleTraits<T&>
		{
			typedef T ValueType;
			typedef T& RefType;
			typedef T& ParamType;
		};

		template <typename T>
		struct TupleTraits<T*>
		{
			typedef T ValueType;
			typedef T*& RefType;
			typedef T* ParamType;
		};

		//---------------------------------------------------
		// Function Des: DPI乘积方法
		//---------------------------------------------------
		template<class T>
		struct MultiplyTraits
		{
			typedef const T Param;
			typedef typename TupleTraits<Param>::ValueType ReturnType;
			typedef typename TupleTraits<Param>::ParamType ParamType;

			///-------------- ScaleMultiplyT
			static inline ReturnType ScaleMultiplyT(ParamType tValue, float fScale)
			{
				CHECK_DPIXY(tValue);
				return static_cast<ReturnType>(tValue * fScale);
			}

			///-------------- UnScaleDivideT
			static inline ReturnType UnScaleDivideT(ParamType tValue, float fScale)
			{
				CHECK_DPIXY(tValue);
				return static_cast<ReturnType>(tValue / fScale);
			}

			//---------------------------------------------------
			// Function Des:  ScaleMultiplyObj声明
			//---------------------------------------------------
			template<class E>
			static inline typename TupleTraits<E>::ValueType ScaleMultiplyObj(typename TupleTraits<E>::ParamType tValue);

			/// --------------------  特化 好像不是特化 是重载     RECT CRect
			static inline typename TupleTraits<RECT>::ValueType ScaleMultiplyObj(typename TupleTraits<RECT>::ParamType tValue)
			{
				CHECK_DPIXY(tValue);
				RECT rtRect;
				rtRect.left = (tValue.left == -1) ? tValue.left : MultiplyTraits<LONG>::ScaleMultiplyT(tValue.left, DPISCALEXVAL);
				rtRect.top = (tValue.top == -1) ? tValue.top : MultiplyTraits<LONG>::ScaleMultiplyT(tValue.top, DPISCALEYVAL);
				rtRect.right = (tValue.right == -1) ? tValue.right : MultiplyTraits<LONG>::ScaleMultiplyT(tValue.right, DPISCALEXVAL);
				rtRect.bottom = (tValue.bottom == -1) ? tValue.bottom : MultiplyTraits<LONG>::ScaleMultiplyT(tValue.bottom, DPISCALEYVAL);
				return rtRect;
			}

			static inline typename TupleTraits<DM::CRect>::ValueType ScaleMultiplyObj(typename TupleTraits<DM::CRect>::ParamType tValue)
			{
				CHECK_DPIXY(tValue);
				DM::CRect rtRect;
				rtRect.left = (tValue.left == -1) ? tValue.left : MultiplyTraits<LONG>::ScaleMultiplyT(tValue.left, DPISCALEXVAL);
				rtRect.top = (tValue.top == -1) ? tValue.top : MultiplyTraits<LONG>::ScaleMultiplyT(tValue.top, DPISCALEYVAL);
				rtRect.right = (tValue.right == -1) ? tValue.right : MultiplyTraits<LONG>::ScaleMultiplyT(tValue.right, DPISCALEXVAL);
				rtRect.bottom = (tValue.bottom == -1) ? tValue.bottom : MultiplyTraits<LONG>::ScaleMultiplyT(tValue.bottom, DPISCALEYVAL);
				return rtRect;
			}

			///------------------------------------------------------- SIZE CSize
			static inline typename TupleTraits<SIZE>::ValueType ScaleMultiplyObj(typename TupleTraits<SIZE>::ParamType tValue)
			{
				CHECK_DPIXY(tValue);
				SIZE sz;
				sz.cx = (tValue.cx == -1) ? tValue.cx : MultiplyTraits<LONG>::ScaleMultiplyT(tValue.cx, DPISCALEXVAL);
				sz.cy = (tValue.cy == -1) ? tValue.cy : MultiplyTraits<LONG>::ScaleMultiplyT(tValue.cy, DPISCALEYVAL);
				return sz;
			}

			static inline typename TupleTraits<DM::CSize>::ValueType ScaleMultiplyObj(typename TupleTraits<DM::CSize>::ParamType tValue)
			{
				CHECK_DPIXY(tValue);
				DM::CSize sz;
				sz.cx = (tValue.cx == -1) ? tValue.cx : MultiplyTraits<LONG>::ScaleMultiplyT(tValue.cx, DPISCALEXVAL);
				sz.cy = (tValue.cy == -1) ? tValue.cy : MultiplyTraits<LONG>::ScaleMultiplyT(tValue.cy, DPISCALEYVAL);
				return sz;
			}

			///------------------------------------------------------- POINT CPoint
			static inline typename TupleTraits<POINT>::ValueType ScaleMultiplyObj(typename TupleTraits<POINT>::ParamType tValue)
			{
				CHECK_DPIXY(tValue);
				POINT pt;
				pt.x = (tValue.x == -1) ? tValue.x : MultiplyTraits<LONG>::ScaleMultiplyT(tValue.x, DPISCALEXVAL);
				pt.y = (tValue.y == -1) ? tValue.y : MultiplyTraits<LONG>::ScaleMultiplyT(tValue.y, DPISCALEYVAL);
				return pt;
			}

			static inline typename TupleTraits<DM::CPoint>::ValueType ScaleMultiplyObj(typename TupleTraits<DM::CPoint>::ParamType tValue)
			{
				CHECK_DPIXY(tValue);
				DM::CPoint pt;
				pt.x = (tValue.x == -1) ? tValue.x : MultiplyTraits<LONG>::ScaleMultiplyT(tValue.x, DPISCALEXVAL);
				pt.y = (tValue.y == -1) ? tValue.y : MultiplyTraits<LONG>::ScaleMultiplyT(tValue.y, DPISCALEYVAL);
				return pt;
			}
			
			//---------------------------------------------------
			// Function Des: UnScaleDevideObj声明
			//---------------------------------------------------
			template<class E>
			static inline typename TupleTraits<E>::ValueType UnScaleDevideObj(typename TupleTraits<E>::ParamType tValue);

			/// ----------------------------------------- RECT CRect
			static inline typename TupleTraits<RECT>::ValueType UnScaleDevideObj(typename TupleTraits<RECT>::ParamType tValue)
			{
				CHECK_DPIXY(tValue);
				RECT rtRect;
				rtRect.left = (tValue.left == -1) ? tValue.left : MultiplyTraits<LONG>::UnScaleDivideT(tValue.left, DPISCALEXVAL);
				rtRect.top = (tValue.top == -1) ? tValue.top : MultiplyTraits<LONG>::UnScaleDivideT(tValue.top, DPISCALEYVAL);
				rtRect.right = (tValue.right == -1) ? tValue.right : MultiplyTraits<LONG>::UnScaleDivideT(tValue.right, DPISCALEXVAL);
				rtRect.bottom = (tValue.bottom == -1) ? tValue.bottom : MultiplyTraits<LONG>::UnScaleDivideT(tValue.bottom, DPISCALEYVAL);
				return rtRect;
			}

			static inline typename TupleTraits<DM::CRect>::ValueType UnScaleDevideObj(typename TupleTraits<DM::CRect>::ParamType tValue)
			{
				CHECK_DPIXY(tValue);
				DM::CRect rtRect;
				rtRect.left = (tValue.left == -1) ? tValue.left : MultiplyTraits<LONG>::UnScaleDivideT(tValue.left, DPISCALEXVAL);
				rtRect.top = (tValue.top == -1) ? tValue.top : MultiplyTraits<LONG>::UnScaleDivideT(tValue.top, DPISCALEYVAL);
				rtRect.right = (tValue.right == -1) ? tValue.right : MultiplyTraits<LONG>::UnScaleDivideT(tValue.right, DPISCALEXVAL);
				rtRect.bottom = (tValue.bottom == -1) ? tValue.bottom : MultiplyTraits<LONG>::UnScaleDivideT(tValue.bottom, DPISCALEYVAL);
				return rtRect;
			}

			///------------------------------------------------------- SIZE CSize
			static inline typename TupleTraits<SIZE>::ValueType UnScaleDevideObj(typename TupleTraits<SIZE>::ParamType tValue)
			{
				CHECK_DPIXY(tValue);
				SIZE sz;
				sz.cx = (tValue.cx == -1) ? tValue.cx : MultiplyTraits<LONG>::UnScaleDivideT(tValue.cx, DPISCALEXVAL);
				sz.cy = (tValue.cy == -1) ? tValue.cy : MultiplyTraits<LONG>::UnScaleDivideT(tValue.cy, DPISCALEYVAL);
				return sz;
			}

			static inline typename TupleTraits<DM::CSize>::ValueType UnScaleDevideObj(typename TupleTraits<DM::CSize>::ParamType tValue)
			{
				CHECK_DPIXY(tValue);
				DM::CSize sz;
				sz.cx = (tValue.cx == -1) ? tValue.cx : MultiplyTraits<LONG>::UnScaleDivideT(tValue.cx, DPISCALEXVAL);
				sz.cy = (tValue.cy == -1) ? tValue.cy : MultiplyTraits<LONG>::UnScaleDivideT(tValue.cy, DPISCALEYVAL);
				return sz;
			}

			///------------------------------------------------------- POINT CPoint
			static inline typename TupleTraits<POINT>::ValueType UnScaleDevideObj(typename TupleTraits<POINT>::ParamType tValue)
			{
				CHECK_DPIXY(tValue);
				POINT pt;
				pt.x = (tValue.x == -1) ? tValue.x : MultiplyTraits<LONG>::UnScaleDivideT(tValue.x, DPISCALEXVAL);
				pt.y = (tValue.y == -1) ? tValue.y : MultiplyTraits<LONG>::UnScaleDivideT(tValue.y, DPISCALEYVAL);
				return pt;
			}

			static inline typename TupleTraits<DM::CPoint>::ValueType UnScaleDevideObj(typename TupleTraits<DM::CPoint>::ParamType tValue)
			{
				CHECK_DPIXY(tValue);
				DM::CPoint pt;
				pt.x = (tValue.x == -1) ? tValue.x : MultiplyTraits<LONG>::UnScaleDivideT(tValue.x, DPISCALEXVAL);
				pt.y = (tValue.y == -1) ? tValue.y : MultiplyTraits<LONG>::UnScaleDivideT(tValue.y, DPISCALEYVAL);
				return pt;
			}
		};

		//---------------------------------------------------
		// Function Des: 特化引用类型的参数
		//---------------------------------------------------
		template<class T>
		struct MultiplyTraits<T&>
		{
			typedef T& Param;
			typedef typename TupleTraits<Param>::ValueType ReturnType;
			typedef typename TupleTraits<Param>::ParamType ParamType;

			///-------------- ScaleMultiplyT
			static inline ReturnType ScaleMultiplyT(ParamType tValue, float fScale)
			{
				CHECK_DPIXY(tValue);
				tValue = static_cast<ReturnType>(tValue * fScale);
				return tValue;
			}

			///-------------- UnScaleDivideT
			static inline ReturnType UnScaleDivideT(ParamType tValue, float fScale)
			{
				CHECK_DPIXY(tValue);
				tValue = static_cast<ReturnType>(tValue / fScale);
				return tValue;
			}

			//---------------------------------------------------
			// Function Des:  ScaleMultiplyObj声明
			//---------------------------------------------------
			template<class E>
			static inline typename TupleTraits<E&>::ValueType ScaleMultiplyObj(typename TupleTraits<E&>::ParamType tValue);

			/// --------------------  特化 好像不是特化 是重载     RECT CRect
			static inline typename TupleTraits<RECT&>::ValueType ScaleMultiplyObj(typename TupleTraits<RECT&>::ParamType tValue)
			{
				CHECK_DPIXY(tValue);
				if(tValue.left != -1) MultiplyTraits<LONG&>::ScaleMultiplyT(tValue.left, DPISCALEXVAL);
				if(tValue.top != -1) MultiplyTraits<LONG&>::ScaleMultiplyT(tValue.top, DPISCALEYVAL);
				if(tValue.right != -1) MultiplyTraits<LONG&>::ScaleMultiplyT(tValue.right, DPISCALEXVAL);
				if(tValue.bottom != -1) MultiplyTraits<LONG&>::ScaleMultiplyT(tValue.bottom, DPISCALEYVAL);
				return tValue;
			}

			static inline typename TupleTraits<DM::CRect&>::ValueType ScaleMultiplyObj(typename TupleTraits<DM::CRect&>::ParamType tValue)
			{
				CHECK_DPIXY(tValue);
				if (tValue.left != -1) MultiplyTraits<LONG&>::ScaleMultiplyT(tValue.left, DPISCALEXVAL);
				if (tValue.top != -1) MultiplyTraits<LONG&>::ScaleMultiplyT(tValue.top, DPISCALEYVAL);
				if (tValue.right != -1) MultiplyTraits<LONG&>::ScaleMultiplyT(tValue.right, DPISCALEXVAL);
				if (tValue.bottom != -1) MultiplyTraits<LONG&>::ScaleMultiplyT(tValue.bottom, DPISCALEYVAL);
				return tValue;
			}

			///------------------------------------------------------- SIZE CSize
			static inline typename TupleTraits<SIZE&>::ValueType ScaleMultiplyObj(typename TupleTraits<SIZE&>::ParamType tValue)
			{
				if(tValue.cx != -1) MultiplyTraits<LONG&>::ScaleMultiplyT(tValue.cx, DPISCALEXVAL);
				if(tValue.cy != -1) MultiplyTraits<LONG&>::ScaleMultiplyT(tValue.cy, DPISCALEYVAL);
				return tValue;
			}

			static inline typename TupleTraits<DM::CSize&>::ValueType ScaleMultiplyObj(typename TupleTraits<DM::CSize&>::ParamType tValue)
			{
				CHECK_DPIXY(tValue);
				if (tValue.cx != -1) MultiplyTraits<LONG&>::ScaleMultiplyT(tValue.cx, DPISCALEXVAL);
				if (tValue.cy != -1) MultiplyTraits<LONG&>::ScaleMultiplyT(tValue.cy, DPISCALEYVAL);
				return tValue;
			}

			///------------------------------------------------------- POINT CPoint
			static inline typename TupleTraits<POINT&>::ValueType ScaleMultiplyObj(typename TupleTraits<POINT&>::ParamType tValue)
			{
				CHECK_DPIXY(tValue);
				if(tValue.x != -1) MultiplyTraits<LONG&>::ScaleMultiplyT(tValue.x, DPISCALEXVAL);
				if(tValue.y != -1) MultiplyTraits<LONG&>::ScaleMultiplyT(tValue.y, DPISCALEYVAL);
				return tValue;
			}

			static inline typename TupleTraits<DM::CPoint&>::ValueType ScaleMultiplyObj(typename TupleTraits<DM::CPoint&>::ParamType tValue)
			{
				CHECK_DPIXY(tValue);
				if(tValue.x != -1) MultiplyTraits<LONG&>::ScaleMultiplyT(tValue.x, DPISCALEXVAL);
				if(tValue.y != -1) MultiplyTraits<LONG&>::ScaleMultiplyT(tValue.y, DPISCALEYVAL);
				return tValue;
			}

			//---------------------------------------------------
			// Function Des: UnScaleDevideObj声明
			//---------------------------------------------------
			template<class E>
			static inline typename TupleTraits<E&>::ValueType UnScaleDevideObj(typename TupleTraits<E&>::ParamType tValue);

			/// ----------------------------------------- RECT CRect
			static inline typename TupleTraits<RECT&>::ValueType UnScaleDevideObj(typename TupleTraits<RECT&>::ParamType tValue)
			{
				CHECK_DPIXY(tValue);
				if(tValue.left != -1) MultiplyTraits<LONG&>::UnScaleDivideT(tValue.left, DPISCALEXVAL);
				if(tValue.top != -1) MultiplyTraits<LONG&>::UnScaleDivideT(tValue.top, DPISCALEYVAL);
				if(tValue.right != -1) MultiplyTraits<LONG&>::UnScaleDivideT(tValue.right, DPISCALEXVAL);
				if(tValue.bottom != -1) MultiplyTraits<LONG&>::UnScaleDivideT(tValue.bottom, DPISCALEYVAL);
				return tValue;
			}

			static inline typename TupleTraits<DM::CRect&>::ValueType UnScaleDevideObj(typename TupleTraits<DM::CRect&>::ParamType tValue)
			{
				CHECK_DPIXY(tValue);
				if(tValue.left != -1) MultiplyTraits<LONG&>::UnScaleDivideT(tValue.left, DPISCALEXVAL);
				if(tValue.top != -1) MultiplyTraits<LONG&>::UnScaleDivideT(tValue.top, DPISCALEYVAL);
				if(tValue.right != -1) MultiplyTraits<LONG&>::UnScaleDivideT(tValue.right, DPISCALEXVAL);
				if(tValue.bottom != -1) MultiplyTraits<LONG&>::UnScaleDivideT(tValue.bottom, DPISCALEYVAL);
				return tValue;
			}

			///------------------------------------------------------- SIZE CSize
			static inline typename TupleTraits<SIZE&>::ValueType UnScaleDevideObj(typename TupleTraits<SIZE&>::ParamType tValue)
			{
				CHECK_DPIXY(tValue);
				if(tValue.cx != -1) MultiplyTraits<LONG&>::UnScaleDivideT(tValue.cx, DPISCALEXVAL);
				if(tValue.cy != -1) MultiplyTraits<LONG&>::UnScaleDivideT(tValue.cy, DPISCALEYVAL);
				return tValue;
			}

			static inline typename TupleTraits<DM::CSize&>::ValueType UnScaleDevideObj(typename TupleTraits<DM::CSize&>::ParamType tValue)
			{
				CHECK_DPIXY(tValue);
				if(tValue.cx != -1) MultiplyTraits<LONG&>::UnScaleDivideT(tValue.cx, DPISCALEXVAL);
				if(tValue.cy != -1) MultiplyTraits<LONG&>::UnScaleDivideT(tValue.cy, DPISCALEYVAL);
				return tValue;
			}

			///------------------------------------------------------- POINT CPoint
			static inline typename TupleTraits<POINT&>::ValueType UnScaleDevideObj(typename TupleTraits<POINT&>::ParamType tValue)
			{
				CHECK_DPIXY(tValue);
				if (tValue.x != -1) MultiplyTraits<LONG&>::UnScaleDivideT(tValue.x, DPISCALEXVAL);
				if (tValue.y != -1) MultiplyTraits<LONG&>::UnScaleDivideT(tValue.y, DPISCALEYVAL);
				return tValue;
			}

			static inline typename TupleTraits<DM::CPoint&>::ValueType UnScaleDevideObj(typename TupleTraits<DM::CPoint&>::ParamType tValue)
			{
				CHECK_DPIXY(tValue);
				if (tValue.x != -1) MultiplyTraits<LONG&>::UnScaleDivideT(tValue.x, DPISCALEXVAL);
				if (tValue.y != -1) MultiplyTraits<LONG&>::UnScaleDivideT(tValue.y, DPISCALEYVAL);
				return tValue;
			}
		};

		//---------------------------------------------------
		// Function Des: 特化指针类型的参数
		//---------------------------------------------------
		template<class T>
		struct MultiplyTraits<T*>
		{
			typedef T* Param;
			typedef typename TupleTraits<Param>::ValueType ReturnType;
			typedef typename TupleTraits<Param>::ParamType ParamType;

			static inline ReturnType ScaleMultiplyT(ParamType tValue, float fScale)
			{
				if (!tValue)
				{
					return static_cast<ReturnType>(0);
				}
				CHECK_DPIXY(*tValue);
				*tValue = static_cast<ReturnType>((*tValue) * fScale);
				return *tValue;
			}

			///-------------- UnScaleDivideT
			static inline ReturnType UnScaleDivideT(ParamType tValue, float fScale)
			{
				if (!tValue)
				{
					return static_cast<ReturnType>(0);
				}
				CHECK_DPIXY(*tValue);
				*tValue = static_cast<ReturnType>(*tValue / fScale);
				return *tValue;
			}

			//---------------------------------------------------
			// Function Des:  ScaleMultiplyObj声明
			//---------------------------------------------------
			template<class E>
			static inline typename TupleTraits<E*>::ValueType ScaleMultiplyObj(typename TupleTraits<E*>::ParamType tValue);

			/// --------------------  特化 好像不是特化 是重载     RECT CRect
			static inline typename TupleTraits<RECT*>::ValueType ScaleMultiplyObj(typename TupleTraits<RECT*>::ParamType tValue)
			{
				if (!tValue)
				{
					return {0, 0, 0, 0};
				}
				CHECK_DPIXY(*tValue);
				if (tValue->left != -1) MultiplyTraits<LONG*>::ScaleMultiplyT(&tValue->left, DPISCALEXVAL);
				if (tValue->top != -1) MultiplyTraits<LONG*>::ScaleMultiplyT(&tValue->top, DPISCALEYVAL);
				if (tValue->right != -1) MultiplyTraits<LONG*>::ScaleMultiplyT(&tValue->right, DPISCALEXVAL);
				if (tValue->bottom != -1) MultiplyTraits<LONG*>::ScaleMultiplyT(&tValue->bottom, DPISCALEYVAL);
				return *tValue;
			}

			static inline typename TupleTraits<DM::CRect*>::ValueType ScaleMultiplyObj(typename TupleTraits<DM::CRect*>::ParamType tValue)
			{
				if (!tValue)
				{
					return DM::CRect( 0,0,0,0 );
				}
				CHECK_DPIXY(*tValue);
				if (tValue->left != -1) MultiplyTraits<LONG*>::ScaleMultiplyT(&tValue->left, DPISCALEXVAL);
				if (tValue->top != -1) MultiplyTraits<LONG*>::ScaleMultiplyT(&tValue->top, DPISCALEYVAL);
				if (tValue->right != -1) MultiplyTraits<LONG*>::ScaleMultiplyT(&tValue->right, DPISCALEXVAL);
				if (tValue->bottom != -1) MultiplyTraits<LONG*>::ScaleMultiplyT(&tValue->bottom, DPISCALEYVAL);
				return *tValue;
			}

			///------------------------------------------------------- SIZE CSize
			static inline typename TupleTraits<SIZE*>::ValueType ScaleMultiplyObj(typename TupleTraits<SIZE*>::ParamType tValue)
			{
				if (!tValue)
				{
					return {0, 0};
				}
				if (tValue->cx != -1) MultiplyTraits<LONG*>::ScaleMultiplyT(&tValue->cx, DPISCALEXVAL);
				if (tValue->cy != -1) MultiplyTraits<LONG*>::ScaleMultiplyT(&tValue->cy, DPISCALEYVAL);
				return *tValue;
			}

			static inline typename TupleTraits<DM::CSize*>::ValueType ScaleMultiplyObj(typename TupleTraits<DM::CSize&>::ParamType tValue)
			{
				if (!tValue)
				{
					return DM::CSize(0, 0);
				}
				CHECK_DPIXY(*tValue);
				if (tValue->cx != -1) MultiplyTraits<INT*>::ScaleMultiplyT(&tValue->cx, DPISCALEXVAL);
				if (tValue->cy != -1) MultiplyTraits<INT*>::ScaleMultiplyT(&tValue->cy, DPISCALEYVAL);
				return *tValue;
			}

			///------------------------------------------------------- POINT CPoint
			static inline typename TupleTraits<POINT*>::ValueType ScaleMultiplyObj(typename TupleTraits<POINT*>::ParamType tValue)
			{
				if (!tValue)
				{
					return { 0, 0 };
				}
				CHECK_DPIXY(*tValue);
				if (tValue->x != -1) MultiplyTraits<LONG*>::ScaleMultiplyT(&tValue->x, DPISCALEXVAL);
				if (tValue->y != -1) MultiplyTraits<LONG*>::ScaleMultiplyT(&tValue->y, DPISCALEYVAL);
				return *tValue;
			}

			static inline typename TupleTraits<DM::CPoint*>::ValueType ScaleMultiplyObj(typename TupleTraits<DM::CPoint*>::ParamType tValue)
			{
				if (!tValue)
				{
					return DM::CPoint(0, 0);
				}
				CHECK_DPIXY(*tValue);
				if (tValue->x != -1) MultiplyTraits<LONG*>::ScaleMultiplyT(&tValue->x, DPISCALEXVAL);
				if (tValue->y != -1) MultiplyTraits<LONG*>::ScaleMultiplyT(&tValue->y, DPISCALEYVAL);
				return *tValue;
			}

			//---------------------------------------------------
			// Function Des: UnScaleDevideObj声明
			//---------------------------------------------------
			template<class E>
			static inline typename TupleTraits<E*>::ValueType UnScaleDevideObj(typename TupleTraits<E*>::ParamType tValue);

			/// ----------------------------------------- RECT CRect
			static inline typename TupleTraits<RECT*>::ValueType UnScaleDevideObj(typename TupleTraits<RECT*>::ParamType tValue)
			{
				if (!tValue)
				{
					return { 0,0,0,0 };
				}
				CHECK_DPIXY(*tValue);
				if (tValue->left != -1) MultiplyTraits<LONG*>::UnScaleDivideT(&tValue->left, DPISCALEXVAL);
				if (tValue->top != -1) MultiplyTraits<LONG*>::UnScaleDivideT(&tValue->top, DPISCALEYVAL);
				if (tValue->right != -1) MultiplyTraits<LONG*>::UnScaleDivideT(&tValue->right, DPISCALEXVAL);
				if (tValue->bottom != -1) MultiplyTraits<LONG*>::UnScaleDivideT(&tValue->bottom, DPISCALEYVAL);
				return *tValue;
			}

			static inline typename TupleTraits<DM::CRect*>::ValueType UnScaleDevideObj(typename TupleTraits<DM::CRect*>::ParamType tValue)
			{
				if (!tValue)
				{
					return DM::CRect(0,0,0,0);
				}
				CHECK_DPIXY(*tValue);
				if (tValue->left != -1) MultiplyTraits<LONG*>::UnScaleDivideT(&tValue->left, DPISCALEXVAL);
				if (tValue->top != -1) MultiplyTraits<LONG*>::UnScaleDivideT(&tValue->top, DPISCALEYVAL);
				if (tValue->right != -1) MultiplyTraits<LONG*>::UnScaleDivideT(&tValue->right, DPISCALEXVAL);
				if (tValue->bottom != -1) MultiplyTraits<LONG*>::UnScaleDivideT(&tValue->bottom, DPISCALEYVAL);
				return *tValue;
			}

			///------------------------------------------------------- SIZE CSize
			static inline typename TupleTraits<SIZE*>::ValueType UnScaleDevideObj(typename TupleTraits<SIZE*>::ParamType tValue)
			{
				if (!tValue)
				{
					return {0, 0};
				}
				CHECK_DPIXY(*tValue);
				if (tValue->cx != -1) MultiplyTraits<LONG*>::UnScaleDivideT(&tValue->cx, DPISCALEXVAL);
				if (tValue->cy != -1) MultiplyTraits<LONG*>::UnScaleDivideT(&tValue->cy, DPISCALEYVAL);
				return *tValue;
			}

			static inline typename TupleTraits<DM::CSize&>::ValueType UnScaleDevideObj(typename TupleTraits<DM::CSize&>::ParamType tValue)
			{
				if (!tValue)
				{
					return DM::CSize(0, 0 );
				}
				CHECK_DPIXY(*tValue);
				if (tValue->cx != -1) MultiplyTraits<INT*>::UnScaleDivideT(&tValue->cx, DPISCALEXVAL);
				if (tValue->cy != -1) MultiplyTraits<INT*>::UnScaleDivideT(&tValue->cy, DPISCALEYVAL);
				return *tValue;
			}

			///------------------------------------------------------- POINT CPoint
			static inline typename TupleTraits<POINT*>::ValueType UnScaleDevideObj(typename TupleTraits<POINT*>::ParamType tValue)
			{
				if (!tValue)
				{
					return{ 0, 0 };
				}
				CHECK_DPIXY(*tValue);
				if (tValue->x != -1) MultiplyTraits<LONG*>::UnScaleDivideT(&tValue->x, DPISCALEXVAL);
				if (tValue->y != -1) MultiplyTraits<LONG*>::UnScaleDivideT(&tValue->y, DPISCALEYVAL);
				return *tValue;
			}

			static inline typename TupleTraits<DM::CPoint*>::ValueType UnScaleDevideObj(typename TupleTraits<DM::CPoint*>::ParamType tValue)
			{
				if (!tValue)
				{
					return DM::CPoint( 0, 0);
				}
				CHECK_DPIXY(*tValue);
				if (tValue->x != -1) MultiplyTraits<LONG*>::UnScaleDivideT(&tValue->x, DPISCALEXVAL);
				if (tValue->y != -1) MultiplyTraits<LONG*>::UnScaleDivideT(&tValue->y, DPISCALEYVAL);
				return *tValue;
			}
		};

		//---------------------------------------------------
		// Function Des: DpiScale x,y,obj方法
		//---------------------------------------------------
		template<class T, class DPITraits = MultiplyTraits< T > >
		inline typename TupleTraits<T>::ValueType DpiScaleX(typename TupleTraits<T>::ParamType tValue)
		{
			return DPITraits::ScaleMultiplyT(tValue, m_fScaleX);
		}

		template<class T, class DPITraits = MultiplyTraits< T > >
		inline typename TupleTraits<T>::ValueType DpiScaleY(typename TupleTraits<T>::ParamType tValue)
		{
			return DPITraits::ScaleMultiplyT(tValue, m_fScaleY);
		}

		template<class T, class DPITraits = MultiplyTraits< T > >
		inline typename TupleTraits<T>::ValueType DpiScaleObj(typename TupleTraits<T>::ParamType tValue)
		{
			return DPITraits::ScaleMultiplyObj(tValue);
		}

		//---------------------------------------------------
		// Function Des: DpiUnScale x,y,obj方法
		//---------------------------------------------------
		template<class T, class DPITraits = MultiplyTraits< T > >
		inline typename TupleTraits<T>::ValueType DpiUnScaleX(typename TupleTraits<T>::ParamType tValue)
		{
			return DPITraits::UnScaleDivideT(tValue, m_fScaleX);
		}

		template<class T, class DPITraits = MultiplyTraits< T >>
		inline typename TupleTraits<T>::ValueType DpiUnScaleY(typename TupleTraits<T>::ParamType tValue)
		{
			return DPITraits::UnScaleDivideT(tValue, m_fScaleY);
		}

		template<class T, class DPITraits = MultiplyTraits< T >>
		inline typename TupleTraits<T>::ValueType DpiUnScaleObj(typename TupleTraits<T>::ParamType tValue)
		{
			return DPITraits::UnScaleDevideObj(tValue);
		}
		///---------------------------------------------------------------------------------------- end

		// Determine the screen dimensions in relative pixels.
		int ScaledScreenWidth();
		int ScaledScreenHeight();

		// Detemine if needed dpi scale, based 96 dpi.
		bool IsNeededScale();

	private:

		// This function initializes the CDPI Class
		void _Init();

		// This returns a 96-DPI scaled-down equivalent value for nIndex
		// For example, the value 120 at 120 DPI setting gets scaled down to 96
		// X and Y versions are provided, though to date all Windows OS releases
		// have equal X and Y scale values
		int _ScaledSystemMetricX(int nIndex);

		// This returns a 96-DPI scaled-down equivalent value for nIndex
		// For example, the value 120 at 120 DPI setting gets scaled down to 96
		// X and Y versions are provided, though to date all Windows OS releases
		// have equal X and Y scale values
		int _ScaledSystemMetricY(int nIndex);

	private:
		// Member variable indicating whether the class has been initialized
		bool m_fInitialized;

		bool m_bDPIAdaptFlag;

		// X and Y DPI values are provided, though to date all
		// Windows OS releases have equal X and Y scale values
	private:
		int m_dpiX;
		int m_dpiY;
		int m_realdpiX;
		int m_realdpiY;
		float m_fScaleX;
		float m_fScaleY;
	};
}

liaozhilong88
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
在linux环境下通过DPI接口访问DM数据库
weixin_42447367的博客
02-05 1056
第一步）在linux下要有gcc编译环境 第二步）准备一个文件/opt/dpitest用于存放相关的脚本文件 其中.c文件为相关操作示例的脚本，这些文件的脚本在达梦数据库的社区网站上可以找到，具体网址如下： http://eco.dameng.com/docs/zh-cn/app-dev/c_c++_dpi.html 其中makefile为编译脚本，编写makefile是为了省去编译时输入的参数，让make进行自动化编译，通过这个makefile，可以用来编译一个.c文件 dpi_bind.c为绑定变量
redm-uiprompt:用于创建和使用UI提示的库
03-19
提示 RedM中用于UI提示的面向对象的库。 特征 使用Uiprompt和UipromptGroup类简化了提示创建 诸如onControlJustPressed和onHoldModeJustCompleted类的提示事件的回调 自动清除提示 安装 在资源目录中创建一个名为uiprompt的文件夹。 将fxmanifest.lua和uiprompt.lua复制到此文件夹。 将start uiprompt添加到server.cfg 。 使用 在你想使用这个库，添加任何资源@uiprompt/uiprompt.lua如在客户端脚本fxmanifest.lua ： fx_version " adamant " game " rdr3 " rdr3_warning " I acknowledge that this is a prerelease build of RedM, and I am
REDM-开源的商业化DirectUI库
hgy413的专栏
09-20 3273
REDM-开源的商业化DirectUI库
REDM库使用教程01（详细入门）
MusicMan
04-23 4497
写这篇文章初衷在于，虽然开发这套框架的作者很叼，但是教程写的有点糟糕，坑了我一个晚上研究。 REDM库的简单介绍 https://gitee.com/hgy413/REDM 然后要先装好VS2010;装VS2010可以网上搜一下，教程应该是一大堆的。 其次夸一下yy；大公司是真的舒服。 不说了 ，进入正题 首先,先用SVN将其拷贝到本地硬盘当中 SVN 地址：svn://gitee....
开源一套DirectUI界面库
05-24
最近改玩WinRT和Metro了，看到有些朋友还在玩基于GDI的DirectUI，正好自己以前也尝试写过的，反正放着也没用，开源吧。 这个DirectUI界面库主要参考一个老外的程序, 支持各种Layout模式,实现了各种基本控件(SplitBar, PictureBox, Button, Radio, CheckBox, Label, HyperLink, ProgressBar, trackBar, ListBox, Edit, ComboBox, Tab Control, Toolbar, Menu, tree)，控件基本全部支持键盘操作，支持键盘导航，支持Tooltip，支持多语言，支持换肤，支持异形窗口，支持Layered Window, 支持插件2次开发，支持Alpha通道，支持各种图像处理。
DM和Tlloc.dll库
最新发布
05-21
标题中的“DM和Tlloc.dll库”是指两种动态链接库（Dynamic Link Library，简称DLL）文件，它们在Microsoft Visual C++ 6.0（简称VC6.0）环境下用于Windows 7系统的程序调试。DLL文件是Windows操作系统中的一种特殊...
国产化改造，如何将Oracle数据完整迁移到DM数据库。
10-08
国产化改造，如何将Oracle数据完整迁移到DM数据库。 本文将详细介绍将Oracle数据完整迁移到DM数据库的过程，包括分析待移植系统、数据迁移、PL/SQL移植、移植结果校验、应用系统移植、测试和优化等几个方面的工作。...
arm64和x86_64版本 达梦数据DPI — DM8 DPI — dmPython驱动
02-16
目录结构如下： ... - DPI.h - DPIext.h - DPItypes.h libcrypto.so libdmdpi.a libdmdpi.so libssl.so 在安装dmPython时需要指定的达梦DPI，设置LD_LIBRARY_PATH时使用；注意架构不一样，用的DPI不一样，坑死
uart.rar_dm642 uart_驱动库
09-19
UART驱动库对于DM642来说至关重要，它允许DM642与外部设备进行数据交换，通过串行接口发送和接收数据。 驱动库通常包含两部分：驱动源代码和库工程。驱动源代码是低级代码，直接与硬件交互，处理中断、配置波特率、...
DM码编译库资源
10-17
在这个名为“DM码编译库资源”的压缩包中，包含了一个用于生成和解析DM码的C++库，这将对理解和使用DM码在编程中的应用非常有帮助。 首先，让我们深入了解一下DM码的基本结构。DM码通常是由黑色和白色的正方形或...
DMUI:DMUI组件库
05-09
DMUI 基于vue 2+ ，为公司产品打(zao)造(lun)的(zi)可复用UI组件，适用于 移动 和 部分PC 端，其中包括 基础组件 和 应用组件，目前 组件 和 文档 在不断完善中。 特性 基于 >=v2.1.4 开发的可复用 UI 组件，并且可随产品需要扩展 使用Vue官方的工作流，支持 ES6 一系列产品线都在使用中 关于SEO问题推荐使用插件 浏览器支持 适用于 移动 和 部分PC 端 通用项目工程 开发 全局引入 -- 在 webpack 入口文件 main.js 中如下配置： # 安装 cnpm install dsh-m-ui --save # 引入css import 'dsh-m-ui/package/dmui.min.css' # 引入dmui.min.js import dmui from 'dsh-m-ui' # 注入到vue Vue.use(dmui) 按
写一个DPI自适应的Win32程序
大飞的博客
09-11 7402
当前高DPI的显示器越来越流行，动辄2K，甚至4K，一些老的应用程序在这些显示器显示效果非常差，这是为什么了呢？这是因为老的应用程序经常以96DPI来设计的，老的应用程序缺省是DPI Unawareness的，所以系统会自动把程序进行拉伸，比如现在DPI是144，那么程序界面就像拉伸150%，这就会造成界面模糊，下面是一个例子, DPI为96的界面把DPI改为150%（144）之后
Qt高清DPI下的显示，自适应分辨率
热门推荐
yinyuchen1的博客
08-14 1万+
针对Qt要在windows高清DPI下进行显示，且相对于在分辨率下1920*1080上显示无异常，下面有几种方案： 方案1：使用配置文件qt.conf 在Qt配置文件qt.conf文件中进行配置，其中0，1，2对应Windows函数中的枚举变量，此种方案可以在DPI每次增加%25界面都会有相应的变化。详见Qt帮助文档https://doc.qt.io/qt-5/highdpi.html 缺...
WindowsDPI适配 学习笔记
Junyi的实验室
03-19 1万+
Google上看到大多数人设置DPI缩放的时候，用的是 SetProcessDPIAware 这个函数，但是，MSDN上说： SetProcessDPIAware is available for use in the operating systems specified in the Requirements section. It may be altered or un...
实现每显示器高DPI识别(Per-Monitor DPI Aware)的注意事项
ayang1986的专栏
07-24 6839
转载自：https://www.52pojie.cn/thread-512713-1-1.html 为了在Win10下随时随地程序窗口都不模糊都能正常缩放，你必须在你的程序中加入Per-Monitor DPI Aware支持因为Win10开始，用户在设置应用中调整DPI是不需要注销的！于是一些System Aware和Unaware的应用会被DWM虚拟化技术进行粗暴缩放，于是就模糊了如果你定义你...
关于Windows高DPI的一些简单总结
MY的专栏
02-19 2132
我们知道，关于高DPI的支持， Windows XP时代就开始有了, 那时关于高DPI的支持比较简单， 但是从Vista/Win7 到现在Win8 /Win8.1， Windows关于高DPI的支持已经发生了很大的变化， 下面我们依次简单介绍下。 如果说以前XP时代我们还有理由不关注高DPI，  那么在移动设备时代和大显示器的高分辨率时代， 我们就没有理由不关注高DPI了， 比如Surf
国产化改造：Oracle数据完整迁移到DM数据库操作手记
2.2 迁移方案设计基于 Oracle 到 DM 数据库迁移的对象列表，确定使用 DTS 工具进行基础数据迁移，通过手工方式移植 PL/SQL 代码，对移植结果进行校验，进行应用系统的移植、测试和优化。 3 移植过程中需要注意的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值