Autor Beitrag
NeoInDerMATRIX
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 245

Win95, Win98(+se), WinNT, Win2000, WinME, WinXP(+pro), VISTA, Linux(SuSe), DOS [MultiMon(3)], Vista
D6 PeE + (FP 2.0l) + D3 Pe + D2005+ D2006 Arch
BeitragVerfasst: Di 11.01.05 00:19 
Hallo,

also ich habe volgendes Problem. Ich möchte alle nötigen Daten von einem Multimonitorsystem in eine eigene Class Konstrucktion einlesen. Dazu zählen unter anderem alle vorhandenen Monitore mit einstellungen und deren ScreenModes. Das geht auch schon soweit. Nun möchte ich von jedem dieser Monnitore auch noch den gerade eingestellten ScreenMode auslesen. Was sich allerdings als nicht so einfach erwiesen hat. Den akktuellen ScreenMode benötige ich nur als Index. Von der WinAPI Function EnumDisplaySettings bekomme ich aber nur die Werte des aktuellen ScreenModes. Und da liegt nun mein Problem. Wie bekomme ich diese Werte in einen Index?

ausblenden volle Höhe Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321:
322:
323:
324:
325:
326:
327:
328:
329:
330:
331:
332:
333:
334:
335:
336:
337:
338:
339:
340:
341:
342:
343:
344:
345:
346:
347:
348:
349:
350:
351:
352:
353:
354:
355:
356:
357:
358:
359:
360:
361:
362:
363:
364:
365:
366:
367:
368:
369:
370:
371:
372:
373:
374:
375:
376:
377:
378:
379:
380:
381:
382:
383:
384:
385:
386:
387:
388:
389:
390:
391:
392:
393:
394:
395:
396:
397:
398:
399:
// ... gekürtzt ...

Type
    // Neo: orientation used by monitor
    TMonitorOrientation = (mo0, mo90, mo180, mo270);
    TMonitorFixedOutput = (mfoDefault, mfoCenter, mfoStretch);
    TOScrICMMethod = (mimNone, mimSystem, mimDriver, mimDevice);
    TOScrICMIntent = (miiABSColorMetric, miiColorMetric, miiContrast, miiSaturate);
    TDither = (ditherNone, ditherCoarse, ditherFine, ditherLineart, ditherErrorDiffusion, ditherGrayscale);
    TMonitor = Record
        Valid: Boolean; // Neo: indicate monitor exists
        ID: Integer; // Neo: monitor index
        Handle: HMONITOR; // Neo: monitor handle
        MonitorName: String; // Neo: montor name
        DeviceName: String; // Neo: device name
        DriverVersion: DWORD; // Neo:
        Orientation: TMonitorOrientation; // Neo:
        Desktop: Boolean; // BenBE: Monitor is attached to a desktop
        Primary: Boolean; // Neo: is set if this monitor is the primary
        Mirror: Boolean; // Neo: is set if this monitor is a mirro
        VGA: Boolean; // BenBE: Monitor is VGA only
        VirtRect: TRect; // BenBE: Virtuelle Coordinaten auf dem Desktop
        WorkRect: TRect; // BenBE: Arbeitskoordinaten auf dem Monitor
    End;
    TScreenMode = Record
        Valid: Boolean; // Neo: indicate screenmode exits
        Mode: Integer; // Neo: screenmode id
        SizeX: Integer; // Neo: pixel in x range
        SizeY: Integer; // Neo: pixel in y range
        BitsPerPixel: Integer; // Neo: bit used for one pixel
        Frequence: Integer; // Neo: frequenced used
        PixelPerInch: Integer; // Neo: pixel used for one inch
        Orientation: TMonitorOrientation; // Neo:
        Pal: Boolean; // Neo: is set if a pal is used
        GrayScale: Boolean; // Neo: is grayscaled mode
        Interlaced: Boolean; // Neo: is interlaced mode
        ICMMethod: TOScrICMMethod; // Neo:
        ICMIntent: TOScrICMIntent; // Neo:
        Dither: TDither; // Neo:
    End;

// ... gekürtzt ...

    tpfd_Flags = Set of
        (fpfd_Draw_To_Window, fpfd_Draw_To_Bitmap,
         fpfd_Support_GDI, fpfd_Support_OpenGL,
         fpfd_DoubleBuffer, fpfd_Stereo,
         fpfd_DoubleBuffer_DontCare, fpfd_Stereo_DontCare,

         fpfd_Type_RGBA, fpfd_Type_ColorIndex,

         fpfd_Main_Plane, fpfd_Overlay_Plane, fpfd_Underlay_Plane
        );

