# Knihovna Object Micro Widget 2 (verze z 20. října 2026)

import micro_widget as mw
from event import *

class MWValue:
    def __init__(self):
        super().__init__()
        self.mw_value = None

    def get_mw_value(self):
        return self.mw_value

    def set_mw_value(self, mw_value):
        self.mw_value = mw_value
        return self

    def destroy_mw_value(self):
        raise NotImplementedError("Method has to be rewritten.")
        
    def delete_mw_value(self):
        self.destroy_mw_value()
        self.set_mw_value(None)
        return self

    def make_mw_value(self, root):
        raise NotImplementedError("Method has to be rewritten.")

    def create_mw_value(self):
        self.set_mw_value(self.make_mw_value(self.get_mw_window()))
        return self


class Widget(Announcer):
    def __init__(self):
        super().__init__()
        self.mw_window = None

    def get_mw_window(self):
        return self.mw_window

    def set_mw_window(self, mw_window):
        self.mw_window = mw_window
        return self

    def create_mw_values(self, mw_window):
        self.set_mw_window(mw_window)
        self.create_mw_value()
        return self

    def destroy_mw_values(self):
        self.destroy_mw_value()
        self.set_mw_window(None)
        return self

    def is_mw_displayed(self):
        return self.get_mw_window() != None

class AtomicWidget(MWValue, Widget):
    pass
    
class EmptyWidget(AtomicWidget):
    def create_mw_value(self):
        pass

    def destroy_mw_value(self):
        pass

    def move(self, dx, dy):
        return self
        
class PlacedWidget(AtomicWidget):
    def __init__(self):
        super().__init__()
        self.x = 0
        self.y = 0

    def get_x(self):
        return self.x

    def set_x(self, x):
        self.x = x
        if self.is_mw_displayed():
            self.mw_update_position()
        return self

    def get_y(self):
        return self.y

    def set_y(self, y):
        self.y = y
        if self.is_mw_displayed():
            self.mw_update_position()
        return self

    def mw_set_position(self, x, y):
        raise NotImplementedError("Method has to be rewritten.")

    def mw_update_position(self):
        return self.mw_set_position(self.get_x(), self.get_y())
        
    def move(self, dx, dy):
        self.set_x(self.get_x() + dx)
        self.set_y(self.get_y() + dy)
        return self

    def create_mw_value(self):
        super().create_mw_value()
        self.mw_update_position()
        return self

    def destroy_mw_value(self):
        raise NotImplementedError("Method has to be rewritten.")
        
    
    
class Window(MWValue, Announcer):
    def __init__(self):
        super().__init__()
        self.widget = EmptyWidget()
        self.create_mw_value()

    # micro widget
    def get_mw_window(self):
        return self.get_mw_value()
    
    def make_mw_value(self, root):
        return mw.make_window()
    
    # vlastnost widget
    
    def get_widget(self):
        return self.widget

    def set_widget(self, widget):     
        old_widget = self.get_widget()
        old_widget.destroy_mw_values()
        old_widget.set_delegate(None)

        self.widget = widget
        
        widget.set_delegate(self)
        widget.create_mw_values(self.get_mw_value())
        return self

    def main_loop(self):
        mw.main_loop(self.get_mw_value())
        return self

    def update(self):
        mw.update_window(self.get_mw_value())
        return self

    def is_opened(self):
        return mw.is_window_opened(self.get_mw_value())

    def destroy(self):
        mw.destroy_window(self.get_mw_value())
        return self

class TextedWidget(PlacedWidget):
    def __init__(self):
        super().__init__()
        self.text = ""

    # micro widget
    def mw_set_text(self, text):
        raise NotImplementedError("Method has to be rewritten.")
    
    def mw_update_text(self):
        self.mw_set_text(self.get_text())
        return self
        
    def create_mw_value(self):
        super().create_mw_value()
        self.mw_update_text()
        return self

    # vlastnosti
    def get_text(self):
        return self.text

    def set_text(self, text):
        self.text = text
        if self.is_mw_displayed():
            self.mw_update_text()
        return self


class Label(TextedWidget):
    # micro widget
    def make_mw_value(self, mw_window):
        return mw.make_label(mw_window)

    def mw_set_text(self, text):
        mw_label = self.get_mw_value()
        mw.set_label_text(mw_label, text)
        return self

    def mw_set_position(self, x, y):
        mw_label = self.get_mw_value()
        mw.set_label_x(mw_label, x)
        mw.set_label_y(mw_label, y)
        return self

    def destroy_mw_value(self):
        mw.destroy_label(self.get_mw_value())
        return self

