Mercurial > mplayer.hg
annotate gui/skin/skin.c @ 35450:31a5320909f7
Don't include config.h if not necessary.
author | ib |
---|---|
date | Fri, 30 Nov 2012 23:30:47 +0000 |
parents | a3e8af09792d |
children | 411875efca3f |
rev | line source |
---|---|
26458 | 1 /* |
2 * This file is part of MPlayer. | |
3 * | |
4 * MPlayer is free software; you can redistribute it and/or modify | |
5 * it under the terms of the GNU General Public License as published by | |
6 * the Free Software Foundation; either version 2 of the License, or | |
7 * (at your option) any later version. | |
8 * | |
9 * MPlayer is distributed in the hope that it will be useful, | |
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 * GNU General Public License for more details. | |
13 * | |
14 * You should have received a copy of the GNU General Public License along | |
15 * with MPlayer; if not, write to the Free Software Foundation, Inc., | |
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. | |
17 */ | |
23077 | 18 |
33968 | 19 /** |
20 * @file | |
21 * @brief Skin parser | |
22 */ | |
23 | |
23077 | 24 #include <stdio.h> |
25 #include <string.h> | |
26 | |
32873 | 27 #include "skin.h" |
23077 | 28 #include "font.h" |
32893 | 29 #include "gui/app.h" |
33023 | 30 #include "gui/interface.h" |
33556 | 31 #include "gui/ui/widgets.h" |
33046 | 32 #include "gui/util/cut.h" |
33048 | 33 #include "gui/util/string.h" |
23077 | 34 |
26382
b2f4abcf20ed
Make include paths consistent; do not use ../ in them.
diego
parents:
26365
diff
changeset
|
35 #include "help_mp.h" |
23703
9fb716ab06a3
Avoid code duplication and ugly config.h hack by using av_strlcat/av_strlcpy
reimar
parents:
23077
diff
changeset
|
36 #include "libavutil/avstring.h" |
32944 | 37 #include "libavutil/common.h" |
32873 | 38 #include "mp_msg.h" |
23077 | 39 |
32873 | 40 typedef struct { |
41 const char *name; | |
42 int (*func)(char *in); | |
43 } _item; | |
23077 | 44 |
33749 | 45 char *skinDirInHome; |
46 char *skinMPlayerDir; | |
47 | |
32937 | 48 static guiItems *skin; |
23077 | 49 |
32873 | 50 static int linenumber; |
51 static unsigned char path[512]; | |
23077 | 52 |
32980
2bfd000bb789
Cosmetic: Rename pointers handling current window and items.
ib
parents:
32979
diff
changeset
|
53 static unsigned char currWinName[32]; |
2bfd000bb789
Cosmetic: Rename pointers handling current window and items.
ib
parents:
32979
diff
changeset
|
54 static wItem *currWin; |
2bfd000bb789
Cosmetic: Rename pointers handling current window and items.
ib
parents:
32979
diff
changeset
|
55 static int *currWinItemIdx; |
2bfd000bb789
Cosmetic: Rename pointers handling current window and items.
ib
parents:
32979
diff
changeset
|
56 static wItem *currWinItems; |
23077 | 57 |
33968 | 58 /** |
59 * @brief Display a skin error message. | |
60 * | |
61 * @param format format string | |
62 * @param ... arguments | |
63 */ | |
33022 | 64 static void skin_error(const char *format, ...) |
23077 | 65 { |
32873 | 66 char p[512]; |
67 va_list ap; | |
68 | |
69 va_start(ap, format); | |
70 vsnprintf(p, sizeof(p), format, ap); | |
71 va_end(ap); | |
72 | |
33023 | 73 gmp_msg(MSGT_GPLAYER, MSGL_ERR, MSGTR_SKIN_ERRORMESSAGE, linenumber, p); |
23077 | 74 } |
75 | |
33968 | 76 /** |
77 * @brief Check whether a @a section definition has started. | |
78 * | |
79 * @param item name of the item to be put in a message in case of an error | |
80 * | |
81 * @return 1 (ok) or 0 (error) | |
82 */ | |
33106 | 83 static int section_item(char *item) |
33054
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
84 { |
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
85 if (!skin) { |
33106 | 86 skin_error(MSGTR_SKIN_ERROR_SECTION, item); |
33054
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
87 return 0; |
32873 | 88 } |
89 | |
33054
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
90 return 1; |
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
91 } |
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
92 |
33968 | 93 /** |
94 * @brief Check whether a @a window definition has started. | |
95 * | |
96 * @param item name of the item to be put in a message in case of an error | |
97 * | |
98 * @return 1 (ok) or 0 (error) | |
99 */ | |
33106 | 100 static int window_item(char *item) |
33054
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
101 { |
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
102 if (!currWinName[0]) { |
33106 | 103 skin_error(MSGTR_SKIN_ERROR_WINDOW, item); |
33054
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
104 return 0; |
32873 | 105 } |
23077 | 106 |
33054
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
107 return 1; |
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
108 } |
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
109 |
33968 | 110 /** |
111 * @brief Check whether a specific @a window definition has started. | |
112 * | |
113 * @param name name of the window to be checked | |
114 * | |
115 * @return 0 (ok) or 1 (error) | |
116 */ | |
33058 | 117 static int in_window(char *name) |
118 { | |
119 if (strcmp(currWinName, name) == 0) { | |
33062 | 120 skin_error(MSGTR_SKIN_ERROR_ITEM, name); |
33058 | 121 return 1; |
32873 | 122 } |
123 | |
33058 | 124 return 0; |
125 } | |
126 | |
33968 | 127 /** |
128 * @brief Read a skin @a image file. | |
129 * | |
130 * @param fname filename (with path) | |
33972
91882b432024
Cosmetic: Rename skinImageRead() parameter bf img in doxygen comment.
ib
parents:
33969
diff
changeset
|
131 * @param img pointer suitable to store the image data |
33968 | 132 * |
133 * @return return code of #bpRead() | |
134 */ | |
33969 | 135 int skinImageRead(char *fname, guiImage *img) |
32873 | 136 { |
33969 | 137 int i = bpRead(fname, img); |
32873 | 138 |
139 switch (i) { | |
140 case -1: | |
33022 | 141 skin_error(MSGTR_SKIN_BITMAP_16bit, fname); |
32873 | 142 break; |
143 | |
144 case -2: | |
33022 | 145 skin_error(MSGTR_SKIN_BITMAP_FileNotFound, fname); |
32873 | 146 break; |
147 | |
148 case -5: | |
33022 | 149 skin_error(MSGTR_SKIN_BITMAP_PNGReadError, fname); |
32873 | 150 break; |
151 | |
152 case -8: | |
33022 | 153 skin_error(MSGTR_SKIN_BITMAP_ConversionError, fname); |
32873 | 154 break; |
155 } | |
156 | |
157 return i; | |
23077 | 158 } |
159 | |
33968 | 160 /** |
161 * @brief Get next free item in current @a window. | |
162 * | |
163 * @return pointer to next free item (ok) or NULL (error) | |
164 */ | |
33098 | 165 static wItem *next_item(void) |
166 { | |
167 wItem *item = NULL; | |
168 | |
169 if (*currWinItemIdx < MAX_ITEMS - 1) { | |
170 (*currWinItemIdx)++; | |
171 item = &currWinItems[*currWinItemIdx]; | |
172 } else | |
173 skin_error(MSGTR_SKIN_TooManyItemsDeclared); | |
174 | |
175 return item; | |
176 } | |
177 | |
33968 | 178 /** |
179 * @brief Parse a @a section definition. | |
180 * | |
181 * Syntax: section=movieplayer | |
182 * | |
183 * @param in definition to be analyzed | |
184 * | |
185 * @return 0 (ok) or 1 (error) | |
186 */ | |
33106 | 187 static int item_section(char *in) |
23077 | 188 { |
33064 | 189 if (skin) { |
190 skin_error(MSGTR_SKIN_ERROR_ITEM, "section"); | |
191 return 1; | |
192 } | |
193 | |
33055 | 194 if (!strcmp(strlower(in), "movieplayer")) |
33555 | 195 skin = &guiApp; |
33067 | 196 else { |
197 skin_error(MSGTR_SKIN_UNKNOWN_NAME, in); | |
198 return 1; | |
199 } | |
32873 | 200 |
33985 | 201 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] section: %s\n", in); |
32873 | 202 |
203 return 0; | |
23077 | 204 } |
205 | |
33968 | 206 /** |
207 * @brief Parse an @a end definition. | |
208 * | |
209 * Syntax: end | |
210 * | |
211 * @param in definition to be analyzed | |
212 * | |
213 * @return 0 (ok) or 1 (error) | |
214 */ | |
33106 | 215 static int item_end(char *in) |
23077 | 216 { |
32951 | 217 char *space, *name; |
218 | |
33985 | 219 (void)in; |
220 | |
32980
2bfd000bb789
Cosmetic: Rename pointers handling current window and items.
ib
parents:
32979
diff
changeset
|
221 if (currWinName[0]) { |
32951 | 222 space = " "; |
32980
2bfd000bb789
Cosmetic: Rename pointers handling current window and items.
ib
parents:
32979
diff
changeset
|
223 name = currWinName; |
32951 | 224 } else { |
225 space = ""; | |
226 name = "section"; | |
227 } | |
228 | |
33106 | 229 if (!section_item("end")) |
33054
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
230 return 1; |
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
231 |
33985 | 232 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] %send (%s)\n", space, name); |
32951 | 233 |
32980
2bfd000bb789
Cosmetic: Rename pointers handling current window and items.
ib
parents:
32979
diff
changeset
|
234 if (currWinName[0]) { |
2bfd000bb789
Cosmetic: Rename pointers handling current window and items.
ib
parents:
32979
diff
changeset
|
235 currWinName[0] = 0; |
2bfd000bb789
Cosmetic: Rename pointers handling current window and items.
ib
parents:
32979
diff
changeset
|
236 currWin = NULL; |
2bfd000bb789
Cosmetic: Rename pointers handling current window and items.
ib
parents:
32979
diff
changeset
|
237 currWinItemIdx = NULL; |
2bfd000bb789
Cosmetic: Rename pointers handling current window and items.
ib
parents:
32979
diff
changeset
|
238 currWinItems = NULL; |
32873 | 239 } else |
32937 | 240 skin = NULL; |
32873 | 241 |
242 return 0; | |
23077 | 243 } |
244 | |
33968 | 245 /** |
246 * @brief Parse a @a window definition. | |
247 * | |
34697 | 248 * Syntax: window=main|video|playbar|menu |
33968 | 249 * |
250 * @param in definition to be analyzed | |
251 * | |
252 * @return 0 (ok) or 1 (error) | |
253 */ | |
33106 | 254 static int item_window(char *in) |
23077 | 255 { |
33106 | 256 if (!section_item("window")) |
33054
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
257 return 1; |
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
258 |
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
259 if (currWinName[0]) { |
33062 | 260 skin_error(MSGTR_SKIN_ERROR_ITEM, "window"); |
33054
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
261 return 1; |
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
262 } |
32873 | 263 |
33083 | 264 strlower(in); |
23077 | 265 |
34697 | 266 if (strcmp(in, "sub") == 0) |
267 strcpy(in, "video"); // legacy | |
268 | |
33083 | 269 if (strcmp(in, "main") == 0) { |
33095 | 270 currWin = &skin->main; |
271 currWinItemIdx = &skin->IndexOfMainItems; | |
272 currWinItems = skin->mainItems; | |
34697 | 273 } else if (strcmp(in, "video") == 0) { |
274 currWin = &skin->video; | |
33083 | 275 currWinItemIdx = NULL; |
276 currWinItems = NULL; | |
277 } else if (strcmp(in, "playbar") == 0) { | |
33555 | 278 currWin = &skin->playbar; |
279 currWinItemIdx = &skin->IndexOfPlaybarItems; | |
280 currWinItems = skin->playbarItems; | |
33083 | 281 } else if (strcmp(in, "menu") == 0) { |
33095 | 282 currWin = &skin->menu; |
283 currWinItemIdx = &skin->IndexOfMenuItems; | |
284 currWinItems = skin->menuItems; | |
33066 | 285 } else { |
33065 | 286 skin_error(MSGTR_SKIN_UNKNOWN_NAME, in); |
33066 | 287 return 1; |
288 } | |
32873 | 289 |
33083 | 290 av_strlcpy(currWinName, in, sizeof(currWinName)); |
291 | |
33985 | 292 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] window: %s\n", currWinName); |
32873 | 293 |
294 return 0; | |
23077 | 295 } |
296 | |
33968 | 297 /** |
298 * @brief Parse a @a base definition. | |
299 * | |
300 * Syntax: base=image,x,y[,width,height] | |
301 * | |
302 * @param in definition to be analyzed | |
303 * | |
304 * @return 0 (ok) or 1 (error) | |
305 */ | |
33106 | 306 static int item_base(char *in) |
23077 | 307 { |
33090 | 308 unsigned char fname[256]; |
33089 | 309 unsigned char file[512]; |
32873 | 310 int x, y; |
33089 | 311 int w = 0, h = 0; |
34697 | 312 int is_video, is_bar, is_menu; |
32873 | 313 |
33106 | 314 if (!window_item("base")) |
33054
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
315 return 1; |
23077 | 316 |
34697 | 317 is_video = (strcmp(currWinName, "video") == 0); |
34698 | 318 is_bar = (strcmp(currWinName, "playbar") == 0); |
319 is_menu = (strcmp(currWinName, "menu") == 0); | |
33104 | 320 |
32873 | 321 cutItem(in, fname, ',', 0); |
33089 | 322 x = cutItemToInt(in, ',', 1); |
323 y = cutItemToInt(in, ',', 2); | |
324 w = cutItemToInt(in, ',', 3); | |
325 h = cutItemToInt(in, ',', 4); | |
32873 | 326 |
33985 | 327 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] image: %s", fname); |
23077 | 328 |
33105 | 329 currWin->type = itBase; |
33104 | 330 |
33105 | 331 if (!is_menu) { |
332 currWin->x = x; | |
333 currWin->y = y; | |
32873 | 334 |
33985 | 335 mp_msg(MSGT_GPLAYER, MSGL_DBG2, " %d,%d", x, y); |
33105 | 336 } |
32951 | 337 |
33985 | 338 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "\n"); |
32873 | 339 |
33105 | 340 av_strlcpy(file, path, sizeof(file)); |
341 av_strlcat(file, fname, sizeof(file)); | |
32873 | 342 |
33969 | 343 if (skinImageRead(file, &currWin->Bitmap) != 0) |
33105 | 344 return 1; |
32873 | 345 |
33105 | 346 currWin->width = currWin->Bitmap.Width; |
347 currWin->height = currWin->Bitmap.Height; | |
32873 | 348 |
34697 | 349 if (is_video) { |
33089 | 350 if (w && h) { |
33096 | 351 currWin->width = w; |
352 currWin->height = h; | |
32873 | 353 } |
33105 | 354 } |
32873 | 355 |
33985 | 356 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] bitmap: %dx%d\n", currWin->width, currWin->height); |
32951 | 357 |
34697 | 358 if (!is_video) { |
33555 | 359 if (!bpRenderMask(&currWin->Bitmap, &currWin->Mask)) { |
33114 | 360 skin_error(MSGTR_SKIN_NotEnoughMemory); |
361 return 1; | |
362 } | |
33985 | 363 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] mask: %lux%lu\n", currWin->Mask.Width, currWin->Mask.Height); |
33105 | 364 } |
33101
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
365 |
33105 | 366 if (is_bar) |
33555 | 367 skin->playbarIsPresent = 1; |
33105 | 368 if (is_menu) |
369 skin->menuIsPresent = 1; | |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
27377
diff
changeset
|
370 |
32873 | 371 return 0; |
23077 | 372 } |
373 | |
33968 | 374 /** |
375 * @brief Parse a @a background definition. | |
376 * | |
377 * Syntax: background=R,G,B | |
378 * | |
379 * @param in definition to be analyzed | |
380 * | |
381 * @return 0 (ok) or 1 (error) | |
382 */ | |
33106 | 383 static int item_background(char *in) |
23077 | 384 { |
33106 | 385 if (!window_item("background")) |
33054
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
386 return 1; |
23077 | 387 |
33058 | 388 if (in_window("main")) |
389 return 1; | |
33088 | 390 if (in_window("playbar")) |
391 return 1; | |
33058 | 392 if (in_window("menu")) |
393 return 1; | |
23077 | 394 |
32980
2bfd000bb789
Cosmetic: Rename pointers handling current window and items.
ib
parents:
32979
diff
changeset
|
395 currWin->R = cutItemToInt(in, ',', 0); |
2bfd000bb789
Cosmetic: Rename pointers handling current window and items.
ib
parents:
32979
diff
changeset
|
396 currWin->G = cutItemToInt(in, ',', 1); |
2bfd000bb789
Cosmetic: Rename pointers handling current window and items.
ib
parents:
32979
diff
changeset
|
397 currWin->B = cutItemToInt(in, ',', 2); |
23077 | 398 |
33985 | 399 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] background color: #%02x%02x%02x\n", currWin->R, currWin->G, currWin->B); |
23077 | 400 |
32873 | 401 return 0; |
23077 | 402 } |
403 | |
33968 | 404 /** |
405 * @brief Parse a @a button definition. | |
406 * | |
407 * Syntax: button=image,x,y,width,height,message | |
408 * | |
409 * @param in definition to be analyzed | |
410 * | |
411 * @return 0 (ok) or 1 (error) | |
412 */ | |
33106 | 413 static int item_button(char *in) |
23077 | 414 { |
33090 | 415 unsigned char fname[256]; |
33089 | 416 unsigned char file[512]; |
417 int x, y, w, h, message; | |
32873 | 418 char msg[32]; |
33098 | 419 wItem *item; |
32873 | 420 |
33106 | 421 if (!window_item("button")) |
33054
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
422 return 1; |
32873 | 423 |
34697 | 424 if (in_window("video")) |
33058 | 425 return 1; |
426 if (in_window("menu")) | |
427 return 1; | |
23077 | 428 |
32873 | 429 cutItem(in, fname, ',', 0); |
33089 | 430 x = cutItemToInt(in, ',', 1); |
431 y = cutItemToInt(in, ',', 2); | |
432 w = cutItemToInt(in, ',', 3); | |
433 h = cutItemToInt(in, ',', 4); | |
32873 | 434 cutItem(in, msg, ',', 5); |
435 | |
33071 | 436 message = appFindMessage(msg); |
437 | |
438 if (message == -1) { | |
439 skin_error(MSGTR_SKIN_UnknownMessage, msg); | |
440 return 1; | |
441 } | |
442 | |
33985 | 443 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] button image: %s %d,%d\n", fname, x, y); |
444 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] message: %s (#%d)\n", msg, message); | |
445 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] size: %dx%d\n", w, h); | |
33102
de688a61e439
Move debug messages so that they will be processed earlier.
ib
parents:
33101
diff
changeset
|
446 |
33098 | 447 item = next_item(); |
448 | |
449 if (!item) | |
450 return 1; | |
451 | |
452 item->type = itButton; | |
453 item->x = x; | |
454 item->y = y; | |
455 item->width = w; | |
456 item->height = h; | |
457 item->message = message; | |
33101
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
458 item->pressed = btnReleased; |
23077 | 459 |
33098 | 460 if (item->message == evPauseSwitchToPlay) |
461 item->pressed = btnDisabled; | |
23077 | 462 |
33098 | 463 item->Bitmap.Image = NULL; |
32873 | 464 |
465 if (strcmp(fname, "NULL") != 0) { | |
33089 | 466 av_strlcpy(file, path, sizeof(file)); |
467 av_strlcat(file, fname, sizeof(file)); | |
32873 | 468 |
33969 | 469 if (skinImageRead(file, &item->Bitmap) != 0) |
32873 | 470 return 1; |
32951 | 471 |
33985 | 472 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] (bitmap: %lux%lu)\n", item->Bitmap.Width, item->Bitmap.Height); |
32873 | 473 } |
474 | |
475 return 0; | |
23077 | 476 } |
477 | |
33968 | 478 /** |
479 * @brief Parse a @a selected definition. | |
480 * | |
481 * Syntax: selected=image | |
482 * | |
483 * @param in definition to be analyzed | |
484 * | |
485 * @return 0 (ok) or 1 (error) | |
486 */ | |
33106 | 487 static int item_selected(char *in) |
32873 | 488 { |
33089 | 489 unsigned char file[512]; |
33096 | 490 wItem *currItem; |
32873 | 491 |
33106 | 492 if (!window_item("selected")) |
33054
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
493 return 1; |
32873 | 494 |
33058 | 495 if (in_window("main")) |
496 return 1; | |
34697 | 497 if (in_window("video")) |
33058 | 498 return 1; |
499 if (in_window("playbar")) | |
500 return 1; | |
32873 | 501 |
33985 | 502 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] image selected: %s\n", in); |
33102
de688a61e439
Move debug messages so that they will be processed earlier.
ib
parents:
33101
diff
changeset
|
503 |
33096 | 504 currItem = &skin->menuSelected; |
505 currItem->type = itBase; | |
32873 | 506 |
33089 | 507 av_strlcpy(file, path, sizeof(file)); |
33091 | 508 av_strlcat(file, in, sizeof(file)); |
32873 | 509 |
33969 | 510 if (skinImageRead(file, &currItem->Bitmap) != 0) |
32873 | 511 return 1; |
512 | |
33096 | 513 currItem->width = currItem->Bitmap.Width; |
514 currItem->height = currItem->Bitmap.Height; | |
32873 | 515 |
33985 | 516 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] bitmap: %dx%d\n", currItem->width, currItem->height); |
32873 | 517 |
518 return 0; | |
519 } | |
29263
0f1b5b68af32
whitespace cosmetics: Remove all trailing whitespace.
diego
parents:
27377
diff
changeset
|
520 |
33968 | 521 /** |
522 * @brief Parse a @a menu definition. | |
523 * | |
524 * Syntax: menu=x,y,width,height,message | |
525 * | |
526 * @param in definition to be analyzed | |
527 * | |
528 * @return 0 (ok) or 1 (error) | |
529 */ | |
33106 | 530 static int item_menu(char *in) |
32873 | 531 { |
33089 | 532 int x, y, w, h, message; |
33071 | 533 char msg[32]; |
33096 | 534 wItem *item; |
32873 | 535 |
33106 | 536 if (!window_item("menu")) |
33054
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
537 return 1; |
32873 | 538 |
33058 | 539 if (in_window("main")) |
540 return 1; | |
34697 | 541 if (in_window("video")) |
33058 | 542 return 1; |
543 if (in_window("playbar")) | |
544 return 1; | |
32873 | 545 |
33089 | 546 x = cutItemToInt(in, ',', 0); |
547 y = cutItemToInt(in, ',', 1); | |
548 w = cutItemToInt(in, ',', 2); | |
549 h = cutItemToInt(in, ',', 3); | |
33071 | 550 cutItem(in, msg, ',', 4); |
551 | |
552 message = appFindMessage(msg); | |
23077 | 553 |
33071 | 554 if (message == -1) { |
555 skin_error(MSGTR_SKIN_UnknownMessage, msg); | |
556 return 1; | |
557 } | |
32873 | 558 |
33098 | 559 item = next_item(); |
560 | |
561 if (!item) | |
562 return 1; | |
563 | |
33100 | 564 item->type = itMenu; |
33096 | 565 item->x = x; |
566 item->y = y; | |
567 item->width = w; | |
568 item->height = h; | |
569 item->message = message; | |
23077 | 570 |
33985 | 571 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] item #%d: %d,%d %dx%d\n", *currWinItemIdx, x, y, w, h); |
572 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] message: %s (#%d)\n", msg, message); | |
23077 | 573 |
33096 | 574 item->Bitmap.Image = NULL; |
33053 | 575 |
32873 | 576 return 0; |
23077 | 577 } |
578 | |
33968 | 579 /** |
580 * @brief Parse a @a hpotmeter definition. | |
581 * | |
582 * Syntax: hpotmeter=button,bwidth,bheight,phases,numphases,default,x,y,width,height,message | |
583 * | |
584 * @param in definition to be analyzed | |
585 * | |
586 * @return 0 (ok) or 1 (error) | |
587 */ | |
33106 | 588 static int item_hpotmeter(char *in) |
32873 | 589 { |
33090 | 590 unsigned char pfname[256]; |
591 unsigned char phfname[256]; | |
33093
3de646fca03b
Cosmetic: Rearrange variable declarations to match parameters.
ib
parents:
33092
diff
changeset
|
592 unsigned char buf[512]; |
3de646fca03b
Cosmetic: Rearrange variable declarations to match parameters.
ib
parents:
33092
diff
changeset
|
593 int pwidth, pheight, ph, d, x, y, w, h, message; |
32873 | 594 wItem *item; |
23077 | 595 |
33106 | 596 if (!window_item("h/v potmeter")) |
33054
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
597 return 1; |
23077 | 598 |
34697 | 599 if (in_window("video")) |
33058 | 600 return 1; |
601 if (in_window("menu")) | |
602 return 1; | |
23077 | 603 |
32873 | 604 cutItem(in, pfname, ',', 0); |
32911 | 605 pwidth = cutItemToInt(in, ',', 1); |
606 pheight = cutItemToInt(in, ',', 2); | |
32873 | 607 cutItem(in, phfname, ',', 3); |
608 ph = cutItemToInt(in, ',', 4); | |
609 d = cutItemToInt(in, ',', 5); | |
610 x = cutItemToInt(in, ',', 6); | |
611 y = cutItemToInt(in, ',', 7); | |
33089 | 612 w = cutItemToInt(in, ',', 8); |
613 h = cutItemToInt(in, ',', 9); | |
614 cutItem(in, buf, ',', 10); | |
32873 | 615 |
33089 | 616 message = appFindMessage(buf); |
23077 | 617 |
33069 | 618 if (message == -1) { |
33089 | 619 skin_error(MSGTR_SKIN_UnknownMessage, buf); |
33069 | 620 return 1; |
621 } | |
622 | |
33985 | 623 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] h/v potmeter image: %s %d,%d %dx%d\n", phfname, x, y, w, h); |
624 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] button image: %s %dx%d\n", pfname, pwidth, pheight); | |
625 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] numphases: %d, default: %d%%\n", ph, d); | |
626 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] message: %s (#%d)\n", buf, message); | |
23077 | 627 |
33098 | 628 item = next_item(); |
629 | |
630 if (!item) | |
631 return 1; | |
632 | |
33101
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
633 item->type = itHPotmeter; |
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
634 item->x = x; |
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
635 item->y = y; |
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
636 item->width = w; |
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
637 item->height = h; |
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
638 item->pwidth = pwidth; |
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
639 item->pheight = pheight; |
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
640 item->numphases = ph; |
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
641 item->value = (float)d; |
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
642 item->message = message; |
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
643 item->pressed = btnReleased; |
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
644 |
32873 | 645 item->Bitmap.Image = NULL; |
23077 | 646 |
32873 | 647 if (strcmp(phfname, "NULL") != 0) { |
33089 | 648 av_strlcpy(buf, path, sizeof(buf)); |
649 av_strlcat(buf, phfname, sizeof(buf)); | |
32873 | 650 |
33969 | 651 if (skinImageRead(buf, &item->Bitmap) != 0) |
32873 | 652 return 1; |
32951 | 653 |
33985 | 654 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] (potmeter bitmap: %lux%lu)\n", item->Bitmap.Width, item->Bitmap.Height); |
32873 | 655 } |
656 | |
657 item->Mask.Image = NULL; | |
23077 | 658 |
32873 | 659 if (strcmp(pfname, "NULL") != 0) { |
33089 | 660 av_strlcpy(buf, path, sizeof(buf)); |
661 av_strlcat(buf, pfname, sizeof(buf)); | |
32873 | 662 |
33969 | 663 if (skinImageRead(buf, &item->Mask) != 0) |
32873 | 664 return 1; |
32951 | 665 |
33985 | 666 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] (button bitmap: %lux%lu)\n", item->Mask.Width, item->Mask.Height); |
32873 | 667 } |
668 | |
669 return 0; | |
23077 | 670 } |
671 | |
33968 | 672 /** |
673 * @brief Parse a @a vpotmeter definition. | |
674 * | |
675 * Syntax: vpotmeter=button,bwidth,bheight,phases,numphases,default,x,y,width,height,message | |
676 * | |
677 * @param in definition to be analyzed | |
678 * | |
679 * @return 0 (ok) or 1 (error) | |
680 */ | |
33106 | 681 static int item_vpotmeter(char *in) |
23077 | 682 { |
33056 | 683 int r; |
32873 | 684 wItem *item; |
23077 | 685 |
33106 | 686 r = item_hpotmeter(in); |
33056 | 687 |
688 if (r == 0) { | |
33057 | 689 item = &currWinItems[*currWinItemIdx]; |
690 item->type = itVPotmeter; | |
33056 | 691 } |
33053 | 692 |
32873 | 693 return r; |
23077 | 694 } |
695 | |
33968 | 696 /** |
697 * @brief Parse a @a potmeter definition. | |
698 * | |
699 * Syntax: potmeter=phases,numphases,default,x,y,width,height,message | |
700 * | |
701 * @param in definition to be analyzed | |
702 * | |
703 * @return 0 (ok) or 1 (error) | |
704 */ | |
33106 | 705 static int item_potmeter(char *in) |
32873 | 706 { |
33093
3de646fca03b
Cosmetic: Rearrange variable declarations to match parameters.
ib
parents:
33092
diff
changeset
|
707 unsigned char phfname[256]; |
33089 | 708 unsigned char buf[512]; |
33093
3de646fca03b
Cosmetic: Rearrange variable declarations to match parameters.
ib
parents:
33092
diff
changeset
|
709 int ph, d, x, y, w, h, message; |
32873 | 710 wItem *item; |
23077 | 711 |
33106 | 712 if (!window_item("potmeter")) |
33054
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
713 return 1; |
23077 | 714 |
34697 | 715 if (in_window("video")) |
33058 | 716 return 1; |
717 if (in_window("menu")) | |
718 return 1; | |
23077 | 719 |
32873 | 720 cutItem(in, phfname, ',', 0); |
721 ph = cutItemToInt(in, ',', 1); | |
722 d = cutItemToInt(in, ',', 2); | |
723 x = cutItemToInt(in, ',', 3); | |
724 y = cutItemToInt(in, ',', 4); | |
33089 | 725 w = cutItemToInt(in, ',', 5); |
726 h = cutItemToInt(in, ',', 6); | |
727 cutItem(in, buf, ',', 7); | |
32873 | 728 |
33089 | 729 message = appFindMessage(buf); |
23077 | 730 |
33069 | 731 if (message == -1) { |
33089 | 732 skin_error(MSGTR_SKIN_UnknownMessage, buf); |
33069 | 733 return 1; |
734 } | |
735 | |
33985 | 736 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] potmeter image: %s %d,%d %dx%d\n", phfname, x, y, w, h); |
737 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] numphases: %d, default: %d%%\n", ph, d); | |
738 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] message: %s (#%d)\n", buf, message); | |
23077 | 739 |
33098 | 740 item = next_item(); |
741 | |
742 if (!item) | |
743 return 1; | |
744 | |
33101
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
745 item->type = itPotmeter; |
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
746 item->x = x; |
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
747 item->y = y; |
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
748 item->width = w; |
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
749 item->height = h; |
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
750 item->numphases = ph; |
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
751 item->value = (float)d; |
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
752 item->message = message; |
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
753 |
32873 | 754 item->Bitmap.Image = NULL; |
23077 | 755 |
32873 | 756 if (strcmp(phfname, "NULL") != 0) { |
33089 | 757 av_strlcpy(buf, path, sizeof(buf)); |
758 av_strlcat(buf, phfname, sizeof(buf)); | |
32873 | 759 |
33969 | 760 if (skinImageRead(buf, &item->Bitmap) != 0) |
32873 | 761 return 1; |
32951 | 762 |
33985 | 763 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] (bitmap: %lux%lu)\n", item->Bitmap.Width, item->Bitmap.Height); |
32873 | 764 } |
765 | |
766 return 0; | |
23077 | 767 } |
768 | |
33968 | 769 /** |
770 * @brief Parse a @a font definition. | |
771 * | |
772 * Syntax: font=fontfile | |
773 * | |
774 * @param in definition to be analyzed | |
775 * | |
776 * @return 0 (ok) or 1 (error) | |
777 */ | |
33106 | 778 static int item_font(char *in) |
32873 | 779 { |
33092
83052a4ac698
Use more appropriate name for variable and reduce it to reasonable size.
ib
parents:
33091
diff
changeset
|
780 char fnt[256]; |
23077 | 781 |
33106 | 782 if (!window_item("font")) |
33054
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
783 return 1; |
23077 | 784 |
34697 | 785 if (in_window("video")) |
33058 | 786 return 1; |
787 if (in_window("menu")) | |
788 return 1; | |
23077 | 789 |
33092
83052a4ac698
Use more appropriate name for variable and reduce it to reasonable size.
ib
parents:
33091
diff
changeset
|
790 cutItem(in, fnt, ',', 0); // Note: This seems needless but isn't for compatibility |
83052a4ac698
Use more appropriate name for variable and reduce it to reasonable size.
ib
parents:
33091
diff
changeset
|
791 // reasons with a meanwhile depreciated second parameter. |
33099
0b17f6bed6fc
Don't needlessly store font information in the wItems array
ib
parents:
33098
diff
changeset
|
792 switch (fntRead(path, fnt)) { |
32873 | 793 case -1: |
33097 | 794 skin_error(MSGTR_SKIN_NotEnoughMemory); |
32873 | 795 return 1; |
23077 | 796 |
32873 | 797 case -2: |
33022 | 798 skin_error(MSGTR_SKIN_FONT_TooManyFontsDeclared); |
32873 | 799 return 1; |
800 | |
801 case -3: | |
33022 | 802 skin_error(MSGTR_SKIN_FONT_FontFileNotFound); |
32873 | 803 return 1; |
804 | |
805 case -4: | |
33022 | 806 skin_error(MSGTR_SKIN_FONT_FontImageNotFound); |
32873 | 807 return 1; |
808 } | |
809 | |
33985 | 810 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] font: %s (#%d)\n", fnt, fntFindID(fnt)); |
32951 | 811 |
32873 | 812 return 0; |
23077 | 813 } |
814 | |
33968 | 815 /** |
816 * @brief Parse a @a slabel definition. | |
817 * | |
818 * Syntax: slabel=x,y,fontfile,"text" | |
819 * | |
820 * @param in definition to be analyzed | |
821 * | |
822 * @return 0 (ok) or 1 (error) | |
823 */ | |
33106 | 824 static int item_slabel(char *in) |
23077 | 825 { |
33094
2faf1c3ded5d
Cosmetic: Rearrange variable declarations to match parameters.
ib
parents:
33093
diff
changeset
|
826 int x, y, id; |
33090 | 827 char fnt[256]; |
33094
2faf1c3ded5d
Cosmetic: Rearrange variable declarations to match parameters.
ib
parents:
33093
diff
changeset
|
828 char txt[256]; |
32873 | 829 wItem *item; |
830 | |
33106 | 831 if (!window_item("slabel")) |
33054
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
832 return 1; |
23077 | 833 |
34697 | 834 if (in_window("video")) |
33058 | 835 return 1; |
836 if (in_window("menu")) | |
837 return 1; | |
32873 | 838 |
839 x = cutItemToInt(in, ',', 0); | |
840 y = cutItemToInt(in, ',', 1); | |
33089 | 841 cutItem(in, fnt, ',', 2); |
842 cutItem(in, txt, ',', 3); | |
843 cutItem(txt, txt, '"', 1); | |
32951 | 844 |
33985 | 845 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] slabel: \"%s\"\n", txt); |
846 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] pos: %d,%d\n", x, y); | |
23077 | 847 |
33089 | 848 id = fntFindID(fnt); |
23077 | 849 |
32873 | 850 if (id < 0) { |
33097 | 851 skin_error(MSGTR_SKIN_FONT_NonExistentFont, fnt); |
32873 | 852 return 1; |
853 } | |
23077 | 854 |
33985 | 855 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] font: %s (#%d)\n", fnt, id); |
23077 | 856 |
33098 | 857 item = next_item(); |
858 | |
859 if (!item) | |
860 return 1; | |
861 | |
32873 | 862 item->type = itSLabel; |
863 item->x = x; | |
864 item->y = y; | |
865 item->width = -1; | |
866 item->height = -1; | |
33101
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
867 item->fontid = id; |
33089 | 868 item->label = strdup(txt); |
23077 | 869 |
32979
4905f5a87357
Replace some awkward and unnecessary usages of strlen().
ib
parents:
32958
diff
changeset
|
870 if (!item->label) { |
33097 | 871 skin_error(MSGTR_SKIN_NotEnoughMemory); |
32873 | 872 return 1; |
873 } | |
23077 | 874 |
32873 | 875 return 0; |
23077 | 876 } |
877 | |
33968 | 878 /** |
879 * @brief Parse a @a dlabel definition. | |
880 * | |
881 * Syntax: dlabel=x,y,width,align,fontfile,"text" | |
882 * | |
883 * @param in definition to be analyzed | |
884 * | |
885 * @return 0 (ok) or 1 (error) | |
886 */ | |
33106 | 887 static int item_dlabel(char *in) |
32873 | 888 { |
33094
2faf1c3ded5d
Cosmetic: Rearrange variable declarations to match parameters.
ib
parents:
33093
diff
changeset
|
889 int x, y, w, a, id; |
33090 | 890 char fnt[256]; |
33094
2faf1c3ded5d
Cosmetic: Rearrange variable declarations to match parameters.
ib
parents:
33093
diff
changeset
|
891 char txt[256]; |
32873 | 892 wItem *item; |
23077 | 893 |
33106 | 894 if (!window_item("dlabel")) |
33054
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
895 return 1; |
23077 | 896 |
34697 | 897 if (in_window("video")) |
33058 | 898 return 1; |
899 if (in_window("menu")) | |
900 return 1; | |
32873 | 901 |
33089 | 902 x = cutItemToInt(in, ',', 0); |
903 y = cutItemToInt(in, ',', 1); | |
904 w = cutItemToInt(in, ',', 2); | |
905 a = cutItemToInt(in, ',', 3); | |
906 cutItem(in, fnt, ',', 4); | |
907 cutItem(in, txt, ',', 5); | |
908 cutItem(txt, txt, '"', 1); | |
32951 | 909 |
33985 | 910 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] dlabel: \"%s\"\n", txt); |
911 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] pos: %d,%d\n", x, y); | |
912 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] width: %d, align: %d\n", w, a); | |
23077 | 913 |
33089 | 914 id = fntFindID(fnt); |
23077 | 915 |
32873 | 916 if (id < 0) { |
33097 | 917 skin_error(MSGTR_SKIN_FONT_NonExistentFont, fnt); |
32873 | 918 return 1; |
919 } | |
23077 | 920 |
33985 | 921 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] font: %s (#%d)\n", fnt, id); |
23077 | 922 |
33098 | 923 item = next_item(); |
924 | |
925 if (!item) | |
926 return 1; | |
927 | |
32873 | 928 item->type = itDLabel; |
929 item->x = x; | |
930 item->y = y; | |
33089 | 931 item->width = w; |
32873 | 932 item->height = -1; |
33101
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
933 item->fontid = id; |
930338bde973
Order member assignments according to their definition in the structure.
ib
parents:
33100
diff
changeset
|
934 item->align = a; |
33089 | 935 item->label = strdup(txt); |
23077 | 936 |
32979
4905f5a87357
Replace some awkward and unnecessary usages of strlen().
ib
parents:
32958
diff
changeset
|
937 if (!item->label) { |
33097 | 938 skin_error(MSGTR_SKIN_NotEnoughMemory); |
32873 | 939 return 1; |
940 } | |
23077 | 941 |
32873 | 942 return 0; |
23077 | 943 } |
944 | |
33968 | 945 /** |
946 * @brief Parse a @a decoration definition. | |
947 * | |
948 * Syntax: decoration=enable|disable | |
949 * | |
950 * @param in definition to be analyzed | |
951 * | |
952 * @return 0 (ok) or 1 (error) | |
953 */ | |
33106 | 954 static int item_decoration(char *in) |
23077 | 955 { |
33106 | 956 if (!window_item("decoration")) |
33054
ed66afc0b06c
Replace macros to check whether a command is allowed by functions.
ib
parents:
33053
diff
changeset
|
957 return 1; |
32873 | 958 |
34697 | 959 if (in_window("video")) |
33058 | 960 return 1; |
961 if (in_window("playbar")) | |
962 return 1; | |
963 if (in_window("menu")) | |
964 return 1; | |
32873 | 965 |
33086 | 966 strlower(in); |
32873 | 967 |
33086 | 968 if (strcmp(in, "enable") != 0 && strcmp(in, "disable") != 0) { |
969 skin_error(MSGTR_SKIN_UnknownParameter, in); | |
32873 | 970 return 1; |
971 } | |
23077 | 972 |
33087 | 973 skin->mainDecoration = (strcmp(in, "enable") == 0); |
23077 | 974 |
33985 | 975 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] decoration: %s\n", in); |
32873 | 976 |
977 return 0; | |
23077 | 978 } |
979 | |
33968 | 980 /** |
981 * @brief Parsing functions responsible for skin item definitions. | |
982 */ | |
32878 | 983 static _item skinItem[] = { |
33106 | 984 { "background", item_background }, |
985 { "base", item_base }, | |
986 { "button", item_button }, | |
987 { "decoration", item_decoration }, | |
988 { "dlabel", item_dlabel }, | |
989 { "end", item_end }, | |
990 { "font", item_font }, | |
991 { "hpotmeter", item_hpotmeter }, | |
992 { "menu", item_menu }, | |
993 { "potmeter", item_potmeter }, | |
994 { "section", item_section }, | |
995 { "selected", item_selected }, | |
996 { "slabel", item_slabel }, | |
997 { "vpotmeter", item_vpotmeter }, | |
998 { "window", item_window } | |
32873 | 999 }; |
1000 | |
33968 | 1001 /** |
1002 * @brief Build the skin file path for a skin name. | |
1003 * | |
1004 * @param dir skins directory | |
1005 * @param sname name of the skin | |
1006 * | |
1007 * @return skin file path | |
1008 * | |
1009 * @note As a side effect, variable #path gets set to the skin path. | |
1010 */ | |
33081
d217fdc83e63
(Almost entirely) cosmetic: Use more appropriate variable names.
ib
parents:
33079
diff
changeset
|
1011 static char *setname(char *dir, char *sname) |
32873 | 1012 { |
33081
d217fdc83e63
(Almost entirely) cosmetic: Use more appropriate variable names.
ib
parents:
33079
diff
changeset
|
1013 static char skinfname[512]; |
32873 | 1014 |
33081
d217fdc83e63
(Almost entirely) cosmetic: Use more appropriate variable names.
ib
parents:
33079
diff
changeset
|
1015 av_strlcpy(skinfname, dir, sizeof(skinfname)); |
d217fdc83e63
(Almost entirely) cosmetic: Use more appropriate variable names.
ib
parents:
33079
diff
changeset
|
1016 av_strlcat(skinfname, "/", sizeof(skinfname)); |
d217fdc83e63
(Almost entirely) cosmetic: Use more appropriate variable names.
ib
parents:
33079
diff
changeset
|
1017 av_strlcat(skinfname, sname, sizeof(skinfname)); |
d217fdc83e63
(Almost entirely) cosmetic: Use more appropriate variable names.
ib
parents:
33079
diff
changeset
|
1018 av_strlcat(skinfname, "/", sizeof(skinfname)); |
d217fdc83e63
(Almost entirely) cosmetic: Use more appropriate variable names.
ib
parents:
33079
diff
changeset
|
1019 av_strlcpy(path, skinfname, sizeof(path)); |
d217fdc83e63
(Almost entirely) cosmetic: Use more appropriate variable names.
ib
parents:
33079
diff
changeset
|
1020 av_strlcat(skinfname, "skin", sizeof(skinfname)); |
32873 | 1021 |
33081
d217fdc83e63
(Almost entirely) cosmetic: Use more appropriate variable names.
ib
parents:
33079
diff
changeset
|
1022 return skinfname; |
23077 | 1023 } |
1024 | |
33968 | 1025 /** |
1026 * @brief Read and parse a skin. | |
1027 * | |
1028 * @param sname name of the skin | |
1029 * | |
1030 * @return 0 (ok), -1 (skin file not found or not readable) or -2 (parsing error) | |
1031 */ | |
33081
d217fdc83e63
(Almost entirely) cosmetic: Use more appropriate variable names.
ib
parents:
33079
diff
changeset
|
1032 int skinRead(char *sname) |
23077 | 1033 { |
33081
d217fdc83e63
(Almost entirely) cosmetic: Use more appropriate variable names.
ib
parents:
33079
diff
changeset
|
1034 char *skinfname; |
34578 | 1035 FILE *skinfile; |
33081
d217fdc83e63
(Almost entirely) cosmetic: Use more appropriate variable names.
ib
parents:
33079
diff
changeset
|
1036 unsigned char line[256]; |
33075 | 1037 unsigned char item[32]; |
32873 | 1038 unsigned char param[256]; |
32944 | 1039 unsigned int i; |
32873 | 1040 |
33081
d217fdc83e63
(Almost entirely) cosmetic: Use more appropriate variable names.
ib
parents:
33079
diff
changeset
|
1041 skinfname = setname(skinDirInHome, sname); |
23077 | 1042 |
34578 | 1043 if ((skinfile = fopen(skinfname, "rt")) == NULL) { |
33081
d217fdc83e63
(Almost entirely) cosmetic: Use more appropriate variable names.
ib
parents:
33079
diff
changeset
|
1044 skinfname = setname(skinMPlayerDir, sname); |
32873 | 1045 |
34578 | 1046 if ((skinfile = fopen(skinfname, "rt")) == NULL) { |
33081
d217fdc83e63
(Almost entirely) cosmetic: Use more appropriate variable names.
ib
parents:
33079
diff
changeset
|
1047 mp_msg(MSGT_GPLAYER, MSGL_ERR, MSGTR_SKIN_SkinFileNotFound, skinfname); |
32873 | 1048 return -1; |
1049 } | |
23077 | 1050 } |
32873 | 1051 |
33985 | 1052 mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[skin] configuration file: %s\n", skinfname); |
23077 | 1053 |
32932 | 1054 appFreeStruct(); |
23077 | 1055 |
33078 | 1056 skin = NULL; |
1057 currWinName[0] = 0; | |
33079 | 1058 linenumber = 0; |
23077 | 1059 |
34578 | 1060 while (fgetstr(line, sizeof(line), skinfile)) { |
32873 | 1061 linenumber++; |
1062 | |
33081
d217fdc83e63
(Almost entirely) cosmetic: Use more appropriate variable names.
ib
parents:
33079
diff
changeset
|
1063 strswap(line, '\t', ' '); |
d217fdc83e63
(Almost entirely) cosmetic: Use more appropriate variable names.
ib
parents:
33079
diff
changeset
|
1064 trim(line); |
d217fdc83e63
(Almost entirely) cosmetic: Use more appropriate variable names.
ib
parents:
33079
diff
changeset
|
1065 decomment(line); |
32873 | 1066 |
33081
d217fdc83e63
(Almost entirely) cosmetic: Use more appropriate variable names.
ib
parents:
33079
diff
changeset
|
1067 if (!*line) |
32873 | 1068 continue; |
23077 | 1069 |
33081
d217fdc83e63
(Almost entirely) cosmetic: Use more appropriate variable names.
ib
parents:
33079
diff
changeset
|
1070 cutItem(line, item, '=', 0); |
d217fdc83e63
(Almost entirely) cosmetic: Use more appropriate variable names.
ib
parents:
33079
diff
changeset
|
1071 cutItem(line, param, '=', 1); |
33075 | 1072 strlower(item); |
32873 | 1073 |
33076
27999e9c1b3f
Leave loop after item function has been found and called.
ib
parents:
33075
diff
changeset
|
1074 for (i = 0; i < FF_ARRAY_ELEMS(skinItem); i++) { |
27999e9c1b3f
Leave loop after item function has been found and called.
ib
parents:
33075
diff
changeset
|
1075 if (!strcmp(item, skinItem[i].name)) { |
35360 | 1076 if (skinItem[i].func(param) != 0) { |
1077 fclose(skinfile); | |
32873 | 1078 return -2; |
35360 | 1079 } else |
33076
27999e9c1b3f
Leave loop after item function has been found and called.
ib
parents:
33075
diff
changeset
|
1080 break; |
27999e9c1b3f
Leave loop after item function has been found and called.
ib
parents:
33075
diff
changeset
|
1081 } |
27999e9c1b3f
Leave loop after item function has been found and called.
ib
parents:
33075
diff
changeset
|
1082 } |
33077 | 1083 |
1084 if (i == FF_ARRAY_ELEMS(skinItem)) { | |
1085 skin_error(MSGTR_SKIN_UNKNOWN_ITEM, item); | |
35360 | 1086 fclose(skinfile); |
33077 | 1087 return -2; |
1088 } | |
32873 | 1089 } |
1090 | |
35360 | 1091 fclose(skinfile); |
1092 | |
32873 | 1093 if (linenumber == 0) { |
33081
d217fdc83e63
(Almost entirely) cosmetic: Use more appropriate variable names.
ib
parents:
33079
diff
changeset
|
1094 mp_msg(MSGT_GPLAYER, MSGL_ERR, MSGTR_SKIN_SkinFileNotReadable, skinfname); |
32873 | 1095 return -1; |
1096 } | |
1097 | |
1098 return 0; | |
23077 | 1099 } |