← Back to branch summary

~ubuntu-branches/ubuntu/wily/geany/wily

« back to all changes in this revision

Viewing changes to scintilla/lexlib/OptionSet.h

  • Committer: Package Import Robot
  • Author(s): Chow Loong Jin
  • Date: 2011-12-10 07:43:26 UTC
  • mfrom: (3.3.7 sid)
  • Revision ID: package-import@ubuntu.com-20111210074326-s8yqbew5i20h33tf
Tags: 0.21-1ubuntu1
* Merge from Debian Unstable, remaining changes:
  - debian/patches/20_use_evince_viewer.patch:
     + use evince as viewer for pdf and dvi files
  - debian/patches/20_use_x_terminal_emulator.patch:
     + use x-terminal-emulator as terminal
  - debian/control
     + Add breaks on geany-plugins-common << 0.20
* Also fixes bugs:
  - Filter for MATLAB/Octave files filters everythign (LP: 885505)

Show diffs side-by-side

added added

removed removed

Lines of Context:
scintilla/lexlib/OptionSet.h
 
1
// Scintilla source code edit control
 
2
/** @file OptionSet.h
 
3
 ** Manage descriptive information about an options struct for a lexer.
 
4
 ** Hold the names, positions, and descriptions of boolean, integer and string options and
 
5
 ** allow setting options and retrieving metadata about the options.
 
6
 **/
 
7
// Copyright 2010 by Neil Hodgson <neilh@scintilla.org>
 
8
// The License.txt file describes the conditions under which this software may be distributed.
 
9
 
 
10
#ifndef OPTIONSET_H
 
11
#define OPTIONSET_H
 
12
 
 
13
#ifdef SCI_NAMESPACE
 
14
namespace Scintilla {
 
15
#endif
 
16
 
 
17
template <typename T>
 
18
class OptionSet {
 
19
        typedef T Target;
 
20
        typedef bool T::*plcob;
 
21
        typedef int T::*plcoi;
 
22
        typedef std::string T::*plcos;
 
23
        struct Option {
 
24
                int opType;
 
25
                union {
 
26
                        plcob pb;
 
27
                        plcoi pi;
 
28
                        plcos ps;
 
29
                };
 
30
                std::string description;
 
31
                Option() :
 
32
                        opType(SC_TYPE_BOOLEAN), pb(0), description("") {
 
33
                }
 
34
                Option(plcob pb_, std::string description_="") :
 
35
                        opType(SC_TYPE_BOOLEAN), pb(pb_), description(description_) {
 
36
                }
 
37
                Option(plcoi pi_, std::string description_) :
 
38
                        opType(SC_TYPE_INTEGER), pi(pi_), description(description_) {
 
39
                }
 
40
                Option(plcos ps_, std::string description_) :
 
41
                        opType(SC_TYPE_STRING), ps(ps_), description(description_) {
 
42
                }
 
43
                bool Set(T *base, const char *val) {
 
44
                        switch (opType) {
 
45
                        case SC_TYPE_BOOLEAN: {
 
46
                                        bool option = atoi(val) != 0;
 
47
                                        if ((*base).*pb != option) {
 
48
                                                (*base).*pb = option;
 
49
                                                return true;
 
50
                                        }
 
51
                                        break;
 
52
                                }
 
53
                        case SC_TYPE_INTEGER: {
 
54
                                        int option = atoi(val);
 
55
                                        if ((*base).*pi != option) {
 
56
                                                (*base).*pi = option;
 
57
                                                return true;
 
58
                                        }
 
59
                                        break;
 
60
                                }
 
61
                        case SC_TYPE_STRING: {
 
62
                                        if ((*base).*ps != val) {
 
63
                                                (*base).*ps = val;
 
64
                                                return true;
 
65
                                        }
 
66
                                        break;
 
67
                                }
 
68
                        }
 
69
                        return false;
 
70
                }
 
71
        };
 
72
        typedef std::map<std::string, Option> OptionMap;
 
73
        OptionMap nameToDef;
 
74
        std::string names;
 
75
        std::string wordLists;
 
76
 
 
77
        void AppendName(const char *name) {
 
78
                if (!names.empty())
 
79
                        names += "\n";
 
80
                names += name;
 
81
        }
 
82
public:
 
83
        virtual ~OptionSet() {
 
84
        }
 
85
        void DefineProperty(const char *name, plcob pb, std::string description="") {
 
86
                nameToDef[name] = Option(pb, description);
 
87
                AppendName(name);
 
88
        }
 
89
        void DefineProperty(const char *name, plcoi pi, std::string description="") {
 
90
                nameToDef[name] = Option(pi, description);
 
91
                AppendName(name);
 
92
        }
 
93
        void DefineProperty(const char *name, plcos ps, std::string description="") {
 
94
                nameToDef[name] = Option(ps, description);
 
95
                AppendName(name);
 
96
        }
 
97
        const char *PropertyNames() {
 
98
                return names.c_str();
 
99
        }
 
100
        int PropertyType(const char *name) {
 
101
                typename OptionMap::iterator it = nameToDef.find(name);
 
102
                if (it != nameToDef.end()) {
 
103
                        return it->second.opType;
 
104
                }
 
105
                return SC_TYPE_BOOLEAN;
 
106
        }
 
107
        const char *DescribeProperty(const char *name) {
 
108
                typename OptionMap::iterator it = nameToDef.find(name);
 
109
                if (it != nameToDef.end()) {
 
110
                        return it->second.description.c_str();
 
111
                }
 
112
                return "";
 
113
        }
 
114
 
 
115
        bool PropertySet(T *base, const char *name, const char *val) {
 
116
                typename OptionMap::iterator it = nameToDef.find(name);
 
117
                if (it != nameToDef.end()) {
 
118
                        return it->second.Set(base, val);
 
119
                }
 
120
                return false;
 
121
        }
 
122
 
 
123
        void DefineWordListSets(const char * const wordListDescriptions[]) {
 
124
                if (wordListDescriptions) {
 
125
                        for (size_t wl = 0; wordListDescriptions[wl]; wl++) {
 
126
                                if (!wordLists.empty())
 
127
                                        wordLists += "\n";
 
128
                                wordLists += wordListDescriptions[wl];
 
129
                        }
 
130
                }
 
131
        }
 
132
 
 
133
        const char *DescribeWordListSets() {
 
134
                return wordLists.c_str();
 
135
        }
 
136
};
 
137
 
 
138
#ifdef SCI_NAMESPACE
 
139
}
 
140
#endif
 
141
 
 
142
#endif