Style Works XT Universal Patch
with EMC Styleworks (Style Works) 2000 / Styleworks XT you can take an arrangement style from a Roland, Yamaha, Korg, Ketron, General Music, Technics, or Wersi keyboard and automatically convert it to work on your keyboard. With the same program you can also take any part of a MIDI file song and turn any section into an intro/ending, variation, or fill in for your own keyboard! Fully upgraded for the latest keyboards including Tyros 1, KN7000, Roland E80, G70.
AbstractThe X Window System protocol, Version 11, was deliberatelydesigned to be extensible, to provide for both anticipated andunanticipated needs. The X11 core did not anticipate that theproperties of X server screens might need to change dynamically, asoccurs frequently with desktops, laptops and hand held computers notenvisioned in the 1980's.The Resize and Rotate extension (RandR) is a very small set of client andserver extensions designed to allow clients to modify the size, acceleratedvisuals and rotation of an X screen. RandR also has provisions for informingclients when screens have been resized or rotated and it allows clients todiscover which visuals have hardware acceleration available.RandR needs to be discussed in concert with recent developments in X serverimplementation and the new Render extension to understand the implicationsof the aggregate. In isolation, RandR seems to provide a limited but usefulimprovement, but together with the Render extension and reimplementation ofthe X server rendering code, RandR provides part of a key change in X WindowSystem capabilities. We believe this will enable much easier migration andreplication of applications between X servers for pervasive computing. Thispaper also describes this vision.IntroductionThe X Window System [SG92] extension framework has served us well, allowingsignificant extensions to the X design over the last 14 years. Thisextension framework has encouraged new functionality to be introduced, andhas encapsulated optional functionality permitting clean non-universaldeployment. Probably more importantly, the extension framework has isolated``bad'' ideas from the core X functionality allowing their eventual atrophyinto irrelevance. 1At the time X11 was designed, we did not anticipate that the properties of Xserver screens might need to change dynamically. However, this routinelyoccurs today with laptops, and handheld computers.Even most current desktop systems share this need. As there is usually asignificant performance and display memory tradeoff between screenresolution and depths, the ability to change display characteristics withoutrestarting your X session is needed by general users (particularlygamers).Laptops and handheld computers need to change their screen size to driveexternal monitors at different resolutions than their built in screens.Permitting these portable devices to rotate their display provides forbetter use of screen real-estate in applications that prefer displays withthe rotated aspect ratio. It is convenient to flip a laptop sideways whenreading documents intended for paper presentation--the aspect ration moreclosely matches the document leaving less wasted space. Projectors usingmirror systems may find flipped and/or rotated screens very useful. Fromthe applications perspective, rotating the screen is essentially the same aschanging the screen size.We expect that most applications can remain relatively oblivious to screensize changes, though simple modifications may be required in toolkits andwindow managers. The only real challenge which screen size change presentsto most applications is in ensuring that menus stay visible on the screen.Menus are an important special case as they are typically the only userinterface elements not managed by the window manager. Applications mustremain informed about the size of the screen to ensure that menus do notextend beyond the boundaries of the screen making portions inaccessible tothe user. As menus are generally provided by toolkits, rather than directlyby applications, simple changes within the toolkits should resolve theseproblems. Toolkits may also wish to take advantage of accelerationinformation provided by RandR to maximize performance.RenderingThe true physical ``depth'' of a display's frame buffer may need tochange to either support different screen resolutions due tolimitations in the size of display memory or for performance. Sinceapplications currently have a static view of visual types available ona server, and changing visuals dynamically would likely break too manyapplications, the visuals advertised by the X server will not changewhen frame buffer depth changes: instead, the rendering of the screenmay need to change from hardware accelerated rendering to software.A key enabler of this extension is the advent of software frame bufferrendering code (called ``fb'', to distinguishes it from the ``mfb'' and``cfb'' implementations used in older X server implementations) that cansupport all depths simultaneously (while being dramatically more compact andas fast or faster than the old frame buffer code on current processors).Recent machines are fast enough for this to provide an adequate level ofperformance for all but the most performance critical applications. The Render extension enables arbitrary conversions among pixel formatsallowing, for example, the display of 24 bit RGB data on a 16 bit display.RandR needs this to convert all pixel formats to one supported by thedisplay hardware.RandR permits the list of visuals that are accelerated by the hardware tochange on the fly. Toolkits and/or occasionally clients may want to follow this information and dynamically select which visual is being used.This extension can inform clients when such changes occur.Migration and ReplicationMigration takes an existing running application and transfers it's display toanother device. Replication takes that same application and duplicates it'soutput (and input) on multiple devices. MotivationWe believe the ability to migrate applications between X servers is acritical component for the vision of pervasive computing: applicationsshould be able to migrate between displays routinely as users move andinteract with handheld, desktop, appliance and projector screens in theglobal internet environment. Additionally, applications should be able tosurvive the loss of their server connection. At some future time theyshould reconnect to either the same or other device.For example, you should be able to tell an application running on yourhandheld computer to use a nearby desktop display, keyboard and mouse,or a projector on the wall. This should not require stopping andstarting the application. You should be able to go home, and decideto import applications you left running at work. There are obviouslysecurity, authentication and authorization problems left to work out,but these are generally independent of the base window system.Difficulties Migrating X ApplicationsMigration and replication have traditionally been difficult in X due anumber of interrelated factors:pseudocolor displays - There was no guarantee that the color you needed or even an approximation of it would be available on the destination server.pixmap depths - servers have typically only supported a fewof the permitted possible pixmap depths;the software frame buffer code typically only supported 1, 8 and32 bit displays, and would not be present if the server did nothave the capability to be used at that depth.frame buffer depth - lack of any capability to emulate non-nativeframe buffer formats.These taken together meant that applications and toolkits had to becarefully written to survive migration or replication, and thatapplications on most common tookits could not migrate at all.Retrofitting the toolkits was very difficult afterwards due to theseissues. Server resources (e.g. pixmaps) might need recomputation toalternate depths, and applications often depend on particular visual typesbe available throughout their execution. Pixel values do not easilymap between servers for pseudocolor visual types, and are not evenpresent with pixmaps, which do not have inherent color information.While migration of applications between X servers has always possiblein X, it was so difficult that unless prior thought were taken bothtoolkits and applications it would not occur. In practice, it isextremely rare, since toolkit writers did not think it important (atleast at the beginning of their projects).As a result, in practice, migration and replication has at besthappened rarely and has been fraught with problems. Only a fewresearch toolkits like Trestle [MN91] have been builtwith these capabilities, and the retrofit into existing toolkits wouldhave been so difficult as to be impossible. In our opinion, thisproblem has been one of the most painful limitations in X11protocol's design. Only a limited number of applications have beenmigratable and replicable, for example, GNU/emacs [Sta00] usingthe obscure ``make-frame-on-display'' function.Proxy server approaches [GWY94] came closest to a general solution,but have serious drawbacks. For best performance, applications shouldbe communicating directly with the X server without a proxy. The proxy mustreformat much of the X protocol traffic and even still, ensuring that theresult remains compliant with the X protocol specification is quitedifficult. Even with these difficulties, proxy servers remain useful.Another problem is the large variation of display sizes, applications thatfit easily on a desktop screen may not fit on a handheld or appliancescreen. This problem has intensified over the last 10 years as X servershave been deployed on progressively smaller platforms. Proxy server basedreplication can't make applications adapt to this change, only toolkit basedsolutions can. Replicated applications are the basis of important realtime collaborative applications, and this ability should span handhelds,desktops and larger displays.Promoting Toolkit Level Migration and ReplicationThe best solution is for applications and toolkits to support migration andreplication themselves. Making it easy for existing toolkit implementers toimplement migration and replication is key to migration and replicationbecoming ubiquitous. The solutions we have outlined provide for moreuniformity among the capabilities of different X servers. This increaseduniformity should simplify the implementation of migration and replication inexisting toolkits and applications that were not designed to cope withmultiple disparate X servers.It has taken more than five years longer for pseudocolor to phase out thanwe had anticipated. Instead of increasing in capability, display hardwarearchitecture remained relatively constant while costs reduced dramatically.Fortunately, most desktop environments are finally regularly running intruecolor mode. Very few applications now require pseudocolor visual typesto function, whereas pseudocolor was was dominant 10 years ago. The dominantapplications that people care about now work with fixed color maps. Thelack of pseudocolor displays simplifies the translation among colorrepresentations.Additionally, the Render extension moves applications toward a more abstractrepresentation of color, pixel values become much less important asapplications focus on color while the extension automatically translatesbetween the various representations of the data. Modern toolkits like GTK+ 2.0 and Qt [Dal01] now isolateapplications entirely from visual representations from X, and shouldbecome much easier to adapt to enable server migration and replication.This would enable all new X applications to be used in a fundamentally moreinteresting fashion. Even applications entirely based on Xt basedwidgets or other toolkit should be so migratable with some work, aswe have carefully avoided violating the invariants found in mostapplications we are aware of. We strongly advocate the toolkit workto complete this vision.RandR itself only provides a small part of the solution (the abilityto determine which visuals are accelerated after a change event). Thedeployment of the RandR and the Render extensions in concert with``fb'', but more importantly the internal X server implementationrequired to support them results in X servers offering all pixmapdepths. With the phase out of pseudocolor visual types, this shoulddramatically reduce the variability of server configurationsencountered by toolkits. Rather than few if any servers supportingall depths, all servers will eventually support all depths. So weexpect to see a great increase in uniformity between X serverimplementations as these servers deploy, greatly easing the problemsfaced by toolkit implementers. See the section below on Serverimplementation for details.As of the time of this writing, we have not demonstrated applicationmigration using these facilities. We plan to do so soon.DescriptionClients can select for RRScreenChange events to be informed if certainproperties of a screen have changed.The root depth, visual and colormap cannot change when a screen isreconfigured to avoid confusing naive clients. Instead, the X servermay re-render onto a different depth of framebuffer, and therefore thevisuals that can be accelerated by hardware may change. Clients maytherefore wish to be informed when these changes occur, and selectother visuals for rendering.Any server supporting this extension will not list the same visual idat more than one depth. This is to make a visual id uniquely identifya depth.The core protocol allows the same visual ID to be reported formultiple screens, but as the sample X server implementation does notdo so and as there is no change in functionality by making thisrestriction, the RandR extension gains quite a bit of simplicity byenforcing this restriction.Suppose a non-RandR-aware client has a window on a non-default depth24 visual, and is switched to a higher resolution, where depth 24 isnot supported. How can this work? In this and similar cases, the window will be rendered using softwareand updated asynchronously to the display using the Render extensioncapabilities for blting between depths. Note that your performancemay suffer, although experience with the shadow frame bufferimplementation in the XFree86 server shows that the hit isnot as bad as you might think; the real frame buffer is never beingread, only written.For simplicity, RandR uses the ``acceleration'' Boolean value instead of themore complex integer for visual quality that the Double BufferExtension [EW94] uses.Applications will search for ``accelerated'' visuals which meet theirrequirements with the assumption that non-accelerated visuals will beimplemented using the method described above.ImplementationDuring the implementation of RandR within XFree86, several distinct issuesneeded addressing:Multiple Depths. RandR requires that all possible depths be availableall of the time.Rotation. As hardware doesn't normally support this, software willhave to rotate all rasterization.Size and Depth Changing. Changing the size requires recomputation ofwindow clip lists, changing the depth requires reprogramming the hardware.Each was managed without significant new code by taking advantage of recentadvancements within the XFree86 distribution.Supporting Additional DepthsBecause of the pixel-value oriented rasterization model in the core Xprotocol, the X server is essentially required to render using precisely thesame pixel format as is advertised to applications. This implies thatwhen the hardware frame buffer format does not match the visual, the servermust store the pixels off screen in their advertised format. This ensuresthat raster operations that directly manipulate pixel values operatecorrectly and that applications can continue to use GetImage and retrieveprecisely the right values.This is implemented using the XFree86 shadow framebuffer code. The shadow frame buffer code was originally designed to allowsimple X server porting to frame buffers using a format not supported by theframe buffer code. It works by creating a virtual frame buffer inapplication memory. All rendering operations are directed to this virtualframe buffer and the areas affected by these operations are tracked by theshadow frame buffer code. The hardware frame buffer is periodically updatedby copying data from the shadow frame buffer as seen inFigure 1. 2b1af7f3a8