def mw_button_click_callback(mw_button):
    button = mw.get_button_data(mw_button)
    button.clicked()

    
class Button(TextedWidget):
    # micro widget
    def make_mw_value(self, window):
        return mw.make_button(window)

    def mw_set_text(self, text):
        mw_value = self.get_mw_value()
        mw.set_button_text(mw_value, text)
        
    def create_mw_value(self):
        super().create_mw_value()
        mw_button = self.get_mw_value()
        mw.set_button_data(mw_button, self)
        mw.set_button_click_callback(mw_button, mw_button_click_callback)
        return self

    def mw_set_position(self, x, y):
        mw_button = self.get_mw_value()
        mw.set_button_x(mw_button, x)
        mw.set_button_y(mw_button, y)
        return self

    def destroy_mw_value(self):
        mw.destroy_button(self.get_mw_value())
        return self

    # události
    def clicked(self):
        self.send_event("ev_button_clicked")
        return self

class ValuedWidget(PlacedWidget):
    def __init__(self):
        super().__init__()
        self.value = self.get_init_value()

    # micro widget
    def mw_set_value(self, value):
        raise NotImplementedError("Method has to be rewritten.")
    
    def mw_update_value(self):
        self.mw_set_value(self.get_value())
        return self
        
    def create_mw_value(self):
        super().create_mw_value()
        self.mw_update_value()
        return self

    # vlastnosti
    def get_init_value(self):
        raise NotImplementedError("Method has to be rewritten.")
    
    def get_value(self):
        return self.value
    
    def set_value(self, value):
        if value != self.get_value():
            self.value = value
            if self.is_mw_displayed():
                self.mw_update_value()
            self.change()
        return self

    # metody
    def change(self):
        raise NotImplementedError("Method has to be rewritten.")
        

def mw_entry_change_callback(mw_entry):
    entry = mw.get_entry_data(mw_entry)
    entry.set_value(mw.get_entry_value(mw_entry))
    
class Entry(ValuedWidget):
    def get_init_value(self):
        return ""
    
    # micro widget
    def make_mw_value(self, mw_window):
        return mw.make_entry(mw_window)
    
    def create_mw_value(self):
        super().create_mw_value()
        mw_entry = self.get_mw_value()
        mw.set_entry_data(mw_entry, self)
        mw.set_entry_change_callback(mw_entry, mw_entry_change_callback)
        return self

    def mw_set_position(self, x, y):
        mw_entry = self.get_mw_value()
        mw.set_entry_x(mw_entry, x)
        mw.set_entry_y(mw_entry, y)
        return self

    def destroy_mw_value(self):
        mw.destroy_entry(self.get_mw_value())
        return self

    def mw_set_value(self, text):
        mw_entry = self.get_mw_value()
        mw.set_entry_value(mw_entry, text)
        return self

    # změna
    def change(self):
        self.send_event("ev_entry_change")
        return self

class SelectableWidget(ValuedWidget):
    def get_init_value(self):
        return False

    def is_selected(self):
        return self.get_value()

    def toggle(self):
        return self.set_value(not self.get_value())
    
def mw_checkbox_change_callback(mw_checkbox):
    checkbox = mw.get_checkbox_data(mw_checkbox)
    checkbox.set_value(mw.get_checkbox_value(mw_checkbox))
        
class Checkbox(SelectableWidget):
    # micro widget
    def make_mw_value(self, mw_window):
        return mw.make_checkbox(mw_window)
    
    def create_mw_value(self):
        super().create_mw_value()
        mw_checkbox = self.get_mw_value()
        mw.set_checkbox_data(mw_checkbox, self)
        mw.set_checkbox_change_callback(mw_checkbox, mw_checkbox_change_callback)
        return self

    def mw_set_position(self, x, y):
        mw_checkbox = self.get_mw_value()
        mw.set_checkbox_x(mw_checkbox, x)
        mw.set_checkbox_y(mw_checkbox, y)
        return self

    def destroy_mw_value(self):
        mw.destroy_checkbox(self.get_mw_value())
        return self

    def mw_set_value(self, text):
        mw_checkbox = self.get_mw_value()
        mw.set_checkbox_value(mw_checkbox, text)
        return self

    # změna
    def change(self):
        self.send_event("ev_checkbox_change")
        return self

