Subversion Repositories mdb

Rev

Rev 24 | Rev 26 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
23 andreas 1
/*
2
 * Copyright (C) 2015 by Andreas Theofilu <andreas@theosys.at>
3
 *
4
 * All rights reserved. No warranty, explicit or implicit, provided.
5
 *
6
 * NOTICE:  All information contained herein is, and remains
7
 * the property of Andreas Theofilu and his suppliers, if any.
8
 * The intellectual and technical concepts contained
9
 * herein are proprietary to Andreas Theofilu and its suppliers and
10
 * may be covered by European and Foreign Patents, patents in process,
11
 * and are protected by trade secret or copyright law.
12
 * Dissemination of this information or reproduction of this material
13
 * is strictly forbidden unless prior written permission is obtained
14
 * from Andreas Theofilu.
15
 */
25 andreas 16
MODULE_NAME='MDB_UI'	(dev dvTPs[], dev vdvMDB, char IP[], char path[])
23 andreas 17
 
18
#include 'mSNAPI'
19
 
20
DEFINE_TYPE
21
	struct ST_SONG
22
	{
23
		integer nID;
24
		char sTitle[128];
25
		char sArtist[128];
26
		char sAlbum[128];
27
		char sGenre[128];
28
		char sCover[64];
29
	};
30
 
31
DEFINE_CONSTANT
32
	constant integer MAX_LINES =		5;
33
 
34
	constant char sPopupList[] = 		'MFp_MDB_list';
35
	constant char sPopupAudio[] = 		'MFp_MDB_audio';
36
	constant char sPopupDetail[] = 		'MFp_MDB_detail';
37
	constant char sPopupMenu[] = 		'MFp_MDB_menu';
24 andreas 38
	constant char sPopupUsers[] =		'MFp_MDB_users';
39
	constant char sPopupSelUser[] =		'MFp_MDB_select_user';
23 andreas 40
 
25 andreas 41
	constant integer BTN_SCROLLBAR =	256;
42
 
23 andreas 43
	constant integer BTN_SAVE =			340;
44
	constant integer BTN_DELETE =		341;
45
	constant integer BTN_NOW_PLAYING =	342;
25 andreas 46
	constant integer BTN_QUEUE =		349;
23 andreas 47
 
48
	constant integer BTN_TITLE = 		350;
49
	constant integer BTN_ARTIST =		351;
50
	constant integer BTN_GENRE =		352;
51
	constant integer BTN_ALBUM =		353;
52
	constant integer BTN_PLAYLIST =		354;
25 andreas 53
	constant integer BTN_RETURN =		355;
23 andreas 54
 
55
	constant integer BTN_LINE1_PIC =	301;
56
	constant integer BTN_LINE1_LINE =	321;
57
	constant integer BTN_LINE2_PIC =	302;
58
	constant integer BTN_LINE2_LINE =	322;
59
	constant integer BTN_LINE3_PIC =	303;
60
	constant integer BTN_LINE3_LINE =	323;
61
	constant integer BTN_LINE4_PIC =	304;
62
	constant integer BTN_LINE4_LINE =	324;
63
	constant integer BTN_LINE5_PIC =	305;
64
	constant integer BTN_LINE5_LINE =	325;
65
	constant integer BTN_LINE6_PIC =	306;
66
	constant integer BTN_LINE6_LINE =	326;
67
	constant integer BTN_LINE7_PIC =	307;
68
	constant integer BTN_LINE7_LINE =	327;
69
	constant integer BTN_LINE8_PIC =	308;
70
	constant integer BTN_LINE8_LINE =	328;
71
	constant integer BTN_LINE9_PIC =	309;
72
	constant integer BTN_LINE9_LINE =	329;
73
	constant integer BTN_LINE10_PIC =	310;
74
	constant integer BTN_LINE10_LINE =	330;
75
 
76
	constant integer BTN_MENU1 =		261;
77
	constant integer BTN_MENU2 =		262;
78
	constant integer BTN_MENU3 =		263;
79
	constant integer BTN_MENU4 =		264;
80
	constant integer BTN_MENU5 =		265;
81
	constant integer BTN_MENU6 =		266;
82
	constant integer BTN_MENU7 =		267;
83
	constant integer BTN_MENU8 =		268;
84
	constant integer BTN_MENU9 =		269;
85
	constant integer BTN_MENU10 =		270;
86
 
25 andreas 87
	constant integer BTN_DETAIL_BACK =	400;
88
	constant integer BTN_USER_OK =		401;
89
	constant integer BTN_USER_CANCEL =	402;
90
 
23 andreas 91
	constant integer TEXT_TITLE =		1001;
92
	constant integer TEXT_PROGRES =		1002;
93
	constant integer TEXT_MENU_TITLE =	1003;
94
 
95
	constant integer TEXT_DETAIL_TITLE =	1011;
96
	constant integer TEXT_DETAIL_ARTIST =	1012;
97
	constant integer TEXT_DETAIL_ALBUM =	1013;
98
	constant integer TEXT_DETAIL_GENRE =	1014;
99
	constant integer TEXT_DETAIL_TIME_PROG =1015;
100
	constant integer TEXT_DETAIL_TIME_TOTAL=1016;
101
 
24 andreas 102
	constant integer TEXT_INPUT_UNAME =		1021;
103
	constant integer TEXT_INPUT_PLAYLIST =	1022;
104
 
25 andreas 105
	constant integer LVL_SCROLLBAR =		7;
23 andreas 106
 
25 andreas 107
	constant char TOK_TXT_NONE[] =			'NONE';
108
	constant char TOK_TXT_TITLE[] =			'TITLE';
109
	constant char TOK_TXT_ARTIST[] =		'ARTIST';
110
	constant char TOK_TXT_ALBUM[] =			'ALBUM';
111
	constant char TOK_TXT_GENRE[] =			'GENRE';
112
	constant char TOK_TXT_QUEUE[] =			'QUEUE';
113
	constant char TOK_TXT_PLAYLIST[] =		'PLAYLIST';
23 andreas 114
 
25 andreas 115
	constant integer TOK_NONE =				0;
116
	constant integer TOK_TITLE =			1;
117
	constant integer TOK_ARTIST =			2;
118
	constant integer TOK_ALBUM =			3;
119
	constant integer TOK_GENRE =			4;
120
	constant integer TOK_QUEUE =			5;
121
	constant integer TOK_PLAYLIST =			6;
122
 
123
	constant integer TODO_USER_SELECT = 		1;		// select a user
124
	constant integer TODO_USER_LIST_PLAYLIST =	2;		// List the playlist
125
	constant integer TODO_USER_SAVE_PLAYLIST =	3;		// Save queue to playlist
126
	constant integer TODO_USER_PLAYLIST_QUEUE = 4;		// Move a playlist to the queue
127
 
23 andreas 128
	constant integer nNavigation[] =
129
	{
130
		BTN_SAVE,
131
		BTN_DELETE,
132
		BTN_NOW_PLAYING,
25 andreas 133
		BTN_QUEUE,
23 andreas 134
		BTN_TITLE,
135
		BTN_ARTIST,
136
		BTN_GENRE,
137
		BTN_ALBUM,
138
		BTN_PLAYLIST
139
	};
