windows设置虚拟显示器为主屏，关闭其他显示器

于 2025-06-19 15:37:43 发布
阅读量206 收藏
点赞数 2
CC 4.0 BY-SA版权
文章标签： windows 计算机外设
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43284805/article/details/148768082

枚举当前所有显示器，可以选择任意虚拟显示器为主屏，并关闭其他显示器，用于隐私防护功能，实现demo，按需调整

可直接运行查看效果，按提示执行

display_utils.h

#pragma once

#include <windows.h>
#include <vector>
#include <string>

// 保存显示设备的状态信息
struct DisplayState {
    std::wstring deviceName; // 设备名（如 \\.\DISPLAY1）
    int sysIdx; // 系统分配的编号（用于唯一标识）
    std::vector<DISPLAYCONFIG_PATH_INFO> paths; // 显示路径信息
    std::vector<DISPLAYCONFIG_MODE_INFO> modes; // 显示模式信息
};

// 保存单个显示器的信息
struct MonitorInfo {
    MONITORINFOEXW mi; // 包含显示器的详细信息（如设备名、区域等）
};

// 显示器分组结果
struct MonitorGroupResult {
    std::vector<MonitorInfo> monitors; // 所有枚举到的显示器信息
    std::vector<int> monitorSysIds; // 每个显示器对应的系统编号（与DisplayState::sysIdx对应）
    std::vector<int> monitorToDisplayStateIdx; // monitors中每个显示器对应的DisplayState索引
    // 说明：monitors、monitorSysIds、monitorToDisplayStateIdx 三者应一一对应，理想情况下size一致
    // 但在实际枚举和分组过程中，可能由于某些显示器未能正确获取编号、或DisplayState未能完全匹配，导致size不一致
    // 例如：有的物理显示器被系统识别但未分配sysIdx，或虚拟显示器被枚举但未能建立完整映射
    // 这会导致 monitors.size() != monitorSysIds.size()，从而出现越界风险
};

// 判断设备字符串是否为虚拟显示器
bool is_virtual_display(const std::wstring& deviceString);

// 全局恢复函数
void restore_displays(const std::vector<DISPLAYCONFIG_PATH_INFO>& paths, const std::vector<DISPLAYCONFIG_MODE_INFO>& modes);

// 全局快照获取函数
bool get_current_display_config(std::vector<DISPLAYCONFIG_PATH_INFO>& paths, std::vector<DISPLAYCONFIG_MODE_INFO>& modes);

// 备份并枚举所有显示器，输出显示状态和分组结果
void enum_monitors(std::vector<DisplayState>& displayStates, MonitorGroupResult& group);

// 根据显示状态重新分组所有显示器
MonitorGroupResult enum_and_group_monitors(const std::vector<DisplayState>& displayStates);

// 设置指定设备名为主显示器
int set_primary_display(const std::wstring& deviceName);

// 禁用除主显示器外的所有显示器
void disable_other_displays(const std::vector<MonitorInfo>& monitors, const std::vector<int>& monitorToDisplayStateIdx, const std::vector<DisplayState>& displayStates, int primaryIdx);

// 展示当前所有显示器详细信息
void print_monitor_list(const MonitorGroupResult& group, std::vector<bool>& isVirtualList);

display_utils.cpp

#include "display_utils.h"
#include <algorithm>
#include <initguid.h>
#include <devguid.h>
#include <setupapi.h>
#include <strsafe.h>
#include <iostream>

bool is_virtual_display(const std::wstring& deviceString) {
    // 常见虚拟显示器关键字
    static const wchar_t* keywords[] = { L"SuiwenDispDriver", L"Virtual", L"Splashtop", L"VNC", L"Dummy", L"Mirage", L"SpaceDesk", L"USB", L"Remote" };
    for (auto& kw : keywords) {
        if (deviceString.find(kw) != std::wstring::npos) return true;
    }
    return false;
}

