#!/usr/bin/env python

"""

PyQt-compatible resources for use with WebStack.

Copyright (C) 2005 Paul Boddie <paul@boddie.org.uk>

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public

License along with this library; if not, write to the Free Software

Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA

"""

import XSLForms.Prepare

import XSLForms.Resources.Common

import XSLForms.Resources.WebResources

import WebStack.Generic

import os

import libxml2dom

class XSLFormsResource(XSLForms.Resources.WebResources.XSLFormsResource):

    """

    An XSLForms resource supporting PyQt-compatible Web applications for use

    with WebStack.

    """

    widget_resources = {}

    def __init__(self, design_identifier):

        self.factory = Factory()

        self.default_design = design_identifier

        # NOTE: Filename extended by string concatenation.

        self.template_resources = {}

        for design_identifier, design_name in self.design_resources.items():

            self.template_resources[design_identifier] = (design_name + ".xhtml", design_name + ".xsl")

    # Resource methods.

    def prepare_output(self, design_identifier):

        """

        Prepare the output stylesheets using the given 'design_identifier' to

        indicate which templates and stylesheets are to be employed in the

        production of output from the resource.

        The 'design_identifier' is used as a key to the 'design_resources' and

        'template_resources' dictionary attributes.

        Return the full path to the output stylesheet for use with 'send_output'

        or 'get_result'.

        """

        design_path = self.prepare_design(design_identifier)

        template_filename, output_filename = self.template_resources[output_identifier]

        output_path = os.path.abspath(os.path.join(self.resource_dir, output_filename))

        template_path = os.path.abspath(os.path.join(self.resource_dir, template_filename))

        XSLForms.Prepare.ensure_qt_template(design_path, template_path)

        XSLForms.Prepare.ensure_stylesheet(template_path, output_path)

        return output_path

    # PyQt compatibility methods.

    def get_document(self, document_identifier):

        return libxml2dom.parse(self.prepare_document(document_identifier))

    def prepare_widget(self, design_identifier, widget_identifier, parent=None):

        design_path = self.prepare_design(design_identifier)

        fragment_name, widget_name = self.widget_resources[widget_identifier]

        fragment_path = os.path.abspath(os.path.join(self.resource_dir, fragment_name))

        XSLForms.Prepare.ensure_qt_fragment(design_path, fragment_path, widget_name)

        # NOTE: Implement the equivalent here!

        return qtui.QWidgetFactory.create(fragment_path, None, parent)

    def child(self, name):

        return self.doc.child(name)

    # PyQt structural methods.

    def form_init(self):

        raise NotImplementedError, "form_init"

    def form_refresh(self):

        raise NotImplementedError, "form_refresh"

    # Standard XSLFormsResource method, overridden to handle presentation.

    def respond_to_form(self, trans, form):

        """

        Respond to the request described by the given transaction 'trans', using

        the given 'form' object to conveniently retrieve field (request

        parameter) information and structured form information (as DOM-style XML

        documents).

        """

        # Remember the document since it is accessed independently elsewhere.

        doc = form.get_document(self.default_design)

        if doc is None:

            self.doc = UINode(form.new_document(self.default_design))

        else:

            self.doc = UINode(doc)

        self.form_init()

        # NOTE: Updates happen here.

        self.form_refresh()

        trans.set_content_type(WebStack.Generic.ContentType("application/xhtml+xml", self.encoding))

        design_xsl = self.prepare_output(self.default_design)

        self.send_output(trans, [design_xsl], doc._node)

class UINode:

    "A PyQt widget tree emulation node."

    def __init__(self, node):

        self._node = node

    def child(self, name):

        nodes = self._node.xpath(name)

        if len(nodes) > 0:

            return UINode(nodes[0])

        else:

            return None

    def children(self):

        return [UINode(node) for node in self._node.childNodes]

    def count(self):

        return len(self._node.childNodes)

    def currentText(self):

        return self.getAttribute("value")

    def currentItem(self):

        found = self._node.xpath("*[@value=current()/@value]")

        if found:

            return int(found.xpath("count(preceding-sibling::*)"))

        else:

            return 0

    def insertItem(self, item, position=-1):

    def parent(self):

        return UINode(self._node.parentNode)

    def removeItem(self, item):

    def remove(self, item):

    def layout(self):

        return self

    def setCurrentItem(self):

    def deleteLater(self):

        self._node.parentNode.removeChild(self._node)

class Factory:

    "A widget factory helper class."

    def connect(self, widget, obj):

        pass

    def find_widgets(self, widget, name):

        """

        Find within the given 'widget' (a DOM node) the widget with the given

        'name'.

        """

        return widget.getElementsByTagName(name)

# vim: tabstop=4 expandtab shiftwidth=4