Recent

« previous next »
Pages: 1 [2]

Author Topic: GetMonitorsInfo - please help update the database  (Read 1921 times)

KodeZwerg

  • Hero Member
  • *****
  • Posts: 2050
  • Fifty shades of code.
    • Delphi & FreePascal
Re: GetMonitorsInfo - please help update the database
« Reply #15 on: December 20, 2022, 10:04:24 am »
Maybe it is useful to this project, here is another windows way of how to gather information:
Code: Pascal  [Select][+][-]
  1. type
  2.   TDEVMODES = array of TDEVMODEW;
  3.   TCurrentMonitor = packed record
  4.     DRIVERVERSION,
  5.     TECHNOLOGY,
  6.     DT_PLOTTER,
  7.     DT_RASDISPLAY,
  8.     DT_RASPRINTER,
  9.     DT_RASCAMERA,
  10.     DT_CHARSTREAM,
  11.     DT_METAFILE,
  12.     DT_DISPFILE,
  13.     HORZSIZE,
  14.     VERTSIZE,
  15.     HORZRES,
  16.     VERTRES,
  17.     LOGPIXELSX,
  18.     LOGPIXELSY,
  19.     BITSPIXEL,
  20.     PLANES,
  21.     NUMBRUSHES,
  22.     NUMPENS,
  23.     NUMFONTS,
  24.     NUMCOLORS,
  25.     ASPECTX,
  26.     ASPECTY,
  27.     ASPECTXY,
  28.     PDEVICESIZE,
  29.     CLIPCAPS,
  30.     SIZEPALETTE,
  31.     NUMRESERVED,
  32.     COLORRES,
  33.     VREFRESH,
  34.     DESKTOPHORZRES,
  35.     DESKTOPVERTRES,
  36.     BLTALIGNMENT,
  37.     RASTERCAPS,
  38.     RC_BANDING,
  39.     RC_BITBLT,
  40.     RC_BITMAP64,
  41.     RC_DI_BITMAP,
  42.     RC_DIBTODEV,
  43.     RC_FLOODFILL,
  44.     RC_GDI20_OUTPUT,
  45.     RC_PALETTE,
  46.     RC_SCALING,
  47.     RC_STRETCHBLT,
  48.     RC_STRETCHDIB,
  49.     CURVECAPS,
  50.     CC_NONE,
  51.     CC_CIRCLES,
  52.     CC_PIE,
  53.     CC_CHORD,
  54.     CC_ELLIPSES,
  55.     CC_WIDE,
  56.     CC_STYLED,
  57.     CC_WIDESTYLED,
  58.     CC_INTERIORS,
  59.     CC_ROUNDRECT,
  60.     LINECAPS,
  61.     LC_NONE,
  62.     LC_POLYLINE,
  63.     LC_MARKER,
  64.     LC_POLYMARKER,
  65.     LC_WIDE,
  66.     LC_STYLED,
  67.     LC_WIDESTYLED,
  68.     LC_INTERIORS,
  69.     POLYGONALCAPS,
  70.     PC_NONE,
  71.     PC_POLYGON,
  72.     PC_RECTANGLE,
  73.     PC_WINDPOLYGON,
  74.     PC_SCANLINE,
  75.     PC_WIDE,
  76.     PC_STYLED,
  77.     PC_WIDESTYLED,
  78.     PC_INTERIORS,
  79.     TEXTCAPS,
  80.     TC_OP_CHARACTER,
  81.     TC_OP_STROKE,
  82.     TC_CP_STROKE,
  83.     TC_CR_90,
  84.     TC_CR_ANY,
  85.     TC_SF_X_YINDEP,
  86.     TC_SA_DOUBLE,
  87.     TC_SA_INTEGER,
  88.     TC_SA_CONTIN,
  89.     TC_EA_DOUBLE,
  90.     TC_IA_ABLE,
  91.     TC_UA_ABLE,
  92.     TC_SO_ABLE,
  93.     TC_RA_ABLE,
  94.     TC_VA_ABLE,
  95.     TC_RESERVED,
  96.     TC_SCROLLBLT,
  97.     PC_PATHS: LongInt;
  98.   end;