140
 
141
	constant integer nMenu[] =
142
	{
143
		BTN_MENU1,
144
		BTN_MENU2,
145
		BTN_MENU3,
146
		BTN_MENU4,
147
		BTN_MENU5,
148
		BTN_MENU6,
149
		BTN_MENU7,
150
		BTN_MENU8,
151
		BTN_MENU9,
152
		BTN_MENU10
153
	};
154
 
155
	constant integer nBtns[] =
156
	{
157
		PLAY,
158
		STOP,
159
		PAUSE,
160
		FFWD,						// Jump forward
161
		REW,						// jump backward
162
		SREV,						// Skip backward
163
		SFWD,						// Skip forward
164
		MENU_THUMBS_DN,
165
		MENU_THUMBS_UP,
166
		MEDIA_RANDOM,
24 andreas 167
		MEDIA_REPEAT,
25 andreas 168
		MENU_BACK,
169
		BTN_RETURN
23 andreas 170
	};
171
 
25 andreas 172
	constant integer nBtnUser[] =
173
	{
174
		BTN_DETAIL_BACK,
175
		BTN_USER_OK,
176
		BTN_USER_CANCEL,
177
		TEXT_INPUT_UNAME,
178
		TEXT_INPUT_PLAYLIST
179
	};
180
 
23 andreas 181
	constant integer nLines[] =
182
	{
183
		BTN_LINE1_PIC,
184
		BTN_LINE1_LINE,
185
		BTN_LINE2_PIC,
186
		BTN_LINE2_LINE,
187
		BTN_LINE3_PIC,
188
		BTN_LINE3_LINE,
189
		BTN_LINE4_PIC,
190
		BTN_LINE4_LINE,
191
		BTN_LINE5_PIC,
192
		BTN_LINE5_LINE,
193
		BTN_LINE6_PIC,
194
		BTN_LINE6_LINE,
195
		BTN_LINE7_PIC,
196
		BTN_LINE7_LINE,
197
		BTN_LINE8_PIC,
198
		BTN_LINE8_LINE,
199
		BTN_LINE9_PIC,
200
		BTN_LINE9_LINE,
201
		BTN_LINE10_PIC,
202
		BTN_LINE10_LINE
203
	};
204
 
24 andreas 205
	constant integer PLAYER_PLAY =		1;
206
	constant integer PLAYER_STOP =		2;
207
	constant integer PLAYER_PAUSE =		3;
208
 
23 andreas 209
	constant char sIconTitle[] = 'Song_45x45';
210
	constant char sIconAlbum[] = 'Album_45x45';
211
	constant char sIconGenre[] = 'Genre_45x45';
212
	constant char sIconArtist[] = 'Artist_45x45';
213
	constant char sIconQueue[] = 'Queue_45x45';
214
	constant char sIconPlaylist[] = 'Playlist_45x45';
215
 
216
	constant char sIconsMusic[7][24] =
217
	{
218
		sIconTitle,
219
		sIconArtist,
220
		sIconAlbum,
221
		sIconGenre,
222
		sIconQueue,
223
		sIconPlaylist
224
	};
225
 
226
DEFINE_VARIABLE
227
	volatile integer nStart;				// Index position of current position in list.
25 andreas 228
	volatile integer nOldStart;				// Saves the previous value of nStart if a folder is opened
23 andreas 229
	volatile integer nTotal;				// Total number of data
230
	volatile integer nPage;					// The type of the page: TOK_TITLE, ...
24 andreas 231
	volatile integer nPlayStatus;			// Status of the player
23 andreas 232
	volatile ST_SONG stSong[MAX_LINES];		// The register of currently showed songs
233
	volatile integer nSongIdx;				// The index of the song pointer
25 andreas 234
	volatile char    sActPlaylist[128];		// The name of the actual playlist
24 andreas 235
	volatile integer nLastPressedLine;		// The number of the line pressed last
236
	volatile integer nLastPressedMenu;		// The number of the menu line pressed last
237
	volatile integer nKeyboard[50];			// 1 = Keyboard active
25 andreas 238
	volatile char    sActUser[128];			// The name of the actual loaded user
239
	volatile char    sInputUser[128];		// Username in user dialog popup
240
	volatile char    sInputPlaylist[128];	// Name of playlist in user dialog popup
24 andreas 241
	volatile integer nFolder;				// 0 = Top level of list, 1 = Folder opened
25 andreas 242
	volatile char    sActFolder[128];		// The name of the actual selected folder
243
	volatile integer nScrollbarPressed[50];	// 1 = User is sliding the scrollbar
244
	volatile integer nScrollbarLvl;			// The level of the scrollbar when user releases the scrollbar
245
	volatile integer nRepeat;				// 1 = repeat on, 0 = repeat off
246
	volatile integer nRandom;				// 1 = random on, 0 = random off
247
	volatile integer nToDo;					// What to do next
23 andreas 248
	volatile char _strTok[10][256];
249
 
250
 
251
// DecodeURL: Undo URL encoding on a data segment as necessary for CLI protocol
252
//	(Note: Distructive for input; copy str before call if needed)
253
//   str: String to be decoded
254
define_function char[1024] DecodeURL(char oldStr[])
255
{
256
stack_var char str[1024];
257
stack_var char newStr[1024];
258
stack_var char strSegment[1024];
259
stack_var char strHex[2];
260
 
261
    str = oldStr;
262
    // Loop through string looking for '%' prefix characters
263
    strSegment = remove_string(str, '%', 1);
264
 
265
    while (length_array(strSegment) != 0) 
266
	{
267
		// Strip off '%' character from string segment, fetch HEX ASCII byte, reconstruct
268
		set_length_array(strSegment, length_array(strSegment) - 1);
269
		strHex = Left_String(str, 2);
270
		str = Right_String(str, length_array(str) - 2);
271
		newStr = "newStr,strSegment,HexToI(strHex)";
272
 
273
		strSegment = remove_string(str, '%', 1);
274
    }
275
 
276
    newStr = "newStr,str";
277
    return newStr;
278
}
279
 
24 andreas 280
define_function char[1024] EncodeURL(char oldStr[])
281
{
282
stack_var char str[1024];
25 andreas 283
stack_var char replace[64];
24 andreas 284
stack_var integer len;
285
stack_var integer i;
25 andreas 286
stack_var integer j;
287
stack_var integer flag;
24 andreas 288
 
25 andreas 289
	replace = "':;<>"% ',$27";
24 andreas 290
	len = length_string(oldStr);
291
	str = '';
292
 
293
	for (i = 1; i <= len; i++)
294
	{
25 andreas 295
		flag = false;
296
 
297
		for (j = 1; j <= length_string(replace); j++)
298
		{
299
			if (oldStr[i] == replace[j])
300
			{
301
				str = "str,'%',format('%02X', oldStr[i])";
302
				flag = true;
303
				break;
304
			}
305
		}
306
 
307
		if (!flag)
24 andreas 308
			str = "str,mid_string(oldStr, i, 1)";
309
	}
310
 
311
	return str;
312
}
313
 
