[prefix] Use garbage-collectable section names
[ipxe.git] / src / hci / mucurses / slk.c
1 #include <curses.h>
2 #include <stddef.h>
3 #include <stdlib.h>
4 #include <string.h>
5 #include <assert.h>
6 #include "mucurses.h"
7 #include "cursor.h"
8
9 /** @file
10 *
11 * Soft label key functions
12 */
13
14 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
15
16 #define MIN_SPACE_SIZE 2
17
18 #define SLK_MAX_LABEL_LEN 8
19
20 #define SLK_MAX_NUM_LABELS 12
21
22 #define SLK_MAX_NUM_SPACES 2
23
24 struct _softlabel {
25 // label string
26 char label[SLK_MAX_LABEL_LEN];
27 /* Format of soft label
28 0: left justify
29 1: centre justify
30 2: right justify
31 */
32 unsigned int fmt;
33 };
34
35 struct _softlabelkeys {
36 struct _softlabel fkeys[SLK_MAX_NUM_LABELS];
37 attr_t attrs;
38 /* Soft label layout format
39 0: 3-2-3
40 1: 4-4
41 2: 4-4-4
42 3: 4-4-4 with index line
43 */
44 unsigned int fmt;
45 unsigned int max_label_len;
46 unsigned int maj_space_len;
47 unsigned int num_labels;
48 unsigned int num_spaces;
49 unsigned int spaces[SLK_MAX_NUM_SPACES];
50 struct cursor_pos saved_cursor;
51 attr_t saved_attrs;
52 short saved_pair;
53 };
54
55 static struct _softlabelkeys *slks;
56
57 /*
58 I either need to break the primitives here, or write a collection of
59 functions specifically for SLKs that directly access the screen
60 functions - since this technically isn't part of stdscr, I think
61 this should be ok...
62 */
63
64 static void _enter_slk ( void ) {
65 _store_curs_pos ( stdscr, &slks->saved_cursor );
66 wattr_get ( stdscr, &slks->saved_attrs, &slks->saved_pair, NULL );
67 LINES++;
68 wmove ( stdscr, LINES, 0 );
69 wattrset ( stdscr, slks->attrs );
70 }
71
72 static void _leave_slk ( void ) {
73 LINES--;
74 wattr_set ( stdscr, slks->saved_attrs, slks->saved_pair, NULL );
75 _restore_curs_pos ( stdscr, &slks->saved_cursor );
76 }
77
78 static void _print_label ( struct _softlabel sl ) {
79 int space_ch;
80 char str[SLK_MAX_LABEL_LEN + 1];
81
82 assert ( slks->max_label_len <= SLK_MAX_LABEL_LEN );
83 space_ch = ' ';
84
85 // protect against gaps in the soft label keys array
86 if ( sl.label == NULL ) {
87 memset( str, space_ch, (size_t)(slks->max_label_len) );
88 } else {
89 /* we need to pad the label with varying amounts of leading
90 pad depending on the format of the label */
91 if ( sl.fmt == 1 ) {
92 memset( str, space_ch,
93 (size_t)(slks->max_label_len
94 - strlen(sl.label)) / 2 );
95 }
96 if ( sl.fmt == 2 ) {
97 memset( str, space_ch,
98 (size_t)(slks->max_label_len
99 - strlen(sl.label)) );
100 }
101 strcat(str,sl.label);
102
103 // post-padding
104 memset(str+strlen(str), space_ch,
105 (size_t)(slks->max_label_len - strlen(str)) );
106 }
107
108 // print the formatted label
109 _wputstr ( stdscr, str, NOWRAP, slks->max_label_len );
110 }
111
112 /**
113 * Return the attribute used for the soft function keys
114 *
115 * @ret attrs the current attributes of the soft function keys
116 */
117 attr_t slk_attr ( void ) {
118 return ( slks == NULL ? 0 : slks->attrs );
119 }
120
121 /**
122 * Turn off soft function key attributes
123 *
124 * @v attrs attribute bit mask
125 * @ret rc return status code
126 */
127 int slk_attroff ( const chtype attrs ) {
128 if ( slks == NULL )
129 return ERR;
130 slks->attrs &= ~( attrs & A_ATTRIBUTES );
131 return OK;
132 }
133
134 /**
135 * Turn on soft function key attributes
136 *
137 * @v attrs attribute bit mask
138 * @ret rc return status code
139 */
140 int slk_attron ( const chtype attrs ) {
141 if ( slks == NULL )
142 return ERR;
143 slks->attrs |= ( attrs & A_ATTRIBUTES );
144 return OK;
145 }
146
147 /**
148 * Set soft function key attributes
149 *
150 * @v attrs attribute bit mask
151 * @ret rc return status code
152 */
153 int slk_attrset ( const chtype attrs ) {
154 if ( slks == NULL )
155 return ERR;
156 slks->attrs = ( attrs & A_ATTRIBUTES );
157 return OK;
158 }
159
160 /**
161 * Turn off soft function key attributes
162 *
163 * @v attrs attribute bit mask
164 * @v *opts undefined (for future implementation)
165 * @ret rc return status code
166 */
167 int slk_attr_off ( const attr_t attrs, void *opts __unused ) {
168 return slk_attroff( attrs );
169 }
170
171 /**
172 * Turn on soft function key attributes
173 *
174 * @v attrs attribute bit mask
175 * @v *opts undefined (for future implementation)
176 * @ret rc return status code
177 */
178 int slk_attr_on ( attr_t attrs, void *opts __unused ) {
179 return slk_attron( attrs );
180 }
181
182 /**
183 * Set soft function key attributes
184 *
185 * @v attrs attribute bit mask
186 * @v colour_pair_number colour pair integer
187 * @v *opts undefined (for future implementation)
188 * @ret rc return status code
189 */
190 int slk_attr_set ( const attr_t attrs, short colour_pair_number,
191 void *opts __unused ) {
192 if ( slks == NULL )
193 return ERR;
194
195 if ( ( unsigned short )colour_pair_number > COLORS )
196 return ERR;
197
198 slks->attrs = ( (unsigned short)colour_pair_number << CPAIR_SHIFT ) |
199 ( attrs & A_ATTRIBUTES );
200 return OK;
201 }
202
203 /**
204 * Clear the soft function key labels from the screen
205 *
206 * @ret rc return status code
207 */
208 int slk_clear ( void ) {
209 if ( slks == NULL )
210 return ERR;
211
212 _enter_slk();
213 wclrtoeol ( stdscr );
214 _leave_slk();
215
216 return OK;
217 }
218
219 /**
220 * Set soft label colour pair
221 */
222 int slk_colour ( short colour_pair_number ) {
223 if ( slks == NULL )
224 return ERR;
225 if ( ( unsigned short )colour_pair_number > COLORS )
226 return ERR;
227
228 slks->attrs = ( (unsigned short)colour_pair_number << CPAIR_SHIFT )
229 | ( slks->attrs & A_ATTRIBUTES );
230
231 return OK;
232 }
233
234 /**
235 * Initialise the soft function keys
236 *
237 * @v fmt format of keys
238 * @ret rc return status code
239 */
240 int slk_init ( int fmt ) {
241 unsigned short nmaj, nmin, nblocks, available_width;
242
243 if ( (unsigned)fmt > 3 ) {
244 return ERR;
245 }
246
247 /* There seems to be no API call to free this data structure... */
248 if ( ! slks )
249 slks = calloc(1,sizeof(*slks));
250 if ( ! slks )
251 return ERR;
252
253 slks->attrs = A_DEFAULT;
254 slks->fmt = fmt;
255 switch(fmt) {
256 case 0:
257 nblocks = 8; nmaj = 2; nmin = 5;
258 slks->spaces[0] = 2; slks->spaces[1] = 4;
259 break;
260 case 1:
261 nblocks = 8; nmaj = 1; nmin = 6;
262 slks->spaces[0] = 3;
263 break;
264 case 2:
265 // same allocations as format 3
266 case 3:
267 nblocks = 12; nmaj = 2; nmin = 9;
268 slks->spaces[0] = 3; slks->spaces[1] = 7;
269 break;
270 default:
271 nblocks = 0; nmaj = 0; nmin = 0;
272 break;
273 }
274
275 // determine maximum label length and major space size
276 available_width = COLS - ( ( MIN_SPACE_SIZE * nmaj ) + nmin );
277 slks->max_label_len = available_width / nblocks;
278 slks->maj_space_len = MIN_SPACE_SIZE +
279 ( available_width % nblocks ) / nmaj;
280 slks->num_spaces = nmaj;
281 slks->num_labels = nblocks;
282
283 // strip a line from the screen
284 LINES -= 1;
285
286 return OK;
287 }
288
289 /**
290 * Return the label for the specified soft key
291 *
292 * @v labnum soft key identifier
293 * @ret label return label
294 */
295 char* slk_label ( int labnum ) {
296 if ( slks == NULL )
297 return NULL;
298
299 return slks->fkeys[labnum].label;
300 }
301
302 /**
303 * Restore soft function key labels to the screen
304 *
305 * @ret rc return status code
306 */
307 int slk_restore ( void ) {
308 unsigned int i, j, pos_x,
309 *next_space, *last_space;
310 chtype space_ch;
311
312 if ( slks == NULL )
313 return ERR;
314
315 pos_x = 0;
316
317 _enter_slk();
318
319 space_ch = (chtype)' ' | slks->attrs;
320 next_space = &(slks->spaces[0]);
321 last_space = &(slks->spaces[slks->num_spaces-1]);
322
323 for ( i = 0; i < slks->num_labels ; i++ ) {
324 _print_label( slks->fkeys[i] );
325 pos_x += slks->max_label_len;
326
327 if ( i == *next_space ) {
328 for ( j = 0; j < slks->maj_space_len; j++, pos_x++ )
329 _wputch ( stdscr, space_ch, NOWRAP );
330 if ( next_space < last_space )
331 next_space++;
332 } else {
333 if ( pos_x < COLS )
334 _wputch ( stdscr, space_ch, NOWRAP );
335 pos_x++;
336 }
337 }
338
339 _leave_slk();
340
341 return OK;
342 }
343
344 /**
345 * Configure specified soft key
346 *
347 * @v labnum soft label position to configure
348 * @v *label string to use as soft key label
349 * @v fmt justification format of label
350 * @ret rc return status code
351 */
352 int slk_set ( int labnum, const char *label, int fmt ) {
353 if ( slks == NULL )
354 return ERR;
355 if ( (unsigned short)labnum >= slks->num_labels )
356 return ERR;
357 if ( (unsigned short)fmt >= 3 )
358 return ERR;
359
360 strncpy(slks->fkeys[labnum].label, label,
361 sizeof(slks->fkeys[labnum].label));
362 slks->fkeys[labnum].fmt = fmt;
363
364 return OK;
365 }