#
# Copyright (c) 2002, 2003, 2004, 2005, 2006 Art Haas
#
# This file is part of PythonCAD.
#
# PythonCAD is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# PythonCAD 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with PythonCAD; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
#
# the GTK code for displaying a drawing
#

import types

import pygtk
pygtk.require('2.0')
import gtk
import gobject

from PythonCAD.Generic import image
from PythonCAD.Generic import layer
from PythonCAD.Generic import util

_debug = False

class LayerDisplay(object):
    def __init__(self, im, win):
        """
        This class defines the layer display graphic on the left side of
        the window.  The calling arg should be a member of the image class.
        """
        if _debug is True:
            print "SDB debug: instantiated another LayerDisplay class instance"
        if not isinstance(im, image.Image):
            raise TypeError, "Invalid Image type: " + `type(im)`
        if not isinstance(win, gtk.Window):
            raise TypeError, "Invalid Window type: " + `type(win)`
        _sw = gtk.ScrolledWindow()
        _sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        _model = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_PYOBJECT)
        # _model.connect("rows-reordered", self.__reordered)
        _iter = _model.append(None)
        _layer = im.getTopLayer()
        _layer.connect('visibility_changed', self.__layerVisibilityChanged)
        _layer.connect('name_changed', self.__layerNameChanged)
        _model.set(_iter, 0, _layer.getName())
        _model.set(_iter, 1, _layer)
        _tv = gtk.TreeView(_model)
        _tv.set_reorderable(True) # drag-and-drop
        _tv.set_search_column(0)
        _tv.connect("button_press_event", self.__treeViewButtonPress)
        _select = _tv.get_selection()
        _select.set_mode(gtk.SELECTION_SINGLE)
        _select.connect("changed", self.__selectionChanged)

        _renderer = gtk.CellRendererText()
        # _renderer.set_property("editable", True)
        _renderer.connect("edited", self.__cellEdited)

        _column = gtk.TreeViewColumn(_('Layers'), _renderer, text=0)
        _tv.append_column(_column)
        _sw.add(_tv)
        self.__image = im
        self.__window = win
        self.__sw = _sw
        self.__model = _model
        self.__treeview = _tv
        self.__layer = None

        #
        # establish messages connections
        #

        im.connect('active_layer_changed', self.__activeLayerChanged)
        im.connect('added_child', self.__imageAddedChild)
        im.connect('removed_child', self.__imageRemovedChild)

        _layers = [im.getTopLayer()]
        while len(_layers):
            _layer = _layers.pop()
            self.__layer = _layer
            self.__model.foreach(self.__modelAddLayer)
            _layer.connect('visibility_changed', self.__layerVisibilityChanged)
            _layer.connect('name_changed', self.__layerNameChanged)
            _layers.extend(_layer.getSublayers())

    def __treeViewButtonPress(self, widget, event, data=None):
        _button = event.button
        _x = int(event.x)
        _y = int(event.y)
        _rv = event.window is widget.get_bin_window() and _button == 3
        if _rv:
            _menu = self.__makePopupMenu(widget, _x, _y)
            if _menu is not None:
                _menu.popup(None, None, None, _button, event.time)
        return _rv

    def __makePopupMenu(self, widget, x, y):
        # print "Entered LayerDisplay._makePopupMenu"
        _data = widget.get_path_at_pos(x, y)
        if _data is None:
            return None
        _path, _col, _cx, _cy = _data
        _model = widget.get_model()
        _iter = _model.get_iter(_path)
        _layer = _model.get_value(_iter, 1)
        #
        _menu = gtk.Menu()
        _item = gtk.MenuItem(_('Rename'))
        _item.connect("activate", self.__renameLayer)
        _menu.append(_item)
        if _layer.isVisible():
            _item = gtk.MenuItem(_('Hide'))
            _flag = False
        else:
            _item = gtk.MenuItem(_('Show'))
            _flag = True
        _item.connect("activate", self.__setLayerVisibility, _flag)
        _menu.append(_item)
        _item = gtk.MenuItem(_('Add Child Layer'))
        _item.connect("activate", self.__addChildLayer)
        _menu.append(_item)
        if _layer.hasSublayers():
            _item = gtk.MenuItem(_('Hide Children'))
            _item.connect("activate", self.__setChildrenVisibility, False)
            _menu.append(_item)
            _item = gtk.MenuItem(_('Show Children'))
            _item.connect("activate", self.__setChildrenVisibility, True)
            _menu.append(_item)
        else:
            if _layer.getParentLayer() is not None:
                if not _layer.hasSublayers():
                    _item = gtk.MenuItem(_('Delete'))
                    _item.connect("activate", self.__deleteLayer)
                    _menu.append(_item)
        _item = gtk.MenuItem(_('Clear Layer'))
        _item.connect("activate", self.__clearLayer)
        _menu.append(_item)
        _menu.show_all()
        self.__layer = _layer
        return _menu

    def __selectionChanged(self, selection, data=None):
        if selection is not None:
            _model, _iter = selection.get_selected()
            if _iter is not None:
                _layer = _model.get_value(_iter, 1)
                self.__image.setActiveLayer(_layer)

    def __cellEdited(self, cell_renderer, path, text):
        _model = self.__model
        _iter = _model.get_iter_from_string(path)
        _layer = _model.get_value(_iter, 1)
        _layer.setName(text)
        _model.set(_iter, 0, text)

    def __reordered(self, model, path, iter, new_order):
        print "in reordered()"
        print "model: " + `model`
        print "path: " + `path`
        print "iter: " + `iter`
        print "new_order: " + `new_order`

    def __modelFindLayer(self, iter=None):
        # print "_modelFindLayer() ..."
        _model = self.__model
        _iter = iter
        if _iter is None:
            _iter = _model.get_iter_first()
        _layer = self.__layer
        _path = None
        _mlayer = _model.get_value(_iter, 1)
        if _mlayer is _layer:
            _path = _model.get_path(_iter)
        else:
            if _model.iter_has_child(_iter):
                _child = _model.iter_children(_iter)
                while _child is not None:
                    _path = self.__modelFindLayer(_child)
                    if _path is not None:
                        break
                    _child = _model.iter_next(_child)
        return _path


    def __modelAddLayer(self, model, path, iter):
        # print "_modelAddLayer() ..."
        _layer = self.__layer
        _mlayer = model.get_value(iter, 1)
        _val = _mlayer is _layer.getParentLayer()
        if _val:
            _iter = model.append(iter)
            model.set(_iter, 0, _layer.getName())
            model.set(_iter, 1, _layer)
        return _val

    def __imageAddedChild(self, obj, *args):
        # print "__imageAddedChild()"
        _alen = len(args)
        if _alen < 1:
            raise ValueError, "Invalid argument count: %d" % _alen
        _newlayer = args[0]
        self.__layer = _newlayer
        self.__model.foreach(self.__modelAddLayer)
        _path = self.__modelFindLayer()
        if _path is None:
            raise ValueError, "Layer not found in model!"
        _ppath = _path[:-1]
        _tv = self.__treeview
        while len(_ppath):
            if not _tv.row_expanded(_ppath):
                _tv.expand_row(_ppath, False)
            _ppath = _ppath[:-1]
        _tv.get_selection().select_path(_path)
        _newlayer.connect('visibility_changed', self.__layerVisibilityChanged)
        _newlayer.connect('name_changed', self.__layerNameChanged)

    def __modelDeleteLayer(self, model, path, iter):
        # print "_modelDeleteLayer() ..."
        _mlayer = model.get_value(iter, 1)
        _val = _mlayer is self.__layer
        if _val:
            model.remove(iter)
        return _val

    def __imageRemovedChild(self, obj, *args):
        # print "__imageRemovedChild()"
        _path = self.__modelFindLayer()
        if _path is None:
            raise ValueError, "Layer not found in model!"
        _ppath = _path[:-1]
        _tv = self.__treeview
        while len(_ppath):
            if not _tv.row_expanded(_ppath):
                _tv.expand_row(_ppath, False)
            _ppath = _ppath[:-1]
        self.__model.foreach(self.__modelDeleteLayer)
        self.__layer.disconnect(self)
        _tv.get_selection().select_path(_path[:-1])        

    def __modelDisconnectLayer(self, model, path, iter):
        # print "__modelDisconnnectLayer() ..."
        _layer = model.get_value(iter, 1)
        _layer.disconnect(self)
        return False

    def __activeLayerChanged(self, obj, *args):
        # print "_activeLayerChanged()"
        self.__layer = obj.getActiveLayer()
        _path = self.__modelFindLayer()
        if _path is None:
            raise ValueError, "Layer not found in model!"
        _ppath = _path[:-1]
        _tv = self.__treeview
        while len(_ppath):
            if not _tv.row_expanded(_ppath):
                _tv.expand_row(_ppath, False)
            _ppath = _ppath[:-1]
        _tv.get_selection().select_path(_path)

    def __layerVisibilityChanged(self, obj, *args):
        # print "_layerVisibilityChanged()"
        for _obj in obj.getLayerEntities('point'):
            if _obj.isVisible():
                _obj.sendMessage('refresh')
        _ctypes = ['hcline', 'vcline', 'acline', 'cline', 'ccircle']
        for _ctype in _ctypes:
            for _obj in obj.getLayerEntities(_ctype):
                if _obj.isVisible():
                    _obj.sendMessage('refresh')
        _gtypes = ['segment', 'circle', 'arc', 'leader', 'polyline',
                   'chamfer', 'fillet', 'textblock', 'linear_dimension',
                   'horizontal_dimension', 'vertical_dimension',
                   'radial_dimension', 'angular_dimension']
        for _gtype in _gtypes:
            for _obj in obj.getLayerEntities(_gtype):
                if _obj.isVisible():
                    _obj.sendMessage('refresh')

    def __modelRenameLayer(self, model, path, iter):
        _layer = self.__layer
        _mlayer = model.get_value(iter, 1)
        _val = _mlayer is _layer
        if _val:
            model.set(iter, 0, _layer.getName())
        return _val

    def __layerNameChanged(self, obj, *args):
        self.__layer = obj
        self.__model.foreach(self.__modelRenameLayer)
        
    def __setLayerVisibility(self, menuitem, data=None):
        _image = self.__image
        _image.startAction()
        try:
            self.__layer.setVisibility(data)
        finally:
            _image.endAction()
        return False

    def __setChildrenVisibility(self, menuitem, data=None):
        _image = self.__image
        _image.startAction()
        try:
            _layers = self.__layer.getSublayers()
            while len(_layers):
                _layer = _layers.pop()
                _layer.setVisibility(data)
                _layers.extend(_layer.getSublayers())
        finally:
            _image.endAction()
        return False

    def __deleteLayer(self, menuitem, data=None):
        _image = self.__image
        _layer = self.__layer
        _image.startAction()
        try:
            if _layer.hasChildren():
                _layer.clear()
            _image.delLayer(_layer)
            _layer.finish()
        finally:
            _image.endAction()
        self.__layer = None
        return False

    def __clearLayer(self, menuitem, data=None):
        _image = self.__image
        _image.startAction()
        try:
            self.__layer.clear()
        finally:
            _image.endAction()
        return False

    def __addChildLayer(self, menuitem, data=None):
        if _debug is True:
            print "SDB Debug: entered LayerDisplay.addChildLayer()..."
        _window = self.__window
        _dialog = gtk.Dialog(_('Add New Child Layer'), _window,
                             gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
                             (gtk.STOCK_OK, gtk.RESPONSE_OK,
                              gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT))
        _hbox = gtk.HBox(False, 2)
        _hbox.set_border_width(2)
        _dialog.vbox.pack_start(_hbox, False, False, 0)
        _label = gtk.Label(_('Name:'))
        _hbox.pack_start(_label, False, False, 0)
        _entry = gtk.Entry()
        _entry.set_text(_('NewChildLayer'))
        _hbox.pack_start(_entry, True, True, 0)
        _dialog.show_all()
        _response = _dialog.run()
        if _response == gtk.RESPONSE_OK:
            _name = _entry.get_text()
            if len(_name):
                _new_layer = layer.Layer(_name)
                _image = self.__image
                _image.startAction()
                try:
                    _image.addChildLayer(_new_layer, self.__layer)
                finally:
                    _image.endAction()
        _dialog.destroy()
        return False

    def __renameLayer(self, menuitem, data=None):
        if _debug is True:
            print "SDB debug: entered _renameLayer()"
        _layer = self.__layer
        _name = _layer.getName()
        _window = self.__window
        _dialog = gtk.Dialog(_('Rename Layer'), _window,
                             gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
                             (gtk.STOCK_OK, gtk.RESPONSE_OK,
                              gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT))
        _hbox = gtk.HBox(False, 2)
        _hbox.set_border_width(2)
        _dialog.vbox.pack_start(_hbox, False, False, 0)
        _label = gtk.Label(_('Name:'))
        _hbox.pack_start(_label, False, False, 0)
        _entry = gtk.Entry()
        _entry.set_text(_name)
        _hbox.pack_start(_entry, True, True, 0)
        _dialog.show_all()
        _response = _dialog.run()
        if _response == gtk.RESPONSE_OK:
            _new_name = _entry.get_text()
            if len(_new_name):
                _image = self.__image
                _image.startAction()
                try:
                    _layer.setName(_new_name)
                finally:
                    _image.endAction()
        _dialog.destroy()
        return False

    def close(self):
        self.__model.foreach(self.__modelDisconnectLayer)
        self.__image.disconnect(self)
        self.__image = None
        self.__window = None
        self.__sw = None
        self.__model = None
        self.__treeview = None
        self.__layer = None

    def getWindow(self):
        return self.__sw