23 andreas 314
define_function integer strtok(char str[], char tok[])
315
{
316
stack_var integer i;
317
stack_var integer idx;
318
 
25 andreas 319
	idx = 1;
320
 
321
	for (i = 1; i <= 10; i++)
322
		_strTok[i] = '';
323
 
23 andreas 324
	i = find_string(str, tok, 1);
325
 
326
	while (i && idx <= 10)
327
	{
25 andreas 328
		if (i > 1)
329
			_strTok[idx] = left_string(str, i - length_string(tok));
330
		else
331
			_strTok[idx] = '';
332
 
333
		remove_string(str, tok, 1);
334
		i = find_string(str, tok, 1);
23 andreas 335
		idx++;
336
	}
337
 
25 andreas 338
	if (idx <= 10)
339
		_strTok[idx] = str;
340
 
23 andreas 341
	return idx;
342
}
343
 
344
define_function char[256] getStrTok(integer idx)
345
{
346
	if (idx && idx <= 10)
347
		return _strTok[idx];
348
 
349
	return '';
350
}
351
 
352
define_function clearAllLogos()
353
{
354
	send_command dvTPs,"'^SHO-',itoa(BTN_LINE1_PIC),'.',itoa(BTN_LINE1_PIC+MAX_LINES-1),',0'";
355
}
356
 
357
define_function clearLogo(integer pos)
358
{
359
	if (!pos || pos > MAX_LINES)
360
		return;
361
 
362
	send_command dvTPs,"'^SHO-',itoa(BTN_LINE1_PIC+pos-1),',0'";
363
}
364
 
365
define_function setLogo(char sFile[], integer pos)
366
{
367
stack_var integer nType;
368
stack_var char sHost[64];
369
stack_var char sPath[512];
370
stack_var integer i;
371
 
372
	if (pos > MAX_LINES)
373
		return;
374
 
375
	sHost = IP;
25 andreas 376
	sPath = path;
23 andreas 377
	nType = 0;			// 0 = HTTP, 1 = FTP
378
	send_command dvTPs,"'^SHO-',itoa(300+pos),',1'";
379
 
380
	if (!length_string(sFile))
381
	{
382
		if (nPage && pos)
383
			send_command dvTPs,"'^BBR-',itoa(300+pos),',0,',sIconsMusic[nPage]";
384
 
385
		return;
386
	}
387
 
388
	if (pos && pos <= MAX_LINES)
389
	{
390
		send_command dvTPs,"'^RMF-XBMC_Audio',itoa(pos),',%P',itoa(nType),'%H',sHost,'%A',sPath,'%F',sFile";
391
		send_command dvTPs,"'^BBR-',itoa(300+pos),',0,XBMC_Audio',itoa(pos)";
392
	}
393
	else
394
	{
395
		send_command dvTPs,"'^RMF-XBMC_AudioCover,%P',itoa(nType),'%H',sHost,'%A',sPath,'%F',sFile";
396
		send_command dvTPs,"'^BBR-',itoa(300+pos),',0,XBMC_AudioCover'";
397
	}
398
}
399
 
400
define_function clearPage()
401
{
402
	clearAllLogos();
25 andreas 403
	send_command dvTPs,"'^TXT-',itoa(BTN_LINE1_LINE),'.',itoa(BTN_LINE1_LINE+MAX_LINES-1),',0,'";
23 andreas 404
}
405
 
406
define_function char[32] requestActualPage()
407
{
408
stack_var char sPage[32];
409
 
410
	sPage = '';
411
 
412
	if (nPage == TOK_NONE)
413
		return sPage;
414
 
415
	switch(nPage)
416
	{
417
		case TOK_TITLE:		sPage = TOK_TXT_TITLE;
418
		case TOK_ALBUM:		sPage = TOK_TXT_ALBUM;
419
		case TOK_ARTIST:	sPage = TOK_TXT_ARTIST;
420
		case TOK_GENRE:		sPage = TOK_TXT_GENRE;
421
		case TOK_QUEUE:		sPage = TOK_TXT_QUEUE;
422
		case TOK_PLAYLIST:	sPage = TOK_TXT_PLAYLIST;
423
	}
424
 
425
	return sPage;
426
}
427
 
24 andreas 428
define_function char[256] getPageLine(integer line)
429
{
430
	if (!line || line > MAX_LINES)
431
		return '';
432
 
433
	switch(nPage)
434
	{
435
		case TOK_TITLE:		return stSong[line].sTitle;
436
		case TOK_ARTIST:	return stSong[line].sArtist;
437
		case TOK_ALBUM:		return stSong[line].sAlbum;
438
		case TOK_GENRE:		return stSong[line].sGenre;
439
	}
440
 
441
	return '';
442
}
443
 
23 andreas 444
define_function integer setActualPage(char pg[])
445
{
446
	nPage = TOK_NONE;
447
 
448
	select
449
	{
450
		active (pg == TOK_TXT_TITLE):		nPage = TOK_TITLE;
451
		active (pg == TOK_TXT_ARTIST):		nPage = TOK_ARTIST;
452
		active (pg == TOK_TXT_ALBUM):		nPage = TOK_ALBUM;
453
		active (pg == TOK_TXT_GENRE):		nPage = TOK_GENRE;
454
		active (pg == TOK_TXT_QUEUE):		nPage = TOK_QUEUE;
455
		active (pg == TOK_TXT_PLAYLIST):	nPage = TOK_PLAYLIST;
456
	}
457
 
458
	switch(nPage)
459
	{
460
		case TOK_TITLE:
461
		case TOK_ALBUM:
462
		case TOK_ARTIST:
463
		case TOK_GENRE:
464
		case TOK_PLAYLIST:
465
			send_command dvTPs, "'@PPN-',sPopupAudio";
466
		break;
467
 
468
		case TOK_QUEUE:
469
			send_command dvTPs, "'@PPN-',sPopupList";
470
		break;
471
	}
472
 
24 andreas 473
	switch(nPage)
474
	{
475
		case TOK_TITLE:		send_command dvTPs, "'^TXT-',itoa(TEXT_TITLE),',0,Titles'";
476
		case TOK_ARTIST:	send_command dvTPs, "'^TXT-',itoa(TEXT_TITLE),',0,Artists'";
477
		case TOK_ALBUM:		send_command dvTPs, "'^TXT-',itoa(TEXT_TITLE),',0,Albums'";
478
		case TOK_GENRE:		send_command dvTPs, "'^TXT-',itoa(TEXT_TITLE),',0,Genres'";
479
		case TOK_QUEUE:		send_command dvTPs, "'^TXT-',itoa(TEXT_TITLE),',0,Queue'";
480
		case TOK_PLAYLIST:	send_command dvTPs, "'^TXT-',itoa(TEXT_TITLE),',0,Playlist'";
481
	}
482
 
23 andreas 483
	return nPage;
484
}
485
 
24 andreas 486
define_function displayPageInfo(integer st, integer tot)
487
{
488
stack_var integer bis;
489
 
490
	if (st)
491
	{
492
		bis = st + MAX_LINES - 1;
493
		send_command dvTPs, "'^TXT-',itoa(TEXT_PROGRES),',0,',itoa(st),' to ',itoa(bis),' of ',itoa(tot)";
494
	}
495
	else
496
		send_command dvTPs, "'^TXT-',itoa(TEXT_PROGRES),',0,'";
25 andreas 497
 
498
	// Scrollbar initialisieren
499
	if (tot && st <= tot)
500
		bis = type_cast(100.0 / tot * st);
501
	else
502
		bis = 0;
503
 
504
	send_level dvTPs, LVL_SCROLLBAR, bis;
24 andreas 505
}
506
 
