De kunst is dan juist om dat verband in dit geval wel te zien. Namelijk, bedenk dat in de nabije toekomst wellicht 17" LCDs met een resolutie van (zeg) 1600*1200 uitkomen. Je wilt dan wellicht via software alles naar een voor jou prettige grote 'scalen'. Een lagere resolutie instellen om objecten groter te maken en dat dan door je monitor te laten interpoleren op zijn native resolutie lijkt me nou niet echt super voor je beeldkwaliteit. Zeker als de twee resoluties niet een geheel getal factor schelen.
Het schalen slaat op dat Vensters butons textlabels in masage boxen en GDI menu corect worden weergegeven.
Zoiets ja, een venster moet uniform kleiner of groter gemaakt worden door de scale of zoom factor die in eerste instantie voor de hele desktop geldt. Niet zoals nu dat als je je fonts groter zet, de verhoudingen in je window niet meer kloppen.
Gegeven een bepaalde scale/zoom factor wordt de hele desktop dan gerenderd met de windows in een bepaalde grote. Als dat eenmaal gedaan is moet de user afzonderlijke windows natuurlijk nog wel kleiner/groter kunnen maken op de gebruikelijke manier, waarbij dan een intern layout algortime de window opnieuw indeeld en er niet meer als een 'enkel plaatje' gescaled wordt.
Eventueel zou je de user een keuze kunnen geven: bv randen/sizebox met linker mouse button verslepen is de 'her-indelende' grote verandering, en met rechter mouse button is een uniforme scale.
[...]
Nee dat is niet scahlen maar het view fustrum is fixed dus raterisation[...]
scalen stond ook tussen aanhalings tekentjes. Als je desktop geheel dmv een vector beschrijving gegeven is dan raster je die in een bepaalde logische groote. Des te hoger je resolutie is des te fijner je dat kunt doen. Bitmaps die je altijd zult houden zul je wel echt scalen.
Maar het hangt er een beetje van af hoe je de term 'scalen' wilt interpreteren. Namelijk als je bij een gegeven logische en vaste resolutie een vector object wilt vergroten of verkleinen spreek je ook van scalen. (bv de dock van Mac OS X).
PDF is adobe Ducument formaat dus vergeliik dat met Word of zoiets vergelijkbare documenten en niet met win32_GDI aansturen voor win32 GUI
Nee dat is niet waar. Ooit van Display Postscript gehoord (DPS)? Een PDF render engine lijkt daar zeer sterk op. Het systeem is echt niet alleen bedoelt voor documenten, maar dus ook voor het realtime renderen van de output van een applicatie, of in dit geval van de gehele OS. Voorbeelden van OS'en die dit gebruiken zijn bv NeXT Step/Open Step en NeWS (DPS) en Mac OS X (PDF). OS X zou eerst ook DPS gaan gebruiken, maar omdat hier license fees voor betaald moesten worden en voor het gelijkwaardige PDF niet, werd voor PDF gekozen. Overigens is PDF gebasseerd op Postscript.
GDI en MFC en daarvan is PDF niet de tegenhanger van dat is gewoon Applicatie code.
Een PDF renderer op OS level kan prima gebruikt worden ipv GDI. Dit (de postscript variant dan) is ook wat Bill Gates heel vroeger al wilde (Windows 1 tijdperk) maar destijds was dat veel te langzaam.
Met MFC haal je pas echt dingen door elkaar, want MFC is alleen een class library die grotendeels een OO schil op de Win32 API is en een paar eigen classen meebrengt (zoals CString, CMap enz). MFC zelf rendert dus niks.
Waar MFC wel een rol zou kunnen spelen is in het ter beschikking stellen van layout managers voor Windows. Dit zie je bv ook terug in andere toolkits zoals bv Motif of AWT. Deze stellen dan een Windows object samen die dan uiteindelijk door de renderer (GDI, X Window System, DPS, Quartz, etc) getekent worden.
Helaas bied MFC geen layout managers, maar zet je alle controls meestal op vaste plekken in je root window en zorg je zelf in een OnSize handler voor het resizen.
Het feit dat bij 'large fonts' buttons en andere childwindows niet mee scalen is dus wel indirect het gevolg van MFC en de Win32 API daar deze dus geen layout managers bieden.
Dat heeft met de aplle API te maken OpenGL heeft niks met correcte schaling te maken dat bepaald hoe de interfaces en API implementatie van het OS is.
Uhm? Zei ik dat dan?
Het feit is dat de gehele Apple desktop door OpenGL gerenderd kan worden. Technisch is een full desktop scale dus veel makkelijker te doen dan in Windows (GDI) of Unix systemen die op het X Window Systeem zijn gebasseerd. Het is daarom vreemd dat Apple hier geen
gebruik van maakt.
als je van 800x600 naar 1600x1200 gaat dan wordt het speel beeld wel gedetaileeder maar de optimenu wordt te klein
Dit is waarschijnlijk omdat het menu een bitmap overlay is op de OpenGL scene. Je kunt wel fonts in OpenGL renderen maar de support is heel beperkt. Een Widget toolkit zit ook niet standaard in OpenGL. Je kunt wel iets doen met glut maar dat is heel beperkt.
GDI kan ook via DirectX gestuurd worden maar de implementatie
van de programeur bepaald of het wel of niet goed meeschaald.
Volgens mij is dit niet helemaal zo. GDI calls worden niet gemapped naar DirectX calls die dan hardware versneld gerenderd kunnen worden. GDI en DirectX zijn grotendeels complementaire systemen. Je kunt overigens wel de GDI calls gebruiken om in een DirectX surface te tekenen, maar dat verschilt volgens mij (correct me if I'm wrong) weinig met het tekenen in een andere device context (bv printer of window). Maw, je tekent in dat geval gewoon een bitmap en geen lijst van vector objecten die door de display hardware verwerkt kunnen worden.
Het probleem is juist de GDI schaling van de win32 API niet het werkveld van de app
Het probleem is dat jij PDF alleen als een app ziet en niet als een render engine kent

maar stel de systeem font maar eens op 400% en dan kijken of je wat kan lezen uit message box of instelling popup boxen zoals apparaatbeheer etc.
In 1 woord: verschrikkelijk! Maar daar ging de thread dus ook juist grotendeels over

Het huidige systeem voldoet zo slecht dat een vervanging nodig is. Omdat die vervanging uitblijft houdt dit de ontwikkeling tegen voor hogere resolutie hardware,
ben zo benieuwd naar longhorn.
Hoop eigenlijk eerder op iets uit de Unix hoek. Dan kan MS het idee altijd nog lenen.