class ImageView(object):
    def __init__(self, im, xmin=0.0, ymax=0.0, upp=1.0):
        if _debug is True:
            print "SDB debug: Created new ImageView class instance"
        if not isinstance(im, image.Image):
            raise TypeError, "Invalid Image type: " + `type(im)`
        _xmin = util.get_float(xmin)
        _ymax = util.get_float(ymax)
        _upp = util.get_float(upp)
        if not _upp > 0.0:
            raise ValueError, "Invalid units-per-pixel value: %g" % _upp
        self.__image = im
        self.__pixmap = None
        self.__gc = None
        self.__width = None
        self.__height = None
        _da = gtk.DrawingArea()
        _da.set_size_request(100, 100)
        _black = gtk.gdk.color_parse('black')
        _da.modify_fg(gtk.STATE_NORMAL, _black)
        _da.modify_bg(gtk.STATE_NORMAL, _black)
        _da.set_flags(gtk.CAN_FOCUS)

        _da.connect("expose_event", self.__exposeEvent)
        _da.connect("realize", self.__realizeEvent)
        _da.connect("configure_event", self.__configureEvent)
        _da.connect("key_press_event", self.__keyPressEvent)
        _da.connect("key_release_event", self.__keyPressEvent)
        _da.connect("enter_notify_event", self.__elNotifyEvent)
        _da.connect("leave_notify_event", self.__elNotifyEvent)
        _da.connect("focus_in_event", self.__focusChangedEvent)
        _da.connect("focus_out_event", self.__focusChangedEvent)

        _da.set_events(gtk.gdk.EXPOSURE_MASK |
                       gtk.gdk.LEAVE_NOTIFY_MASK |
                       gtk.gdk.BUTTON_PRESS_MASK |
                       gtk.gdk.BUTTON_RELEASE_MASK |
                       gtk.gdk.ENTER_NOTIFY_MASK|
                       gtk.gdk.LEAVE_NOTIFY_MASK|
                       gtk.gdk.KEY_PRESS_MASK |
                       gtk.gdk.KEY_RELEASE_MASK |
                       gtk.gdk.FOCUS_CHANGE_MASK |
                       gtk.gdk.POINTER_MOTION_MASK)
        self.__da = _da
        self.__xmin = _xmin
        self.__ymax = _ymax
        self.__upp = _upp
        self.__view = None
        im.connect('added_child', self.__imageAddedChild)
        im.connect('removed_child', self.__imageRemovedChild)
        im.connect('modified', self.__objModified)

    def __realizeEvent(self, widget, data=None):
        _win = widget.window
        _w, _h = _win.get_size()
        self.__width = _w
        self.__height = _h
        _gc = _win.new_gc()
        _gc.set_exposures(True)
        self.__gc = _gc

    def __exposeEvent(self, widget, event, data=None):
        _pixmap = self.__pixmap
        _x, _y, _w, _h = event.area
        _gc = widget.get_style().fg_gc[gtk.STATE_NORMAL]
        widget.window.draw_drawable(_gc, _pixmap, _x, _y, _x, _y, _w, _h)
        return True

    def __configureEvent(self, widget, event, data=None):
        _win = widget.window
        _w, _h = _win.get_size()
        if self.__width != _w or self.__height != _h:
            self.__view = None
            self.__width = _w
            self.__height = _h
            _pixmap = gtk.gdk.Pixmap(_win, _w, _h)
            _gc = widget.get_style().fg_gc[gtk.STATE_NORMAL]
            _pixmap.draw_rectangle(_gc, True, 0, 0, _w, _h)
            self.__pixmap = _pixmap
        return True

    def __focusChangedEvent(self, widget, event, data=None):
        return False

    def __buttonPressEvent(self, widget, event, data=None):
        _rv = False
        _tool = gtkimage.getTool()
        gtkimage.setToolpoint(event)
        if (event.button == 1 and
            _tool is not None and
            _tool.hasHandler('button_press')):
            _rv = _tool.getHandler('button_press')(gtkimage, widget,
                                                   event, _tool)
        return _rv

    def __buttonReleaseEvent(self, widget, event, data=None):
        _rv = False
        _tool = gtkimage.getTool()
        gtkimage.setToolpoint(event)
        if (event.button == 1 and
            _tool is not None and
            _tool.hasHandler('button_release')):
            _rv = _tool.getHandler('button_release')(gtkimage, widget,
                                                     event, _tool)
        return _rv

    def __keyPressEvent(self, widget, event, data=None):
        _key = event.keyval
        _rv = (_key == gtk.keysyms.Left or
               _key == gtk.keysyms.Right or
               _key == gtk.keysyms.Up or
               _key == gtk.keysyms.Down)
        if _rv:
            _mods = event.state & gtk.accelerator_get_default_mod_mask()
            _dx = _dy = None
            if (_key == gtk.keysyms.Left):
                _dx = -1.0
            elif (_key == gtk.keysyms.Right):
                _dx = 1.0
            elif (_key == gtk.keysyms.Up):
                _dy = 1.0
            elif (_key == gtk.keysyms.Down):
                _dy = -1.0
            else:
                raise ValueError, "Unexpected keyval: %d" % _key
            if (_mods == gtk.gdk.CONTROL_MASK):
                _scale = 0.25
            elif (_mods == gtk.gdk.SHIFT_MASK):
                _scale = 0.5
            elif (_mods == gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK):
                _scale = 1.0
            else:
                _scale = 0.05
        if not _rv:
            _tool = gtkimage.getTool()
            if _tool is not None and _tool.hasHandler('key_press'):
                _rv = _tool.getHandler('key_press')(gtkimage, widget,
                                                    event, _tool)
        return _rv

    def __keyReleaseEvent(self, widget, event, data=None):
        _rv = False
        _tool = gtkimage.getTool()
        if _tool is not None and _tool.hasHandler('key_release'):
            _rv = _tool.getHandler('key_release')(gtkimage, widget,
                                                  event, _tool)
        return _rv

    def __motionNotifyEvent(self, widget, event, data=None):
        _rv = False
        _tool = gtkimage.getTool()
        gtkimage.setToolpoint(event)
        if _tool is not None and _tool.hasHandler('motion_notify'):
            _rv = _tool.getHandler('motion_notify')(gtkimage, widget,
                                                    event, _tool)
        return _rv
    
    def __elNotifyEvent(self, widget, event, data=None):
        gtkimage.setToolpoint(event)
        return True
                          
    def __drawObject(self, obj, col=None):
        _col = col
        _xmin, _ymin, _xmax, _ymax = self.getView()
        if obj.inRegion(_xmin, _ymin, _xmax, _ymax):
            _image = self.__image
            if _col is None:
                if obj.getParent() is not _image.getActiveLayer():
                    _col = _image.getOption('INACTIVE_LAYER_COLOR')
            obj.draw(self, _col)

    def __imageAddedChild(self, obj, *args):
        # print "_imageAddedChild()"
        _alen = len(args)
        if _alen < 1:
            raise ValueError, "Invalid argument count: %d" % _alen
        _layer = args[0]
        if not isinstance(_layer, layer.Layer):
            raise TypeError, "Unexpected child type: " + `type(_layer)`
        _layer.connect('added_child', self.__layerAddedChild)
        _layer.connect('removed_child', self.__layerRemovedChild)

    def __layerAddedChild(self, obj, *args):
        # print "__layerAddedChild()"
        _alen = len(args)
        if _alen < 1:
            raise ValueError, "Invalid argument count: %d" % _alen
        _child = args[0] # need some verification test here ...
        _child.connect('modified', self.__objModified)
        _child.connect('visibility_changed', self.__objVisibilityChanged)
        _child.connect('refresh', self.__refreshObject)
        _child.connect('change_pending', self.__objChanging)
        if _child.isVisible() and obj.isVisible():
            self.__drawObject(_child)

    def __imageRemovedChild(self, obj, *args):
        # print "__imageRemovedChild()"
        _alen = len(args)
        if _alen < 1:
            raise ValueError, "Invalid argument count: %d" % _alen
        _layer = args[0]
        if not isinstance(_layer, layer.Layer):
            raise TypeError, "Unexpected child type: " + `type(_layer)`
        _layer.disconnect(self)

    def __layerRemovedChild(self, obj, *args):
        # print "__layerDeletedChild()"
        _alen = len(args)
        if _alen < 1:
            raise ValueError, "Invalid argument count: %d" % _alen
        _child = args[0] # need some verification test here ...
        if _child.isVisible() and obj.isVisible():
            _color = self.__image.getOption('BACKGROUND_COLOR')
            self.__drawObject(_child, _color)
        _child.disconnect(self)

    def __objModified(self, obj, *args):
        # print "__objModified()"
        if obj.isVisible() and obj.getParent().isVisible():
            self.__drawObject(obj)

    def __objChanging(self, obj, *args):
        # print "__objChanging()"
        if obj.isVisible() and obj.getParent().isVisible():
            self.__drawObject(obj, self.__image.getOption('BACKGROUND_COLOR'))
            
    def __objVisibilityChanged(self, obj, *args):
        # print "__objVisibilityChanged()"
        if obj.getParent().isVisible():
            _col = None
            if not obj.isVisible():
                _col = self.__image.getOption('BACKGROUND_COLOR')
            self.__drawObject(obj, _col)

    def __refreshObject(self, obj, *args):
        # print "__refreshObject()"
        _col = None
        if not obj.isVisible() or not obj.getParent().isVisible():
            _col = self.__image.getOption('BACKGROUND_COLOR')
        self.__drawObject(obj, _col)

    def getView(self):
        """Get the region of space the ImageView draws

getRegion()

This method returns a tuple of four values: xmin, ymin, xmax, ymax
        """
        if self.__view is None:
            _xmin = self.__xmin
            _ymax = self.__ymax
            _upp = self.__upp
            _w = self.__width
            _h = self.__height
            _xmax = _xmin + (_upp * _w)
            _ymin = _ymax - (_upp * _h)
            self.__view = (_xmin, _ymin, _xmax, _ymax)
        return self.__view

    def getPixmap(self):
        """Return the gtk.gdk.Pixmap for this ImageView.

getPixmap()
        """
        return self.__pixmap

    def getUnitsPerPixel(self):
        """Return the units-per-pixel scaling factor for the ImageView.

getUnitsPerPixel()
        """
        return self.__upp

    def setUnitsPerPixel(self, upp):
        """Set the units-per-pixel scaling factor for the ImageView.

setUnitsPerPixel(upp)

Argument 'upp' should be a float value greater
        """
        _upp = util.get_float(upp)
        if not _upp > 0.0:
            raise ValueError, "Invalid units-per-pixel value: %g" % _upp
        self.__upp = _upp
        self.__view = None

    def pixelsToCoords(self, x, y):
        """Convert from pixel coordinates to x-y coordinates.

pixelsToCoords(x, y)

Arguments 'x' and 'y' should be positive integers. This method
returns a tuple of two float values
        """
        if not isinstance(x, int):
            raise TypeError, "Invalid 'x' type: " + `type(x)`
        if x < 0:
            raise ValueError, "Invalid 'x' value: %d" % x
        if not isinstance(y, int):
            raise TypeError, "Invalid 'y' type: " + `type(y)`
        if y < 0:
            raise ValueError, "Invalid 'y' value: %d" % y
        _upp = self.__upp
        _xc = self.__xmin + (x * _upp)
        _yc = self.__ymax - (y * _upp)
        return _xc, _yc

    def coordsToPixels(self, x, y):
        """Convert from x-y coordinates to pixel coordinates

coordsToPixels(x, y)

Arguments 'x' and 'y' should be float values. This method
returns a tuple holding two integer values
        """
        _x = util.get_float(x)
        _y = util.get_float(y)
        _upp = self.__upp
        _xp = int((x - self.__xmin)/_upp)
        _yp = int((self.__ymax - y)/_upp)
        return _xp, _yp

    def close(self):
        self.__image.disconnect(self)

    def redraw(self):
        """This method draws all the objects visible in the ImageView.

redraw()
        """
        _da = self.__da
        if (_da.flags() & gtk.MAPPED):
            _image = self.__image
            _w = self.__width
            _h = self.__height
            _gc = _da.get_style().fg_gc[gtk.STATE_NORMAL]
            self.__pixmap.draw_rectangle(_gc, True, 0, 0, _w, _h)
            _active = _image.getActiveLayer()
            _layers = [_image.getTopLayer()]
            while (len(_layers)):
                _layer = _layers.pop()
                if _layer is not _active:
                    self.drawLayer(_layer)
                _layers.extend(_layer.getSublayers())
            self.drawLayer(_active)
            _da.queue_draw() # generate an expose event

    def drawLayer(self, l):
        if not isinstance(l, layer.Layer):
            raise TypeError, "Invalid layer type: " + `type(l)`
        if l.getParent() is not self.__image:
            raise ValueError, "Layer not found in Image"
        if l.isVisible():
            _xmin = self.__xmin
            _ymax = self.__ymax
            _upp = self.__upp
            _xmax = _xmin + (_upp * _w)
            _ymin = _ymax - (_upp * _h)
            _col = self.getOption('INACTIVE_LAYER_COLOR')
            if l is self.getActiveLayer():
                _col = None
            _cobjs = []
            _objs = []
            _pts = []
            for _obj in l.objsInRegion(_xmin, _ymin, _xmax, _ymax):
                if _obj.isVisible():
                    if isinstance(_obj, Point):
                        _pts.append(_obj)
                    elif isinstance(_obj, ConstructionObject):
                        _cobjs.append(_obj)
                    else:
                        _objs.append(_obj)
            for _obj in _cobjs:
                _obj.draw(self, _col)
            for _obj in _pts:
                _obj.draw(self, _col)
            for _obj in _objs:
                _obj.draw(self, _col)


