Subversion Repositories mdb

Rev

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