23 andreas 507
define_function displaySong(integer idx)
508
{
509
	if (!idx || idx > MAX_LINES)
510
		return;
511
 
25 andreas 512
	send_command dvTPs, "'^TXT-',itoa(BTN_LINE1_LINE+idx-1),',0,',stSong[idx].sTitle,$0d,$0a,stSong[idx].sArtist";
23 andreas 513
}
514
 
24 andreas 515
define_function askMenuList()
516
{
517
	switch(nPage)
518
	{
519
		case TOK_TITLE:
520
		case TOK_ARTIST:
521
		case TOK_ALBUM:
522
		case TOK_GENRE:
523
			send_command dvTPs, "'@PPN-',sPopupMenu";
524
			send_command dvTPs, "'^TXT-',itoa(BTN_MENU1),'.',itoa(BTN_MENU1+MAX_LINES-1),',0,'";	// Clear all lines
525
			send_command dvTPs, "'^TXT-',itoa(BTN_MENU1),',0,Move to queue and play'";
526
			send_command dvTPs, "'^TXT-',itoa(BTN_MENU2),',0,Add to queue'";
527
			send_command dvTPs, "'^TXT-',itoa(BTN_MENU3),',0,Open folder'";
528
		break;
529
 
530
		case TOK_PLAYLIST:
531
			send_command dvTPs, "'@PPN-',sPopupMenu";
532
			send_command dvTPs, "'^TXT-',itoa(BTN_MENU1),'.',itoa(BTN_MENU1+MAX_LINES-1),',0,'";	// Clear all lines
533
			send_command dvTPs, "'^TXT-',itoa(BTN_MENU1),',0,Move to queue and play'";
534
			send_command dvTPs, "'^TXT-',itoa(BTN_MENU2),',0,Add to queue'";
535
			send_command dvTPs, "'^TXT-',itoa(BTN_MENU3),',0,Show content'";
536
		break;
537
 
538
		case TOK_QUEUE:
539
			send_command dvTPs, "'@PPN-',sPopupMenu";
540
			send_command dvTPs, "'^TXT-',itoa(BTN_MENU1),'.',itoa(BTN_MENU1+MAX_LINES-1),',0,'";	// Clear all lines
541
			send_command dvTPs, "'^TXT-',itoa(BTN_MENU1),',0,Play this now'";
542
			send_command dvTPs, "'^TXT-',itoa(BTN_MENU2),',0,Save this to a playlist'";
543
			send_command dvTPs, "'^TXT-',itoa(BTN_MENU3),',0,Delete from queue'";
544
		break;
545
	}
546
 
547
	switch(nPage)
548
	{
549
		case TOK_TITLE:		send_command dvTPs, "'^TXT-',itoa(TEXT_MENU_TITLE),',0,Title menu'";
550
		case TOK_ARTIST:	send_command dvTPs, "'^TXT-',itoa(TEXT_MENU_TITLE),',0,Artist menu'";
551
		case TOK_ALBUM:		send_command dvTPs, "'^TXT-',itoa(TEXT_MENU_TITLE),',0,Album menu'";
552
		case TOK_GENRE:		send_command dvTPs, "'^TXT-',itoa(TEXT_MENU_TITLE),',0,Genre menu'";
553
		case TOK_QUEUE:		send_command dvTPs, "'^TXT-',itoa(TEXT_MENU_TITLE),',0,Queue menu'";
554
		case TOK_PLAYLIST:	send_command dvTPs, "'^TXT-',itoa(TEXT_MENU_TITLE),',0,Playlist menu'";
555
	}
556
}
557
 
23 andreas 558
DEFINE_START
559
	nStart = 1;
560
	nPage = TOK_NONE;
561
 
562
DEFINE_EVENT
563
	data_event[dvTPs]
564
	{
24 andreas 565
		/*
566
		 * Whenever a panel comes online, it'll be initialized. The actual
567
		 * popup is shown and the pressed (or not pressed) button stated
568
		 * are set.
569
		 */
23 andreas 570
		online:
571
		{
572
			stack_var integer pan;
573
 
574
			pan = get_last(dvTPs);
575
 
576
			switch(nPage)
577
			{
578
				case TOK_TITLE:
25 andreas 579
				case TOK_PLAYLIST:
580
					send_command dvTPs[pan], "'@PPN-',sPopupAudio";
581
					send_command vdvMDB, "'LIST:',requestActualPage(),':',itoa(nStart),':',itoa(MAX_LINES),';'";
582
				break;
583
 
23 andreas 584
				case TOK_ALBUM:
585
				case TOK_ARTIST:
586
				case TOK_GENRE:
587
					send_command dvTPs[pan], "'@PPN-',sPopupAudio";
25 andreas 588
					send_command vdvMDB, "'FOLDER:',requestActualPage(),':',itoa(nStart),':',itoa(MAX_LINES),';'";
23 andreas 589
				break;
590
 
591
				case TOK_QUEUE:
592
					send_command dvTPs[pan], "'@PPN-',sPopupList";
593
					send_command vdvMDB, "'LIST:',requestActualPage(),':',itoa(nStart),':',itoa(MAX_LINES),';'";
594
				break;
25 andreas 595
 
596
				default:
597
					send_command dvTPs[pan], "'@PPN-',sPopupAudio";
598
					nStart = 1;
599
					send_command vdvMDB, "'LIST:TITLE:',itoa(nStart),':',itoa(MAX_LINES),';'";
23 andreas 600
			}
601
		}
602
	}
603
 
24 andreas 604
	/*
605
	 * The navigation buttons are for setting the wanted views.
606
	 */
23 andreas 607
	button_event[dvTPs, nNavigation]