// ... gekürtzt ...

// *** external API def ***
Function EnumDisplayMonitors(ADC: HDC; AIntersect: PRect; lpfnEnumProc: TMonitorEnumProc; lData: lParam): Boolean; stdcall; External 'User32.dll';
Function EnumDisplayDevices(ADeviceName: PChar; ADeviceIndex: DWORD; Var ADisplayDevice: TDisplayDevice; AFlags: DWORD): Boolean; stdcall; External 'User32.dll' Name 'EnumDisplayDevicesA';

Function GetMonitorInfo(AMonitorHandle: HMONITOR; Var ADataRecord: TMonitorInfo): Boolean; stdcall; External 'User32.dll' Name 'GetMonitorInfoA'; overload;
Function GetMonitorInfo(AMonitorHandle: HMONITOR; Var ADataRecord: TMonitorInfoEx): Boolean; stdcall; External 'User32.dll' Name 'GetMonitorInfoA'; overload;

Function MonitorFromPoint(APoint: TPoint; AFlags: DWORD): HMONITOR; stdcall; External 'User32.dll';
Function MonitorFromRect(ARect: TRect; AFlags: DWORD): HMONITOR; stdcall; External 'User32.dll';
Function MonitorFromWindow(AWindowHandle: HWND; AFlags: DWORD): HMONITOR; stdcall; External 'User32.dll';

// ... gekürtzt ...

Type
    TOScrScreenMode = Record
        SizeX: Integer;
        SizeY: Integer;
        ColorDepth: Integer;
        Frequency: Integer;
        PixelPerInch: Integer;
        // Mode: Integer;
        Pal: Boolean;
        GrayScale: Boolean;
        Interlaced: Boolean;
        ICMMethod: TOScrICMMethod;
        ICMIntent: TOScrICMIntent;
        Dither: TDither;
    End;
    TOScrMonitorFlag = Set Of (smfDesktop, smfMirror, smfPrimary, smfVGA);
    TOScrOrientation = (so0, so90, so180, so270);
    POScrMonitor = ^TOScrMonitor;
    TOScrMonitor = Class
        Handle: HMONITOR; // Neo: handle for monitor

        Flag: TOScrMonitorFlag; // Neo: Primary, Mirror, VGA, Desktop

        ModeCount: Integer; // Neo: avail screenmode on monitor
        Modes: Array Of TOScrScreenMode; // Neo: buffer with screenmode
        CurrMode: Integer; // Neo: current active screenmode

        MonitorName: String; // Neo: Monitorname
        MonitorDLL: String; // Neo: Monitor DLL
        DeviceName: String; // Neo: name of device
        DriverVersion: DWORD; // Neo: version of driver
        DriverName: String; // Neo: name of driver

        Orrientation: TOScrOrientation; // Neo: orientation of screen

        Position: TPoint; // Neo: position to Primary monitor

        Constructor Create; // Neo: create and init monitor class
        Destructor Destroy; Override; // Neo: destroy and free all res

        Procedure ScanScreenModes; // Neo: scann al avail screenmodes
        Procedure Update; // Neo: scann current settings

        Function ChoosPixelFormat(ADC: hDC; AModeNum: Integer; AColorDepth: Byte; AZBufferDepth: Byte; Const AFlag: tpfd_Flags = [fpfd_Draw_To_Window, fpfd_Support_OpenGL, fpfd_DoubleBuffer, fpfd_Type_RGBA, fpfd_Main_Plane]): tPixelFormatDescriptor;
        Function DescribePixelFormat(ADC: hDC; AModeNum: Integer): tPixelFormatDescriptor;
        Function SetPixelFormat(ADC: hDC; AModeNum: Integer): Boolean;

        Function ModeStr(AModeNum: Integer; Const AFormatStr: String = '%dx%dx%d (%d Hz)'): String;
    End;
    POScrScreen = ^TOScrScreen;
    TOScrScreen = Class
        MonitorCount: Integer; // Neo: count of monitors
        Monitors: Array Of TOScrMonitor; // Neo: monitors

        Constructor Create; // Neo: create and init als avail data for screen
        Destructor Destroy; Override; // Neo: destroy and free class

        Procedure ScanMonitors; // Neo: scann all avail monitors
        Procedure Update; // Neo: update settings

    End;