// 获取所有显示路径和模式
bool get_current_display_config(std::vector<DISPLAYCONFIG_PATH_INFO>& paths, std::vector<DISPLAYCONFIG_MODE_INFO>& modes) {
    paths.clear();
    modes.clear();
    UINT32 numPath = 0, numMode = 0;
    LONG ret = GetDisplayConfigBufferSizes(QDC_ALL_PATHS, &numPath, &numMode);
    if (ret != ERROR_SUCCESS) return false;
    paths.resize(numPath);
    modes.resize(numMode);
    ret = QueryDisplayConfig(QDC_ALL_PATHS, &numPath, paths.data(), &numMode, modes.data(), NULL);
    if (ret != ERROR_SUCCESS) return false;
    paths.resize(numPath);
    modes.resize(numMode);
    return true;
}

// 恢复所有显示设置（全局快照）
void restore_displays(const std::vector<DISPLAYCONFIG_PATH_INFO>& paths, const std::vector<DISPLAYCONFIG_MODE_INFO>& modes) {
    if (paths.empty() || modes.empty()) return;
    SetDisplayConfig(
        (UINT32)paths.size(), const_cast<DISPLAYCONFIG_PATH_INFO*>(paths.data()),
        (UINT32)modes.size(), const_cast<DISPLAYCONFIG_MODE_INFO*>(modes.data()),
        SDC_APPLY | SDC_USE_SUPPLIED_DISPLAY_CONFIG | SDC_SAVE_TO_DATABASE
    );
}

// 枚举所有显示器，备份当前配置
void enum_monitors(std::vector<DisplayState>& displayStates, MonitorGroupResult& group) {
    group.monitors.clear();
    group.monitorSysIds.clear();
    group.monitorToDisplayStateIdx.clear();

    struct MonitorWithPos {
        MonitorInfo info;
        std::wstring deviceName;
        std::wstring deviceString;
        int origSysIdx;
        POINT pos;
        int dsIdx;
        bool isVirtual;
    };

    std::vector<MonitorWithPos> physicalMonitors;
    std::vector<MonitorWithPos> virtualMonitors;

    int devIdx = 0;
    DISPLAY_DEVICEW dd;
    dd.cb = sizeof(dd);

    while (EnumDisplayDevicesW(NULL, devIdx, &dd, 0)) {
        if (!(dd.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP)) {
            devIdx++;
            continue;
        }

        std::wstring deviceName(dd.DeviceName);
        std::wstring deviceString(dd.DeviceString);

        // 获取显示器的桌面坐标
        DEVMODEW dm;
        ZeroMemory(&dm, sizeof(dm));
        dm.dmSize = sizeof(dm);
        if (!EnumDisplaySettingsW(deviceName.c_str(), ENUM_CURRENT_SETTINGS, &dm)) {
            devIdx++;
            continue;
        }

        // 查找对应的物理显示器（MONITORINFOEXW）
        MONITORINFOEXW mi = {};
        mi.cbSize = sizeof(mi);
        auto enumProc = [](HMONITOR hMon, HDC, LPRECT, LPARAM lParam) -> BOOL {
            auto* param = reinterpret_cast<std::pair<std::wstring, MONITORINFOEXW*>*>(lParam);
            MONITORINFOEXW miTemp = {};
            miTemp.cbSize = sizeof(miTemp);
            if (GetMonitorInfoW(hMon, &miTemp)) {
                if (param->first == miTemp.szDevice) {
                    *(param->second) = miTemp;
                    return FALSE;
                }
            }
            return TRUE;
            };
        std::pair<std::wstring, MONITORINFOEXW*> param(deviceName, &mi);
        EnumDisplayMonitors(NULL, NULL, enumProc, reinterpret_cast<LPARAM>(&param));
        if (wcslen(mi.szDevice) == 0) {
            devIdx++;
            continue;
        }

        // 查找 DisplayState
        int dsIdx = -1;
        for (size_t j = 0; j < displayStates.size(); ++j) {
            if (displayStates[j].deviceName == deviceName) {
                dsIdx = (int)j;
                break;
            }
        }

        // 解析原始编号
        int origSysIdx = -1;
        size_t pos = deviceName.find(L"DISPLAY");
        if (pos != std::wstring::npos) {
            origSysIdx = _wtoi(deviceName.c_str() + pos + 7);
        }

        MonitorWithPos m;
        m.info.mi = mi;
        m.deviceName = deviceName;
        m.deviceString = deviceString;
        m.origSysIdx = origSysIdx;
        m.pos.x = dm.dmPosition.x;
        m.pos.y = dm.dmPosition.y;
        m.dsIdx = dsIdx;
        m.isVirtual = is_virtual_display(deviceString);

        if (m.isVirtual)
            virtualMonitors.push_back(m);
        else
            physicalMonitors.push_back(m);

        devIdx++;
    }

    // 排序物理屏
    std::sort(physicalMonitors.begin(), physicalMonitors.end(), [](const MonitorWithPos& a, const MonitorWithPos& b) {
        if (a.pos.y != b.pos.y)
            return a.pos.y < b.pos.y;
        return a.pos.x < b.pos.x;
        });

    // 排序虚拟屏
    std::sort(virtualMonitors.begin(), virtualMonitors.end(), [](const MonitorWithPos& a, const MonitorWithPos& b) {
        if (a.pos.y != b.pos.y)
            return a.pos.y < b.pos.y;
        return a.pos.x < b.pos.x;
        });

    int logicIdx = 1;
    for (const auto& m : physicalMonitors) {
        group.monitors.push_back(m.info);
        group.monitorSysIds.push_back(logicIdx++);
        group.monitorToDisplayStateIdx.push_back(m.dsIdx);
    }
    for (const auto& m : virtualMonitors) {
        group.monitors.push_back(m.info);
        group.monitorSysIds.push_back(logicIdx++);
        group.monitorToDisplayStateIdx.push_back(m.dsIdx);
    }
}