608
	{
609
		push:
610
		{
25 andreas 611
		stack_var integer pan;
612
 
613
			pan = get_last(dvTPs);
614
 
23 andreas 615
			switch(BUTTON.INPUT.CHANNEL)
616
			{
25 andreas 617
				case BTN_TITLE:		
618
					send_command vdvMDB, "'LIST:TITLE:1:',itoa(MAX_LINES),';'"; 
619
					nFolder = 0; 
620
					nStart = 1;
621
					nPage = TOK_TITLE;
622
				break;
623
 
624
				case BTN_ARTIST:	
625
					send_command vdvMDB, "'FOLDER:ARTIST:1:',itoa(MAX_LINES),';'"; 
626
					nFolder = 0; 
627
					nStart = 1;
628
					nPage = TOK_ARTIST;
629
				break;
630
 
631
				case BTN_ALBUM:		
632
					send_command vdvMDB, "'FOLDER:ALBUM:1:',itoa(MAX_LINES),';'"; 
633
					nFolder = 0; 
634
					nStart = 1;
635
					nPage = TOK_ALBUM;
636
				break;
637
 
638
				case BTN_GENRE:		
639
					send_command vdvMDB, "'FOLDER:GENRE:1:',itoa(MAX_LINES),';'"; 
640
					nFolder = 0; 
641
					nStart = 1;
642
					nPage = TOK_GENRE;
643
				break;
644
 
645
				case BTN_QUEUE: 
646
					send_command vdvMDB, "'LIST:QUEUE:1:',itoa(MAX_LINES),';'"; 
647
					nFolder = 0; 
648
					nStart = 1;
649
					nPage = TOK_QUEUE;
650
				break;
651
 
652
				case BTN_PLAYLIST:
653
					if (!length_string(sActUser))
654
					{
655
						send_command dvTPs[pan], "'@PPN-',sPopupSelUser";
656
						send_command dvTPs[pan], "'@AKB-',sActUser,';Enter name of user'";
657
						nKeyboard[pan] = TEXT_INPUT_UNAME;
658
						nToDo = TODO_USER_SELECT;
659
					}
660
					else
661
					{
662
						nFolder = 0;
663
						nStart = 1;
664
						nPage = TOK_PLAYLIST;
665
						send_command vdvMDB, "'LIST:PLAYLIST:1:',itoa(MAX_LINES),';'";
666
					}
667
				break;
668
 
669
				case BTN_NOW_PLAYING:
670
					if (nPlayStatus == PLAYER_PLAY || nPlayStatus == PLAYER_PAUSE)
671
						send_command dvTPs, "'@PPN-',sPopupDetail";
672
				break;
673
 
674
				case BTN_SAVE:
675
					send_command dvTPs[pan], "'@PPN-',sPopupSelUser";
676
					sInputUser = sActUser;
677
					sInputPlaylist = '';
678
					send_command dvTPs[pan], "'^TXT-',itoa(TEXT_INPUT_UNAME),',0,',sActUser";
679
					send_command dvTPs[pan], "'^TXT-',itoa(TEXT_INPUT_UNAME),',0,'";
680
					send_command dvTPs[pan], "'@AKB-',sActPlaylist,';Enter name of playlist'";
681
					nToDo = TODO_USER_SAVE_PLAYLIST;
682
					nKeyboard[pan] = TEXT_INPUT_PLAYLIST;
683
				break;
684
 
685
				case BTN_DELETE:
686
					send_command vdvMDB, "'DELETE:QUEUE:-1;'";
687
				break;
23 andreas 688
			}
689
		}
690
	}
691
 
24 andreas 692
	/*
693
	 * This buttons control mostly the player. With them you can play, stop
694
	 * pause, etc. the player and scroll through lists.
695
	 * Common to this buttons is, that they conform to the AMX SNAPI standard.
696
	 * All of them are declared in the file "mSNAPI.axi".
697
	 */
23 andreas 698
	button_event[dvTPs, nBtns]
699
	{
700
		push:
701
		{
702
			switch(BUTTON.INPUT.CHANNEL)
703
			{
704
				case PLAY:			send_command vdvMDB, 'PLAY;';
25 andreas 705
				case PAUSE:			send_command vdvMDB, 'PLAYPAUSE;';
23 andreas 706
				case STOP:			send_command vdvMDB, 'STOP;';
707
				case FFWD:			send_command vdvMDB, 'FORWARD;';
708
				case REW:			send_command vdvMDB, 'REWIND;';
709
				case SREV:			send_command vdvMDB, 'SKIPREW;';
710
				case SFWD:			send_command vdvMDB, 'SKIPFWD;';
711
				case MEDIA_RANDOM:	send_command vdvMDB, 'RANDOM;';
712
				case MEDIA_REPEAT:	send_command vdvMDB, 'REPEAT;';
713
 
25 andreas 714
				case MENU_THUMBS_UP:
23 andreas 715
					if (nStart > MAX_LINES)
716
					{
717
						nStart = nStart - MAX_LINES;
25 andreas 718
 
719
						if (nPage == TOK_TITLE || nPage == TOK_QUEUE || nPage == TOK_PLAYLIST)
720
							send_command vdvMDB, "'LIST:',requestActualPage(),':',itoa(nStart),':',itoa(MAX_LINES),';'";
721
						else
722
							send_command vdvMDB, "'FOLDER:',requestActualPage(),':',itoa(nStart),':',itoa(MAX_LINES),';'";
23 andreas 723
					}
724
				break;
725
 
25 andreas 726
				case MENU_THUMBS_DN:
23 andreas 727
					if (nTotal && (nStart+MAX_LINES) <= nTotal)
728
					{
729
						nStart = nStart + MAX_LINES;
25 andreas 730
 
731
						if (nPage == TOK_TITLE || nPage == TOK_QUEUE || nPage == TOK_PLAYLIST)
732
							send_command vdvMDB, "'LIST:',requestActualPage(),':',itoa(nStart),':',itoa(MAX_LINES),';'";
733
						else
734
							send_command vdvMDB, "'FOLDER:',requestActualPage(),':',itoa(nStart),':',itoa(MAX_LINES),';'";
23 andreas 735
					}
736
				break;
24 andreas 737
 
738
				case MENU_BACK:
25 andreas 739
				case BTN_RETURN:
24 andreas 740
					if (nFolder)
25 andreas 741
					{
742
						nStart = nOldStart;
743
						nFolder = 0;
744
					}
745
 
746
					if (nPage == TOK_TITLE || nPage == TOK_QUEUE || nPage == TOK_PLAYLIST)
24 andreas 747
						send_command vdvMDB, "'LIST:',requestActualPage(),':',itoa(nStart),':',itoa(MAX_LINES),';'";
25 andreas 748
					else
749
						send_command vdvMDB, "'FOLDER:',requestActualPage(),':',itoa(nStart),':',itoa(MAX_LINES),';'";
24 andreas 750
				break;
23 andreas 751
			}
752
		}
24 andreas 753
 
754
		hold[2,repeat]:
755
		{
756
			switch(BUTTON.INPUT.CHANNEL)
757
			{
758
				case FFWD:			send_command vdvMDB, 'FORWARD;';
759
				case REW:			send_command vdvMDB, 'REWIND;';
760
			}
761
		}
23 andreas 762
	}
763
 
24 andreas 764
	button_event[dvTPs,nLines]
765
	{
766
		push:
767
		{
768
			switch(BUTTON.INPUT.CHANNEL)
769
			{
770
				case BTN_LINE1_PIC:
771
				case BTN_LINE1_LINE:
772
					nLastPressedLine = 1;
773
					askMenuList();
774
				break;
775
 
776
				case BTN_LINE2_PIC:
777
				case BTN_LINE2_LINE:
778
					nLastPressedLine = 2;
779
					askMenuList();
780
				break;
781
 
782
				case BTN_LINE3_PIC:
783
				case BTN_LINE3_LINE:
784
					nLastPressedLine = 3;
785
					askMenuList();
786
				break;
787
 
788
				case BTN_LINE4_PIC:
789
				case BTN_LINE4_LINE:
790
					nLastPressedLine = 4;
791
					askMenuList();
792
				break;
793
 
794
				case BTN_LINE5_PIC:
795
				case BTN_LINE5_LINE:
796
					nLastPressedLine = 5;
797
					askMenuList();
798
				break;
799
 
800
				case BTN_LINE6_PIC:
801
				case BTN_LINE6_LINE:
802
					nLastPressedLine = 6;
803
					askMenuList();
804
				break;
805
 
806
				case BTN_LINE7_PIC:
807
				case BTN_LINE7_LINE:
808
					nLastPressedLine = 7;
809
					askMenuList();
810
				break;
811
 
812
				case BTN_LINE8_PIC:
813
				case BTN_LINE8_LINE:
814
					nLastPressedLine = 8;
815
					askMenuList();
816
				break;
817
 
818
				case BTN_LINE9_PIC:
819
				case BTN_LINE9_LINE:
820
					nLastPressedLine = 9;
821
					askMenuList();
822
				break;
823
 
824
				case BTN_LINE10_PIC:
825
				case BTN_LINE10_LINE:
826
					nLastPressedLine = 10;
827
					askMenuList();
828
				break;
829
			}
830
		}
831
	}