Code: Pascal  [Select][+][-]
  1. function GetMonitorInfo(var DevModes: TDEVMODES; var CurMon: TCurrentMonitor): Boolean;
  2. var
  3.   DC: THandle;
  4.   ModeNum: DWORD;
  5.   DM: TDEVMODEW;
  6. begin
  7.   Result := False;
  8.   DC := GetDC(Handle);
  9.   if ((DC <> 0) and (DC <> INVALID_HANDLE_VALUE)) then
  10.     begin
  11.       CurMon.DRIVERVERSION := GetDeviceCaps(DC, DRIVERVERSION);
  12.       CurMon.TECHNOLOGY := GetDeviceCaps(DC, TECHNOLOGY);
  13.       CurMon.DT_PLOTTER := GetDeviceCaps(DC, DT_PLOTTER);
  14.       CurMon.DT_RASDISPLAY := GetDeviceCaps(DC, DT_RASDISPLAY);
  15.       CurMon.DT_RASPRINTER := GetDeviceCaps(DC, DT_RASPRINTER);
  16.       CurMon.DT_RASCAMERA := GetDeviceCaps(DC, DT_RASCAMERA);
  17.       CurMon.DT_CHARSTREAM := GetDeviceCaps(DC, DT_CHARSTREAM);
  18.       CurMon.DT_METAFILE := GetDeviceCaps(DC, DT_METAFILE);
  19.       CurMon.DT_DISPFILE := GetDeviceCaps(DC, DT_DISPFILE);
  20.       CurMon.HORZSIZE := GetDeviceCaps(DC, HORZSIZE);
  21.       CurMon.VERTSIZE := GetDeviceCaps(DC, VERTSIZE);
  22.       CurMon.HORZRES := GetDeviceCaps(DC, HORZRES);
  23.       CurMon.VERTRES := GetDeviceCaps(DC, VERTRES);
  24.       CurMon.LOGPIXELSX := GetDeviceCaps(DC, LOGPIXELSX);
  25.       CurMon.LOGPIXELSY := GetDeviceCaps(DC, LOGPIXELSY);
  26.       CurMon.BITSPIXEL := GetDeviceCaps(DC, BITSPIXEL);
  27.       CurMon.PLANES := GetDeviceCaps(DC, PLANES);
  28.       CurMon.NUMBRUSHES := GetDeviceCaps(DC, NUMBRUSHES);
  29.       CurMon.NUMPENS := GetDeviceCaps(DC, NUMPENS);
  30.       CurMon.NUMFONTS := GetDeviceCaps(DC, NUMFONTS);
  31.       CurMon.NUMCOLORS := GetDeviceCaps(DC, NUMCOLORS);
  32.       CurMon.ASPECTX := GetDeviceCaps(DC, ASPECTX);
  33.       CurMon.ASPECTY := GetDeviceCaps(DC, ASPECTY);
  34.       CurMon.ASPECTXY := GetDeviceCaps(DC, ASPECTXY);
  35.       CurMon.PDEVICESIZE := GetDeviceCaps(DC, PDEVICESIZE);
  36.       CurMon.CLIPCAPS := GetDeviceCaps(DC, CLIPCAPS);
  37.       CurMon.SIZEPALETTE := GetDeviceCaps(DC, SIZEPALETTE);
  38.       CurMon.NUMRESERVED := GetDeviceCaps(DC, NUMRESERVED);
  39.       CurMon.COLORRES := GetDeviceCaps(DC, COLORRES);
  40.       CurMon.VREFRESH := GetDeviceCaps(DC, VREFRESH);
  41.       CurMon.DESKTOPHORZRES := GetDeviceCaps(DC, DESKTOPHORZRES);
  42.       CurMon.DESKTOPVERTRES := GetDeviceCaps(DC, DESKTOPVERTRES);
  43.       CurMon.BLTALIGNMENT := GetDeviceCaps(DC, BLTALIGNMENT);
  44.       CurMon.RASTERCAPS := GetDeviceCaps(DC, RASTERCAPS);
  45.       CurMon.RC_BANDING := GetDeviceCaps(DC, RC_BANDING);
  46.       CurMon.RC_BITBLT := GetDeviceCaps(DC, RC_BITBLT);
  47.       CurMon.RC_BITMAP64 := GetDeviceCaps(DC, RC_BITMAP64);
  48.       CurMon.RC_DI_BITMAP := GetDeviceCaps(DC, RC_DI_BITMAP);
  49.       CurMon.RC_DIBTODEV := GetDeviceCaps(DC, RC_DIBTODEV);
  50.       CurMon.RC_FLOODFILL := GetDeviceCaps(DC, RC_FLOODFILL);
  51.       CurMon.RC_GDI20_OUTPUT := GetDeviceCaps(DC, RC_GDI20_OUTPUT);
  52.       CurMon.RC_PALETTE := GetDeviceCaps(DC, RC_PALETTE);
  53.       CurMon.RC_SCALING := GetDeviceCaps(DC, RC_SCALING);
  54.       CurMon.RC_STRETCHBLT := GetDeviceCaps(DC, RC_STRETCHBLT);
  55.       CurMon.RC_STRETCHDIB := GetDeviceCaps(DC, RC_STRETCHDIB);
  56.       CurMon.CURVECAPS := GetDeviceCaps(DC, CURVECAPS);
  57.       CurMon.CC_NONE := GetDeviceCaps(DC, CC_NONE);
  58.       CurMon.CC_CIRCLES := GetDeviceCaps(DC, CC_CIRCLES);
  59.       CurMon.CC_PIE := GetDeviceCaps(DC, CC_PIE);
  60.       CurMon.CC_CHORD := GetDeviceCaps(DC, CC_CHORD);
  61.       CurMon.CC_ELLIPSES := GetDeviceCaps(DC, CC_ELLIPSES);
  62.       CurMon.CC_WIDE := GetDeviceCaps(DC, CC_WIDE);
  63.       CurMon.CC_STYLED := GetDeviceCaps(DC, CC_STYLED);
  64.       CurMon.CC_WIDESTYLED := GetDeviceCaps(DC, CC_WIDESTYLED);
  65.       CurMon.CC_INTERIORS := GetDeviceCaps(DC, CC_INTERIORS);
  66.       CurMon.CC_ROUNDRECT := GetDeviceCaps(DC, CC_ROUNDRECT);
  67.       CurMon.LINECAPS := GetDeviceCaps(DC, LINECAPS);
  68.       CurMon.LC_NONE := GetDeviceCaps(DC, LC_NONE);
  69.       CurMon.LC_POLYLINE := GetDeviceCaps(DC, LC_POLYLINE);
  70.       CurMon.LC_MARKER := GetDeviceCaps(DC, LC_MARKER);
  71.       CurMon.LC_POLYMARKER := GetDeviceCaps(DC, LC_POLYMARKER);
  72.       CurMon.LC_WIDE := GetDeviceCaps(DC, LC_WIDE);
  73.       CurMon.LC_STYLED := GetDeviceCaps(DC, LC_STYLED);
  74.       CurMon.LC_WIDESTYLED := GetDeviceCaps(DC, LC_WIDESTYLED);
  75.       CurMon.LC_INTERIORS := GetDeviceCaps(DC, LC_INTERIORS);
  76.       CurMon.POLYGONALCAPS := GetDeviceCaps(DC, POLYGONALCAPS);
  77.       CurMon.PC_NONE := GetDeviceCaps(DC, PC_NONE);
  78.       CurMon.PC_POLYGON := GetDeviceCaps(DC, PC_POLYGON);
  79.       CurMon.PC_RECTANGLE := GetDeviceCaps(DC, PC_RECTANGLE);
  80.       CurMon.PC_WINDPOLYGON := GetDeviceCaps(DC, PC_WINDPOLYGON);
  81.       CurMon.PC_SCANLINE := GetDeviceCaps(DC, PC_SCANLINE);
  82.       CurMon.PC_WIDE := GetDeviceCaps(DC, PC_WIDE);
  83.       CurMon.PC_STYLED := GetDeviceCaps(DC, PC_STYLED);
  84.       CurMon.PC_WIDESTYLED := GetDeviceCaps(DC, PC_WIDESTYLED);
  85.       CurMon.PC_INTERIORS := GetDeviceCaps(DC, PC_INTERIORS);
  86.       CurMon.TEXTCAPS := GetDeviceCaps(DC, TEXTCAPS);
  87.       CurMon.TC_OP_CHARACTER := GetDeviceCaps(DC, TC_OP_CHARACTER);
  88.       CurMon.TC_OP_STROKE := GetDeviceCaps(DC, TC_OP_STROKE);
  89.       CurMon.TC_CP_STROKE := GetDeviceCaps(DC, TC_CP_STROKE);
  90.       CurMon.TC_CR_90 := GetDeviceCaps(DC, TC_CR_90);
  91.       CurMon.TC_CR_ANY := GetDeviceCaps(DC, TC_CR_ANY);
  92.       CurMon.TC_SF_X_YINDEP := GetDeviceCaps(DC, TC_SF_X_YINDEP);
  93.       CurMon.TC_SA_DOUBLE := GetDeviceCaps(DC, TC_SA_DOUBLE);
  94.       CurMon.TC_SA_INTEGER := GetDeviceCaps(DC, TC_SA_INTEGER);
  95.       CurMon.TC_SA_CONTIN := GetDeviceCaps(DC, TC_SA_CONTIN);
  96.       CurMon.TC_EA_DOUBLE := GetDeviceCaps(DC, TC_EA_DOUBLE);
  97.       CurMon.TC_IA_ABLE := GetDeviceCaps(DC, TC_IA_ABLE);
  98.       CurMon.TC_UA_ABLE := GetDeviceCaps(DC, TC_UA_ABLE);
  99.       CurMon.TC_SO_ABLE := GetDeviceCaps(DC, TC_SO_ABLE);
  100.       CurMon.TC_RA_ABLE := GetDeviceCaps(DC, TC_RA_ABLE);
  101.       CurMon.TC_VA_ABLE := GetDeviceCaps(DC, TC_VA_ABLE);
  102.       CurMon.TC_RESERVED := GetDeviceCaps(DC, TC_RESERVED);
  103.       CurMon.TC_SCROLLBLT := GetDeviceCaps(DC, TC_SCROLLBLT);
  104.       CurMon.PC_PATHS := GetDeviceCaps(DC, PC_PATHS);
  105.       ReleaseDC(Handle, DC);
  106.     end;
  107.   SetLength(DevModes, Pred(High(WORD)));
  108.   for ModeNum := 0 to Pred(High(WORD)) do
  109.     begin
  110.       if (not EnumDisplaySettingsW(nil, ModeNum, DM)) then
  111.         Break;
  112.       DevModes[ModeNum].dmBitsPerPel := DM.dmBitsPerPel;
  113.       DevModes[ModeNum].dmCollate := DM.dmCollate;
  114.       DevModes[ModeNum].dmColor := DM.dmColor;
  115.       DevModes[ModeNum].dmCopies := DM.dmCopies;
  116.       DevModes[ModeNum].dmDefaultSource := DM.dmDefaultSource;
  117.       DevModes[ModeNum].dmDeviceName := DM.dmDeviceName;
  118.       DevModes[ModeNum].dmDisplayFixedOutput := DM.dmDisplayFixedOutput;
  119.       DevModes[ModeNum].dmDisplayFlags := DM.dmDisplayFlags;
  120.       DevModes[ModeNum].dmDisplayFrequency := DM.dmDisplayFrequency;
  121.       DevModes[ModeNum].dmDisplayOrientation := DM.dmDisplayOrientation;
  122.       DevModes[ModeNum].dmDitherType := DM.dmDitherType;
  123.       DevModes[ModeNum].dmDriverExtra := DM.dmDriverExtra;
  124.       DevModes[ModeNum].dmDriverVersion := DM.dmDriverVersion;
  125.       DevModes[ModeNum].dmDuplex := DM.dmDuplex;
  126.       DevModes[ModeNum].dmFields := DM.dmFields;
  127.       DevModes[ModeNum].dmFormName := DM.dmFormName;
  128.       DevModes[ModeNum].dmICMIntent := DM.dmICMIntent;
  129.       DevModes[ModeNum].dmICMMethod := DM.dmICMMethod;
  130.       DevModes[ModeNum].dmLogPixels := DM.dmLogPixels;
  131.       DevModes[ModeNum].dmMediaType := DM.dmMediaType;
  132.       DevModes[ModeNum].dmOrientation := DM.dmOrientation;
  133.       DevModes[ModeNum].dmPanningHeight := DM.dmPanningHeight;
  134.       DevModes[ModeNum].dmPanningWidth := DM.dmPanningWidth;
  135.       DevModes[ModeNum].dmPaperLength := DM.dmPaperLength;
  136.       DevModes[ModeNum].dmPaperSize := DM.dmPaperSize;
  137.       DevModes[ModeNum].dmPaperWidth := DM.dmPaperWidth;
  138.       DevModes[ModeNum].dmPelsHeight := DM.dmPelsHeight;
  139.       DevModes[ModeNum].dmPelsWidth := DM.dmPelsWidth;
  140.       DevModes[ModeNum].dmPosition := DM.dmPosition;
  141.       DevModes[ModeNum].dmPrintQuality := DM.dmPrintQuality;
  142.       DevModes[ModeNum].dmReserved1 := DM.dmReserved1;
  143.       DevModes[ModeNum].dmReserved2 := DM.dmReserved2;
  144.       DevModes[ModeNum].dmSize := DM.dmSize;
  145.       DevModes[ModeNum].dmScale := DM.dmScale;
  146.       DevModes[ModeNum].dmSpecVersion := DM.dmSpecVersion;
  147.       DevModes[ModeNum].dmTTOption := DM.dmTTOption;
  148.       DevModes[ModeNum].dmYResolution := DM.dmYResolution;
  149.     end;
  150.   SetLength(DevModes, ModeNum);
  151.   Result := (Length(DevModes) > 0);
  152. end;
Code: Pascal  [Select][+][-]
  1. procedure TForm1.Button1Click(Sender: TObject);
  2. var
  3.   DevModes: TDEVMODES;
  4.   CurMon: TCurrentMonitor;
  5.   i: Integer;
  6. begin
  7.   if GetMonitorInfo(DevModes, CurMon) then
  8.     begin
  9.       Memo1.Lines.Add(Format('%d bit, %d x %d @ %d Hz', [curMon.BITSPIXEL, curMon.HORZRES, curMon.VERTRES, curMon.VREFRESH]));
  10.       for i := 0 to Pred(Length(DevModes)) do
  11.         Memo1.Lines.Add(Format('%d: %d bit, %d x %d @ %d Hz', [i, DevModes[i].dmBitsPerPel, DevModes[i].dmPelsWidth, DevModes[i].dmPelsHeight, DevModes[i].dmDisplayFrequency]));
  12.     end;
  13. end;
curMon will hold up a set of informations about currently monitor while DvModes hold informations about all supported modes
Logged
« Last Edit: Tomorrow at 31:76:97 xm by KodeZwerg »
Pages: 1 [2]
« previous next »
 

TinyPortal © 2005-2018