class ImageWindow(object):
    def __init__(self, im):
        if _debug is True:
            print "SDB debug: instantiated another ImageWindow class instance"
        if not isinstance(im, image.Image):
            raise TypeError, "Invalid Image type: " + `type(im)`
        self.__image = im
        #
        # Display window
        #
        _window = gtk.Window()
        _window.set_title("Untitled")
        _window.connect("destroy", self._closeImage)
        _width = min(1024, int(0.8 * float(gtk.gdk.screen_width())))
        _height = min(768, int(0.8 * float(gtk.gdk.screen_height())))
        _window.set_default_size(_width, _height)
        #
        _vbox = gtk.VBox(False, 2)
        _vbox.set_border_width(2)
        _window.add(_vbox)
        self.__ldisp = LayerDisplay(im)

    def getImage(self):
        """Return the Image stored in the ImageDisplay.

getImage()
        """
        return self.__image

    image = property(getImage, None, None, "The Image used for visualizing.")

    def closeImage(self, widget):
        """Close a window containing a Image.

closeImage()
        """
        _image = self.__image
        _image.close()
        _image.disconnect(self)
        self.__ldisp(close)
        for _i in xrange(len(globals.imagelist)):
            _gimage = globals.imagelist[_i]
            if _image is _gimage:
                del globals.imagelist[_i]
                _gimage.window.destroy()
                if not len(globals.imagelist):
                    gtk.main_quit()
                break
        return False