// 分组（此处直接返回已有分组）
MonitorGroupResult enum_and_group_monitors(const std::vector<DisplayState>& displayStates) {
    MonitorGroupResult group;
    for (size_t i = 0; i < displayStates.size(); ++i) {
        MonitorInfo mi;
        wcsncpy_s(mi.mi.szDevice, displayStates[i].deviceName.c_str(), CCHDEVICENAME);
        group.monitors.push_back(mi);
        group.monitorSysIds.push_back(displayStates[i].sysIdx);
        group.monitorToDisplayStateIdx.push_back((int)i);
    }
    return group;
}

// 设置主屏
int set_primary_display(const std::wstring& deviceName) {
    std::vector<DISPLAYCONFIG_PATH_INFO> paths;
    std::vector<DISPLAYCONFIG_MODE_INFO> modes;
    if (!get_current_display_config(paths, modes)) return -1;

    // 找到所有活动源
    struct ScreenInfo {
        DISPLAYCONFIG_PATH_INFO* path;
        DISPLAYCONFIG_MODE_INFO* mode;
        std::wstring deviceName;
        int width;
        int height;
        bool isPrimary;
    };
    std::vector<ScreenInfo> screens;

    for (auto& path : paths) {
        if (!(path.flags & DISPLAYCONFIG_PATH_ACTIVE)) continue;

        DISPLAYCONFIG_SOURCE_DEVICE_NAME srcName = {};
        srcName.header.type = DISPLAYCONFIG_DEVICE_INFO_GET_SOURCE_NAME;
        srcName.header.size = sizeof(srcName);
        srcName.header.adapterId = path.sourceInfo.adapterId;
        srcName.header.id = path.sourceInfo.id;
        if (DisplayConfigGetDeviceInfo(&srcName.header) != ERROR_SUCCESS) continue;

        // 找到对应的 mode
        DISPLAYCONFIG_MODE_INFO* mode = nullptr;
        for (auto& m : modes) {
            if (m.infoType == DISPLAYCONFIG_MODE_INFO_TYPE_SOURCE &&
                m.adapterId.HighPart == path.sourceInfo.adapterId.HighPart &&
                m.adapterId.LowPart == path.sourceInfo.adapterId.LowPart &&
                m.id == path.sourceInfo.id) {
                mode = &m;
                break;
            }
        }
        if (!mode) continue;

        int width = mode->sourceMode.width;
        int height = mode->sourceMode.height;
        bool isPrimary = (deviceName == srcName.viewGdiDeviceName);

        screens.push_back({ &path, mode, srcName.viewGdiDeviceName, width, height, isPrimary });
    }

    if (screens.empty()) return -1;

    // 主屏放在(0,0)，其他屏幕依次横向排列
    int x = 0;
    int y = 0;
    // 先主屏
    for (auto& s : screens) {
        if (s.isPrimary) {
            s.mode->sourceMode.position.x = 0;
            s.mode->sourceMode.position.y = 0;
            x = s.width;
            y = 0;
            break;
        }
    }
    // 再其他屏
    for (auto& s : screens) {
        if (!s.isPrimary) {
            s.mode->sourceMode.position.x = x;
            s.mode->sourceMode.position.y = y;
            x += s.width;
        }
    }

    // 应用配置
    LONG ret = SetDisplayConfig(
        (UINT32)paths.size(), paths.data(),
        (UINT32)modes.size(), modes.data(),
        SDC_APPLY | SDC_USE_SUPPLIED_DISPLAY_CONFIG | SDC_SAVE_TO_DATABASE
    );
    printf("SetDisplayConfig return: %ld\n", ret);
    return (ret == ERROR_SUCCESS) ? 0 : -1;
}

