from config import *
from imagefunctions import ImageSetLoader, ImageStretcher, ImageSet

def draw_line(surf, from_point, to_point):
    draw.line(surf, (255,255,255), from_point, to_point)

def main():
    pygame.init()
    imageset_loader = ImageSetLoader()
    image_set = imageset_loader.button
    image_stretcher = ImageStretcher(image_set.normal)
    button_image = image_stretcher(size=(200, 50), 
                                   fill=(250, 250, 250, 150))
    screen = pygame.display.set_mode((640, 480))
    backup = pygame.image.load('images/standard/back.jpg').convert()
    back = backup.copy()
    m = [0, 0]
    md = False
    
    while True:
        for event in pygame.event.get():
            if event.type == QUIT:
                sys.exit()
            elif event.type == MOUSEBUTTONDOWN:
                print event
                if not md and event.button == 1:
                    md = True
                    m[:] = event.pos
                elif event.button == 3:
                    back = backup.copy()

            elif event.type == MOUSEBUTTONUP:
                if md and event.button == 1:
                    md = False
            elif event.type == MOUSEMOTION:
                print event
                if md and event.buttons[0]:
                    x, y = tuple(m)
                    dx, dy = event.rel
                    to_point = (x+dx, y+dy)
                    draw_line(back, from_point=m, to_point=to_point)
                    m[:] = to_point
            else:
                print event
                
        screen.blit(back, (0, 0))
        screen.blit(button_image, (250, 250))
        pygame.display.flip()
                
class Control(object):
    """Meta-Class containing basics for all control elements"""
    def __init__(self):
        pass

class Container(Control, sprite.OrderedUpdates):
    def __init__(self):
        Control.__init__(self)
        sprite.OrderedUpdates.__init__(self)
    
class Widget(Control, sprite.Sprite):
    def __init__(self):
        Control.__init__(self)
        sprite.Sprite.__init__(self)
    
class ContainerWidget(Container, Widget):
    def __init__(self):
        Widget.__init__(self)
        Container.__init__(self)
        
class Desktop(Container):
    def __init__(self):
        Container.__init__(self)
        
class Layer(Container):
    def __init__(self):
        Container.__init__(self)

class Frame(Container, Widget):
    def __init__(self):
        Container.__init__(self)
        Widget.__init__(self)
        
class Button(Container, Widget):
    def __init__(self):
        Container.__init__(self)
        Widget.__init__(self)
    
class Entry(Container, Widget):
    def __init__(self):
        Container.__init__(self)
        Widget.__init__(self)
    
class Label(Container, Widget):
    def __init__(self):
        Container.__init__(self)
        Widget.__init__(self)
    
class Text(Container, Widget):
    def __init__(self):
        Container.__init__(self)
        Widget.__init__(self)
    
class Checkbutton(Container, Widget):
    def __init__(self):
        Container.__init__(self)
        Widget.__init__(self)
    
class Radiobutton(Container, Widget):
    def __init__(self):
        Container.__init__(self)
        Widget.__init__(self)
    
class Listbox(Container, Widget):
    def __init__(self):
        Container.__init__(self)
        Widget.__init__(self)
    
class Scrollbar(Container, Widget):
    def __init__(self):
        Container.__init__(self)
        Widget.__init__(self)

class Root(sprite.OrderedUpdates):
    def __init__(self):
        self.update_rect()
        print self.rect
        
    def update(self, *args):
        self.update_rect()
        sprite.OrderedUpdates.update(self, *args)
        
    def update_rect(self):
        """Update own rect with display surface rect"""
        try:
            self.rect = pygame.display.get_surface().get_rect()
        except AttributeError:
            # skip and set dummy until pygame.display is initialized
            self.rect = Rect(0, 0, 0, 0)
            
class _Widget(sprite.OrderedUpdates):
    def __init__(self, master=None,
                       rect=None, 
                       position=(0, 0), 
                       width=100, 
                       height=20):
        if rect: 
            self.rect = rect
        else:
            self.rect = Rect(position, (width, height))

        self.master = master
        if master:
            self.master.add(self)
        
    def render_image(self):
        """Render widget-specific image surface and save in self.image"""
        self.image = Surface(self.rect.size)
        
        
def spritecollidetopmost(sprite, group, collided = None):
    """pygame.sprite.spritecollideany(sprite, group) -> sprite
       finds any sprites that collide

       Given a sprite and a group of sprites, this will
       return the first sprite that collides with the given
       sprite and comes last in the group. If there are no 
       collisions this returns None.

       If you don't need all the features of the
       spritecollide function, this function will be a
       bit quicker.
       
       Param group must have the attribute _spritelist
       containing all sprite references in layered order.
       Group "OrderedUpdates" provides this funtionality.

       All sprites must have a "rect" value, which is a
       rectangle of the sprite area."""

    if collided:
        for i in xrange(len(group._spritelist)):
            s = group._spritelist[-i]
            if collided( sprite, s ):
                return s
    else:
        spritecollide = sprite.rect.colliderect
        for i in xrange(len(group._spritelist)):
            s = group._spritelist[-i]
            if spritecollide(s.rect):
                return s
            
    return None

if __name__ == "__main__":
    main()