def mw_radiobutton_change_callback(mw_radiobutton):
    radiobutton = mw.get_radiobutton_data(mw_radiobutton)
    radiobutton.set_value(mw.get_radiobutton_value(mw_radiobutton))
    
class Radiobutton(SelectableWidget):
    # micro widget
    def make_mw_value(self, mw_window):
        return mw.make_radiobutton(mw_window)
    
    def create_mw_value(self):
        super().create_mw_value()
        mw_radiobutton = self.get_mw_value()
        mw.set_radiobutton_data(mw_radiobutton, self)
        mw.set_radiobutton_change_callback(mw_radiobutton, mw_radiobutton_change_callback)
        return self

    def mw_set_position(self, x, y):
        mw_radiobutton = self.get_mw_value()
        mw.set_radiobutton_x(mw_radiobutton, x)
        mw.set_radiobutton_y(mw_radiobutton, y)
        return self

    def destroy_mw_value(self):
        mw.destroy_radiobutton(self.get_mw_value())
        return self

    def mw_set_value(self, text):
        mw_radiobutton = self.get_mw_value()
        mw.set_radiobutton_value(mw_radiobutton, text)
        return self

    # změna
    def change(self):
        self.send_event("ev_radiobutton_change")
        return self
    

class Group(Widget):
    def __init__(self):
        super().__init__()
        self.items = []

    def get_items(self):
        return self.items[:]

    def check_item(self, item):
        if not isinstance(item, Widget):
            raise TypeError("Items have to be widgets.")
    
    def check_items(self, items):
        for item in items:
            self.check_item(item)
        return self

    def set_items(self, items):
        self.check_items(items)
        self.set_items_delegate(None)
        self.do_set_items(items)
        self.set_items_delegate(self)
        return self

    def is_mw_displayed(self):
        return self.get_mw_window() != None
        
    def set_items_delegate(self, delegate):
        for item in self.get_items():
            item.set_delegate(delegate)
        return self

    def create_mw_value(self):
        return self

    def destroy_mw_value(self):
        return self
    
    def move(self, dx, dy):
        for item in self.get_items():
            item.move(dx, dy)
        return self

    def do_set_items(self, items):
        if self.is_mw_displayed():
            self.destroy_items_mw_values()
        self.items = items[:]
        if self.is_mw_displayed():
            self.create_items_mw_values(self.get_mw_window())
        return self

    # micro widget
    def create_mw_values(self, mw_window):
        super().create_mw_values(mw_window)
        self.create_items_mw_values(mw_window)
        return self

    def create_items_mw_values(self, mw_window):
        for item in self.get_items():
            item.create_mw_values(mw_window)
        return self
    
    def destroy_mw_values(self):
        super().destroy_mw_values()
        self.destroy_items_mw_values()
        return self

    def destroy_items_mw_values(self):
        for item in self.get_items():
            item.destroy_mw_values()
        return self

"""
class EventTrace:
    def ev_entry_change(self, sender):
        print("ev_entry_change", self, sender)

    def ev_radiobutton_change(self, sender):
        print("ev_radiobutton_change", self, sender)

    def ev_checkbox_change(self, sender):
        print("ev_checkbox_change", self, sender)

    def ev_button_clicked(self, sender):
        print("ev_button_clicked", self, sender)
        
class MyWindow(Window, EventTrace):
    pass
        
class MyGroup(Group, EventTrace):
    pass

class MyEntry(Entry, EventTrace):
    pass

class MyButton(Button, EventTrace):
    pass

class MyRadiobutton(Radiobutton, EventTrace):
    pass

class MyCheckbox(Checkbox, EventTrace):
    pass
            
window = MyWindow()
label = Label().set_text("Rostlina").set_x(10).set_y(10)
entry = MyEntry().set_value("Pavla").set_x(10).set_y(30)
group = MyGroup().set_items([label, entry])
button = MyButton().set_text("Klikni na mě!").move(10, 60)

radiobutton = MyRadiobutton().move(10, 90)
checkbox = MyCheckbox().move(30, 90)

group2 = MyGroup().set_items([radiobutton, checkbox])
group3 = MyGroup().set_items([group, button, group2])



window.set_widget(group3)
"""