832
 
833
	button_event[dvTPs,nMenu]
834
	{
835
		push:
836
		{
837
		stack_var integer pan;
838
 
839
			pan = get_last(dvTPs);
840
 
841
			switch(BUTTON.INPUT.CHANNEL)
842
			{
843
				case BTN_MENU1:
844
					if (nPage != TOK_PLAYLIST && nPage != TOK_QUEUE)	// Move to queue and play
845
					{
846
						if (nPlayStatus == PLAYER_PLAY || nPlayStatus == PLAYER_PAUSE)
847
							send_command vdvMDB, 'STOP;';
848
 
849
						send_command vdvMDB, 'DELETE:QUEUE:-1;';
25 andreas 850
 
851
						if (nPage == TOK_TITLE)
852
							send_command vdvMDB, "'PLAY:ID:',itoa(stSong[nLastPressedLine].nID),';'";
853
						else
854
							send_command vdvMDB, "'PLAY:',requestActualPage(),':',stSong[nLastPressedLine].sTitle,';'";
24 andreas 855
					}
856
					else if (nPage == TOK_PLAYLIST)
857
					{
858
						if (length_string(sActUser) && length_string(sActPlaylist))
859
						{
860
							if (nPlayStatus == PLAYER_PLAY || nPlayStatus == PLAYER_PAUSE)
861
								send_command vdvMDB, 'STOP;';
862
 
863
							send_command vdvMDB, 'DELETE:QUEUE:-1;';
864
							send_command vdvMDB, "'PLAY:PLAYLIST:',EncodeURL(sActPlaylist),';'";
865
						}
866
					}
867
					else if (nPage == TOK_QUEUE)
868
						send_command vdvMDB, "'PLAY:QUEUE:',itoa(nStart+nLastPressedLine-1),';'";
869
				break;
870
 
871
				case BTN_MENU2:
872
					if (nPage != TOK_PLAYLIST && nPage != TOK_QUEUE)	// Add to queue
25 andreas 873
					{
874
						if (nPage == TOK_TITLE)
875
							send_command vdvMDB, "'ADD:ID:',itoa(stSong[nLastPressedLine].nID),';'";
876
						else
877
							send_command vdvMDB, "'ADD:',requestActualPage(),':',stSong[nLastPressedLine].sTitle,';'";
878
					}
24 andreas 879
					else if (nPage == TOK_PLAYLIST)
880
						send_command vdvMDB, "'ADD:PLAYLIST:',EncodeURL(sActPlaylist),';'";
881
					else if (nPage == TOK_QUEUE)
882
					{
883
						send_command dvTPs[pan], "'@PPN-',sPopupSelUser";
25 andreas 884
						sInputUser = sActUser;
885
						sInputPlaylist = '';
24 andreas 886
						send_command dvTPs[pan], "'^TXT-',itoa(TEXT_INPUT_UNAME),',0,',sActUser";
887
						send_command dvTPs[pan], "'@AKB-',sActPlaylist,';Enter name of playlist'";
25 andreas 888
						nToDo = TODO_USER_PLAYLIST_QUEUE;
24 andreas 889
						nKeyboard[pan] = TEXT_INPUT_PLAYLIST;
890
					}
891
				break;
892
 
893
				case BTN_MENU3:
894
					if (nPage != TOK_PLAYLIST && nPage != TOK_QUEUE)	// Open folder
895
					{
25 andreas 896
						sActFolder = stSong[nLastPressedLine].sTitle;	// Get name of folder
897
						nFolder = true;									// Set marker for folder
898
						nOldStart = nStart;								// Save current position
899
						nStart = 1;										// Reset start position
900
						send_command vdvMDB, "'LISTFOLDER:',requestActualPage(),':',stSong[nLastPressedLine].sTitle,':1:',itoa(MAX_LINES),';'";
24 andreas 901
					}
902
					else if (nPage == TOK_PLAYLIST)
903
					{
25 andreas 904
						nOldStart = nStart;
905
						nFolder = 1;
906
						nStart = 1;
907
						send_command vdvMDB, "'PLIST:',EncodeURL(sActUser),':',EncodeURL(stSong[nLastPressedLine].sTitle),':',itoa(nStart),':',itoa(MAX_LINES),';'";
24 andreas 908
					}
909
					else if (nPage == TOK_QUEUE)
910
						send_command vdvMDB, "'DELETE:QUEUE:',itoa(stSong[nLastPressedLine].nID),';'";
911
				break;
912
			}
25 andreas 913
 
914
			if (nPage != TOK_QUEUE)
915
				send_command dvTPs, "'@PPN-',sPopupAudio";
916
			else
917
				send_command dvTPs, "'@PPN-',sPopupList";
24 andreas 918
		}
919
	}
920
 
25 andreas 921
	button_event[dvTPs,nBtnUser]