// 禁用除主屏外的所有显示器
void disable_other_displays(const std::vector<MonitorInfo>& monitors, const std::vector<int>& monitorToDisplayStateIdx, const std::vector<DisplayState>& displayStates, int primaryIdx) {
    std::vector<DISPLAYCONFIG_PATH_INFO> paths;
    std::vector<DISPLAYCONFIG_MODE_INFO> modes;
    if (!get_current_display_config(paths, modes)) return;

    std::wstring primaryName = monitors[primaryIdx].mi.szDevice;

    // 找到主屏的 adapterId/sourceId
    LUID primaryAdapterId = {};
    UINT32 primarySourceId = 0;
    bool foundPrimary = false;
    for (auto& path : paths) {
        DISPLAYCONFIG_SOURCE_DEVICE_NAME srcName = {};
        srcName.header.type = DISPLAYCONFIG_DEVICE_INFO_GET_SOURCE_NAME;
        srcName.header.size = sizeof(srcName);
        srcName.header.adapterId = path.sourceInfo.adapterId;
        srcName.header.id = path.sourceInfo.id;
        if (DisplayConfigGetDeviceInfo(&srcName.header) != ERROR_SUCCESS) continue;
        if (primaryName == srcName.viewGdiDeviceName) {
            primaryAdapterId = path.sourceInfo.adapterId;
            primarySourceId = path.sourceInfo.id;
            foundPrimary = true;
            break;
        }
    }
    if (!foundPrimary) return;

    // 只保留主屏路径，禁用其他路径
    for (auto& path : paths) {
        DISPLAYCONFIG_SOURCE_DEVICE_NAME srcName = {};
        srcName.header.type = DISPLAYCONFIG_DEVICE_INFO_GET_SOURCE_NAME;
        srcName.header.size = sizeof(srcName);
        srcName.header.adapterId = path.sourceInfo.adapterId;
        srcName.header.id = path.sourceInfo.id;
        if (DisplayConfigGetDeviceInfo(&srcName.header) != ERROR_SUCCESS) continue;

        if (primaryName == srcName.viewGdiDeviceName) {
            path.flags |= DISPLAYCONFIG_PATH_ACTIVE;
        }
        else {
            path.flags &= ~DISPLAYCONFIG_PATH_ACTIVE;
        }
    }

    // 设置主屏坐标为(0,0)
    for (auto& mode : modes) {
        if (mode.infoType == DISPLAYCONFIG_MODE_INFO_TYPE_SOURCE &&
            mode.adapterId.HighPart == primaryAdapterId.HighPart &&
            mode.adapterId.LowPart == primaryAdapterId.LowPart &&
            mode.id == primarySourceId) {
            mode.sourceMode.position.x = 0;
            mode.sourceMode.position.y = 0;
        }
    }

    // 应用配置
    LONG ret = SetDisplayConfig(
        (UINT32)paths.size(), paths.data(),
        (UINT32)modes.size(), modes.data(),
        SDC_APPLY | SDC_USE_SUPPLIED_DISPLAY_CONFIG | SDC_SAVE_TO_DATABASE
    );
    printf("disable_other_displays SetDisplayConfig return: %ld\n", ret);
}


