def _get_name_element(self, name):
     painter = functions.obtain_valid_painter(painterstyle.DEF_PAINTER,
                                              size=style.SIZE)
     el = Clickable(name)
     el.set_painter(painter)
     el.finish()
     return el

    def finish(self):
        Clickable.finish(self)
##        self.e_color.stick_to(self, "right", "right")
##        self.e_color.move((-2,0))
        store(self, mode="h")
        self.fit_children()
        self._set_launcher()

 def __init__(self,
              params,
              text="",
              title=None,
              click_cancel=False,
              text_ok="Ok",
              text_cancel="Cancel",
              paramsetter_elements=None):
     """params can either be a varset or a paramsetter.
     title can either be a string or an element."""
     if isinstance(params, ParamSetter):
         self.paramsetter = params
     else:
         self.paramsetter = ParamSetter(params, elements=paramsetter_elements)
         self.paramsetter.finish()
     self.click_cancel = click_cancel
     self.max_chars = float("inf")
     self.cut_text = ".."
     self.launcher = None
     e_title = _get_title(title)
     if e_title:
         elements = [e_title, self.paramsetter]
     else:
         elements = [self.paramsetter]
     box = launchmod.make_ok_cancel_box(elements, text_ok, text_cancel)
     self.launched = box
     Clickable.__init__(self, text)

 def solo_blit(self):
     Clickable.solo_blit(self)
     if self._checked:
         clip = self.get_clip()
         r = self._check_img.get_rect()
         r.center = clip.center
         self.surface.blit(self._check_img, r)

def make_image_button(img_normal, img_pressed=None, img_hover=None,
                        alpha=255, colorkey=None, text=""):
    e = Clickable(text)
    painter = ButtonImage(img_normal, img_pressed, img_hover, alpha, colorkey)
    e.set_painter(painter)
    e.finish()
    return e

    def _force_unpress(self):
        self._count = 0
        Clickable._unpress(self)
##        self._unhover_noblit()
        ev_untog = Event(constants.THORPY_EVENT,
                        id=constants.EVENT_UNTOGGLE, el=self)
        post(ev_untog)
        self.toggled = False

 def _press(self):
     Clickable._press(self)
     self._count += 1
     if not self.toggled:
         ev_tog = Event(constants.THORPY_EVENT, id=constants.EVENT_TOGGLE,
                         el=self)
         post(ev_tog)
         self.toggled = True

 def _reaction_press(self, pygame_event):
     Clickable._reaction_press(self, pygame_event)
     if self.current_state_key == constants.STATE_PRESSED:
         self.enter()
     elif self._activated:
         if not self.quit_on_click:
             self._value = self._inserted
         self.exit()

 def __init__(self):
     Clickable.__init__(self)
     reac_rightclick = Reaction(parameters.BUTTON_UNPRESS_EVENT,
                                self._reaction_rightpress,
                                {"button": parameters.RIGHT_CLICK_BUTTON},
                                name=constants.REAC_RIGHT_CLICK)
     self.add_reaction(reac_rightclick)
     self.normal_params.polite_set("painter size", (16, 16))
     self.press_params.polite_set("painter size", (16, 16))

 def finish(self):
     Clickable.finish(self)
     # cursor is initialized in finish because _iwriter needs self.fusionner
     #   to initialize...
     while not self._iwriter._is_small_enough(self._inserted) and self._inserted:
         self._inserted = self._inserted[:-1]
     self._iwriter.refresh_img()
     self.cursor = _Cursor(self)
     self.add_elements(list([self.cursor]))
     self._refresh_pos()
     self.cursor.finish()
     self._name_element.user_func = self.enter

 def finish(self):
     Clickable.finish(self)
     # cursor is initialized in finish because _iwriter needs self.fusionner
     #   to initialize...
     self.make_small_enough(self._inserted)
     if not self._iwriter._is_small_enough(self._inserted):
         functions.debug_msg("Inserter is too small for value", self._inserted)
         if self.auto_resize:
             self.set_size(self._iwriter.get_rect().inflate((2,2)).size)
     self._iwriter.refresh_img()
     self.cursor = _Cursor(self)
     self.add_elements(list([self.cursor]))
     self._refresh_pos()
     self.cursor.finish()
     self._name_element.user_func = self.enter

 def __init__(self,
              browser,
              name_txt="",
              file_txt="",
              launcher_txt="",
              normal_params=None,
              file_width=None,
              show_select=True,
              click_quit=False):
     """<browser> : the browser to be launched. Can either be a Browser
                    instance or a BrowserLight instance.
     <name_txt> : the text that stands before the (optionnal) file name and
                  the button to launch browser.
     <file_txt> : the default value shown to the user.
     <launcher_txt> : the text on the launcher button.
     """
     file_width = style.FILE_WIDTH if file_width is None else file_width
     self.show_select = show_select
     if not self.show_select:
         file_txt = ""
     _Launcher.__init__(self, "", normal_params, click_quit)
     self._spawn = "center"
     self.file_width = file_width
     self._done_element = Clickable(style.OK_TXT)
     self._done_element.finish()
     self._cancel_element = Clickable(style.CANCEL_TXT)
     self._cancel_element.finish()
     g = Ghost([self._done_element, self._cancel_element])
     g.finish()
     g.fit_children()
     g.rank = float("inf")
     store(g, g.get_elements(), "h")
     # to launch : must not be in self._elements!
     self.browser = browser
     box = Box(elements=[self.browser, g],
               storer_params=None)
     box.finish()
     self.launched_element = box
     self._deny_child(self.launched_element)
     # launcher
     self.launcher_el = self.get_launcher_element(launcher_txt)
     self.launcher_el.user_func = self.launch_box
     # name
     self._name_element = self._get_name_element(name_txt)
     self._name_element.user_func = self.launch_box
     self._file_element = self._get_file_element(file_txt)
     self.add_elements([self._name_element, self.launcher_el, self._file_element])

