---

inputbox_generic.cpp

Go to the documentation of this file.

/*
        ClanGUI, copyrights by various people. Have a look in the CREDITS file.
        
        This sourcecode is distributed using the Library GNU Public Licence,
        version 2 or (at your option) any later version. Please read LICENSE
        for details.
*/

#include "precomp.h"
#include "inputbox_generic.h"
#include "API/GUI/component_options.h"
#include "API/Display/Input/input.h"

CL_ComponentOptions CL_InputBox_Generic::create_options(
        const CL_Rect &pos,
        const std::string &text,
        bool password_mode,
        bool readonly,
        int maxlength)
{
        CL_ComponentOptions options;

        options.add_option_as_int("x", pos.x1);
        options.add_option_as_int("y", pos.y1);
        options.add_option_as_int("width", pos.get_width());
        options.add_option_as_int("height", pos.get_height());
        options.add_option_as_bool("passwordmode", password_mode);
        options.add_option_as_bool("readonly", readonly);
        options.add_option_as_int("maxlength", maxlength);
        options.add_option("text", text);

        return options;
}

CL_InputBox_Generic::CL_InputBox_Generic(CL_InputBox *self, const CL_ComponentOptions &options, CL_StyleManager *style)
:
        inputbox(self)
{
        ctrl_down = false;
        shift_down = false;

        mouse_selecting = false;
        edited = false;

        if(options.exists("text"))
                set_text(options.get_value("text"));
        else
                set_text("");

        if(options.exists("passwordmode"))
                password_mode = options.get_value_as_bool("passwordmode");
        else
                password_mode = false;

        if(options.exists("readonly"))
                read_only = options.get_value_as_bool("readonly");
        else
                read_only = false;

        if(options.exists("maxlength"))
                set_max_length(options.get_value_as_int("maxlength"));
        else
                set_max_length(0);

        slot_key_down = inputbox->sig_key_down().connect(CL_CreateSlot(this, &CL_InputBox_Generic::on_key_down));
        slot_key_up = inputbox->sig_key_up().connect(CL_CreateSlot(this, &CL_InputBox_Generic::on_key_up));
        slot_mouse_move = inputbox->sig_mouse_moved().connect(CL_CreateSlot(this, &CL_InputBox_Generic::on_mouse_move));
}

void CL_InputBox_Generic::on_key_down(CL_Component *comp, CL_InputDevice *device, CL_Key key)
{
        // Start selecting with mouse?
        if (device == CL_Input::pointers[0])
        {
                cursor_position = text.size();
                selecting = false;
                selection_start = -1;
                selection_end = -1;
//              cursor_position = get_mouse_position(key.x, key.y);
/*              mouse_selecting = true;
                selecting = true;
                selection_start = cursor_position;
                inputbox->capture_mouse();
*/              return;
        }

        // Keyboard?
        // TODO: Isn't there a better way to check this ?
        if ((CL_Keyboard *)device != CL_Input::keyboards[0]) return;

        switch (key.id)
        {
        case CL_KEY_DELETE:
                del();
                break;
        case CL_KEY_BACKSPACE:
                backspace();
                break;
        case CL_KEY_END:
                check_selection();      
                end(selecting);
                break;
        case CL_KEY_HOME:
                check_selection();      
                home(selecting);
                break;
        case CL_KEY_LEFT:
                check_selection();      
//              if (ctrl_down)
//                      word_left();
//              else
                        move_cursor(-1, selecting);
                break;
        case CL_KEY_RIGHT:
                check_selection();      
//              if (ctrl_down)
//                      word_right();
//              else
                        move_cursor(1, selecting);
                break;
        case CL_KEY_ENTER:
                sig_return_pressed(text);
//              inputbox->clear_focus();
                break;
        case CL_KEY_LCTRL:
        case CL_KEY_RCTRL:
                ctrl_down = true;
                break;
        case CL_KEY_LSHIFT:
        case CL_KEY_RSHIFT:
                shift_down = true;
                break;
        default:
                update_text(key);
                break;
        }
}

void CL_InputBox_Generic::on_key_up(CL_Component *comp, CL_InputDevice *device, CL_Key key)
{
        // End mouse-selecting
        if (device == CL_Input::pointers[0])
        {
/*              cursor_position = get_mouse_position(key.x, key.y);
                if (mouse_selecting && cursor_position == selection_start)
                        selecting = false;
                mouse_selecting = false;
                inputbox->release_mouse();
*/              return;
        }

        switch (key.id)
        {
        case CL_KEY_LCTRL:
        case CL_KEY_RCTRL:
                ctrl_down = false;
                break;
        case CL_KEY_LSHIFT:
        case CL_KEY_RSHIFT:
                shift_down = false;
                break;
        }
}

