source: branches/stable/WINDOW/aw_select.hxx

// ================================================================ //
//                                                                  //
//   File      : aw_select.hxx                                      //
//   Purpose   :                                                    //
//                                                                  //
//   Coded by Ralf Westram (coder@reallysoft.de) in February 2010   //
//   Institute of Microbiology (Technical University Munich)        //
//   http://www.arb-home.de/                                        //
//                                                                  //
// ================================================================ //

#ifndef AW_SELECT_HXX
#define AW_SELECT_HXX

#ifndef AW_WINDOW_HXX
#include <aw_window.hxx>
#endif
#ifndef ARBDB_H
#include <arbdb.h>
#endif
#ifndef AW_SCALAR_HXX
#include "aw_scalar.hxx"
#endif

// cppcheck-suppress noConstructor
class AW_selection_list_entry : virtual Noncopyable {
    char      *displayed;
    AW_scalar  value;

    static char *copy_string_for_display(const char *str);

public:
    // @@@ make members private
    AW_selection_list_entry *next;

    static const size_t MAX_DISPLAY_LENGTH = 8192; // 8192 -> no wrap-around happens in motif
    // 100000 -> works in motif (no crash, but ugly because line wraps around - overwriting itself)
    // setting it to 750000 crashes with "X Error BadLength" in motif (when a string with that length is displayed)

    template<typename T>
    AW_selection_list_entry(const char *display, T val)
        : displayed(copy_string_for_display(display)),
          value(val),
          next(NULp)
    {}
    ~AW_selection_list_entry() { free(displayed); }

    const AW_scalar& get_value() const { return value; }
    void set_value(const AW_scalar& val) { value = val; }

    const char *get_displayed() const { return displayed; } // may differ from string passed to set_displayed() if the string was longer than MAX_DISPLAY_LENGTH
    void set_displayed(const char *displayed_) { freeset(displayed, copy_string_for_display(displayed_)); }
};

typedef int (*sellist_cmp_fun)(const char *disp1, const char *disp2);
typedef void (*sellist_update_cb)(AW_selection_list *, AW_CL);

class AW_selection_list : virtual Noncopyable {
    AW_selection_list_entry *get_entry_at(int index) const;

    char             *variable_name;
    AW_VARIABLE_TYPE  variable_type;

    sellist_update_cb update_cb;
    AW_CL             cl_update;

    void append_entry(AW_selection_list_entry *new_entry);

public:
    AW_selection_list(const char *variable_name_, int variable_type_, Widget select_list_widget_);
    ~AW_selection_list();

    Widget select_list_widget;

    AW_selection_list_entry *list_table;
    AW_selection_list_entry *last_of_list_table;
    AW_selection_list_entry *default_select;
    AW_selection_list      *next;

    // ******************** real public ***************

    const char *get_awar_name() const { return variable_name; }
#if defined(ASSERTION_USED)
    GB_TYPES get_awar_type() const { return GB_TYPES(variable_type); }
#endif

    size_t size();

    // type-independent:
    void insert(const char *displayed, const AW_scalar& value);
    void insert_default(const char *displayed, const AW_scalar& value);

    template <class T> void insert(const char *displayed, T value) { insert(displayed, AW_scalar(value)); }
    template <class T> void insert_default(const char *displayed, T value) { insert_default(displayed, AW_scalar(value)); }

    void init_from_array(const CharPtrArray& entries, const char *default_displayed, const char *default_value);

    void update();
    void refresh();

    void set_update_callback(sellist_update_cb ucb, AW_CL cl_user);

    void sort(bool backward, bool case_sensitive); // uses displayed value!
    void sortCustom(sellist_cmp_fun cmp);          // uses displayed value!

    AW_scalar get_awar_value() const;
    void set_awar_value(const AW_scalar& new_value);

    const AW_scalar *get_default_value() const;
    const char *get_default_display() const;

    void select_default();

    const AW_scalar *get_selected_value() const; // may differ from get_awar_value() if default is selected (returns value passed to insert_default)

    int get_index_of(const AW_scalar& searched_value);
    int get_index_of_selected();

    const AW_scalar *get_value_at(int index);

    void select_element_at(int wanted_index);
    void move_selection(int offset);

    bool default_is_selected() const;

    void delete_element_at(int index);
    void delete_value(const AW_scalar& value);
    void delete_default();
    void clear();

    void move_content_to(AW_selection_list *target_list);

    void     to_array(StrArray& array, bool values); // only works with string-type selection-lists!
    GB_HASH *to_hash(bool case_sens);                // only works with string-type selection-lists!

    char *get_content_as_string(long number_of_lines); // displayed content (e.g. for printing)

    // save/load:
    void set_file_suffix(const char *suffix);
    GB_ERROR load(const char *filename);
    GB_ERROR save(const char *filename, long number_of_lines);
};

class AW_selection_list_iterator {
    AW_selection_list_entry *entry;
public:
    AW_selection_list_iterator(AW_selection_list *sellist)
        : entry(sellist->list_table)
    {}
    AW_selection_list_iterator(AW_selection_list *sellist, int index)
        : entry(sellist->list_table)
    {
        aw_assert(index>=0);
        forward(index);
    }

    operator bool() const { return entry; }

    const char *get_displayed() { return entry ? entry->get_displayed() : NULp; }
    const AW_scalar *get_value() const { return entry ? &entry->get_value() : NULp; }

    void set_displayed(const char *disp) { aw_assert(entry); entry->set_displayed(disp); }
    void set_value(const AW_scalar& val) { aw_assert(entry); entry->set_value(val); }

    void forward(size_t offset) {
        while (offset--) ++(*this);
    }
    AW_selection_list_iterator& operator++() {
        if (entry) entry = entry->next;
        return *this;
    }
};

class AW_selection : virtual Noncopyable {
    //! a AW_selection_list which knows how to fill itself
    // (clients can't modify)

    AW_selection_list *sellist;

    virtual void fill() = 0;

protected:
    void insert(const char *displayed, const char *value) { sellist->insert(displayed, value); }
    void insert_default(const char *displayed, const char *value) { sellist->insert_default(displayed, value); }

    void insert_plain(const char *displayed_value) { insert(displayed_value, displayed_value); }

    void insert(const char *displayed, int32_t value) { sellist->insert(displayed, value); }
    void insert_default(const char *displayed, int32_t value) { sellist->insert_default(displayed, value); }

public:
    AW_selection(AW_selection_list *sellist_) : sellist(sellist_) {}
    virtual ~AW_selection() {}

    void refresh();
    AW_selection_list *get_sellist() { return sellist; }

    void get_values(StrArray& intoArray) { get_sellist()->to_array(intoArray, true); }
    void get_displayed(StrArray& intoArray) { get_sellist()->to_array(intoArray, false); }
};


class AW_DB_selection : public AW_selection { // derived from a Noncopyable
    GBDATA *gbd;                                    // root container of data displayed in selection list
public:
    AW_DB_selection(AW_selection_list *sellist_, GBDATA *gbd_);
    ~AW_DB_selection() OVERRIDE;

    GBDATA *get_gbd() { return gbd; }
    GBDATA *get_gb_main();
};


#else
#error aw_select.hxx included twice
#endif // AW_SELECT_HXX