// ... gekürtzt ...

Implementation

// ... gekürtzt ...

Constructor TOScrMonitor.Create;
Begin
    Inherited Create;
    OmorphiaDebugStr(vl_CodeName, 'tOScrMonitor.Create', '--');
    // Neo: only create with valid handle
    If IsValidHandle(Handle) Then
    Begin
        OmorphiaErrorStr(vl_FatalError, 'tOScrMonitor.Creat', '??? an Handle is set ???');
        Fail;
    End;
    // Neo: clear class
    ModeCount := 0;
End;

Destructor TOScrMonitor.Destroy;
Begin
    OmorphiaDebugStr(vl_CodeName, 'tOScrMonitor.Destroy', '--');
    // Neo: free and nill all data in class
    SetLength(Modes, 0);
    Flag := [];
    CurrMode := -1;
    MonitorName := '';
    MonitorDLL := '';
    DeviceName := '';
    DriverVersion := $0000;
    DriverName := '';
    Orrientation := so0;
    Position.X := 0;
    Position.Y := 0;
    Inherited;
End;

Procedure TOScrMonitor.ScanScreenModes;
Var
    Dev: tDevMode;
    Lauf: Integer;
    pfd: tPixelFormatDescriptor;
    DC: hDC;
Begin
    OmorphiaDebugStr(vl_CodeName, 'tOScrMonitor.ScanScreenModes', '--');
    // Neo: init run with mode 0 and clear record for first api call
    Lauf := 0;
    ZeroMemory(@Dev, SizeOf(Dev));
    Dev.dmSize := SizeOf(Dev);
    // Neo: scann all avail screen modes
    While EnumDisplaySettings(PChar(DeviceName), Lauf, Dev) Do
    Begin
        // Neo: ok add screenmode
        SetLength(Modes, Lauf + 1);
        // Neo: translate dev record to us
        Modes[Lauf].SizeX := Dev.dmPelsWidth;
        Modes[Lauf].SizeY := Dev.dmPelsHeight;
        Modes[Lauf].ColorDepth := Dev.dmBitsPerPel;
        Modes[Lauf].Frequency := Dev.dmDisplayFrequency;
        Modes[Lauf].PixelPerInch := Dev.dmYResolution;
        Modes[Lauf].Pal := Not Dev.dmBitsPerPel > 8;
        Modes[Lauf].GrayScale := Dev.dmDisplayFlags And dm_GrayScale > 0;
        Modes[Lauf].Interlaced := Dev.dmDisplayFlags And dm_Interlaced > 0;
        Modes[Lauf].ICMMethod := TOScrICMMethod(Dev.dmICMMethod);
        Modes[Lauf].ICMIntent := TOScrICMIntent(Dev.dmICMIntent);
        // Neo: clear record for next read
        ZeroMemory(@Dev, SizeOf(Dev));
        Dev.dmSize := SizeOf(Dev);
        // Neo: read pixelformat data
//        DC:=CreateDC(NIL, pCHar(DeviceName), NIL, NIL);
//        pfd:=DescribePixelFormat(DeviceContext, Lauf);
//        DeleteDC(DC);
        // Neo: select the next mode number
        Inc(Lauf);
    End;
    // Neo: save the last mode number as count
    ModeCount := Lauf;
End;

Procedure TOScrMonitor.Update;
Var
    Dev: tDevMode;
Begin
    OmorphiaDebugStr(vl_CodeName, 'tOScrMonitor.Update', '--');
    // Neo: get current screenmode
    ZeroMemory(@Dev, SizeOf(Dev));
    Dev.dmSize := SizeOf(Dev);
    EnumDisplaySettings(PChar(DeviceName), Enum_Current_Settings, Dev);

End;