// 展示当前所有显示器详细信息
void print_monitor_list(const MonitorGroupResult& group, std::vector<bool>& isVirtualList) {
    isVirtualList.clear();
    printf("可用显示器列表：\n");
    for (size_t idx = 0; idx < group.monitors.size(); ++idx) {
        int sysIdx = group.monitorSysIds[idx];
        LPCWSTR deviceName = group.monitors[idx].mi.szDevice;
        LPCWSTR deviceString = L"未知";
        bool isVirtual = false;

        // 检查deviceName有效性
        if (deviceName == nullptr || wcslen(deviceName) == 0) {
            printf("  %d: [无效设备名] 跳过\n", sysIdx);
            isVirtualList.push_back(false);
            continue;
        }

        // 获取设备友好名和虚拟标志
        DISPLAY_DEVICEW ddName;
        ZeroMemory(&ddName, sizeof(ddName));
        ddName.cb = sizeof(ddName);
        int devIdx2 = 0;
        bool found = false;
        while (EnumDisplayDevicesW(NULL, devIdx2, &ddName, 0)) {
            if (ddName.DeviceName[0] != L'\0' && deviceName[0] != L'\0' &&
                wcsncmp(ddName.DeviceName, deviceName, CCHDEVICENAME) == 0) {
                deviceString = ddName.DeviceString;
                std::wstring devStr(ddName.DeviceString);
                isVirtual = is_virtual_display(devStr);
                found = true;
                break;
            }
            devIdx2++;
        }
        if (!found) {
            isVirtual = false;
        }

        printf("  %d: %ws [%ws] 类型: %s 区域: (%ld,%ld)-(%ld,%ld)\n",
            sysIdx,
            deviceName ? deviceName : L"(null)",
            deviceString ? deviceString : L"(null)",
            isVirtual ? "虚拟" : "物理",
            group.monitors[idx].mi.rcMonitor.left, group.monitors[idx].mi.rcMonitor.top,
            group.monitors[idx].mi.rcMonitor.right, group.monitors[idx].mi.rcMonitor.bottom);
        isVirtualList.push_back(isVirtual);
    }
    printf("\n显示器数量: %zu\n", group.monitors.size());
}

main.cpp

#define _CRT_SECURE_NO_WARNINGS
#include <windows.h>
#include <stdio.h>
#include <vector>
#include <string>
#include "display_utils.h"