24 andreas 922
	{
923
		push:
924
		{
925
			stack_var integer pan;
926
 
927
			pan = get_last(dvTPs);
928
 
25 andreas 929
			switch(BUTTON.INPUT.CHANNEL)
24 andreas 930
			{
25 andreas 931
				case TEXT_INPUT_UNAME:
932
					if (!nKeyboard[pan])
933
					{
934
						nKeyboard[pan] = TEXT_INPUT_UNAME;
935
						send_command dvTPs[pan],"'@AKB-',sActUser,';Enter user name'";
936
					}
937
				break;
24 andreas 938
 
25 andreas 939
				case TEXT_INPUT_PLAYLIST:
940
					if (!nKeyboard[pan])
941
					{
942
						nKeyboard[pan] = TEXT_INPUT_PLAYLIST;
943
						send_command dvTPs[pan],"'@AKB-',sActPlaylist,';Enter name of playlist'";
944
					}
945
				break;
24 andreas 946
 
25 andreas 947
				case BTN_USER_OK:
948
					send_command dvTPs[pan],"'@PPF-',sPopupSelUser";
24 andreas 949
 
25 andreas 950
					switch(nToDo)
951
					{
952
						case TODO_USER_SELECT:
953
							sActUser = sInputUser;
954
							send_command vdvMDB, "'USER:',EncodeURL(sInputUser),':;'";
955
						break;
956
 
957
						case TODO_USER_LIST_PLAYLIST:
958
							sActPlaylist = sInputPlaylist;
959
							nOldStart = nStart;
960
							nFolder = 1;
961
							nStart = 1;
962
							send_command vdvMDB, "'PLIST:',EncodeURL(sActUser),':',EncodeURL(stSong[nLastPressedLine].sTitle),':',itoa(nStart),':',itoa(MAX_LINES),';'";
963
						break;
964
 
965
						case TODO_USER_SAVE_PLAYLIST:
966
							sActUser = sInputUser;
967
							sActPlaylist = sInputPlaylist;
968
 
969
							if (length_string(sActUser) && length_string(sActPlaylist))
970
								send_command vdvMDB, "'SAVEQUEUE:',EncodeURL(sActUser),':',EncodeURL(sActPlaylist),';'";
971
						break;
972
 
973
						case TODO_USER_PLAYLIST_QUEUE:
974
							sActUser = sInputUser;
975
							sActPlaylist = sInputPlaylist;
976
 
977
							if (length_string(sActUser) && length_string(sActPlaylist))
978
								send_command vdvMDB, "'ADD:PLAYLIST:',EncodeURL(sActPlaylist),';'";
979
						break;
980
					}
981
 
982
					nToDo = 0;
983
				break;
984
 
985
				case BTN_USER_CANCEL:
986
					nToDo = 0;
987
					send_command dvTPs[pan],"'@PPF-',sPopupSelUser";
988
				break;
989
 
990
				case BTN_DETAIL_BACK:
991
					if (nPage == TOK_QUEUE)
992
						send_command dvTPs,"'@PPN-',sPopupAudio";
993
					else
994
						send_command dvTPs,"'@PPN-',sPopupList";
995
				break;
24 andreas 996
			}
997
		}
998
	}
999
 
1000
	/*
1001
	 * This event catches everything comming from the COMM - module. Here the
1002
	 * AMX part of the COMM - module only makes a network connection to the
1003
	 * player. The API of the player is made to replace a heavy AMX COMM -
1004
	 * module. Everything normally is done inside an AMX COMM - module, is
1005
	 * done by the player itself, running on a Linux platform. This makes the
1006
	 * communication with it fairly easy.
1007
	 */
23 andreas 1008
	data_event[vdvMDB]