Function tOScrMonitor.ChoosPixelFormat(ADC: hDC; AModeNum: Integer; AColorDepth: Byte; AZBufferDepth: Byte; Const AFlag: tpfd_Flags = [fpfd_Draw_To_Window, fpfd_Support_OpenGL, fpfd_DoubleBuffer, fpfd_Type_RGBA, fpfd_Main_Plane]): tPixelFormatDescriptor;
Begin
  ZeroMemory(@Result, SizeOf(Result));
  Result.Size:=SizeOf(Result);
  Result.Version:=1;

  If fpfd_Draw_To_Window in AFlag Then
    Result.Flag:=Result.Flag or pfd_Draw_To_Window;
  If fpfd_Draw_To_Bitmap in AFlag Then
    Result.Flag:=Result.Flag or pfd_Draw_To_Bitmap;
  If fpfd_Support_GDI in AFlag Then
    Result.Flag:=Result.Flag or pfd_Support_GDI;
  If fpfd_Support_OpenGL in AFlag Then
    Result.Flag:=Result.Flag or pfd_Support_OpenGL;
  If fpfd_DoubleBuffer in AFlag Then
    Result.Flag:=Result.Flag or pfd_DoubleBuffer;
  If fpfd_Stereo in AFlag Then
    Result.Flag:=Result.Flag or pfd_Stereo;
  If fpfd_DoubleBuffer_DontCare in AFlag Then
    Result.Flag:=Result.Flag or pfd_DoubleBuffer_DontCare;
  If fpfd_Stereo_DontCare in AFlag Then
    Result.Flag:=Result.Flag or pfd_Stereo_DontCare;

  If fpfd_Type_RGBA in AFlag Then
    Result.PixelType:=Result.PixelType or pfd_Type_RGBA;
  If fpfd_Type_ColorIndex in AFlag Then
    Result.PixelType:=Result.PixelType or pfd_Type_ColorIndex;

  If fpfd_Main_Plane in AFlag Then
    Result.LayerType:=Result.LayerType or pfd_Main_Plane;
  If fpfd_Overlay_Plane in AFlag Then
    Result.LayerType:=Result.LayerType or pfd_Overlay_Plane;
  If fpfd_Underlay_Plane in AFlag Then
    Result.LayerType:=Result.LayerType or pfd_Underlay_Plane;

  Result.ColorBits:=AColorDepth;
  Result.DepthBits:=AZBufferDepth;

  Windows.ChoosePixelFormat(ADC, @Result);
  DbgLastOSError;
End;

Function tOScrMonitor.DescribePixelFormat(ADC: hDC; AModeNum: Integer): tPixelFormatDescriptor;
Var
 Temp: tagPixelFormatDescriptor;
Begin
 ZeroMemory(@Temp, SizeOf(Temp));
 Windows.DescribePixelFormat(ADC, AModeNum, SizeOf(Temp), Temp);
 DbgLastOSError;
 Result:=tPixelFormatDescriptor(Temp);
End;

Function tOScrMonitor.SetPixelFormat(ADC: hDC; AModeNum: Integer): Boolean;
Var
 Temp: tPixelFormatDescriptor;
Begin
 Temp:=DescribePixelFormat(ADC, AmodeNum);
 Result:=Windows.SetPixelFormat(ADC, AModeNum, @Temp);
End;

Function tOScrMonitor.ModeStr(AModeNum: Integer; Const AFormatStr: String = '%dx%dx%d (%d Hz)'): String;
Begin
 Result:=Format(AFormatStr, [Modes[AModeNum].SizeX, Modes[AModeNum].SizeY, Modes[AModeNum].ColorDepth, Modes[AModeNum].Frequency]);
End;

Constructor TOScrScreen.Create;
Begin
    OmorphiaDebugStr(vl_CodeName, 'tOScrScreen.Create', '--');
    Inherited Create;
    // Neo: clear class
    MonitorCount := 0;
    Monitors := Nil;

    // Neo: scan all avail monitors
    ScanMonitors;
    // Neo: update the current settings
    Update;
End;

Destructor TOScrScreen.Destroy;
Begin
    OmorphiaDebugStr(vl_CodeName, 'tOScrScreen.Destroy', '--');
    Inherited Destroy;
End;