int main() {
    // 1. 启动时备份全局显示配置
    std::vector<DISPLAYCONFIG_PATH_INFO> backupPaths;
    std::vector<DISPLAYCONFIG_MODE_INFO> backupModes;
    get_current_display_config(backupPaths, backupModes);

    // 2. 枚举、分组、编号、索引
    std::vector<DisplayState> displayStates;
    MonitorGroupResult group;
    enum_monitors(displayStates, group);

    std::vector<bool> isVirtualList;
    print_monitor_list(group, isVirtualList);

    // 3. 选择虚拟显示器为主屏
    int selectedSysIdx = 0;
    int selectedMonitorIdx = -1;
    std::wstring selectedDeviceName;
    while (true) {
        printf("请输入要设置为主屏的虚拟显示器编号: ");
        if (scanf("%d", &selectedSysIdx) != 1) {
            printf("输入错误，请重新输入。\n");
            while (getchar() != '\n');
            continue;
        }
        selectedMonitorIdx = -1;
        for (size_t i = 0; i < group.monitors.size(); ++i) {
            if (group.monitorSysIds[i] == selectedSysIdx) {
                if (isVirtualList[i]) {
                    selectedMonitorIdx = (int)i;
                    selectedDeviceName = group.monitors[i].mi.szDevice;
                }
                else {
                    printf("所选显示器为物理显示器，不能设置为主屏，请重新选择虚拟显示器。\n");
                }
                break;
            }
        }
        bool found = false;
        for (size_t i = 0; i < group.monitorSysIds.size(); ++i) {
            if (group.monitorSysIds[i] == selectedSysIdx) {
                found = true;
                break;
            }
        }
        if (selectedMonitorIdx == -1) {
            if (!found) {
                printf("编号 %d 不存在，请重新输入。\n", selectedSysIdx);
            }
            continue;
        }
        break;
    }

    // 4. 再次检测显示设备状态是否有变化（如有物理屏断开/新接入）
    std::vector<DisplayState> latestDisplayStates;
    MonitorGroupResult latestGroup;
    enum_monitors(latestDisplayStates, latestGroup);

    printf("\n当前显示器数量: %zu\n", latestGroup.monitors.size());

    // 检查所选DeviceName是否还存在
    int newSelectedMonitorIdx = -1;
    for (size_t i = 0; i < latestGroup.monitors.size(); ++i) {
        if (wcscmp(latestGroup.monitors[i].mi.szDevice, selectedDeviceName.c_str()) == 0) {
            newSelectedMonitorIdx = (int)i;
            break;
        }
    }

    // 5. 如果断开，重新展示并循环选择
    while (newSelectedMonitorIdx == -1) {
        printf("您选择的编号%d对应的屏幕（%ls）已断开或不存在。\n", selectedSysIdx, selectedDeviceName.c_str());
        printf("请重新选择主屏：\n");
        isVirtualList.clear();
        print_monitor_list(latestGroup, isVirtualList);

        // 重新选择
        selectedSysIdx = 0;
        selectedMonitorIdx = -1;
        selectedDeviceName.clear();
        while (true) {
            printf("请输入要设置为主屏的虚拟显示器编号: ");
            if (scanf("%d", &selectedSysIdx) != 1) {
                printf("输入错误，请重新输入。\n");
                while (getchar() != '\n');
                continue;
            }
            selectedMonitorIdx = -1;
            for (size_t i = 0; i < latestGroup.monitors.size(); ++i) {
                if (latestGroup.monitorSysIds[i] == selectedSysIdx) {
                    if (isVirtualList[i]) {
                        selectedMonitorIdx = (int)i;
                        selectedDeviceName = latestGroup.monitors[i].mi.szDevice;
                    }
                    else {
                        printf("所选显示器为物理显示器，不能设置为主屏，请重新选择虚拟显示器。\n");
                    }
                    break;
                }
            }
            bool found = false;
            for (size_t i = 0; i < latestGroup.monitorSysIds.size(); ++i) {
                if (latestGroup.monitorSysIds[i] == selectedSysIdx) {
                    found = true;
                    break;
                }
            }
            if (selectedMonitorIdx == -1) {
                if (!found) {
                    printf("编号 %d 不存在，请重新输入。\n", selectedSysIdx);
                }
                continue;
            }
            break;
        }
        // 检查新选择的DeviceName是否还存在
        newSelectedMonitorIdx = -1;
        for (size_t i = 0; i < latestGroup.monitors.size(); ++i) {
            if (wcscmp(latestGroup.monitors[i].mi.szDevice, selectedDeviceName.c_str()) == 0) {
                newSelectedMonitorIdx = (int)i;
                break;
            }
        }
    }
    bool changed = false;
    if (latestGroup.monitors.size() != group.monitors.size()) {
        changed = true;
        printf("屏幕数量有变化。\n");
        get_current_display_config(backupPaths, backupModes);
    }

    // 6. 更新group和selectedMonitorIdx
    group = latestGroup;
    selectedMonitorIdx = newSelectedMonitorIdx;
    displayStates = std::move(latestDisplayStates);

    // 7. 设置虚拟显示器为主屏
    int result = set_primary_display(group.monitors[selectedMonitorIdx].mi.szDevice);
    if (result == 0) {
        printf("已将虚拟显示器 %ls 设置为主屏。\n", group.monitors[selectedMonitorIdx].mi.szDevice);
    }
    else {
        printf("设置主屏失败。err:%d\n", GetLastError());
        return -1;
    }

    // 8. 关闭除主屏外的所有显示器
    disable_other_displays(group.monitors, group.monitorToDisplayStateIdx, displayStates, selectedMonitorIdx);

    printf("\n按回车键恢复原有显示设置并退出...");
    getchar(); getchar();

    // 9. 恢复所有显示设备的原始设置（全局快照）
    restore_displays(backupPaths, backupModes);

    printf("已恢复所有显示设置。\n");
    return 0;
}