def make_button(text, func=None, params=None):
    button = Clickable(text)
    button.finish()
    button.scale_to_title()
    if func:
        button.user_func = func
    if params:
        button.user_params = params
    return button

 def get_launcher_element(self, name):
     size = (style.SIZE[0], style.Y_SMALL_SIZE)
     painter = functions.obtain_valid_painter(
         painterstyle.BROWSER_LAUNCHER_PAINTER,
         size=size)
     el = Clickable(name)
     el.set_painter(painter)
     el.set_style(style.STYLE_BROWSER_LAUNCHER)
     el.finish()
     return el

 def _get_name_element(self, name, namestyle):
     painter = functions.obtain_valid_painter(
         painterstyle.INSERTER_NAME_PAINTER,
         size=style.SIZE)
     el = Clickable(name)
     el.set_painter(painter)
     if namestyle:
         el.set_style(namestyle)
     el.finish()
     return el

 def __init__(self,
              colorsetter,
              text="",
              show_select=True,
              click_cancel=False):
     self.text = text
     self.show_select = show_select
     self.click_cancel = click_cancel
     if not isinstance(colorsetter, ColorSetter):
         self.colorsetter = ColorSetter.make(self.text, value=colorsetter)
     else:
         self.colorsetter = colorsetter
     self.old_color = self.colorsetter.get_value()
     self.launched = launchmod.make_ok_cancel_box([self.colorsetter], "Ok", "Cancel") #!!! text
     self.launcher = None
     self.e_color = get_example_element(self.colorsetter.get_color(), (20,20))
     self.e_text = Element(self.text)
     self.e_text.set_style("text")
     self.e_text.finish()
     self.unlaunch_func = None
     Clickable.__init__(self, elements=[self.e_text, self.e_color])

    def __init__(self,
                 browser,
                 const_text="",
                 var_text="",
                 show_select=True,
                 click_cancel=False,
                 text_ok="Ok",
                 text_cancel="Cancel"):
        self.recenter=True
        self.const_text = const_text
        self.var_text = var_text
        self.click_cancel = click_cancel
##        self.max_chars = float("inf")
        self.max_chars = 30
        self.cut_text = ".."
        self.show_select = show_select
        self.launcher = None
        self.unlaunch_func = None
        box = launchmod.make_ok_cancel_box([browser], text_ok, text_cancel)
        self.launched = box
        self.browser = browser
        Clickable.__init__(self, self.const_text+self.var_text)

 def _set_path_elements(self, ycoord=None):
     self.remove_all_elements()
     i = 0
     for s in self._path_list:
         e = Clickable(s)
         e.set_style("text")
         e.normal_params.params["font_size"] = style.PATH_FONT_SIZE
         e.press_params.params["font_size"] = style.PATH_FONT_SIZE
         e.finish()
         e.user_func = self._reaction_path
         e.user_params = {"n" : i}
         e.set_jailed(self.father)
         e._lock_jail = True
         self.add_elements([e])
         i += 1
     father = self
     if self.father.is_finished():
         father = self.father
     fr = father.get_storer_rect()
     wtot = h_store(fr, self._elements, gap=0, xstart="auto", ycoord=ycoord)
     if wtot > fr.width:
         h_store(fr, self._elements, gap=0, ycoord=ycoord,
                     xstart=fr.right - wtot-2)
     self._n = len(self._elements)

 def _get_launched_el(self, els, size, storer_params):
     _done_element = Clickable(style.OK_TXT)
     _cancel_element = Clickable(style.CANCEL_TXT)
     _done_element.finish()
     _cancel_element.finish()
     g = Ghost([_done_element, _cancel_element])
     g.finish()
     g.englobe_childrens()
     g.rank = float("inf")
     store(g, g.get_elements(), "h")
     els += [g]
     box = Box(elements=els, size=size, storer_params=storer_params)
     box.finish() #box stores its elements
     return box, _done_element, _cancel_element

 def _reaction_press(self, pygame_event):
     Clickable._reaction_press(self, pygame_event)
     if self.current_state_key == constants.STATE_PRESSED:
         self.check()