1

/* $Id$ */

     2

     3

/** @file sortlist_type.h Base types for having sorted lists in GUIs. */

     4

     5

#ifndef SORTLIST_TYPE_H

     6

#define SORTLIST_TYPE_H

     7

     8

#include "core/enum_type.hpp"

     9

#include "core/bitmath_func.hpp"

    10

#include "core/mem_func.hpp"

    11

#include "core/sort_func.hpp"

    12

#include "misc/smallvec.h"

    13

#include "date_type.h"

    14

    15

enum SortListFlags {

    16

	VL_NONE       = 0,      ///< no sort

    17

	VL_DESC       = 1 << 0, ///< sort descending or ascending

    18

	VL_RESORT     = 1 << 1, ///< instruct the code to resort the list in the next loop

    19

	VL_REBUILD    = 1 << 2, ///< rebuild the sort list

    20

	VL_FIRST_SORT = 1 << 3, ///< sort with qsort first

    21

	VL_END        = 1 << 4,

    22

};

    23

DECLARE_ENUM_AS_BIT_SET(SortListFlags);

    24

    25

struct Listing {

    26

	bool order;    ///< Ascending/descending

    27

	byte criteria; ///< Sorting criteria

    28

};

    29

    30

template <typename T>

    31

class GUIList : public SmallVector<T, 32> {

    32

public:

    33

	typedef int CDECL SortFunction(const T*, const T*);

    34

    36

	SortFunction* const *func_list; ///< The sort criteria functions

    37

	SortListFlags flags;            ///< used to control sorting/resorting/etc.

    38

	uint8 sort_type;                ///< what criteria to sort on

    39

	uint16 resort_timer;            ///< resort list after a given amount of ticks if set

    40

    41

	/**

    42

	 * Check if the list is sortable

    43

	 *

    44

	 * @return true if we can sort the list

    45

	 */

    46

	bool IsSortable() const

    47

	{

    48

		return (this->data != NULL && this->items >= 2);

    49

	}

    50

    51

	/**

    52

	 * Reset the resort timer

    53

	 */

    54

	void ResetResortTimer()

    55

	{

    56

		/* Resort every 10 days */

    57

		this->resort_timer = DAY_TICKS * 10;

    58

	}

    59

    60

public:

    61

	GUIList() :

    62

		func_list(NULL),

    63

		flags(VL_FIRST_SORT),

    64

		sort_type(0),

    65

		resort_timer(1)

    66

	{};

    67

    68

	/**

    69

	 * Get the sorttype of the list

    70

	 *

    71

	 * @return The current sorttype

    72

	 */

    73

	uint8 SortType() const

    74

	{

    75

		return this->sort_type;

    76

	}

    77

    78

	/**

    79

	 * Set the sorttype of the list

    80

	 *

    81

	 * @param n_type the new sort type

    82

	 */

    83

	void SetSortType(uint8 n_type)

    84

	{

    85

		if (this->sort_type != n_type) {

    86

			SETBITS(this->flags, VL_RESORT | VL_FIRST_SORT);

    87

			this->sort_type = n_type;

    88

		}

    89

	}

    90

    91

	/**

    92

	 * Export current sort conditions

    93

	 *

    94

	 * @return the current sort conditions

    95

	 */

    96

	Listing GetListing() const

    97

	{

    98

		Listing l;

    99

		l.order = HASBITS(this->flags, VL_DESC);

   100

		l.criteria = this->sort_type;

   101

   102

		return l;

   103

	}

   104

   105

	/**

   106

	 * Import sort conditions

   107

	 *

   108

	 * @param l The sport conditions we want to use

   109

	 */

   110

	void SetListing(Listing l)

   111

	{

   112

		if (l.order) {

   113

			SETBITS(this->flags, VL_DESC);

   114

		} else {

   115

			CLRBITS(this->flags, VL_DESC);

   116

		}

   117

		this->sort_type = l.criteria;

   118

   119

		SETBITS(this->flags, VL_FIRST_SORT);

   120

	}

   121

   122

