foryali first commit

works continue..

x11/util/zorg/comar/package.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+
+from pisi.version import Version
+
+def postInstall(fromVersion, fromRelease, toVersion, toRelease):
+    if fromVersion and Version("0.90") <= Version(fromVersion) <= Version("0.96"):
+        from zorg import config
+
+        busId = call("zorg", "Xorg.Display", "activeDeviceID")
+        device = config.getDeviceInfo(busId)
+
+        if device:
+            config.saveDeviceInfo(device)
+            config.saveXorgConfig(device)
+
+    if fromRelease and int(fromRelease) < 81:
+        from zorg import config
+
+        layout, variant = config.getKeymapOld()
+        config.saveKeymap(layout, variant)

x11/util/zorg/comar/xorg.display.py

@@ -0,0 +1,222 @@
+# -*- coding: utf-8 -*-
+
+import os
+
+import comar
+from pardus.sysutils import *
+
+from zorg.config import *
+from zorg.consts import *
+from zorg.probe import *
+from zorg.utils import *
+
+kernel_module_file = os.path.join(config_dir, "kernel_module")
+
+def getDevice():
+    bus = configuredBus()
+    if not bus:
+        return None
+
+    return getDeviceInfo(bus)
+
+def getDeviceOutput(output):
+    dev = getDevice()
+    if not dev:
+        return None, None
+
+    if output not in dev.outputs:
+        dev.outputs[output] = Output(output)
+
+    return dev, dev.outputs[output]
+
+# Model methods
+
+def ready(boot):
+    opts = {}
+
+    if boot:
+        opts = get_kernel_option("xorg")
+
+    if "keymap" in opts:
+        keymap = opts["keymap"].split("/", 1)
+        setKeymap(*keymap)
+
+    if "safe" in opts:
+        return False
+
+    driver = opts.get("driver")
+
+    if driver or "probe" in opts:
+        return initialConfig(driver)
+
+    busId = configuredBus()
+    if not busId:
+        return initialConfig()
+
+    if boot:
+        # Check if the active card is changed
+        try:
+            device = getDeviceInfo(busId)
+        except IOError:
+            # Device is not present on specified bus.
+            # Check if the new device is configured before.
+            newBus = getPrimaryCard()
+            if newBus:
+                device = getDeviceInfo(VideoDevice(newBus).bus_id)
+                if device and not device.isChanged():
+                    # Yes, it is configured before.
+                    # Reenable driver and write xorg.conf.
+                    device.enableDriver()
+                    saveXorgConfig(device)
+                else:
+                    # This is a different card.
+                    return initialConfig()
+            else:
+                # No card is present. Return True in order to
+                # start with a manually edited xorg.conf.
+                return True
+        else:
+            if not device or device.isChanged():
+                return initialConfig()
+
+    # Check kernel module. Later, this should be done
+    # with Xorg.Driver.ready method.
+    if os.path.exists(kernel_module_file):
+        kernelModule = file(kernel_module_file).read()
+        if run("/sbin/modprobe", "-i", kernelModule) and kernelModule != "fglrx":
+            return False
+
+    return True
+
+def initialConfig(preferredDriver=None):
+    bus = getPrimaryCard()
+
+    if bus:
+        device = VideoDevice(bus)
+    else:
+        # This machine might be a terminal server with no video cards.
+        # We start X and leave the decision to the user.
+        log_debug("No video card found.")
+        return True
+
+    if preferredDriver is None:
+        preferredDriver = device.preferredDriver()
+
+    device.setDriver(preferredDriver)
+
+    saveDeviceInfo(device)
+    saveXorgConfig(device)
+
+    return True
+
+def safeConfig():
+    bus = getPrimaryCard()
+
+    if bus:
+        device = VideoDevice(bus)
+    else:
+        # See the comment in initialConfig
+        return True
+
+    device.setDriver("vesa")
+    device.depth = 16
+    device.outputs["default"] = Output("default")
+    device.monitors["default"] = Monitor()
+
+    saveDeviceInfo(device)
+    saveXorgConfig(device)
+
+    return True
+
+# FIXME Confusing method name
+def activeDeviceID():
+    return configuredBus()
+
+def listDrivers():
+    drivers = listAvailableDrivers()
+
+    link = comar.Link()
+    packages = list(link.Xorg.Driver)
+    for package in packages:
+        try:
+            info = link.Xorg.Driver[package].getInfo()
+        except dbus.DBusException:
+            continue
+        alias = str(info["alias"])
+        driver = str(info["xorg-module"])
+        drivers.append(alias)
+        if driver in drivers:
+            drivers.remove(driver)
+
+    return sorted(drivers)
+
+def setDriver(driver):
+    dev = getDevice()
+    if dev:
+        dev.setDriver(driver)
+        saveDeviceInfo(dev)
+
+def setDepth(depth):
+    dev = getDevice()
+    if dev:
+        dev.depth = depth
+        saveDeviceInfo(dev)
+
+def setOutput(output, enabled, ignored):
+    dev, out = getDeviceOutput(output)
+
+    if dev:
+        out.setEnabled(enabled)
+        out.setIgnored(ignored)
+
+        saveDeviceInfo(dev)
+
+def setMode(output, resolution, rate):
+    dev, out = getDeviceOutput(output)
+
+    if dev:
+        out.setMode(resolution, rate)
+
+        saveDeviceInfo(dev)
+
+def setOrientation(output, rotation, reflection):
+    dev, out = getDeviceOutput(output)
+
+    if dev:
+        out.setOrientation(rotation, reflection)
+
+        saveDeviceInfo(dev)
+
+def setPosition(output, position, arg):
+    dev, out = getDeviceOutput(output)
+
+    if dev:
+        out.setPosition(position, arg)
+
+        saveDeviceInfo(dev)
+
+def setMonitor(output, vendor, model, horizSync, vertRefresh):
+    dev, out = getDeviceOutput(output)
+
+    if dev:
+        if model:
+            mon = Monitor()
+            mon.vendor  = vendor
+            mon.model   = model
+            mon.hsync   = horizSync
+            mon.vref    = vertRefresh
+            dev.monitors[output] = mon
+        elif output in dev.monitors:
+            del dev.monitors[output]
+        else:
+            return
+
+        saveDeviceInfo(dev)
+
+def syncConfigs():
+    dev = getDevice()
+    if dev:
+        saveXorgConfig(dev)
+
+def setKeymap(layout, variant=""):
+    saveKeymap(layout, variant)