1009
	{
1010
		string:
1011
		{
1012
			stack_var char buf[8192];
1013
 
1014
			while (find_string(DATA.TEXT, ';', 1))
1015
			{
1016
				buf = remove_string(DATA.TEXT, ';', 1);
1017
				set_length_string(buf, length_string(buf) - 1);
1018
 
1019
				select
1020
				{
24 andreas 1021
					/*
1022
					 * This is send by the player whenever the UI should
1023
					 * display a list with song details.
1024
					 * The correct popup must be displayed and the contents
1025
					 * should be filled with the data from the player.
1026
					 */
25 andreas 1027
					active(find_string(buf, 'LINE:', 1)):
23 andreas 1028
					{
1029
					stack_var char sPg[32];
1030
					stack_var integer nSongID;
1031
					stack_var integer nLine;
1032
					stack_var integer anz;
1033
					stack_var integer i;
1034
 
25 andreas 1035
						remove_string(buf, 'LINE:', 1);
23 andreas 1036
						anz = strtok(buf, ':');
25 andreas 1037
 
23 andreas 1038
						for (i = 1; i <= anz; i++)
1039
						{
1040
							switch (i)
1041
							{
1042
								case 1: sPg = getStrTok(i);
1043
								case 2: nSongID = atoi(getStrTok(i));
1044
								case 3: nLine = atoi(getStrTok(i));
25 andreas 1045
								case 4: stSong[nLine].sTitle = DecodeURL(getStrTok(i));
1046
								case 5: stSong[nLine].sArtist = DecodeURL(getStrTok(i));
1047
								case 6: stSong[nLine].sAlbum = DecodeURL(getStrTok(i));
1048
								case 7: stSong[nLine].sGenre = DecodeURL(getStrTok(i));
1049
								case 8: stSong[nLine].sCover = DecodeURL(getStrTok(i));
23 andreas 1050
							}
1051
						}
1052
 
1053
						stSong[nLine].nID = nSongID;
1054
 
1055
						if (nLine == 1)
1056
						{
1057
							setActualPage(sPg);
1058
							clearPage();
1059
						}
1060
 
1061
						displaySong(nLine);
1062
					}
1063
 
25 andreas 1064
					active(find_string(buf, 'FOLDER:', 1)):
1065
					{
1066
					stack_var char sPg[32];
1067
					stack_var integer nLine;
1068
					stack_var integer anz;
1069
					stack_var integer i;
1070
 
1071
						remove_string(buf, 'FOLDER:', 1);
1072
						anz = strtok(buf, ':');
1073
 
1074
						for (i = 1; i <= anz; i++)
1075
						{
1076
							switch(i)
1077
							{
1078
								case 1: sPg = getStrTok(i);
1079
								case 2: nLine = atoi(getStrTok(i));
1080
								case 3: stSong[nLine].sTitle = DecodeURL(getStrTok(i));
1081
								case 4: stSong[nLine].sCover = DecodeURL(getStrTok(i));
1082
							}
1083
						}
1084
 
1085
						stSong[nLine].nID = 0;
1086
						stSong[nLine].sAlbum = '';
1087
						stSong[nLine].sArtist = '';
1088
						stSong[nLine].sGenre = '';
1089
 
1090
						if (nLine == 1)
1091
						{
1092
							setActualPage(sPg);
1093
							clearPage();
1094
						}
1095
 
1096
						displaySong(nLine);
1097
					}
1098
 
1099
					active(find_string(buf, 'PLAYLIST:', 1)):
1100
					{
1101
					stack_var integer nLine;
1102
					stack_var integer anz;
1103
					stack_var integer i;
1104
 
1105
						remove_string(buf, 'PLAYLIST:', 1);
1106
						anz = strtok(buf, ':');
1107
 
1108
						for (i = 1; i <= anz; i++)
1109
						{
1110
							switch(i)
1111
							{
1112
								case 1: nLine = atoi(getStrTok(i));
1113
								case 2: sActUser = DecodeURL(getStrTok(i));
1114
								case 3: stSong[nLine].sTitle = DecodeURL(getStrTok(i));
1115
							}
1116
						}
1117
 
1118
						stSong[nLine].nID = 0;
1119
						stSong[nLine].sAlbum = '';
1120
						stSong[nLine].sArtist = '';
1121
						stSong[nLine].sGenre = '';
1122
 
1123
						if (nLine == 1)
1124
						{
1125
							setActualPage('PLAYLIST');
1126
							clearPage();
1127
						}
1128
 
1129
						displaySong(nLine);
1130
					}
1131
 
1132
					active(find_string(buf, 'FOLDERNAME:', 1)):
1133
					{
1134
						remove_string(buf, 'FOLDERNAME:', 1);
1135
						sActFolder = buf;
1136
						nFolder = 1;
1137
					}
1138
 
24 andreas 1139
					active(find_string(buf, 'PLAYING:', 1)):
1140
					{
1141
					stack_var integer nSongID;
1142
					stack_var char sTitle[256];
1143
					stack_var char sArtist[256];
1144
					stack_var char sAlbum[256];
1145
					stack_var char sGenre[256];
1146
					stack_var char sCover[256];
1147
					stack_var integer anz;
1148
					stack_var integer i;
1149
 
1150
						remove_string(buf, 'PLAYING:', 1);
1151
						anz = strtok(buf, ':');
1152
 
1153
						for (i = 1; i <= anz; i++)
1154
						{
1155
							switch (i)
1156
							{
1157
								case 1: nSongID = atoi(getStrTok(i));
1158
								case 2: sTitle = DecodeURL(getStrTok(i));
1159
								case 3: sArtist = DecodeURL(getStrTok(i));
1160
								case 4: sAlbum = DecodeURL(getStrTok(i));
1161
								case 5: sGenre = DecodeURL(getStrTok(i));
1162
								case 6: sCover = DecodeURL(getStrTok(i));
1163
							}
1164
						}
1165
 
1166
						// Initialize detail fields
25 andreas 1167
						send_command dvTPs, "'^TXT-',itoa(TEXT_DETAIL_TITLE),',0,',sTitle";
1168
						send_command dvTPs, "'^TXT-',itoa(TEXT_DETAIL_ARTIST),',0,',sArtist";
1169
						send_command dvTPs, "'^TXT-',itoa(TEXT_DETAIL_ALBUM),',0,',sAlbum";
1170
						send_command dvTPs, "'^TXT-',itoa(TEXT_DETAIL_GENRE),',0,',sGenre";
24 andreas 1171
						setLogo(sCover, 0);
1172
					}
1173
 
25 andreas 1174
					active(find_string(buf, 'USER:', 1)):
1175
					{
1176
						remove_string(buf, 'USER:', 1);
1177
						sActUser = DecodeURL(buf);
1178
					}
1179
 
23 andreas 1180
					active(find_string(buf, 'TOTAL:', 1)):
1181
					{
1182
						remove_string(buf, 'TOTAL:', 1);
1183
						nTotal = atoi(buf);
24 andreas 1184
						displayPageInfo(nStart, nTotal);
23 andreas 1185
					}
1186
 
1187
					active(find_string(buf, 'PAGE:', 1)):
1188
					{
1189
						remove_string(buf, 'PAGE:', 1);
1190
						setActualPage(buf);
24 andreas 1191
						displayPageInfo(nStart, nTotal);
23 andreas 1192
					}
24 andreas 1193
 
25 andreas 1194
					active(find_string(buf, 'PLAYER:', 1)):
24 andreas 1195
					{
1196
						remove_string(buf, 'PLAYER:', 1);
1197
 
1198
						if (buf == 'PLAY')
1199
						{
1200
							nPlayStatus = PLAYER_PLAY;
1201
							on[dvTPs,PLAY];
1202
							off[dvTPs,STOP];
1203
							off[dvTPs,PAUSE];
1204
						}
1205
						else if (buf == 'STOP')
1206
						{
1207
							nPlayStatus = PLAYER_STOP;
1208
							off[dvTPs,PLAY];
1209
							on[dvTPs,STOP];
1210
							off[dvTPs,PAUSE];
1211
						}
1212
						else if (buf == 'PAUSE')
1213
						{
1214
							nPlayStatus = PLAYER_PAUSE;
1215
							off[dvTPs,PLAY];
1216
							off[dvTPs,STOP];
1217
							on[dvTPs,PAUSE];
1218
						}
1219
						else
1220
						{
1221
							nPlayStatus = 0;
1222
							off[dvTPs,PLAY];
1223
							off[dvTPs,STOP];
1224
							off[dvTPs,PAUSE];
1225
						}
1226
					}
1227
 
25 andreas 1228
					active(find_string(buf, 'RANDOM:', 1)):
1229
					{
1230
						remove_string(buf, 'RANDOM:', 1);
1231
 
1232
						if (buf == 'TRUE')
1233
							nRandom = 1;
1234
						else
1235
							nRandom = 0;
1236
					}
1237
 
1238
					active(find_string(buf, 'REPEAT:', 1)):
1239
					{
1240
						remove_string(buf, 'REPEAT:', 1);
1241
 
1242
						if (buf == 'TRUE')
1243
							nRepeat = 1;
1244
						else
1245
							nRepeat = 0;
1246
					}
1247
 
1248
					active(find_string(buf, 'ERROR:PLAYLIST:No user selected', 1)):
1249
					{
1250
						sActUser = '';
1251
						nKeyboard[get_last(dvTPs)] = TEXT_INPUT_UNAME;
1252
						send_command dvTPs[get_last(dvTPs)],"'@AKB-',sActUser,';Enter user name'";
1253
					}
1254
 
24 andreas 1255
					active(find_string(buf, 'KEYBOARD:', 1)):
1256
					{
1257
					stack_var integer pan;
1258
 
1259
						remove_string(buf, 'KEYBOARD:', 1);
1260
						pan = atoi(buf);
1261
						remove_string(buf, ':', 1);
1262
 
1263
						if (nKeyboard[pan] == TEXT_INPUT_UNAME)
1264
						{
25 andreas 1265
							sInputUser = buf;
1266
							send_command dvTPs[pan], "'^TXT-',itoa(TEXT_INPUT_UNAME),',0,',sInputUser";
24 andreas 1267
							nKeyboard[pan] = 0;
1268
						}
1269
						else if (nKeyboard[pan] == TEXT_INPUT_PLAYLIST)
1270
						{
25 andreas 1271
							sInputPlaylist = buf;
1272
							send_command dvTPs, "'^TXT-',itoa(TEXT_INPUT_PLAYLIST),',0,',sInputPlaylist";
24 andreas 1273
							nKeyboard[pan] = 0;
1274
						}
1275
					}
23 andreas 1276
				}
1277
			}
1278
		}
1279
	}
25 andreas 1280
 
1281
	button_event[dvTPs,BTN_SCROLLBAR]
1282
	{
1283
		push:
1284
		{
1285
		stack_var integer pan;
1286
 
1287
			pan = get_last(dvTPs)
1288
			nScrollbarPressed[pan] = 1;
1289
		}
1290
 
1291
		release:
1292
		{
1293
		stack_var integer pan;
1294
 
1295
			pan = get_last(dvTPs)
1296
			nScrollbarPressed[pan] = 0;
1297
 
1298
			if (nTotal)
1299
			{
1300
				nStart = type_cast(nTotal / 100.0 * nScrollbarLvl);
1301
				send_command vdvMDB, "'LIST:',requestActualPage(),':',itoa(nStart),':',itoa(MAX_LINES),';'";
1302
			}
1303
		}
1304
	}
1305
 
1306
	level_event[dvTPs,LVL_SCROLLBAR]
1307
	{
1308
	stack_var integer pan;
1309
 
1310
		pan = get_last(dvTPs);
1311
 
1312
		if (nScrollbarPressed[pan])
1313
			nScrollbarLvl = LEVEL.VALUE;
1314
	}
1315
 
1316
DEFINE_PROGRAM
1317
	[dvTPs,MEDIA_RANDOM] = nRandom;
1318
	[dvTPs,MEDIA_REPEAT] = nRepeat;