	/**

   123

	 * Check if a resort is needed next loop

   124

	 *  If used the resort timer will decrease every call

   125

	 *  till 0. If 0 reached the resort bit will be set and

   126

	 *  the timer will be reset.

   127

	 *

   128

	 * @return true if resort bit is set for next loop

   129

	 */

   130

	bool NeedResort()

   131

	{

   132

		if (--this->resort_timer == 0) {

   133

			SETBITS(this->flags, VL_RESORT);

   134

			this->ResetResortTimer();

   135

			return true;

   136

		}

   137

		return false;

   138

	}

   139

   140

	/**

   141

	 * Force a resort next Sort call

   142

	 *  Reset the resort timer if used too.

   143

	 */

   144

	void ForceResort()

   145

	{

   146

		SETBITS(this->flags, VL_RESORT);

   147

	}

   148

   149

	/**

   150

	 * Check if the sort order is descending

   151

	 *

   152

	 * @return true if the sort order is descending

   153

	 */

   154

	bool IsDescSortOrder() const

   155

	{

   156

		return HASBITS(this->flags, VL_DESC);

   157

	}

   158

   159

	/**

   160

	 * Toogle the sort order

   161

	 *  Since that is the worst condition for the sort function

   162

	 *  reverse the list here.

   163

	 */

   164

	void ToggleSortOrder()

   165

	{

   166

		this->flags ^= VL_DESC;

   167

   168

		if (this->IsSortable()) MemReverseT(this->data, this->items);

   169

	}

   170

   171

	/**

   172

	 * Sort the list.

   173

	 *  For the first sorting we use qsort since it is

   174

	 *  faster for irregular sorted data. After that we

   175

	 *  use gsort.

   176

	 *

   177

	 * @param compare The function to compare two list items

   178

	 * @return true if the list sequence has been altered

   179

	 * */

   180

	bool Sort(SortFunction *compare)

   181

	{

   182

		/* Do not sort if the resort bit is not set */

   183

		if (!HASBITS(this->flags, VL_RESORT)) return false;

   184

   185

		CLRBITS(this->flags, VL_RESORT);

   186

   187

		this->ResetResortTimer();

   188

   189

		/* Do not sort when the list is not sortable */

   190

		if (!this->IsSortable()) return false;

   191

   192

		const bool desc = HASBITS(this->flags, VL_DESC);

   193

   194

		if (HASBITS(this->flags, VL_FIRST_SORT)) {

   195

			CLRBITS(this->flags, VL_FIRST_SORT);

   196

   197

			QSortT(this->data, this->items, compare, desc);

   198

			return true;

   199

		}

   200

   201

		GSortT(this->data, this->items, compare, desc);

   202

		return true;

   203

	}

   204

   205

	/**

   206

	 * Hand the array of sort function pointers to the sort list

   207

	 *

   208

	 * @param n_funcs The pointer to the first sort func

   209

	 */

   210

	void SetSortFuncs(SortFunction* const* n_funcs)

   211

	{

   212

		this->func_list = n_funcs;

   213

	}

   214

   215

	/**

   216

	 * Overload of Sort()

   217

	 * Overloaded to reduce external code

   218

	 *

   219

	 * @return true if the list sequence has been altered

   220

	 */

   221

	bool Sort()

   222

	{

   223

		assert(this->func_list != NULL);

   224

		return this->Sort(this->func_list[this->sort_type]);

   225

	}

   226

   227

	/**

   228

	 * Check if a rebuild is needed

   229

	 * @return true if a rebuild is needed

   230

	 */

   231

	bool NeedRebuild() const

   232

	{

   233

		return HASBITS(this->flags, VL_REBUILD);

   234

	}

   235

   236

	/**

   237

	 * Force that a rebuild is needed

   238

	 */

   239

	void ForceRebuild()

   240

	{

   241

		SETBITS(this->flags, VL_REBUILD);

   242

	}

   243

   244

	/**

   245

	 * Notify the sortlist that the rebuild is done

   246

	 *

   247

	 * @note This forces a resort

   248

	 */

   249

	void RebuildDone()

   250

	{

   251

		CLRBITS(this->flags, VL_REBUILD);

   253

	}

   254

};

   255

   256

#endif /* SORTLIST_TYPE_H */