void CL_InputBox_Generic::on_mouse_move(CL_Component *comp, CL_InputDevice *device, int x, int y)
{
        if (mouse_selecting)
                cursor_position = get_mouse_position(x, y);
}

void CL_InputBox_Generic::check_selection()
{
        if(shift_down)
        {
                if(selecting == false)
                {
                        selecting = true;
                        selection_start = cursor_position;
                }
        }
        else
        {
                selecting = false;
                selection_start = -1;
                selection_end = -1;
        }
}

void CL_InputBox_Generic::set_text(const std::string &new_text)
{
        // TODO: Check against max_length

        text = new_text;
        selecting = false;
        selection_start = -1;
        selection_end = -1;
        cursor_position = text.size();
}

const std::string &CL_InputBox_Generic::get_marked_text() const
{
        throw CL_Error("CL_InputBox_Generic::get_marked_text() is not implemented");
}

void CL_InputBox_Generic::set_max_length(int length)
{
        max_length = length;

        if(text.size() > max_length && max_length != 0)
                text.erase(max_length, text.size());
}

void CL_InputBox_Generic::select_all()
{
        throw CL_Error("CL_InputBox_Generic::select_all() is not implemented");
}

void CL_InputBox_Generic::deselect()
{
        throw CL_Error("CL_InputBox_Generic::deselect() is not implemented");
}

void CL_InputBox_Generic::set_selection(int start, int length)
{
        throw CL_Error("CL_InputBox_Generic::set_selection() is not implemented");
}

void CL_InputBox_Generic::set_cursor_position(int pos)
{
        cursor_position = pos;
        if(cursor_position < 0)
                cursor_position = 0;
        if(cursor_position > max_length - 1 && max_length != 0)
                cursor_position = max_length - 1;
}

void CL_InputBox_Generic::del()
{
        if (selecting)
                cut();
        else if (cursor_position < (int)text.size())
                text.erase(cursor_position, 1);
}

void CL_InputBox_Generic::backspace()
{
        if (selecting)
                cut();
        else if (cursor_position > 0)
        {
                text.erase(cursor_position - 1, 1);
                cursor_position--;
        }
}

void CL_InputBox_Generic::home(bool mark)
{
        if(mark)
        {
                selecting = true;
                selection_start = cursor_position;
                selection_end = 0;
        }

        cursor_position = 0;
}

void CL_InputBox_Generic::end(bool mark)
{
        if(mark)
        {
                selecting = true;
                selection_start = cursor_position;
                selection_end = text.size();
        }

        cursor_position = text.size();
}

void CL_InputBox_Generic::move_cursor(int delta, bool mark)
{
        cursor_position += delta;

        // Check bounds
        if (cursor_position < 0) cursor_position = 0;
        if (cursor_position > (int)text.size()) cursor_position = (int)text.size();

        if(mark)
                selection_end = cursor_position;
}

void CL_InputBox_Generic::move_cursor_word(int delta, bool mark)
{
        throw CL_Error("CL_InputBox_Generic::move_cursor_word() is not implemented");
/*
                if (ctrl_down)
                {
                        while (caret_position > 0 && text[caret_position] == ' ') caret_position--;
                        while (caret_position > 0 && text[caret_position] != ' ') caret_position--;
                }
                if (ctrl_down)
                {
                        while (caret_position < (int)text.size() && text[caret_position] == ' ') caret_position++;
                        while (caret_position < (int)text.size() && text[caret_position] != ' ') caret_position++;
                }
*/
}

void CL_InputBox_Generic::cut()
{
        if(selecting) 
        {
                int start = get_selection_start();
                int end = get_selection_length();
                text.erase(start, end);
                cursor_position = start;

                selecting = false;
                selection_start = selection_end = -1;

                if (cursor_position > (int)text.size())
                        cursor_position = (int)text.size();
        }
}

int CL_InputBox_Generic::get_selection_start()
{
        if(selection_start < selection_end)
                return selection_start;
        else
                return selection_end;
}

int CL_InputBox_Generic::get_selection_length()
{
        return abs(selection_start - selection_end);
}

void CL_InputBox_Generic::update_text(CL_Key key)
{
        if (key.ascii != -1)
        {
                cut();
                text.insert(text.begin() + cursor_position, key.ascii);
                cursor_position++;
        }
}

int CL_InputBox_Generic::get_mouse_position(int x, int y)
{
/*      int delta_x = x - X_TEXTOFFSET;
        unsigned int i;
        for (i = 0; i < text.size(); i++)
        {
                char buf[2];
                buf[0] = text[i];
                buf[1] = 0;
                int w = fnt_inputbox->get_text_width(buf);
                delta_x -= w;
                if (delta_x <= -w/2)
                {
                                return i + last_offset;
                }
        }
        return i;
*/
        return text.size() - 1;
}

---