Procedure TOScrScreen.ScanMonitors;
// Neo: i have take some code from BenBE but i must be change some stuff

    Function GetMonitorDataEnumProc(AMonitorHandle: hMonitor; ADC: HDC; ARect: PRect; AScrScreen: lParam): Boolean; Stdcall;
    Var
        DispDev: TDisplayDevice;
        MonInfo: TMonitorInfoEx;
        //  DevMode: tDevMode; // Neo: in futhure i need this, also leave it
        Temp: tOScrScreen;
    Begin
        OmorphiaDebugStr(vl_CodeName, 'tOScrScreen.[GetMonitorDataEnumProc]', '--');
        //BenBE: Ignore all previous errors
        DbgResetOSError;

        Temp := pOScrScreen(AScrScreen)^;
        // Neo: add monitor to class
        SetLength(Temp.Monitors, Temp.MonitorCount + 1);
        Inc(Temp.MonitorCount);
        Temp.Monitors[Temp.MonitorCount - 1] := tOScrMonitor.Create;

        //BenBE: Query information on the display device
        ZeroMemory(@DispDev, SizeOf(DispDev));
        DispDev.Size := SizeOf(DispDev);

        // Neo: get the required data from API
        Result := EnumDisplayDevices(Nil, Temp.MonitorCount - 1, DispDev, 0);
        DbgLastOSError(False);

        //   Dev_DispDev.
           // Neo: grab the data from api
        Temp.Monitors[Temp.MonitorCount - 1].Handle := AMonitorHandle;

        Temp.Monitors[Temp.MonitorCount - 1].MonitorName := DispDev.DeviceString;
        Temp.Monitors[Temp.MonitorCount - 1].DeviceName := DispDev.DeviceName;

        Temp.Monitors[Temp.MonitorCount - 1].Flag := [];

        // Neo: flag Display_Device_Multi_Driver not required
        If DispDev.StateFlags And Display_Device_Attached_To_Desktop > 0 Then
            Temp.Monitors[Temp.MonitorCount - 1].Flag := [smfDesktop];
        If DispDev.StateFlags And Display_Device_Primary_Device > 0 Then
            Temp.Monitors[Temp.MonitorCount - 1].Flag := [smfPrimary];
        If DispDev.StateFlags And Display_Device_Mirroring_Driver > 0 Then
            Temp.Monitors[Temp.MonitorCount - 1].Flag := [smfMirror];
        If DispDev.StateFlags And Display_Device_VGA_Compatible > 0 Then
            Temp.Monitors[Temp.MonitorCount - 1].Flag := [smfVGA];

        // BenBE: Get the monitor information for the current device
        ZeroMemory(@MonInfo, SizeOf(MonInfo));
        MonInfo.Size := SizeOf(MonInfo);
        GetMonitorInfo(Temp.Monitors[Temp.MonitorCount - 1].Handle, MonInfo);
        // Neo: Check for errors
        DbgLastOSError(False);

        //   DispDev.
        Temp.Monitors[Temp.MonitorCount - 1].MonitorDLL := '';
        Temp.Monitors[Temp.MonitorCount - 1].DriverVersion := 0;
        Temp.Monitors[Temp.MonitorCount - 1].DriverName := '';
        Temp.Monitors[Temp.MonitorCount - 1].Orrientation := so0;
        Temp.Monitors[Temp.MonitorCount - 1].Position.X := MonInfo.Real.PositionX;
        Temp.Monitors[Temp.MonitorCount - 1].Position.Y := MonInfo.Real.PositionY;
        //   Temp.Monitors[Temp.MonitorCount - 1].Position:=Dev_MonInfo.Work;


        // Neo: scan all avail screen mode
        Temp.Monitors[Temp.MonitorCount - 1].ScanScreenModes;
        // Neo: mem current seting
        Temp.Monitors[Temp.MonitorCount - 1].Update;
    End;
Begin
    OmorphiaDebugStr(vl_CodeName, 'tOScrScreen.ScanMonitors', '--');
    DbgResetOSError;
    // Neo: in the CallBack woud be set data for record and monitr
    EnumDisplayMonitors(0, Nil, @GetMonitorDataEnumProc, Integer(@Self));
    // BenBE: Check if there were errors
    DbgLastOSError(False);
End;

Procedure TOScrScreen.Update;
Var
    Lauf: Integer;
Begin
    OmorphiaDebugStr(vl_CodeName, 'tOScrScreen.Update', '--');
    DbgResetOSError;
    // Neo: this line must be left, needed for debug
    Lauf := GetSystemMetrics(78);
    DbgLastOSError;
    // Neo: this line must be left, need for debug
    Lauf := GetSystemMetrics(79);
    DbgLastOSError;
End;


Aufgerufen wird zurzeit nur
ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
Var
 t: tOScrScreen;
Begin
 T:=tOScrScreen.Create;
 .
 .
 .
End;


Das ist mein aktueller Source. Ich habe es bereits über umwege Probiert wie ChoosPixelFormat allerdings würde ich dazu nen DC benötigen und den habe ich zu dieser Zeit noch nicht.
Evtl. sehe ich auch mal wieder den Wald vor lauter Bäumen nicht. Würde mich freuen wenn mir jemand helfen kann.

Thx & Cu
Neo

Zitat:
[url=www.de-schneider.de/omorphia/forum/]This is a part of the Project Omorphia[/url]