Czx.¹²³
关注
显示器无信号的原因和解决办法汇总
IhgIot的博客
09-17 1776
综上所述，当显示器无信号时，我们应首先检查硬件连接，确保电缆和设备都连接正确。通过识别和解决这些问题，我们可以恢复显示器的正常工作，并确保正常显示计算机图像。电缆连接问题：检查显示器和计算机之间的连接电缆，确保它们插入正确且牢固。在Windows操作系统中，右键点击桌面空白处，选择“显示设置”或“屏幕分辨率”，尝试调整显示器设置并保存更改。分辨率设置问题：计算机的分辨率设置可能与显示器不兼容，导致无信号。显卡问题：如果您使用的是独立显卡，确保它已正确安装在计算机主板上，并连接好所需的电源线。
windows7/windows10 虚拟显示器部署(Virtual monitor)
MagicFMan的博客
11-20 3806
win7和win10及以上虚拟显示器
[Windows] 一款简单小巧多屏幕的虚拟桌面
01-13
分享一款虚拟桌面的软件，非常好用，最多可以把创建4个虚拟桌面来分开操作，比如这个桌面用来挂cf，另一个就用来LOL挂机，在开一个桌面用来看小电影-.-什么的，可以自由切换等等，这里无作为会附上侧视图！ 谨记喔 软件会（最多）开启4个桌面，文件都是共享的，但是桌面是程序虚拟出来的。比如你在开两个桌面，分别是桌面一、桌面二，它们的图标和桌面上面的文件是共享的。但是你在桌面一登录QQ等应用软件，你切换桌面二是没有的。
Windows虚拟桌面及其管理技巧
最新发布
weixin_30481539的博客
04-27 978
随着信息技术的快速发展，Windows虚拟桌面功能成为提高工作效率和多任务处理能力的强大工具。本章节将为您简要介绍Windows虚拟桌面的基本概念和应用场景，为您揭开虚拟桌面的神秘面纱。虚拟桌面是Windows操作系统中的一个功能，允许用户在同一个物理屏幕上创建多个独立的工作区域。每个虚拟桌面就像一个全新的桌面，拥有自己的任务栏和桌面图标，用户可以在不同的虚拟桌面之间切换以适应不同的工作需求。
Windows虚拟屏幕
weixin_40997505的博客
05-17 977
有时候身边没有物理扩展屏幕，不过又希望能够进行PPT演示的相关操作，所以有这个虚拟屏幕的需求。通过以下命令可以实现设备的安装、使用与释放。
windows虚拟显示器开发（一）
MagicFMan的博客
07-11 8481
这里写自定义目录标题虚拟显示器概述虚拟显示器原理方案 虚拟显示器概述 最近因工作需要，需要在物理显卡上虚拟出一个显示器，我是用的操作系统是win7，查询了下官方文档和网络资源， 没有现成的框架，所以需要自己研究如何一步步实现。 虚拟显示器用途挺多的，我们其实在一些场景中有用到过，比如displaylink，我们网上买的一些USB转HDMI的连接线，在使用过程中我们需要安装displaylink的驱...
绝对好用的Windows虚拟显示器软件下载 | 最新win10虚拟显示器软件和win11虚拟显示器软件
04-03
这里有一款非常实用的Windows虚拟显示器软件，单个物理显示器最多可拓展分成16个独立的Windows虚拟显示器，虚拟显示器的大小可以按用户需求均匀或单独缩放，即支持均匀分布的布局和不对称配置。
关于Windows11的高效办公应用（45）：多显示器扩展设置对远程协作的帮助。
在阿尔法狗用361维向量重构围棋宇宙时，人们惊觉这团硅基智慧正以人类难以企及的速度逼近某种终极规律。
04-12 839
能大幅优化远程协作流程。建议根据团队协作需求动态调整布局（如会议期间切换至复制模式，开发时启用扩展模式），并定期通过。指定不同显示器显示独立的任务栏应用（如主屏固定办公软件，副屏固定沟通工具）。：统一或差异化调整（如主屏 100%、副屏 125% 避免文字过小）。将含机密数据的应用（如财务系统）固定至主屏，避免共享时误投副屏。：将干扰性应用（如邮件、社交媒体）移至副屏，主屏专注核心任务。：同时展示会议窗口、文档、数据分析工具等，减少频繁切换。：扩展屏接入其他设备（如平板、笔记本）实现跨设备协作。
关于Windows11的高效办公应用（73）：外接显示器的高效分屏布局方案。
在阿尔法狗用361维向量重构围棋宇宙时，人们惊觉这团硅基智慧正以人类难以企及的速度逼近某种终极规律。
04-18 1049
空间效率倍增：利用 Snap Layouts + FancyZones 打造黄金工作区任务专注度提升：物理隔离不同工作流（开发/沟通/资料）健康办公保障：符合人体工学的屏幕角度与护眼设置高效实践路线阶段1：掌握原生分屏 + 快捷键（1小时）阶段2：配置 FancyZones 自定义网格（30分钟）阶段3：部署 AutoHotkey/DisplayFusion 自动化（按需进阶）最终实现多屏协同如臂使指，让每一像素都为生产力服务！
DisplayFusion显示器使用好助手
dgnankai的专栏
08-06 7002
i. 多显示器管理ii. 单显示器分割iii. 壁纸管理iv. 任务栏管理v. ……
Windows强大的虚拟桌面工具 可以变成双屏
05-24
Windows强大的虚拟桌面工具 可以变成双屏 可以变换两个桌面，比如一个桌面打开软件，网页之后，觉得不够用，再点击右下角的另外一个框，新的桌面又出来了~
虚拟显示器无需硬件完全免费
02-14
通过国外一个软件的驱动实现 安装虚拟驱动需要时间比较久 解压 以管理员身份运行“VirtualMonitor_cn.bat” 输入1增加一个显示器 如果电脑硬件不行输入7 去注册表开启个 1280,720这类的分辨率1024以下的分辨率无法执行 DisplayAgentSetup要钱 硬件的欺骗器也要钱 这个是通过USbmmidd2.0驱动改的 网课不需要再买个显示器了
Windows最强大的虚拟桌面工具 dexpot 绿色版 多窗口轻松快速切换
09-11
Windows最强大的虚拟桌面工具 dexpot 绿色版 多窗口轻松快速切换
多显示器没有拓展这些显示器
01-14
### 如何设置多显示器以实现屏幕扩展 在Windows 11操作系统中，为了充分利用双屏显示带来的优势，用户需要正确配置主副屏并启用扩展模式。以下是具体的方法： #### 进入显示设置界面 按下`Windows键 + P`组合键，...
配置虚拟显示屏
Sky_of_love_的博客
02-10 160
配置虚拟显示屏。
虚拟机添加显示屏
ylxwk的博客
01-04 4617
虚拟机 linux ubuntu 扩展显示屏 、 多显示器 、 多显示屏 ubuntu多屏显示图片
Windows 10驱动开发入门（五）：创建虚拟显示器 Indirect Display驱动开发
热门推荐
haleycat的博客
06-30 1万+
在开发或者办公中，越大的屏幕看起来就显示越舒服了，通常我们的做法是有两块屏幕，这样显示的内容就变多了，可以很容易提高办公的效率。
【免费下载】 Windows 7/10 虚拟显示器部署指南
gitblog_06588的博客
10-31 618
Windows 7/10 虚拟显示器部署指南 【下载地址】Windows710虚拟显示器部署指南分享03c58 Windows 7/10 虚拟显示器部署指南本资源文件提供了一个详细的指南，帮助用户在Windows 7和Windows 10操作系统上部署虚拟显示器 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值