2 * Copyright (C) 2005-2013 Team XBMC
5 * This Program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2, or (at your option)
10 * This Program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with XBMC; see the file COPYING. If not, see
17 * <http://www.gnu.org/licenses/>.
21 #include "network/Network.h"
23 #include "GUIInfoManager.h"
24 #include "windows/GUIMediaWindow.h"
25 #include "dialogs/GUIDialogProgress.h"
26 #include "Application.h"
28 #include "network/libscrobbler/lastfmscrobbler.h"
29 #include "utils/URIUtils.h"
30 #include "utils/Weather.h"
31 #include "PartyModeManager.h"
32 #include "addons/Visualisation.h"
33 #include "input/ButtonTranslator.h"
34 #include "utils/AlarmClock.h"
36 #include "utils/SystemInfo.h"
37 #include "guilib/GUITextBox.h"
38 #include "pictures/GUIWindowSlideShow.h"
39 #include "music/LastFmManager.h"
40 #include "pictures/PictureInfoTag.h"
41 #include "music/tags/MusicInfoTag.h"
42 #include "guilib/GUIWindowManager.h"
43 #include "playlists/PlayList.h"
44 #include "utils/TuxBoxUtil.h"
45 #include "windowing/WindowingFactory.h"
46 #include "powermanagement/PowerManager.h"
47 #include "settings/AdvancedSettings.h"
48 #include "settings/Settings.h"
49 #include "guilib/LocalizeStrings.h"
50 #include "utils/CPUInfo.h"
51 #include "utils/StringUtils.h"
52 #include "utils/MathUtils.h"
53 #include "utils/SeekHandler.h"
55 #include "addons/Skin.h"
57 // stuff for current song
58 #include "music/MusicInfoLoader.h"
60 #include "GUIUserMessages.h"
61 #include "video/dialogs/GUIDialogVideoInfo.h"
62 #include "music/dialogs/GUIDialogMusicInfo.h"
63 #include "storage/MediaManager.h"
64 #include "utils/TimeUtils.h"
65 #include "threads/SingleLock.h"
66 #include "utils/log.h"
68 #include "pvr/PVRManager.h"
69 #include "pvr/channels/PVRChannelGroupsContainer.h"
70 #include "epg/EpgInfoTag.h"
71 #include "pvr/timers/PVRTimers.h"
72 #include "pvr/recordings/PVRRecording.h"
74 #include "addons/AddonManager.h"
75 #include "interfaces/info/InfoBool.h"
76 #include "video/VideoThumbLoader.h"
77 #include "music/MusicThumbLoader.h"
78 #include "video/VideoDatabase.h"
79 #include "cores/AudioEngine/Utils/AEUtil.h"
81 #define SYSHEATUPDATEINTERVAL 60000
84 using namespace XFILE;
85 using namespace MUSIC_INFO;
86 using namespace ADDON;
91 CGUIInfoManager::CGUIInfoManager(void) :
94 m_lastSysHeatInfoTime = -SYSHEATUPDATEINTERVAL; // make sure we grab CPU temp on the first pass
95 m_lastMusicBitrateTime = 0;
97 m_AfterSeekTimeout = 0;
99 m_playerSeeking = false;
100 m_performingSeek = false;
101 m_nextWindowID = WINDOW_INVALID;
102 m_prevWindowID = WINDOW_INVALID;
103 m_stringParameters.push_back("__ZZZZ__"); // to offset the string parameters by 1 to assure that all entries are non-zero
104 m_currentFile = new CFileItem;
105 m_currentSlide = new CFileItem;
110 m_playerShowTime = false;
111 m_playerShowCodec = false;
112 m_playerShowInfo = false;
117 CGUIInfoManager::~CGUIInfoManager(void)
119 delete m_currentFile;
120 delete m_currentSlide;
123 bool CGUIInfoManager::OnMessage(CGUIMessage &message)
125 if (message.GetMessage() == GUI_MSG_NOTIFY_ALL)
127 if (message.GetParam1() == GUI_MSG_UPDATE_ITEM && message.GetItem())
129 CFileItemPtr item = boost::static_pointer_cast<CFileItem>(message.GetItem());
130 if (m_currentFile->IsSamePath(item.get()))
132 m_currentFile->UpdateInfo(*item);
140 /// \brief Translates a string as given by the skin into an int that we use for more
141 /// efficient retrieval of data. Can handle combined strings on the form
142 /// Player.Caching + VideoPlayer.IsFullscreen (Logical and)
143 /// Player.HasVideo | Player.HasAudio (Logical or)
144 int CGUIInfoManager::TranslateString(const CStdString &condition)
146 // translate $LOCALIZE as required
147 CStdString strCondition(CGUIInfoLabel::ReplaceLocalize(condition));
148 return TranslateSingleString(strCondition);
157 const infomap player_labels[] = {{ "hasmedia", PLAYER_HAS_MEDIA }, // bools from here
158 { "hasaudio", PLAYER_HAS_AUDIO },
159 { "hasvideo", PLAYER_HAS_VIDEO },
160 { "playing", PLAYER_PLAYING },
161 { "paused", PLAYER_PAUSED },
162 { "rewinding", PLAYER_REWINDING },
163 { "forwarding", PLAYER_FORWARDING },
164 { "rewinding2x", PLAYER_REWINDING_2x },
165 { "rewinding4x", PLAYER_REWINDING_4x },
166 { "rewinding8x", PLAYER_REWINDING_8x },
167 { "rewinding16x", PLAYER_REWINDING_16x },
168 { "rewinding32x", PLAYER_REWINDING_32x },
169 { "forwarding2x", PLAYER_FORWARDING_2x },
170 { "forwarding4x", PLAYER_FORWARDING_4x },
171 { "forwarding8x", PLAYER_FORWARDING_8x },
172 { "forwarding16x", PLAYER_FORWARDING_16x },
173 { "forwarding32x", PLAYER_FORWARDING_32x },
174 { "canrecord", PLAYER_CAN_RECORD },
175 { "recording", PLAYER_RECORDING },
176 { "displayafterseek", PLAYER_DISPLAY_AFTER_SEEK },
177 { "caching", PLAYER_CACHING },
178 { "seekbar", PLAYER_SEEKBAR },
179 { "seeking", PLAYER_SEEKING },
180 { "showtime", PLAYER_SHOWTIME },
181 { "showcodec", PLAYER_SHOWCODEC },
182 { "showinfo", PLAYER_SHOWINFO },
183 { "title", PLAYER_TITLE },
184 { "muted", PLAYER_MUTED },
185 { "hasduration", PLAYER_HASDURATION },
186 { "passthrough", PLAYER_PASSTHROUGH },
187 { "cachelevel", PLAYER_CACHELEVEL }, // labels from here
188 { "seekbar", PLAYER_SEEKBAR },
189 { "progress", PLAYER_PROGRESS },
190 { "progresscache", PLAYER_PROGRESS_CACHE },
191 { "volume", PLAYER_VOLUME },
192 { "subtitledelay", PLAYER_SUBTITLE_DELAY },
193 { "audiodelay", PLAYER_AUDIO_DELAY },
194 { "chapter", PLAYER_CHAPTER },
195 { "chaptercount", PLAYER_CHAPTERCOUNT },
196 { "chaptername", PLAYER_CHAPTERNAME },
197 { "starrating", PLAYER_STAR_RATING },
198 { "folderpath", PLAYER_PATH },
199 { "filenameandpath", PLAYER_FILEPATH },
200 { "pauseenabled", PLAYER_CAN_PAUSE },
201 { "seekenabled", PLAYER_CAN_SEEK }};
203 const infomap player_param[] = {{ "art", PLAYER_ITEM_ART }};
205 const infomap player_times[] = {{ "seektime", PLAYER_SEEKTIME },
206 { "seekoffset", PLAYER_SEEKOFFSET },
207 { "timeremaining", PLAYER_TIME_REMAINING },
208 { "timespeed", PLAYER_TIME_SPEED },
209 { "time", PLAYER_TIME },
210 { "duration", PLAYER_DURATION },
211 { "finishtime", PLAYER_FINISH_TIME },
212 { "starttime", PLAYER_START_TIME}};
214 const infomap weather[] = {{ "isfetched", WEATHER_IS_FETCHED },
215 { "conditions", WEATHER_CONDITIONS }, // labels from here
216 { "temperature", WEATHER_TEMPERATURE },
217 { "location", WEATHER_LOCATION },
218 { "fanartcode", WEATHER_FANART_CODE },
219 { "plugin", WEATHER_PLUGIN }};
221 const infomap system_labels[] = {{ "hasnetwork", SYSTEM_ETHERNET_LINK_ACTIVE },
222 { "hasmediadvd", SYSTEM_MEDIA_DVD },
223 { "dvdready", SYSTEM_DVDREADY },
224 { "trayopen", SYSTEM_TRAYOPEN },
225 { "haslocks", SYSTEM_HASLOCKS },
226 { "hasloginscreen", SYSTEM_HAS_LOGINSCREEN },
227 { "ismaster", SYSTEM_ISMASTER },
228 { "isfullscreen", SYSTEM_ISFULLSCREEN },
229 { "isstandalone", SYSTEM_ISSTANDALONE },
230 { "loggedon", SYSTEM_LOGGEDON },
231 { "showexitbutton", SYSTEM_SHOW_EXIT_BUTTON },
232 { "canpowerdown", SYSTEM_CAN_POWERDOWN },
233 { "cansuspend", SYSTEM_CAN_SUSPEND },
234 { "canhibernate", SYSTEM_CAN_HIBERNATE },
235 { "canreboot", SYSTEM_CAN_REBOOT },
236 { "screensaveractive",SYSTEM_SCREENSAVER_ACTIVE },
237 { "cputemperature", SYSTEM_CPU_TEMPERATURE }, // labels from here
238 { "cpuusage", SYSTEM_CPU_USAGE },
239 { "gputemperature", SYSTEM_GPU_TEMPERATURE },
240 { "fanspeed", SYSTEM_FAN_SPEED },
241 { "freespace", SYSTEM_FREE_SPACE },
242 { "usedspace", SYSTEM_USED_SPACE },
243 { "totalspace", SYSTEM_TOTAL_SPACE },
244 { "usedspacepercent", SYSTEM_USED_SPACE_PERCENT },
245 { "freespacepercent", SYSTEM_FREE_SPACE_PERCENT },
246 { "buildversion", SYSTEM_BUILD_VERSION },
247 { "builddate", SYSTEM_BUILD_DATE },
248 { "fps", SYSTEM_FPS },
249 { "dvdtraystate", SYSTEM_DVD_TRAY_STATE },
250 { "freememory", SYSTEM_FREE_MEMORY },
251 { "language", SYSTEM_LANGUAGE },
252 { "temperatureunits", SYSTEM_TEMPERATURE_UNITS },
253 { "screenmode", SYSTEM_SCREEN_MODE },
254 { "screenwidth", SYSTEM_SCREEN_WIDTH },
255 { "screenheight", SYSTEM_SCREEN_HEIGHT },
256 { "currentwindow", SYSTEM_CURRENT_WINDOW },
257 { "currentcontrol", SYSTEM_CURRENT_CONTROL },
258 { "dvdlabel", SYSTEM_DVD_LABEL },
259 { "internetstate", SYSTEM_INTERNET_STATE },
260 { "kernelversion", SYSTEM_KERNEL_VERSION },
261 { "uptime", SYSTEM_UPTIME },
262 { "totaluptime", SYSTEM_TOTALUPTIME },
263 { "cpufrequency", SYSTEM_CPUFREQUENCY },
264 { "screenresolution", SYSTEM_SCREEN_RESOLUTION },
265 { "videoencoderinfo", SYSTEM_VIDEO_ENCODER_INFO },
266 { "profilename", SYSTEM_PROFILENAME },
267 { "profilethumb", SYSTEM_PROFILETHUMB },
268 { "profilecount", SYSTEM_PROFILECOUNT },
269 { "progressbar", SYSTEM_PROGRESS_BAR },
270 { "batterylevel", SYSTEM_BATTERY_LEVEL },
271 { "friendlyname", SYSTEM_FRIENDLY_NAME },
272 { "alarmpos", SYSTEM_ALARM_POS },
273 { "isinhibit", SYSTEM_ISINHIBIT },
274 { "hasshutdown", SYSTEM_HAS_SHUTDOWN },
275 { "haspvr", SYSTEM_HAS_PVR }};
277 const infomap system_param[] = {{ "hasalarm", SYSTEM_HAS_ALARM },
278 { "hascoreid", SYSTEM_HAS_CORE_ID },
279 { "setting", SYSTEM_SETTING },
280 { "hasaddon", SYSTEM_HAS_ADDON },
281 { "coreusage", SYSTEM_GET_CORE_USAGE }};
283 const infomap network_labels[] = {{ "isdhcp", NETWORK_IS_DHCP },
284 { "ipaddress", NETWORK_IP_ADDRESS }, //labels from here
285 { "linkstate", NETWORK_LINK_STATE },
286 { "macaddress", NETWORK_MAC_ADDRESS },
287 { "subnetaddress", NETWORK_SUBNET_MASK }, //subnetaddress is misleading/wrong. should be deprecated. use subnetmask in stead
288 { "subnetmask", NETWORK_SUBNET_MASK },
289 { "gatewayaddress", NETWORK_GATEWAY_ADDRESS },
290 { "dns1address", NETWORK_DNS1_ADDRESS },
291 { "dns2address", NETWORK_DNS2_ADDRESS },
292 { "dhcpaddress", NETWORK_DHCP_ADDRESS }};
294 const infomap musicpartymode[] = {{ "enabled", MUSICPM_ENABLED },
295 { "songsplayed", MUSICPM_SONGSPLAYED },
296 { "matchingsongs", MUSICPM_MATCHINGSONGS },
297 { "matchingsongspicked", MUSICPM_MATCHINGSONGSPICKED },
298 { "matchingsongsleft", MUSICPM_MATCHINGSONGSLEFT },
299 { "relaxedsongspicked",MUSICPM_RELAXEDSONGSPICKED },
300 { "randomsongspicked", MUSICPM_RANDOMSONGSPICKED }};
302 const infomap audioscrobbler[] = {{ "enabled", AUDIOSCROBBLER_ENABLED },
303 { "connectstate", AUDIOSCROBBLER_CONN_STATE }, //labels from here
304 { "submitinterval", AUDIOSCROBBLER_SUBMIT_INT },
305 { "filescached", AUDIOSCROBBLER_FILES_CACHED },
306 { "submitstate", AUDIOSCROBBLER_SUBMIT_STATE }};
308 const infomap lastfm[] = {{ "radioplaying", LASTFM_RADIOPLAYING },
309 { "canlove", LASTFM_CANLOVE},
310 { "canban", LASTFM_CANBAN}};
312 const infomap musicplayer[] = {{ "title", MUSICPLAYER_TITLE },
313 { "album", MUSICPLAYER_ALBUM },
314 { "artist", MUSICPLAYER_ARTIST },
315 { "albumartist", MUSICPLAYER_ALBUM_ARTIST },
316 { "year", MUSICPLAYER_YEAR },
317 { "genre", MUSICPLAYER_GENRE },
318 { "duration", MUSICPLAYER_DURATION },
319 { "tracknumber", MUSICPLAYER_TRACK_NUMBER },
320 { "cover", MUSICPLAYER_COVER },
321 { "bitrate", MUSICPLAYER_BITRATE },
322 { "playlistlength", MUSICPLAYER_PLAYLISTLEN },
323 { "playlistposition", MUSICPLAYER_PLAYLISTPOS },
324 { "channels", MUSICPLAYER_CHANNELS },
325 { "bitspersample", MUSICPLAYER_BITSPERSAMPLE },
326 { "samplerate", MUSICPLAYER_SAMPLERATE },
327 { "codec", MUSICPLAYER_CODEC },
328 { "discnumber", MUSICPLAYER_DISC_NUMBER },
329 { "rating", MUSICPLAYER_RATING },
330 { "comment", MUSICPLAYER_COMMENT },
331 { "lyrics", MUSICPLAYER_LYRICS },
332 { "playlistplaying", MUSICPLAYER_PLAYLISTPLAYING },
333 { "exists", MUSICPLAYER_EXISTS },
334 { "hasprevious", MUSICPLAYER_HASPREVIOUS },
335 { "hasnext", MUSICPLAYER_HASNEXT },
336 { "playcount", MUSICPLAYER_PLAYCOUNT },
337 { "lastplayed", MUSICPLAYER_LASTPLAYED },
338 { "channelname", MUSICPLAYER_CHANNEL_NAME },
339 { "channelnumber", MUSICPLAYER_CHANNEL_NUMBER },
340 { "channelgroup", MUSICPLAYER_CHANNEL_GROUP }
343 const infomap videoplayer[] = {{ "title", VIDEOPLAYER_TITLE },
344 { "genre", VIDEOPLAYER_GENRE },
345 { "country", VIDEOPLAYER_COUNTRY },
346 { "originaltitle", VIDEOPLAYER_ORIGINALTITLE },
347 { "director", VIDEOPLAYER_DIRECTOR },
348 { "year", VIDEOPLAYER_YEAR },
349 { "cover", VIDEOPLAYER_COVER },
350 { "usingoverlays", VIDEOPLAYER_USING_OVERLAYS },
351 { "isfullscreen", VIDEOPLAYER_ISFULLSCREEN },
352 { "hasmenu", VIDEOPLAYER_HASMENU },
353 { "playlistlength", VIDEOPLAYER_PLAYLISTLEN },
354 { "playlistposition", VIDEOPLAYER_PLAYLISTPOS },
355 { "plot", VIDEOPLAYER_PLOT },
356 { "plotoutline", VIDEOPLAYER_PLOT_OUTLINE },
357 { "episode", VIDEOPLAYER_EPISODE },
358 { "season", VIDEOPLAYER_SEASON },
359 { "rating", VIDEOPLAYER_RATING },
360 { "ratingandvotes", VIDEOPLAYER_RATING_AND_VOTES },
361 { "tvshowtitle", VIDEOPLAYER_TVSHOW },
362 { "premiered", VIDEOPLAYER_PREMIERED },
363 { "studio", VIDEOPLAYER_STUDIO },
364 { "mpaa", VIDEOPLAYER_MPAA },
365 { "top250", VIDEOPLAYER_TOP250 },
366 { "cast", VIDEOPLAYER_CAST },
367 { "castandrole", VIDEOPLAYER_CAST_AND_ROLE },
368 { "artist", VIDEOPLAYER_ARTIST },
369 { "album", VIDEOPLAYER_ALBUM },
370 { "writer", VIDEOPLAYER_WRITER },
371 { "tagline", VIDEOPLAYER_TAGLINE },
372 { "hasinfo", VIDEOPLAYER_HAS_INFO },
373 { "trailer", VIDEOPLAYER_TRAILER },
374 { "videocodec", VIDEOPLAYER_VIDEO_CODEC },
375 { "videoresolution", VIDEOPLAYER_VIDEO_RESOLUTION },
376 { "videoaspect", VIDEOPLAYER_VIDEO_ASPECT },
377 { "audiocodec", VIDEOPLAYER_AUDIO_CODEC },
378 { "audiochannels", VIDEOPLAYER_AUDIO_CHANNELS },
379 { "hasteletext", VIDEOPLAYER_HASTELETEXT },
380 { "lastplayed", VIDEOPLAYER_LASTPLAYED },
381 { "playcount", VIDEOPLAYER_PLAYCOUNT },
382 { "hassubtitles", VIDEOPLAYER_HASSUBTITLES },
383 { "subtitlesenabled", VIDEOPLAYER_SUBTITLESENABLED },
384 { "endtime", VIDEOPLAYER_ENDTIME },
385 { "nexttitle", VIDEOPLAYER_NEXT_TITLE },
386 { "nextgenre", VIDEOPLAYER_NEXT_GENRE },
387 { "nextplot", VIDEOPLAYER_NEXT_PLOT },
388 { "nextplotoutline", VIDEOPLAYER_NEXT_PLOT_OUTLINE },
389 { "nextstarttime", VIDEOPLAYER_NEXT_STARTTIME },
390 { "nextendtime", VIDEOPLAYER_NEXT_ENDTIME },
391 { "nextduration", VIDEOPLAYER_NEXT_DURATION },
392 { "channelname", VIDEOPLAYER_CHANNEL_NAME },
393 { "channelnumber", VIDEOPLAYER_CHANNEL_NUMBER },
394 { "channelgroup", VIDEOPLAYER_CHANNEL_GROUP },
395 { "hasepg", VIDEOPLAYER_HAS_EPG },
396 { "parentalrating", VIDEOPLAYER_PARENTAL_RATING }};
398 const infomap mediacontainer[] = {{ "hasfiles", CONTAINER_HASFILES },
399 { "hasfolders", CONTAINER_HASFOLDERS },
400 { "isstacked", CONTAINER_STACKED },
401 { "folderthumb", CONTAINER_FOLDERTHUMB },
402 { "tvshowthumb", CONTAINER_TVSHOWTHUMB },
403 { "seasonthumb", CONTAINER_SEASONTHUMB },
404 { "folderpath", CONTAINER_FOLDERPATH },
405 { "foldername", CONTAINER_FOLDERNAME },
406 { "pluginname", CONTAINER_PLUGINNAME },
407 { "viewmode", CONTAINER_VIEWMODE },
408 { "totaltime", CONTAINER_TOTALTIME },
409 { "hasthumb", CONTAINER_HAS_THUMB },
410 { "sortmethod", CONTAINER_SORT_METHOD },
411 { "showplot", CONTAINER_SHOWPLOT }};
413 const infomap container_bools[] ={{ "onnext", CONTAINER_MOVE_NEXT },
414 { "onprevious", CONTAINER_MOVE_PREVIOUS },
415 { "onscrollnext", CONTAINER_SCROLL_NEXT },
416 { "onscrollprevious", CONTAINER_SCROLL_PREVIOUS },
417 { "numpages", CONTAINER_NUM_PAGES },
418 { "numitems", CONTAINER_NUM_ITEMS },
419 { "currentpage", CONTAINER_CURRENT_PAGE },
420 { "scrolling", CONTAINER_SCROLLING },
421 { "hasnext", CONTAINER_HAS_NEXT },
422 { "hasprevious", CONTAINER_HAS_PREVIOUS },
423 { "canfilter", CONTAINER_CAN_FILTER },
424 { "canfilteradvanced",CONTAINER_CAN_FILTERADVANCED },
425 { "filtered", CONTAINER_FILTERED }};
427 const infomap container_ints[] = {{ "row", CONTAINER_ROW },
428 { "column", CONTAINER_COLUMN },
429 { "position", CONTAINER_POSITION },
430 { "subitem", CONTAINER_SUBITEM },
431 { "hasfocus", CONTAINER_HAS_FOCUS }};
433 const infomap container_str[] = {{ "property", CONTAINER_PROPERTY },
434 { "content", CONTAINER_CONTENT }};
436 const infomap listitem_labels[]= {{ "thumb", LISTITEM_THUMB },
437 { "icon", LISTITEM_ICON },
438 { "actualicon", LISTITEM_ACTUAL_ICON },
439 { "overlay", LISTITEM_OVERLAY },
440 { "label", LISTITEM_LABEL },
441 { "label2", LISTITEM_LABEL2 },
442 { "title", LISTITEM_TITLE },
443 { "tracknumber", LISTITEM_TRACKNUMBER },
444 { "artist", LISTITEM_ARTIST },
445 { "album", LISTITEM_ALBUM },
446 { "albumartist", LISTITEM_ALBUM_ARTIST },
447 { "year", LISTITEM_YEAR },
448 { "genre", LISTITEM_GENRE },
449 { "director", LISTITEM_DIRECTOR },
450 { "filename", LISTITEM_FILENAME },
451 { "filenameandpath", LISTITEM_FILENAME_AND_PATH },
452 { "fileextension", LISTITEM_FILE_EXTENSION },
453 { "date", LISTITEM_DATE },
454 { "size", LISTITEM_SIZE },
455 { "rating", LISTITEM_RATING },
456 { "ratingandvotes", LISTITEM_RATING_AND_VOTES },
457 { "programcount", LISTITEM_PROGRAM_COUNT },
458 { "duration", LISTITEM_DURATION },
459 { "isselected", LISTITEM_ISSELECTED },
460 { "isplaying", LISTITEM_ISPLAYING },
461 { "plot", LISTITEM_PLOT },
462 { "plotoutline", LISTITEM_PLOT_OUTLINE },
463 { "episode", LISTITEM_EPISODE },
464 { "season", LISTITEM_SEASON },
465 { "tvshowtitle", LISTITEM_TVSHOW },
466 { "premiered", LISTITEM_PREMIERED },
467 { "comment", LISTITEM_COMMENT },
468 { "path", LISTITEM_PATH },
469 { "foldername", LISTITEM_FOLDERNAME },
470 { "folderpath", LISTITEM_FOLDERPATH },
471 { "picturepath", LISTITEM_PICTURE_PATH },
472 { "pictureresolution",LISTITEM_PICTURE_RESOLUTION },
473 { "picturedatetime", LISTITEM_PICTURE_DATETIME },
474 { "picturecomment", LISTITEM_PICTURE_COMMENT },
475 { "picturecaption", LISTITEM_PICTURE_CAPTION },
476 { "picturedesc", LISTITEM_PICTURE_DESC },
477 { "picturekeywords", LISTITEM_PICTURE_KEYWORDS },
478 { "picturecammake", LISTITEM_PICTURE_CAM_MAKE },
479 { "picturecammodel", LISTITEM_PICTURE_CAM_MODEL },
480 { "pictureaperture", LISTITEM_PICTURE_APERTURE },
481 { "picturefocallen", LISTITEM_PICTURE_FOCAL_LEN },
482 { "picturefocusdist", LISTITEM_PICTURE_FOCUS_DIST },
483 { "pictureexpmode", LISTITEM_PICTURE_EXP_MODE },
484 { "pictureexptime", LISTITEM_PICTURE_EXP_TIME },
485 { "pictureiso", LISTITEM_PICTURE_ISO },
486 { "picturegpslat", LISTITEM_PICTURE_GPS_LAT },
487 { "picturegpslon", LISTITEM_PICTURE_GPS_LON },
488 { "picturegpsalt", LISTITEM_PICTURE_GPS_ALT },
489 { "studio", LISTITEM_STUDIO },
490 { "country", LISTITEM_COUNTRY },
491 { "mpaa", LISTITEM_MPAA },
492 { "cast", LISTITEM_CAST },
493 { "castandrole", LISTITEM_CAST_AND_ROLE },
494 { "writer", LISTITEM_WRITER },
495 { "tagline", LISTITEM_TAGLINE },
496 { "top250", LISTITEM_TOP250 },
497 { "trailer", LISTITEM_TRAILER },
498 { "starrating", LISTITEM_STAR_RATING },
499 { "sortletter", LISTITEM_SORT_LETTER },
500 { "videocodec", LISTITEM_VIDEO_CODEC },
501 { "videoresolution", LISTITEM_VIDEO_RESOLUTION },
502 { "videoaspect", LISTITEM_VIDEO_ASPECT },
503 { "audiocodec", LISTITEM_AUDIO_CODEC },
504 { "audiochannels", LISTITEM_AUDIO_CHANNELS },
505 { "audiolanguage", LISTITEM_AUDIO_LANGUAGE },
506 { "subtitlelanguage", LISTITEM_SUBTITLE_LANGUAGE },
507 { "isresumable", LISTITEM_IS_RESUMABLE},
508 { "percentplayed", LISTITEM_PERCENT_PLAYED},
509 { "isfolder", LISTITEM_IS_FOLDER },
510 { "originaltitle", LISTITEM_ORIGINALTITLE },
511 { "lastplayed", LISTITEM_LASTPLAYED },
512 { "playcount", LISTITEM_PLAYCOUNT },
513 { "discnumber", LISTITEM_DISC_NUMBER },
514 { "starttime", LISTITEM_STARTTIME },
515 { "endtime", LISTITEM_ENDTIME },
516 { "startdate", LISTITEM_STARTDATE },
517 { "enddate", LISTITEM_ENDDATE },
518 { "nexttitle", LISTITEM_NEXT_TITLE },
519 { "nextgenre", LISTITEM_NEXT_GENRE },
520 { "nextplot", LISTITEM_NEXT_PLOT },
521 { "nextplotoutline", LISTITEM_NEXT_PLOT_OUTLINE },
522 { "nextstarttime", LISTITEM_NEXT_STARTTIME },
523 { "nextendtime", LISTITEM_NEXT_ENDTIME },
524 { "nextstartdate", LISTITEM_NEXT_STARTDATE },
525 { "nextenddate", LISTITEM_NEXT_ENDDATE },
526 { "channelname", LISTITEM_CHANNEL_NAME },
527 { "channelnumber", LISTITEM_CHANNEL_NUMBER },
528 { "channelgroup", LISTITEM_CHANNEL_GROUP },
529 { "hasepg", LISTITEM_HAS_EPG },
530 { "hastimer", LISTITEM_HASTIMER },
531 { "isrecording", LISTITEM_ISRECORDING },
532 { "isencrypted", LISTITEM_ISENCRYPTED },
533 { "progress", LISTITEM_PROGRESS },
534 { "dateadded", LISTITEM_DATE_ADDED },
535 { "dbtype", LISTITEM_DBTYPE },
536 { "dbid", LISTITEM_DBID }};
538 const infomap visualisation[] = {{ "locked", VISUALISATION_LOCKED },
539 { "preset", VISUALISATION_PRESET },
540 { "name", VISUALISATION_NAME },
541 { "enabled", VISUALISATION_ENABLED }};
543 const infomap fanart_labels[] = {{ "color1", FANART_COLOR1 },
544 { "color2", FANART_COLOR2 },
545 { "color3", FANART_COLOR3 },
546 { "image", FANART_IMAGE }};
548 const infomap skin_labels[] = {{ "currenttheme", SKIN_THEME },
549 { "currentcolourtheme",SKIN_COLOUR_THEME },
550 {"hasvideooverlay", SKIN_HAS_VIDEO_OVERLAY},
551 {"hasmusicoverlay", SKIN_HAS_MUSIC_OVERLAY},
552 {"aspectratio", SKIN_ASPECT_RATIO}};
554 const infomap window_bools[] = {{ "ismedia", WINDOW_IS_MEDIA },
555 { "isactive", WINDOW_IS_ACTIVE },
556 { "istopmost", WINDOW_IS_TOPMOST },
557 { "isvisible", WINDOW_IS_VISIBLE },
558 { "previous", WINDOW_PREVIOUS },
559 { "next", WINDOW_NEXT }};
561 const infomap control_labels[] = {{ "hasfocus", CONTROL_HAS_FOCUS },
562 { "isvisible", CONTROL_IS_VISIBLE },
563 { "isenabled", CONTROL_IS_ENABLED },
564 { "getlabel", CONTROL_GET_LABEL }};
566 const infomap playlist[] = {{ "length", PLAYLIST_LENGTH },
567 { "position", PLAYLIST_POSITION },
568 { "random", PLAYLIST_RANDOM },
569 { "repeat", PLAYLIST_REPEAT },
570 { "israndom", PLAYLIST_ISRANDOM },
571 { "isrepeat", PLAYLIST_ISREPEAT },
572 { "isrepeatone", PLAYLIST_ISREPEATONE }};
574 const infomap pvr[] = {{ "isrecording", PVR_IS_RECORDING },
575 { "hastimer", PVR_HAS_TIMER },
576 { "hasnonrecordingtimer", PVR_HAS_NONRECORDING_TIMER },
577 { "nowrecordingtitle", PVR_NOW_RECORDING_TITLE },
578 { "nowrecordingdatetime", PVR_NOW_RECORDING_DATETIME },
579 { "nowrecordingchannel", PVR_NOW_RECORDING_CHANNEL },
580 { "nowrecordingchannelicon", PVR_NOW_RECORDING_CHAN_ICO },
581 { "nextrecordingtitle", PVR_NEXT_RECORDING_TITLE },
582 { "nextrecordingdatetime", PVR_NEXT_RECORDING_DATETIME },
583 { "nextrecordingchannel", PVR_NEXT_RECORDING_CHANNEL },
584 { "nextrecordingchannelicon", PVR_NEXT_RECORDING_CHAN_ICO },
585 { "backendname", PVR_BACKEND_NAME },
586 { "backendversion", PVR_BACKEND_VERSION },
587 { "backendhost", PVR_BACKEND_HOST },
588 { "backenddiskspace", PVR_BACKEND_DISKSPACE },
589 { "backendchannels", PVR_BACKEND_CHANNELS },
590 { "backendtimers", PVR_BACKEND_TIMERS },
591 { "backendrecordings", PVR_BACKEND_RECORDINGS },
592 { "backendnumber", PVR_BACKEND_NUMBER },
593 { "hasepg", PVR_HAS_EPG },
594 { "hastxt", PVR_HAS_TXT },
595 { "hasdirector", PVR_HAS_DIRECTOR },
596 { "totaldiscspace", PVR_TOTAL_DISKSPACE },
597 { "nexttimer", PVR_NEXT_TIMER },
598 { "isplayingtv", PVR_IS_PLAYING_TV },
599 { "isplayingradio", PVR_IS_PLAYING_RADIO },
600 { "isplayingrecording", PVR_IS_PLAYING_RECORDING },
601 { "duration", PVR_PLAYING_DURATION },
602 { "time", PVR_PLAYING_TIME },
603 { "progress", PVR_PLAYING_PROGRESS },
604 { "actstreamclient", PVR_ACTUAL_STREAM_CLIENT },
605 { "actstreamdevice", PVR_ACTUAL_STREAM_DEVICE },
606 { "actstreamstatus", PVR_ACTUAL_STREAM_STATUS },
607 { "actstreamsignal", PVR_ACTUAL_STREAM_SIG },
608 { "actstreamsnr", PVR_ACTUAL_STREAM_SNR },
609 { "actstreamber", PVR_ACTUAL_STREAM_BER },
610 { "actstreamunc", PVR_ACTUAL_STREAM_UNC },
611 { "actstreamvideobitrate", PVR_ACTUAL_STREAM_VIDEO_BR },
612 { "actstreamaudiobitrate", PVR_ACTUAL_STREAM_AUDIO_BR },
613 { "actstreamdolbybitrate", PVR_ACTUAL_STREAM_DOLBY_BR },
614 { "actstreamprogrsignal", PVR_ACTUAL_STREAM_SIG_PROGR },
615 { "actstreamprogrsnr", PVR_ACTUAL_STREAM_SNR_PROGR },
616 { "actstreamisencrypted", PVR_ACTUAL_STREAM_ENCRYPTED },
617 { "actstreamencryptionname", PVR_ACTUAL_STREAM_CRYPTION }};
619 const infomap slideshow[] = {{ "ispaused", SLIDESHOW_ISPAUSED },
620 { "isactive", SLIDESHOW_ISACTIVE },
621 { "israndom", SLIDESHOW_ISRANDOM }};
623 const int picture_slide_map[] = {/* LISTITEM_PICTURE_RESOLUTION => */ SLIDE_RESOLUTION,
624 /* LISTITEM_PICTURE_DATE => */ SLIDE_EXIF_DATE,
625 /* LISTITEM_PICTURE_DATETIME => */ SLIDE_EXIF_DATE_TIME,
626 /* LISTITEM_PICTURE_COMMENT => */ SLIDE_COMMENT,
627 /* LISTITEM_PICTURE_CAPTION => */ SLIDE_IPTC_CAPTION,
628 /* LISTITEM_PICTURE_DESC => */ SLIDE_EXIF_DESCRIPTION,
629 /* LISTITEM_PICTURE_KEYWORDS => */ SLIDE_IPTC_KEYWORDS,
630 /* LISTITEM_PICTURE_CAM_MAKE => */ SLIDE_EXIF_CAMERA_MAKE,
631 /* LISTITEM_PICTURE_CAM_MODEL => */ SLIDE_EXIF_CAMERA_MODEL,
632 /* LISTITEM_PICTURE_APERTURE => */ SLIDE_EXIF_APERTURE,
633 /* LISTITEM_PICTURE_FOCAL_LEN => */ SLIDE_EXIF_FOCAL_LENGTH,
634 /* LISTITEM_PICTURE_FOCUS_DIST => */ SLIDE_EXIF_FOCUS_DIST,
635 /* LISTITEM_PICTURE_EXP_MODE => */ SLIDE_EXIF_EXPOSURE_MODE,
636 /* LISTITEM_PICTURE_EXP_TIME => */ SLIDE_EXIF_EXPOSURE_TIME,
637 /* LISTITEM_PICTURE_ISO => */ SLIDE_EXIF_ISO_EQUIV,
638 /* LISTITEM_PICTURE_GPS_LAT => */ SLIDE_EXIF_GPS_LATITUDE,
639 /* LISTITEM_PICTURE_GPS_LON => */ SLIDE_EXIF_GPS_LONGITUDE,
640 /* LISTITEM_PICTURE_GPS_ALT => */ SLIDE_EXIF_GPS_ALTITUDE };
642 CGUIInfoManager::Property::Property(const CStdString &property, const CStdString ¶meters)
645 CUtil::SplitParams(parameters, params);
648 const CStdString &CGUIInfoManager::Property::param(unsigned int n /* = 0 */) const
650 if (n < params.size())
652 return StringUtils::EmptyString;
655 unsigned int CGUIInfoManager::Property::num_params() const
657 return params.size();
660 void CGUIInfoManager::SplitInfoString(const CStdString &infoString, vector<Property> &info)
662 // our string is of the form:
663 // category[(params)][.info(params).info2(params)] ...
664 // so we need to split on . while taking into account of () pairs
665 unsigned int parentheses = 0;
668 for (size_t i = 0; i < infoString.size(); ++i)
670 if (infoString[i] == '(')
675 else if (infoString[i] == ')')
678 CLog::Log(LOGERROR, "unmatched parentheses in %s", infoString.c_str());
679 else if (!--parentheses)
682 else if (infoString[i] == '.' && !parentheses)
684 if (!property.IsEmpty()) // add our property and parameters
685 info.push_back(Property(property.ToLower(), param));
691 param += infoString[i];
693 property += infoString[i];
696 CLog::Log(LOGERROR, "unmatched parentheses in %s", infoString.c_str());
697 if (!property.IsEmpty())
698 info.push_back(Property(property.ToLower(), param));
701 /// \brief Translates a string as given by the skin into an int that we use for more
702 /// efficient retrieval of data.
703 int CGUIInfoManager::TranslateSingleString(const CStdString &strCondition)
706 CStdString strTest = strCondition;
707 strTest.TrimLeft(" \t\r\n");
708 strTest.TrimRight(" \t\r\n");
710 vector< Property> info;
711 SplitInfoString(strTest, info);
716 const Property &cat = info[0];
717 if (info.size() == 1)
719 if (cat.name == "false" || cat.name == "no" || cat.name == "off")
720 return SYSTEM_ALWAYS_FALSE;
721 else if (cat.name == "true" || cat.name == "yes" || cat.name == "on")
722 return SYSTEM_ALWAYS_TRUE;
723 if (cat.name == "isempty" && cat.num_params() == 1)
724 return AddMultiInfo(GUIInfo(STRING_IS_EMPTY, TranslateSingleString(cat.param())));
725 else if (cat.name == "stringcompare" && cat.num_params() == 2)
727 int info = TranslateSingleString(cat.param(0));
728 int info2 = TranslateSingleString(cat.param(1));
730 return AddMultiInfo(GUIInfo(STRING_COMPARE, info, -info2));
731 // pipe our original string through the localize parsing then make it lowercase (picks up $LBRACKET etc.)
732 CStdString label = CGUIInfoLabel::GetLabel(cat.param(1)).ToLower();
733 int compareString = ConditionalStringParameter(label);
734 return AddMultiInfo(GUIInfo(STRING_COMPARE, info, compareString));
736 else if (cat.name == "integergreaterthan" && cat.num_params() == 2)
738 int info = TranslateSingleString(cat.param(0));
739 int compareInt = atoi(cat.param(1).c_str());
740 return AddMultiInfo(GUIInfo(INTEGER_GREATER_THAN, info, compareInt));
742 else if (cat.name == "substring" && cat.num_params() >= 2)
744 int info = TranslateSingleString(cat.param(0));
745 CStdString label = CGUIInfoLabel::GetLabel(cat.param(1)).ToLower();
746 int compareString = ConditionalStringParameter(label);
747 if (cat.num_params() > 2)
749 if (cat.param(2).CompareNoCase("left") == 0)
750 return AddMultiInfo(GUIInfo(STRING_STR_LEFT, info, compareString));
751 else if (cat.param(2).CompareNoCase("right") == 0)
752 return AddMultiInfo(GUIInfo(STRING_STR_RIGHT, info, compareString));
754 return AddMultiInfo(GUIInfo(STRING_STR, info, compareString));
757 else if (info.size() == 2)
759 const Property &prop = info[1];
760 if (cat.name == "player")
762 for (size_t i = 0; i < sizeof(player_labels) / sizeof(infomap); i++)
764 if (prop.name == player_labels[i].str)
765 return player_labels[i].val;
767 for (size_t i = 0; i < sizeof(player_times) / sizeof(infomap); i++)
769 if (prop.name == player_times[i].str)
770 return AddMultiInfo(GUIInfo(player_times[i].val, TranslateTimeFormat(prop.param())));
772 if (prop.num_params() == 1)
774 for (size_t i = 0; i < sizeof(player_param) / sizeof(infomap); i++)
776 if (prop.name == player_param[i].str)
777 return AddMultiInfo(GUIInfo(player_param[i].val, ConditionalStringParameter(prop.param())));
781 else if (cat.name == "weather")
783 for (size_t i = 0; i < sizeof(weather) / sizeof(infomap); i++)
785 if (prop.name == weather[i].str)
786 return weather[i].val;
789 else if (cat.name == "network")
791 for (size_t i = 0; i < sizeof(network_labels) / sizeof(infomap); i++)
793 if (prop.name == network_labels[i].str)
794 return network_labels[i].val;
797 else if (cat.name == "musicpartymode")
799 for (size_t i = 0; i < sizeof(musicpartymode) / sizeof(infomap); i++)
801 if (prop.name == musicpartymode[i].str)
802 return musicpartymode[i].val;
805 else if (cat.name == "audioscrobbler")
807 for (size_t i = 0; i < sizeof(audioscrobbler) / sizeof(infomap); i++)
809 if (prop.name == audioscrobbler[i].str)
810 return audioscrobbler[i].val;
813 else if (cat.name == "lastfm")
815 for (size_t i = 0; i < sizeof(lastfm) / sizeof(infomap); i++)
817 if (prop.name == lastfm[i].str)
818 return lastfm[i].val;
821 else if (cat.name == "system")
823 for (size_t i = 0; i < sizeof(system_labels) / sizeof(infomap); i++)
825 if (prop.name == system_labels[i].str)
826 return system_labels[i].val;
828 if (prop.num_params() == 1)
830 const CStdString ¶m = prop.param();
831 if (prop.name == "getbool")
833 std::string paramCopy = param;
834 StringUtils::ToLower(paramCopy);
835 return AddMultiInfo(GUIInfo(SYSTEM_GET_BOOL, ConditionalStringParameter(paramCopy, true)));
837 for (size_t i = 0; i < sizeof(system_param) / sizeof(infomap); i++)
839 if (prop.name == system_param[i].str)
840 return AddMultiInfo(GUIInfo(system_param[i].val, ConditionalStringParameter(param)));
842 if (prop.name == "memory")
844 if (param == "free") return SYSTEM_FREE_MEMORY;
845 else if (param == "free.percent") return SYSTEM_FREE_MEMORY_PERCENT;
846 else if (param == "used") return SYSTEM_USED_MEMORY;
847 else if (param == "used.percent") return SYSTEM_USED_MEMORY_PERCENT;
848 else if (param == "total") return SYSTEM_TOTAL_MEMORY;
850 else if (prop.name == "addontitle")
852 int infoLabel = TranslateSingleString(param);
854 return AddMultiInfo(GUIInfo(SYSTEM_ADDON_TITLE, infoLabel, 0));
855 CStdString label = CGUIInfoLabel::GetLabel(param).ToLower();
856 return AddMultiInfo(GUIInfo(SYSTEM_ADDON_TITLE, ConditionalStringParameter(label), 1));
858 else if (prop.name == "addonicon")
860 int infoLabel = TranslateSingleString(param);
862 return AddMultiInfo(GUIInfo(SYSTEM_ADDON_ICON, infoLabel, 0));
863 CStdString label = CGUIInfoLabel::GetLabel(param).ToLower();
864 return AddMultiInfo(GUIInfo(SYSTEM_ADDON_ICON, ConditionalStringParameter(label), 1));
866 else if (prop.name == "idletime")
867 return AddMultiInfo(GUIInfo(SYSTEM_IDLE_TIME, atoi(param.c_str())));
869 if (prop.name == "alarmlessorequal" && prop.num_params() == 2)
870 return AddMultiInfo(GUIInfo(SYSTEM_ALARM_LESS_OR_EQUAL, ConditionalStringParameter(prop.param(0)), ConditionalStringParameter(prop.param(1))));
871 else if (prop.name == "date")
873 if (prop.num_params() == 2)
874 return AddMultiInfo(GUIInfo(SYSTEM_DATE, StringUtils::DateStringToYYYYMMDD(prop.param(0)) % 10000, StringUtils::DateStringToYYYYMMDD(prop.param(1)) % 10000));
875 else if (prop.num_params() == 1)
877 int dateformat = StringUtils::DateStringToYYYYMMDD(prop.param(0));
878 if (dateformat <= 0) // not concrete date
879 return AddMultiInfo(GUIInfo(SYSTEM_DATE, ConditionalStringParameter(prop.param(0), true), -1));
881 return AddMultiInfo(GUIInfo(SYSTEM_DATE, dateformat % 10000));
885 else if (prop.name == "time")
887 if (prop.num_params() == 0)
888 return AddMultiInfo(GUIInfo(SYSTEM_TIME, TIME_FORMAT_GUESS));
889 if (prop.num_params() == 1)
891 TIME_FORMAT timeFormat = TranslateTimeFormat(prop.param(0));
892 if (timeFormat == TIME_FORMAT_GUESS)
893 return AddMultiInfo(GUIInfo(SYSTEM_TIME, StringUtils::TimeStringToSeconds(prop.param(0))));
894 return AddMultiInfo(GUIInfo(SYSTEM_TIME, timeFormat));
897 return AddMultiInfo(GUIInfo(SYSTEM_TIME, StringUtils::TimeStringToSeconds(prop.param(0)), StringUtils::TimeStringToSeconds(prop.param(1))));
900 else if (cat.name == "library")
902 if (prop.name == "isscanning") return LIBRARY_IS_SCANNING;
903 else if (prop.name == "isscanningvideo") return LIBRARY_IS_SCANNING_VIDEO; // TODO: change to IsScanning(Video)
904 else if (prop.name == "isscanningmusic") return LIBRARY_IS_SCANNING_MUSIC;
905 else if (prop.name == "hascontent" && prop.num_params())
907 CStdString cat = prop.param(0); cat.ToLower();
908 if (cat == "music") return LIBRARY_HAS_MUSIC;
909 else if (cat == "video") return LIBRARY_HAS_VIDEO;
910 else if (cat == "movies") return LIBRARY_HAS_MOVIES;
911 else if (cat == "tvshows") return LIBRARY_HAS_TVSHOWS;
912 else if (cat == "musicvideos") return LIBRARY_HAS_MUSICVIDEOS;
913 else if (cat == "moviesets") return LIBRARY_HAS_MOVIE_SETS;
916 else if (cat.name == "musicplayer")
918 for (size_t i = 0; i < sizeof(player_times) / sizeof(infomap); i++) // TODO: remove these, they're repeats
920 if (prop.name == player_times[i].str)
921 return AddMultiInfo(GUIInfo(player_times[i].val, TranslateTimeFormat(prop.param())));
923 if (prop.name == "property")
925 if (prop.param().Equals("fanart_image"))
926 return AddMultiInfo(GUIInfo(PLAYER_ITEM_ART, ConditionalStringParameter("fanart")));
927 return AddListItemProp(prop.param(), MUSICPLAYER_PROPERTY_OFFSET);
929 return TranslateMusicPlayerString(prop.name);
931 else if (cat.name == "videoplayer")
933 for (size_t i = 0; i < sizeof(player_times) / sizeof(infomap); i++) // TODO: remove these, they're repeats
935 if (prop.name == player_times[i].str)
936 return AddMultiInfo(GUIInfo(player_times[i].val, TranslateTimeFormat(prop.param())));
938 if (prop.name == "content" && prop.num_params())
939 return AddMultiInfo(GUIInfo(VIDEOPLAYER_CONTENT, ConditionalStringParameter(prop.param()), 0));
940 for (size_t i = 0; i < sizeof(videoplayer) / sizeof(infomap); i++)
942 if (prop.name == videoplayer[i].str)
943 return videoplayer[i].val;
946 else if (cat.name == "slideshow")
948 for (size_t i = 0; i < sizeof(slideshow) / sizeof(infomap); i++)
950 if (prop.name == slideshow[i].str)
951 return slideshow[i].val;
953 return CPictureInfoTag::TranslateString(prop.name);
955 else if (cat.name == "container")
957 for (size_t i = 0; i < sizeof(mediacontainer) / sizeof(infomap); i++) // these ones don't have or need an id
959 if (prop.name == mediacontainer[i].str)
960 return mediacontainer[i].val;
962 int id = atoi(cat.param().c_str());
963 for (size_t i = 0; i < sizeof(container_bools) / sizeof(infomap); i++) // these ones can have an id (but don't need to?)
965 if (prop.name == container_bools[i].str)
966 return id ? AddMultiInfo(GUIInfo(container_bools[i].val, id)) : container_bools[i].val;
968 for (size_t i = 0; i < sizeof(container_ints) / sizeof(infomap); i++) // these ones can have an int param on the property
970 if (prop.name == container_ints[i].str)
971 return AddMultiInfo(GUIInfo(container_ints[i].val, id, atoi(prop.param().c_str())));
973 for (size_t i = 0; i < sizeof(container_str) / sizeof(infomap); i++) // these ones have a string param on the property
975 if (prop.name == container_str[i].str)
976 return AddMultiInfo(GUIInfo(container_str[i].val, id, ConditionalStringParameter(prop.param())));
978 if (prop.name == "sortdirection")
980 SortOrder order = SortOrderNone;
981 if (prop.param().Equals("ascending"))
982 order = SortOrderAscending;
983 else if (prop.param().Equals("descending"))
984 order = SortOrderDescending;
985 return AddMultiInfo(GUIInfo(CONTAINER_SORT_DIRECTION, order));
987 else if (prop.name == "sort")
989 SORT_METHOD sort = SORT_METHOD_NONE;
990 if (prop.param().Equals("songrating")) sort = SORT_METHOD_SONG_RATING;
991 if (sort != SORT_METHOD_NONE)
992 return AddMultiInfo(GUIInfo(CONTAINER_SORT_METHOD, sort));
995 else if (cat.name == "listitem")
997 int offset = atoi(cat.param().c_str());
998 int ret = TranslateListItem(prop);
999 if (offset || ret == LISTITEM_ISSELECTED || ret == LISTITEM_ISPLAYING || ret == LISTITEM_IS_FOLDER)
1000 return AddMultiInfo(GUIInfo(ret, 0, offset, INFOFLAG_LISTITEM_WRAP));
1003 else if (cat.name == "listitemposition")
1005 int offset = atoi(cat.param().c_str());
1006 int ret = TranslateListItem(prop);
1007 if (offset || ret == LISTITEM_ISSELECTED || ret == LISTITEM_ISPLAYING || ret == LISTITEM_IS_FOLDER)
1008 return AddMultiInfo(GUIInfo(ret, 0, offset, INFOFLAG_LISTITEM_POSITION));
1011 else if (cat.name == "listitemnowrap")
1013 int offset = atoi(cat.param().c_str());
1014 int ret = TranslateListItem(prop);
1015 if (offset || ret == LISTITEM_ISSELECTED || ret == LISTITEM_ISPLAYING || ret == LISTITEM_IS_FOLDER)
1016 return AddMultiInfo(GUIInfo(ret, 0, offset));
1019 else if (cat.name == "visualisation")
1021 for (size_t i = 0; i < sizeof(visualisation) / sizeof(infomap); i++)
1023 if (prop.name == visualisation[i].str)
1024 return visualisation[i].val;
1027 else if (cat.name == "fanart")
1029 for (size_t i = 0; i < sizeof(fanart_labels) / sizeof(infomap); i++)
1031 if (prop.name == fanart_labels[i].str)
1032 return fanart_labels[i].val;
1035 else if (cat.name == "skin")
1037 for (size_t i = 0; i < sizeof(skin_labels) / sizeof(infomap); i++)
1039 if (prop.name == skin_labels[i].str)
1040 return skin_labels[i].val;
1042 if (prop.num_params())
1044 if (prop.name == "string")
1046 if (prop.num_params() == 2)
1047 return AddMultiInfo(GUIInfo(SKIN_STRING, g_settings.TranslateSkinString(prop.param(0)), ConditionalStringParameter(prop.param(1))));
1049 return AddMultiInfo(GUIInfo(SKIN_STRING, g_settings.TranslateSkinString(prop.param(0))));
1051 if (prop.name == "hassetting")
1052 return AddMultiInfo(GUIInfo(SKIN_BOOL, g_settings.TranslateSkinBool(prop.param(0))));
1053 else if (prop.name == "hastheme")
1054 return AddMultiInfo(GUIInfo(SKIN_HAS_THEME, ConditionalStringParameter(prop.param(0))));
1057 else if (cat.name == "window")
1059 if (prop.name == "property" && prop.num_params() == 1)
1060 { // TODO: this doesn't support foo.xml
1061 int winID = cat.param().IsEmpty() ? 0 : CButtonTranslator::TranslateWindow(cat.param());
1062 if (winID != WINDOW_INVALID)
1063 return AddMultiInfo(GUIInfo(WINDOW_PROPERTY, winID, ConditionalStringParameter(prop.param())));
1065 for (size_t i = 0; i < sizeof(window_bools) / sizeof(infomap); i++)
1067 if (prop.name == window_bools[i].str)
1068 { // TODO: The parameter for these should really be on the first not the second property
1069 if (prop.param().Find("xml") >= 0)
1070 return AddMultiInfo(GUIInfo(window_bools[i].val, 0, ConditionalStringParameter(prop.param())));
1071 int winID = prop.param().IsEmpty() ? 0 : CButtonTranslator::TranslateWindow(prop.param());
1072 if (winID != WINDOW_INVALID)
1073 return AddMultiInfo(GUIInfo(window_bools[i].val, winID, 0));
1078 else if (cat.name == "control")
1080 for (size_t i = 0; i < sizeof(control_labels) / sizeof(infomap); i++)
1082 if (prop.name == control_labels[i].str)
1083 { // TODO: The parameter for these should really be on the first not the second property
1084 int controlID = atoi(prop.param().c_str());
1086 return AddMultiInfo(GUIInfo(control_labels[i].val, controlID, 0));
1091 else if (cat.name == "controlgroup" && prop.name == "hasfocus")
1093 int groupID = atoi(cat.param().c_str());
1095 return AddMultiInfo(GUIInfo(CONTROL_GROUP_HAS_FOCUS, groupID, atoi(prop.param(0).c_str())));
1097 else if (cat.name == "playlist")
1099 for (size_t i = 0; i < sizeof(playlist) / sizeof(infomap); i++)
1101 if (prop.name == playlist[i].str)
1102 return playlist[i].val;
1105 else if (cat.name == "pvr")
1107 for (size_t i = 0; i < sizeof(pvr) / sizeof(infomap); i++)
1109 if (prop.name == pvr[i].str)
1114 else if (info.size() == 3)
1116 if (info[0].name == "system" && info[1].name == "platform")
1117 { // TODO: replace with a single system.platform
1118 CStdString platform = info[2].name;
1119 if (platform == "linux") return SYSTEM_PLATFORM_LINUX;
1120 else if (platform == "windows") return SYSTEM_PLATFORM_WINDOWS;
1121 else if (platform == "darwin") return SYSTEM_PLATFORM_DARWIN;
1122 else if (platform == "osx") return SYSTEM_PLATFORM_DARWIN_OSX;
1123 else if (platform == "ios") return SYSTEM_PLATFORM_DARWIN_IOS;
1124 else if (platform == "atv2") return SYSTEM_PLATFORM_DARWIN_ATV2;
1125 else if (platform == "android") return SYSTEM_PLATFORM_ANDROID;
1127 if (info[0].name == "musicplayer")
1128 { // TODO: these two don't allow duration(foo) and also don't allow more than this number of levels...
1129 if (info[1].name == "position")
1131 int position = atoi(info[1].param().c_str());
1132 int value = TranslateMusicPlayerString(info[2].name); // musicplayer.position(foo).bar
1133 return AddMultiInfo(GUIInfo(value, 0, position));
1135 else if (info[1].name == "offset")
1137 int position = atoi(info[1].param().c_str());
1138 int value = TranslateMusicPlayerString(info[2].name); // musicplayer.offset(foo).bar
1139 return AddMultiInfo(GUIInfo(value, 1, position));
1142 else if (info[0].name == "container")
1144 int id = atoi(info[0].param().c_str());
1145 int offset = atoi(info[1].param().c_str());
1146 if (info[1].name == "listitemnowrap")
1147 return AddMultiInfo(GUIInfo(TranslateListItem(info[2]), id, offset));
1148 else if (info[1].name == "listitemposition")
1149 return AddMultiInfo(GUIInfo(TranslateListItem(info[2]), id, offset, INFOFLAG_LISTITEM_POSITION));
1150 else if (info[1].name == "listitem")
1151 return AddMultiInfo(GUIInfo(TranslateListItem(info[2]), id, offset, INFOFLAG_LISTITEM_WRAP));
1158 int CGUIInfoManager::TranslateListItem(const Property &info)
1160 for (size_t i = 0; i < sizeof(listitem_labels) / sizeof(infomap); i++) // these ones don't have or need an id
1162 if (info.name == listitem_labels[i].str)
1163 return listitem_labels[i].val;
1165 if (info.name == "property" && info.num_params() == 1)
1167 if (info.param().Equals("fanart_image"))
1168 return AddListItemProp("fanart", LISTITEM_ART_OFFSET);
1169 return AddListItemProp(info.param());
1171 if (info.name == "art" && info.num_params() == 1)
1172 return AddListItemProp(info.param(), LISTITEM_ART_OFFSET);
1176 int CGUIInfoManager::TranslateMusicPlayerString(const CStdString &info) const
1178 for (size_t i = 0; i < sizeof(musicplayer) / sizeof(infomap); i++)
1180 if (info == musicplayer[i].str)
1181 return musicplayer[i].val;
1186 TIME_FORMAT CGUIInfoManager::TranslateTimeFormat(const CStdString &format)
1188 if (format.IsEmpty()) return TIME_FORMAT_GUESS;
1189 else if (format.Equals("hh")) return TIME_FORMAT_HH;
1190 else if (format.Equals("mm")) return TIME_FORMAT_MM;
1191 else if (format.Equals("ss")) return TIME_FORMAT_SS;
1192 else if (format.Equals("hh:mm")) return TIME_FORMAT_HH_MM;
1193 else if (format.Equals("mm:ss")) return TIME_FORMAT_MM_SS;
1194 else if (format.Equals("hh:mm:ss")) return TIME_FORMAT_HH_MM_SS;
1195 else if (format.Equals("h")) return TIME_FORMAT_H;
1196 else if (format.Equals("h:mm:ss")) return TIME_FORMAT_H_MM_SS;
1197 else if (format.Equals("xx")) return TIME_FORMAT_XX;
1198 return TIME_FORMAT_GUESS;
1201 CStdString CGUIInfoManager::GetLabel(int info, int contextWindow, CStdString *fallback)
1203 if (info >= CONDITIONAL_LABEL_START && info <= CONDITIONAL_LABEL_END)
1204 return GetSkinVariableString(info, false);
1206 CStdString strLabel;
1207 if (info >= MULTI_INFO_START && info <= MULTI_INFO_END)
1208 return GetMultiInfoLabel(m_multiInfo[info - MULTI_INFO_START], contextWindow);
1210 if (info >= SLIDE_INFO_START && info <= SLIDE_INFO_END)
1211 return GetPictureLabel(info);
1213 if (info >= LISTITEM_PROPERTY_START+MUSICPLAYER_PROPERTY_OFFSET &&
1214 info - (LISTITEM_PROPERTY_START+MUSICPLAYER_PROPERTY_OFFSET) < (int)m_listitemProperties.size())
1215 { // grab the property
1219 CStdString property = m_listitemProperties[info - LISTITEM_PROPERTY_START-MUSICPLAYER_PROPERTY_OFFSET];
1220 return m_currentFile->GetProperty(property).asString();
1223 if (info >= LISTITEM_START && info <= LISTITEM_END)
1225 CGUIWindow *window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_HAS_LIST_ITEMS); // true for has list items
1228 CFileItemPtr item = window->GetCurrentListItem();
1229 strLabel = GetItemLabel(item.get(), info, fallback);
1237 case PVR_NEXT_RECORDING_CHANNEL:
1238 case PVR_NEXT_RECORDING_CHAN_ICO:
1239 case PVR_NEXT_RECORDING_DATETIME:
1240 case PVR_NEXT_RECORDING_TITLE:
1241 case PVR_NOW_RECORDING_CHANNEL:
1242 case PVR_NOW_RECORDING_CHAN_ICO:
1243 case PVR_NOW_RECORDING_DATETIME:
1244 case PVR_NOW_RECORDING_TITLE:
1245 case PVR_BACKEND_NAME:
1246 case PVR_BACKEND_VERSION:
1247 case PVR_BACKEND_HOST:
1248 case PVR_BACKEND_DISKSPACE:
1249 case PVR_BACKEND_CHANNELS:
1250 case PVR_BACKEND_TIMERS:
1251 case PVR_BACKEND_RECORDINGS:
1252 case PVR_BACKEND_NUMBER:
1253 case PVR_TOTAL_DISKSPACE:
1254 case PVR_NEXT_TIMER:
1255 case PVR_PLAYING_DURATION:
1256 case PVR_PLAYING_TIME:
1257 case PVR_PLAYING_PROGRESS:
1258 case PVR_ACTUAL_STREAM_CLIENT:
1259 case PVR_ACTUAL_STREAM_DEVICE:
1260 case PVR_ACTUAL_STREAM_STATUS:
1261 case PVR_ACTUAL_STREAM_SIG:
1262 case PVR_ACTUAL_STREAM_SNR:
1263 case PVR_ACTUAL_STREAM_SIG_PROGR:
1264 case PVR_ACTUAL_STREAM_SNR_PROGR:
1265 case PVR_ACTUAL_STREAM_BER:
1266 case PVR_ACTUAL_STREAM_UNC:
1267 case PVR_ACTUAL_STREAM_VIDEO_BR:
1268 case PVR_ACTUAL_STREAM_AUDIO_BR:
1269 case PVR_ACTUAL_STREAM_DOLBY_BR:
1270 case PVR_ACTUAL_STREAM_CRYPTION:
1271 g_PVRManager.TranslateCharInfo(info, strLabel);
1273 case WEATHER_CONDITIONS:
1274 strLabel = g_weatherManager.GetInfo(WEATHER_LABEL_CURRENT_COND);
1275 strLabel = strLabel.Trim();
1277 case WEATHER_TEMPERATURE:
1278 strLabel.Format("%s%s", g_weatherManager.GetInfo(WEATHER_LABEL_CURRENT_TEMP), g_langInfo.GetTempUnitString().c_str());
1280 case WEATHER_LOCATION:
1281 strLabel = g_weatherManager.GetInfo(WEATHER_LABEL_LOCATION);
1283 case WEATHER_FANART_CODE:
1284 strLabel = URIUtils::GetFileName(g_weatherManager.GetInfo(WEATHER_IMAGE_CURRENT_ICON));
1285 URIUtils::RemoveExtension(strLabel);
1287 case WEATHER_PLUGIN:
1288 strLabel = g_guiSettings.GetString("weather.addon");
1291 strLabel = GetDate();
1294 strLabel.Format("%02.2f", m_fps);
1297 strLabel.Format("%2.1f dB", CAEUtil::PercentToGain(g_settings.m_fVolumeLevel));
1299 case PLAYER_SUBTITLE_DELAY:
1300 strLabel.Format("%2.3f s", g_settings.m_currentVideoSettings.m_SubtitleDelay);
1302 case PLAYER_AUDIO_DELAY:
1303 strLabel.Format("%2.3f s", g_settings.m_currentVideoSettings.m_AudioDelay);
1305 case PLAYER_CHAPTER:
1306 if(g_application.IsPlaying() && g_application.m_pPlayer)
1307 strLabel.Format("%02d", g_application.m_pPlayer->GetChapter());
1309 case PLAYER_CHAPTERCOUNT:
1310 if(g_application.IsPlaying() && g_application.m_pPlayer)
1311 strLabel.Format("%02d", g_application.m_pPlayer->GetChapterCount());
1313 case PLAYER_CHAPTERNAME:
1314 if(g_application.IsPlaying() && g_application.m_pPlayer)
1315 g_application.m_pPlayer->GetChapterName(strLabel);
1317 case PLAYER_CACHELEVEL:
1320 if(g_application.IsPlaying() && GetInt(iLevel, PLAYER_CACHELEVEL) && iLevel >= 0)
1321 strLabel.Format("%i", iLevel);
1325 if(g_application.IsPlaying() && g_application.m_pPlayer)
1326 strLabel = GetCurrentPlayTime(TIME_FORMAT_HH_MM);
1328 case PLAYER_DURATION:
1329 if(g_application.IsPlaying() && g_application.m_pPlayer)
1330 strLabel = GetDuration(TIME_FORMAT_HH_MM);
1333 case PLAYER_FILEPATH:
1336 if (m_currentFile->HasMusicInfoTag())
1337 strLabel = m_currentFile->GetMusicInfoTag()->GetURL();
1338 else if (m_currentFile->HasVideoInfoTag())
1339 strLabel = m_currentFile->GetVideoInfoTag()->m_strFileNameAndPath;
1340 if (strLabel.IsEmpty())
1341 strLabel = m_currentFile->GetPath();
1343 if (info == PLAYER_PATH)
1345 // do this twice since we want the path outside the archive if this
1347 if (URIUtils::IsInArchive(strLabel))
1348 strLabel = URIUtils::GetParentPath(strLabel);
1349 strLabel = URIUtils::GetParentPath(strLabel);
1356 if (m_currentFile->HasPVRChannelInfoTag())
1359 return m_currentFile->GetPVRChannelInfoTag()->GetEPGNow(tag) ?
1361 g_guiSettings.GetBool("epg.hidenoinfoavailable") ?
1362 StringUtils::EmptyString :
1363 g_localizeStrings.Get(19055); // no information available
1365 if (m_currentFile->HasPVRRecordingInfoTag() && !m_currentFile->GetPVRRecordingInfoTag()->m_strTitle.IsEmpty())
1366 return m_currentFile->GetPVRRecordingInfoTag()->m_strTitle;
1367 if (m_currentFile->HasVideoInfoTag() && !m_currentFile->GetVideoInfoTag()->m_strTitle.IsEmpty())
1368 return m_currentFile->GetVideoInfoTag()->m_strTitle;
1369 if (m_currentFile->HasMusicInfoTag() && !m_currentFile->GetMusicInfoTag()->GetTitle().IsEmpty())
1370 return m_currentFile->GetMusicInfoTag()->GetTitle();
1371 // don't have the title, so use dvdplayer, label, or drop down to title from path
1372 if (g_application.m_pPlayer && !g_application.m_pPlayer->GetPlayingTitle().IsEmpty())
1373 return g_application.m_pPlayer->GetPlayingTitle();
1374 if (!m_currentFile->GetLabel().IsEmpty())
1375 return m_currentFile->GetLabel();
1376 return CUtil::GetTitleFromPath(m_currentFile->GetPath());
1380 if (g_application.m_pPlayer && !g_application.m_pPlayer->GetPlayingTitle().IsEmpty())
1381 return g_application.m_pPlayer->GetPlayingTitle();
1385 case MUSICPLAYER_TITLE:
1386 case MUSICPLAYER_ALBUM:
1387 case MUSICPLAYER_ARTIST:
1388 case MUSICPLAYER_ALBUM_ARTIST:
1389 case MUSICPLAYER_GENRE:
1390 case MUSICPLAYER_YEAR:
1391 case MUSICPLAYER_TRACK_NUMBER:
1392 case MUSICPLAYER_BITRATE:
1393 case MUSICPLAYER_PLAYLISTLEN:
1394 case MUSICPLAYER_PLAYLISTPOS:
1395 case MUSICPLAYER_CHANNELS:
1396 case MUSICPLAYER_BITSPERSAMPLE:
1397 case MUSICPLAYER_SAMPLERATE:
1398 case MUSICPLAYER_CODEC:
1399 case MUSICPLAYER_DISC_NUMBER:
1400 case MUSICPLAYER_RATING:
1401 case MUSICPLAYER_COMMENT:
1402 case MUSICPLAYER_LYRICS:
1403 case MUSICPLAYER_CHANNEL_NAME:
1404 case MUSICPLAYER_CHANNEL_NUMBER:
1405 case MUSICPLAYER_CHANNEL_GROUP:
1406 case MUSICPLAYER_PLAYCOUNT:
1407 case MUSICPLAYER_LASTPLAYED:
1408 strLabel = GetMusicLabel(info);
1410 case VIDEOPLAYER_TITLE:
1411 case VIDEOPLAYER_ORIGINALTITLE:
1412 case VIDEOPLAYER_GENRE:
1413 case VIDEOPLAYER_DIRECTOR:
1414 case VIDEOPLAYER_YEAR:
1415 case VIDEOPLAYER_PLAYLISTLEN:
1416 case VIDEOPLAYER_PLAYLISTPOS:
1417 case VIDEOPLAYER_PLOT:
1418 case VIDEOPLAYER_PLOT_OUTLINE:
1419 case VIDEOPLAYER_EPISODE:
1420 case VIDEOPLAYER_SEASON:
1421 case VIDEOPLAYER_RATING:
1422 case VIDEOPLAYER_RATING_AND_VOTES:
1423 case VIDEOPLAYER_TVSHOW:
1424 case VIDEOPLAYER_PREMIERED:
1425 case VIDEOPLAYER_STUDIO:
1426 case VIDEOPLAYER_COUNTRY:
1427 case VIDEOPLAYER_MPAA:
1428 case VIDEOPLAYER_TOP250:
1429 case VIDEOPLAYER_CAST:
1430 case VIDEOPLAYER_CAST_AND_ROLE:
1431 case VIDEOPLAYER_ARTIST:
1432 case VIDEOPLAYER_ALBUM:
1433 case VIDEOPLAYER_WRITER:
1434 case VIDEOPLAYER_TAGLINE:
1435 case VIDEOPLAYER_TRAILER:
1436 case VIDEOPLAYER_STARTTIME:
1437 case VIDEOPLAYER_ENDTIME:
1438 case VIDEOPLAYER_NEXT_TITLE:
1439 case VIDEOPLAYER_NEXT_GENRE:
1440 case VIDEOPLAYER_NEXT_PLOT:
1441 case VIDEOPLAYER_NEXT_PLOT_OUTLINE:
1442 case VIDEOPLAYER_NEXT_STARTTIME:
1443 case VIDEOPLAYER_NEXT_ENDTIME:
1444 case VIDEOPLAYER_NEXT_DURATION:
1445 case VIDEOPLAYER_CHANNEL_NAME:
1446 case VIDEOPLAYER_CHANNEL_NUMBER:
1447 case VIDEOPLAYER_CHANNEL_GROUP:
1448 case VIDEOPLAYER_PARENTAL_RATING:
1449 case VIDEOPLAYER_PLAYCOUNT:
1450 case VIDEOPLAYER_LASTPLAYED:
1451 strLabel = GetVideoLabel(info);
1453 case VIDEOPLAYER_VIDEO_CODEC:
1454 if(g_application.IsPlaying() && g_application.m_pPlayer)
1456 SPlayerVideoStreamInfo info;
1457 g_application.m_pPlayer->GetVideoStreamInfo(info);
1458 strLabel = info.videoCodecName;
1461 case VIDEOPLAYER_VIDEO_RESOLUTION:
1462 if(g_application.IsPlaying() && g_application.m_pPlayer)
1463 return CStreamDetails::VideoDimsToResolutionDescription(g_application.m_pPlayer->GetPictureWidth(), g_application.m_pPlayer->GetPictureHeight());
1465 case VIDEOPLAYER_AUDIO_CODEC:
1466 if(g_application.IsPlaying() && g_application.m_pPlayer)
1468 SPlayerAudioStreamInfo info;
1469 g_application.m_pPlayer->GetAudioStreamInfo(g_application.m_pPlayer->GetAudioStream(), info);
1470 strLabel = info.audioCodecName;
1473 case VIDEOPLAYER_VIDEO_ASPECT:
1474 if (g_application.IsPlaying() && g_application.m_pPlayer)
1476 SPlayerVideoStreamInfo info;
1477 g_application.m_pPlayer->GetVideoStreamInfo(info);
1478 strLabel = CStreamDetails::VideoAspectToAspectDescription(info.videoAspectRatio);
1481 case VIDEOPLAYER_AUDIO_CHANNELS:
1482 if(g_application.IsPlaying() && g_application.m_pPlayer)
1484 SPlayerAudioStreamInfo info;
1485 g_application.m_pPlayer->GetAudioStreamInfo(g_application.m_pPlayer->GetAudioStream(), info);
1486 strLabel.Format("%i", info.channels);
1489 case PLAYLIST_LENGTH:
1490 case PLAYLIST_POSITION:
1491 case PLAYLIST_RANDOM:
1492 case PLAYLIST_REPEAT:
1493 strLabel = GetPlaylistLabel(info);
1495 case MUSICPM_SONGSPLAYED:
1496 case MUSICPM_MATCHINGSONGS:
1497 case MUSICPM_MATCHINGSONGSPICKED:
1498 case MUSICPM_MATCHINGSONGSLEFT:
1499 case MUSICPM_RELAXEDSONGSPICKED:
1500 case MUSICPM_RANDOMSONGSPICKED:
1501 strLabel = GetMusicPartyModeLabel(info);
1504 case SYSTEM_FREE_SPACE:
1505 case SYSTEM_USED_SPACE:
1506 case SYSTEM_TOTAL_SPACE:
1507 case SYSTEM_FREE_SPACE_PERCENT:
1508 case SYSTEM_USED_SPACE_PERCENT:
1509 return g_sysinfo.GetHddSpaceInfo(info);
1512 case SYSTEM_CPU_TEMPERATURE:
1513 case SYSTEM_GPU_TEMPERATURE:
1514 case SYSTEM_FAN_SPEED:
1515 case SYSTEM_CPU_USAGE:
1516 return GetSystemHeatInfo(info);
1519 case SYSTEM_VIDEO_ENCODER_INFO:
1520 case NETWORK_MAC_ADDRESS:
1521 case SYSTEM_KERNEL_VERSION:
1522 case SYSTEM_CPUFREQUENCY:
1523 case SYSTEM_INTERNET_STATE:
1525 case SYSTEM_TOTALUPTIME:
1526 case SYSTEM_BATTERY_LEVEL:
1527 return g_sysinfo.GetInfo(info);
1530 case SYSTEM_SCREEN_RESOLUTION:
1531 if(g_Windowing.IsFullScreen())
1532 strLabel.Format("%ix%i@%.2fHz - %s (%02.2f fps)",
1533 g_settings.m_ResInfo[g_guiSettings.m_LookAndFeelResolution].iScreenWidth,
1534 g_settings.m_ResInfo[g_guiSettings.m_LookAndFeelResolution].iScreenHeight,
1535 g_settings.m_ResInfo[g_guiSettings.m_LookAndFeelResolution].fRefreshRate,
1536 g_localizeStrings.Get(244), GetFPS());
1538 strLabel.Format("%ix%i - %s (%02.2f fps)",
1539 g_settings.m_ResInfo[g_guiSettings.m_LookAndFeelResolution].iScreenWidth,
1540 g_settings.m_ResInfo[g_guiSettings.m_LookAndFeelResolution].iScreenHeight,
1541 g_localizeStrings.Get(242), GetFPS());
1545 case CONTAINER_FOLDERPATH:
1546 case CONTAINER_FOLDERNAME:
1548 CGUIWindow *window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
1551 if (info==CONTAINER_FOLDERNAME)
1552 strLabel = ((CGUIMediaWindow*)window)->CurrentDirectory().GetLabel();
1554 strLabel = CURL(((CGUIMediaWindow*)window)->CurrentDirectory().GetPath()).GetWithoutUserDetails();
1558 case CONTAINER_PLUGINNAME:
1560 CGUIWindow *window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
1563 CURL url(((CGUIMediaWindow*)window)->CurrentDirectory().GetPath());
1564 if (url.GetProtocol().Equals("plugin"))
1566 strLabel = url.GetFileName();
1567 URIUtils::RemoveSlashAtEnd(strLabel);
1572 case CONTAINER_VIEWMODE:
1574 CGUIWindow *window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
1577 const CGUIControl *control = window->GetControl(window->GetViewContainerID());
1578 if (control && control->IsContainer())
1579 strLabel = ((IGUIContainer *)control)->GetLabel();
1583 case CONTAINER_SORT_METHOD:
1585 CGUIWindow *window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
1588 const CGUIViewState *viewState = ((CGUIMediaWindow*)window)->GetViewState();
1590 strLabel = g_localizeStrings.Get(viewState->GetSortMethodLabel());
1594 case CONTAINER_NUM_PAGES:
1595 case CONTAINER_NUM_ITEMS:
1596 case CONTAINER_CURRENT_PAGE:
1597 return GetMultiInfoLabel(GUIInfo(info), contextWindow);
1599 case CONTAINER_SHOWPLOT:
1601 CGUIWindow *window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
1603 return ((CGUIMediaWindow *)window)->CurrentDirectory().GetProperty("showplot").asString();
1606 case CONTAINER_TOTALTIME:
1608 CGUIWindow *window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
1611 const CFileItemList& items=((CGUIMediaWindow *)window)->CurrentDirectory();
1613 for (int i=0;i<items.Size();++i)
1615 CFileItemPtr item=items.Get(i);
1616 if (item->HasMusicInfoTag())
1617 duration += item->GetMusicInfoTag()->GetDuration();
1618 else if (item->HasVideoInfoTag())
1619 duration += item->GetVideoInfoTag()->m_streamDetails.GetVideoDuration();
1622 return StringUtils::SecondsToTimeString(duration);
1626 case SYSTEM_BUILD_VERSION:
1627 strLabel = GetVersion();
1629 case SYSTEM_BUILD_DATE:
1630 strLabel = GetBuild();
1632 case SYSTEM_FREE_MEMORY:
1633 case SYSTEM_FREE_MEMORY_PERCENT:
1634 case SYSTEM_USED_MEMORY:
1635 case SYSTEM_USED_MEMORY_PERCENT:
1636 case SYSTEM_TOTAL_MEMORY:
1638 MEMORYSTATUSEX stat;
1639 stat.dwLength = sizeof(MEMORYSTATUSEX);
1640 GlobalMemoryStatusEx(&stat);
1641 int iMemPercentFree = 100 - ((int)( 100.0f* (stat.ullTotalPhys - stat.ullAvailPhys)/stat.ullTotalPhys + 0.5f ));
1642 int iMemPercentUsed = 100 - iMemPercentFree;
1644 if (info == SYSTEM_FREE_MEMORY)
1645 strLabel.Format("%luMB", (ULONG)(stat.ullAvailPhys/MB));
1646 else if (info == SYSTEM_FREE_MEMORY_PERCENT)
1647 strLabel.Format("%i%%", iMemPercentFree);
1648 else if (info == SYSTEM_USED_MEMORY)
1649 strLabel.Format("%luMB", (ULONG)((stat.ullTotalPhys - stat.ullAvailPhys)/MB));
1650 else if (info == SYSTEM_USED_MEMORY_PERCENT)
1651 strLabel.Format("%i%%", iMemPercentUsed);
1652 else if (info == SYSTEM_TOTAL_MEMORY)
1653 strLabel.Format("%luMB", (ULONG)(stat.ullTotalPhys/MB));
1656 case SYSTEM_SCREEN_MODE:
1657 strLabel = g_settings.m_ResInfo[g_graphicsContext.GetVideoResolution()].strMode;
1659 case SYSTEM_SCREEN_WIDTH:
1660 strLabel.Format("%i", g_settings.m_ResInfo[g_graphicsContext.GetVideoResolution()].iScreenWidth);
1662 case SYSTEM_SCREEN_HEIGHT:
1663 strLabel.Format("%i", g_settings.m_ResInfo[g_graphicsContext.GetVideoResolution()].iScreenHeight);
1665 case SYSTEM_CURRENT_WINDOW:
1666 return g_localizeStrings.Get(g_windowManager.GetFocusedWindow());
1668 case SYSTEM_CURRENT_CONTROL:
1670 CGUIWindow *window = g_windowManager.GetWindow(g_windowManager.GetFocusedWindow());
1673 CGUIControl *control = window->GetFocusedControl();
1675 strLabel = control->GetDescription();
1679 #ifdef HAS_DVD_DRIVE
1680 case SYSTEM_DVD_LABEL:
1681 strLabel = g_mediaManager.GetDiskLabel();
1684 case SYSTEM_ALARM_POS:
1685 if (g_alarmClock.GetRemaining("shutdowntimer") == 0.f)
1689 double fTime = g_alarmClock.GetRemaining("shutdowntimer");
1691 strLabel.Format(g_localizeStrings.Get(13213).c_str(),g_alarmClock.GetRemaining("shutdowntimer")/60.f);
1693 strLabel.Format(g_localizeStrings.Get(13214).c_str(),g_alarmClock.GetRemaining("shutdowntimer"));
1696 case SYSTEM_PROFILENAME:
1697 strLabel = g_settings.GetCurrentProfile().getName();
1699 case SYSTEM_PROFILECOUNT:
1700 strLabel.Format("%i", g_settings.GetNumProfiles());
1702 case SYSTEM_LANGUAGE:
1703 strLabel = g_guiSettings.GetString("locale.language");
1705 case SYSTEM_TEMPERATURE_UNITS:
1706 strLabel = g_langInfo.GetTempUnitString();
1708 case SYSTEM_PROGRESS_BAR:
1711 if (GetInt(percent, SYSTEM_PROGRESS_BAR) && percent > 0)
1712 strLabel.Format("%i", percent);
1715 case SYSTEM_FRIENDLY_NAME:
1717 CStdString friendlyName = g_guiSettings.GetString("services.devicename");
1718 if (friendlyName.Equals("XBMC"))
1719 strLabel.Format("%s (%s)", friendlyName.c_str(), g_application.getNetwork().GetHostName().c_str());
1721 strLabel = friendlyName;
1726 strLabel = g_guiSettings.GetString("lookandfeel.skintheme");
1728 case SKIN_COLOUR_THEME:
1729 strLabel = g_guiSettings.GetString("lookandfeel.skincolors");
1731 case SKIN_ASPECT_RATIO:
1733 strLabel = g_SkinInfo->GetCurrentAspect();
1735 case NETWORK_IP_ADDRESS:
1737 CNetworkInterface* iface = g_application.getNetwork().GetFirstConnectedInterface();
1739 return iface->GetCurrentIPAddress();
1742 case NETWORK_SUBNET_MASK:
1744 CNetworkInterface* iface = g_application.getNetwork().GetFirstConnectedInterface();
1746 return iface->GetCurrentNetmask();
1749 case NETWORK_GATEWAY_ADDRESS:
1751 CNetworkInterface* iface = g_application.getNetwork().GetFirstConnectedInterface();
1753 return iface->GetCurrentDefaultGateway();
1756 case NETWORK_DNS1_ADDRESS:
1758 vector<CStdString> nss = g_application.getNetwork().GetNameServers();
1759 if (nss.size() >= 1)
1763 case NETWORK_DNS2_ADDRESS:
1765 vector<CStdString> nss = g_application.getNetwork().GetNameServers();
1766 if (nss.size() >= 2)
1770 case NETWORK_DHCP_ADDRESS:
1772 CStdString dhcpserver;
1776 case NETWORK_LINK_STATE:
1778 CStdString linkStatus = g_localizeStrings.Get(151);
1780 CNetworkInterface* iface = g_application.getNetwork().GetFirstConnectedInterface();
1781 if (iface && iface->IsConnected())
1782 linkStatus += g_localizeStrings.Get(15207);
1784 linkStatus += g_localizeStrings.Get(15208);
1789 case AUDIOSCROBBLER_CONN_STATE:
1790 case AUDIOSCROBBLER_SUBMIT_INT:
1791 case AUDIOSCROBBLER_FILES_CACHED:
1792 case AUDIOSCROBBLER_SUBMIT_STATE:
1793 strLabel=GetAudioScrobblerLabel(info);
1795 case VISUALISATION_PRESET:
1797 CGUIMessage msg(GUI_MSG_GET_VISUALISATION, 0, 0);
1798 g_windowManager.SendMessage(msg);
1799 if (msg.GetPointer())
1801 CVisualisation* viz = NULL;
1802 viz = (CVisualisation*)msg.GetPointer();
1805 strLabel = viz->GetPresetName();
1806 URIUtils::RemoveExtension(strLabel);
1811 case VISUALISATION_NAME:
1814 strLabel = g_guiSettings.GetString("musicplayer.visualisation");
1815 if (CAddonMgr::Get().GetAddon(strLabel,addon) && addon)
1816 strLabel = addon->Name();
1821 CGUIWindow *window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
1823 return ((CGUIMediaWindow *)window)->CurrentDirectory().GetProperty("fanart_color1").asString();
1828 CGUIWindow *window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
1830 return ((CGUIMediaWindow *)window)->CurrentDirectory().GetProperty("fanart_color2").asString();
1835 CGUIWindow *window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
1837 return ((CGUIMediaWindow *)window)->CurrentDirectory().GetProperty("fanart_color3").asString();
1842 CGUIWindow *window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
1844 return ((CGUIMediaWindow *)window)->CurrentDirectory().GetArt("fanart");
1847 case SYSTEM_RENDER_VENDOR:
1848 strLabel = g_Windowing.GetRenderVendor();
1850 case SYSTEM_RENDER_RENDERER:
1851 strLabel = g_Windowing.GetRenderRenderer();
1853 case SYSTEM_RENDER_VERSION:
1854 strLabel = g_Windowing.GetRenderVersionString();
1861 // tries to get a integer value for use in progressbars/sliders and such
1862 bool CGUIInfoManager::GetInt(int &value, int info, int contextWindow, const CGUIListItem *item /* = NULL */) const
1864 if (info >= MULTI_INFO_START && info <= MULTI_INFO_END)
1865 return GetMultiInfoInt(value, m_multiInfo[info - MULTI_INFO_START], contextWindow);
1867 if (info >= LISTITEM_START && info <= LISTITEM_END)
1868 return GetItemInt(value, item, info);
1874 value = g_application.GetVolume();
1876 case PLAYER_SUBTITLE_DELAY:
1877 value = g_application.GetSubtitleDelay();
1879 case PLAYER_AUDIO_DELAY:
1880 value = g_application.GetAudioDelay();
1882 case PLAYER_PROGRESS:
1883 case PLAYER_PROGRESS_CACHE:
1884 case PLAYER_SEEKBAR:
1885 case PLAYER_CACHELEVEL:
1886 case PLAYER_CHAPTER:
1887 case PLAYER_CHAPTERCOUNT:
1889 if( g_application.IsPlaying() && g_application.m_pPlayer)
1893 case PLAYER_PROGRESS:
1894 value = (int)(g_application.GetPercentage());
1896 case PLAYER_PROGRESS_CACHE:
1897 value = (int)(g_application.GetCachePercentage());
1899 case PLAYER_SEEKBAR:
1900 value = (int)g_application.GetSeekHandler()->GetPercent();
1902 case PLAYER_CACHELEVEL:
1903 value = (int)(g_application.m_pPlayer->GetCacheLevel());
1905 case PLAYER_CHAPTER:
1906 value = g_application.m_pPlayer->GetChapter();
1908 case PLAYER_CHAPTERCOUNT:
1909 value = g_application.m_pPlayer->GetChapterCount();
1915 case SYSTEM_FREE_MEMORY:
1916 case SYSTEM_USED_MEMORY:
1918 MEMORYSTATUSEX stat;
1919 stat.dwLength = sizeof(MEMORYSTATUSEX);
1920 GlobalMemoryStatusEx(&stat);
1921 int memPercentUsed = (int)( 100.0f* (stat.ullTotalPhys - stat.ullAvailPhys)/stat.ullTotalPhys + 0.5f );
1922 if (info == SYSTEM_FREE_MEMORY)
1923 value = 100 - memPercentUsed;
1925 value = memPercentUsed;
1928 case SYSTEM_PROGRESS_BAR:
1930 CGUIDialogProgress *bar = (CGUIDialogProgress *)g_windowManager.GetWindow(WINDOW_DIALOG_PROGRESS);
1931 if (bar && bar->IsDialogRunning())
1932 value = bar->GetPercentage();
1935 case SYSTEM_FREE_SPACE:
1936 case SYSTEM_USED_SPACE:
1938 g_sysinfo.GetHddSpaceInfo(value, info, true);
1941 case SYSTEM_CPU_USAGE:
1942 value = g_cpuInfo.getUsedPercentage();
1944 case PVR_PLAYING_PROGRESS:
1945 case PVR_ACTUAL_STREAM_SIG_PROGR:
1946 case PVR_ACTUAL_STREAM_SNR_PROGR:
1947 value = g_PVRManager.TranslateIntInfo(info);
1949 case SYSTEM_BATTERY_LEVEL:
1950 value = g_powerManager.BatteryLevel();
1956 unsigned int CGUIInfoManager::Register(const CStdString &expression, int context)
1958 CStdString condition(CGUIInfoLabel::ReplaceLocalize(expression));
1959 condition.TrimLeft(" \t\r\n");
1960 condition.TrimRight(" \t\r\n");
1962 if (condition.IsEmpty())
1965 CSingleLock lock(m_critInfo);
1966 // do we have the boolean expression already registered?
1967 InfoBool test(condition, context);
1968 for (unsigned int i = 0; i < m_bools.size(); ++i)
1970 if (*m_bools[i] == test)
1974 if (condition.find_first_of("|+[]!") != condition.npos)
1975 m_bools.push_back(new InfoExpression(condition, context));
1977 m_bools.push_back(new InfoSingle(condition, context));
1979 return m_bools.size();
1982 bool CGUIInfoManager::EvaluateBool(const CStdString &expression, int contextWindow)
1984 bool result = false;
1985 unsigned int info = Register(expression, contextWindow);
1987 result = GetBoolValue(info);
1992 TODO: what to do with item-based infobools...
1994 1. if condition is between LISTITEM_START and LISTITEM_END
1995 2. if condition is STRING_IS_EMPTY, STRING_COMPARE, STRING_STR, INTEGER_GREATER_THAN and the
1996 corresponding label is between LISTITEM_START and LISTITEM_END
1998 In both cases they shouldn't be in our cache as they depend on items outside of our control atm.
2000 We only pass a listitem object in for controls inside a listitemlayout, so I think it's probably OK
2001 to not cache these, as they're "pushed" out anyway.
2003 The problem is how do we avoid these? The only thing we have to go on is the expression here, so I
2004 guess what we have to do is call through via Update. One thing we don't handle, however, is that the
2005 majority of conditions (even inside lists) don't depend on the listitem at all.
2007 Advantage is that we know this at creation time I think, so could perhaps signal it in IsDirty()?
2009 bool CGUIInfoManager::GetBoolValue(unsigned int expression, const CGUIListItem *item)
2011 if (expression && --expression < m_bools.size())
2012 return m_bools[expression]->Get(m_updateTime, item);
2016 // checks the condition and returns it as necessary. Currently used
2017 // for toggle button controls and visibility of images.
2018 bool CGUIInfoManager::GetBool(int condition1, int contextWindow, const CGUIListItem *item)
2020 bool bReturn = false;
2021 int condition = abs(condition1);
2023 if (item && condition >= LISTITEM_START && condition < LISTITEM_END)
2024 bReturn = GetItemBool(item, condition);
2025 // Ethernet Link state checking
2026 // Will check if system has a Ethernet Link connection! [Cable in!]
2027 // This can used for the skinner to switch off Network or Inter required functions
2028 else if ( condition == SYSTEM_ALWAYS_TRUE)
2030 else if (condition == SYSTEM_ALWAYS_FALSE)
2032 else if (condition == SYSTEM_ETHERNET_LINK_ACTIVE)
2034 else if (condition == WINDOW_IS_MEDIA)
2035 { // note: This doesn't return true for dialogs (content, favourites, login, videoinfo)
2036 CGUIWindow *pWindow = g_windowManager.GetWindow(g_windowManager.GetActiveWindow());
2037 bReturn = (pWindow && pWindow->IsMediaWindow());
2039 else if (condition == PLAYER_MUTED)
2040 bReturn = g_settings.m_bMute;
2041 else if (condition >= LIBRARY_HAS_MUSIC && condition <= LIBRARY_HAS_MUSICVIDEOS)
2042 bReturn = GetLibraryBool(condition);
2043 else if (condition == LIBRARY_IS_SCANNING)
2045 if (g_application.IsMusicScanning() || g_application.IsVideoScanning())
2050 else if (condition == LIBRARY_IS_SCANNING_VIDEO)
2052 bReturn = g_application.IsVideoScanning();
2054 else if (condition == LIBRARY_IS_SCANNING_MUSIC)
2056 bReturn = g_application.IsMusicScanning();
2058 else if (condition == SYSTEM_PLATFORM_LINUX)
2059 #if defined(_LINUX) && !defined(TARGET_DARWIN) && !defined(TARGET_ANDROID)
2064 else if (condition == SYSTEM_PLATFORM_WINDOWS)
2070 else if (condition == SYSTEM_PLATFORM_DARWIN)
2071 #ifdef TARGET_DARWIN
2076 else if (condition == SYSTEM_PLATFORM_DARWIN_OSX)
2077 #ifdef TARGET_DARWIN_OSX
2082 else if (condition == SYSTEM_PLATFORM_DARWIN_IOS)
2083 #ifdef TARGET_DARWIN_IOS
2088 else if (condition == SYSTEM_PLATFORM_DARWIN_ATV2)
2089 #ifdef TARGET_DARWIN_IOS_ATV2
2094 else if (condition == SYSTEM_PLATFORM_ANDROID)
2095 #if defined(TARGET_ANDROID)
2100 else if (condition == SYSTEM_MEDIA_DVD)
2101 bReturn = g_mediaManager.IsDiscInDrive();
2102 #ifdef HAS_DVD_DRIVE
2103 else if (condition == SYSTEM_DVDREADY)
2104 bReturn = g_mediaManager.GetDriveStatus() != DRIVE_NOT_READY;
2105 else if (condition == SYSTEM_TRAYOPEN)
2106 bReturn = g_mediaManager.GetDriveStatus() == DRIVE_OPEN;
2108 else if (condition == SYSTEM_CAN_POWERDOWN)
2109 bReturn = g_powerManager.CanPowerdown();
2110 else if (condition == SYSTEM_CAN_SUSPEND)
2111 bReturn = g_powerManager.CanSuspend();
2112 else if (condition == SYSTEM_CAN_HIBERNATE)
2113 bReturn = g_powerManager.CanHibernate();
2114 else if (condition == SYSTEM_CAN_REBOOT)
2115 bReturn = g_powerManager.CanReboot();
2116 else if (condition == SYSTEM_SCREENSAVER_ACTIVE)
2117 bReturn = g_application.IsInScreenSaver();
2119 else if (condition == PLAYER_SHOWINFO)
2120 bReturn = m_playerShowInfo;
2121 else if (condition == PLAYER_SHOWCODEC)
2122 bReturn = m_playerShowCodec;
2123 else if (condition >= MULTI_INFO_START && condition <= MULTI_INFO_END)
2125 return GetMultiInfoBool(m_multiInfo[condition - MULTI_INFO_START], contextWindow, item);
2127 else if (condition == SYSTEM_HASLOCKS)
2128 bReturn = g_settings.GetMasterProfile().getLockMode() != LOCK_MODE_EVERYONE;
2129 else if (condition == SYSTEM_HAS_PVR)
2131 else if (condition == SYSTEM_ISMASTER)
2132 bReturn = g_settings.GetMasterProfile().getLockMode() != LOCK_MODE_EVERYONE && g_passwordManager.bMasterUser;
2133 else if (condition == SYSTEM_ISFULLSCREEN)
2134 bReturn = g_Windowing.IsFullScreen();
2135 else if (condition == SYSTEM_ISSTANDALONE)
2136 bReturn = g_application.IsStandAlone();
2137 else if (condition == SYSTEM_ISINHIBIT)
2138 bReturn = g_application.IsIdleShutdownInhibited();
2139 else if (condition == SYSTEM_HAS_SHUTDOWN)
2140 bReturn = (g_guiSettings.GetInt("powermanagement.shutdowntime") > 0);
2141 else if (condition == SYSTEM_LOGGEDON)
2142 bReturn = !(g_windowManager.GetActiveWindow() == WINDOW_LOGIN_SCREEN);
2143 else if (condition == SYSTEM_SHOW_EXIT_BUTTON)
2144 bReturn = g_advancedSettings.m_showExitButton;
2145 else if (condition == SYSTEM_HAS_LOGINSCREEN)
2146 bReturn = g_settings.UsingLoginScreen();
2147 else if (condition == WEATHER_IS_FETCHED)
2148 bReturn = g_weatherManager.IsFetched();
2149 else if (condition >= PVR_CONDITIONS_START && condition <= PVR_CONDITIONS_END)
2150 bReturn = g_PVRManager.TranslateBoolInfo(condition);
2152 else if (condition == SYSTEM_INTERNET_STATE)
2154 g_sysinfo.GetInfo(condition);
2155 bReturn = g_sysinfo.HasInternet();
2157 else if (condition == SKIN_HAS_VIDEO_OVERLAY)
2159 bReturn = g_windowManager.IsOverlayAllowed() && g_application.IsPlayingVideo();
2161 else if (condition == SKIN_HAS_MUSIC_OVERLAY)
2163 bReturn = g_windowManager.IsOverlayAllowed() && g_application.IsPlayingAudio();
2165 else if (condition == CONTAINER_HASFILES || condition == CONTAINER_HASFOLDERS)
2167 CGUIWindow *pWindow = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
2170 const CFileItemList& items=((CGUIMediaWindow*)pWindow)->CurrentDirectory();
2171 for (int i=0;i<items.Size();++i)
2173 CFileItemPtr item=items.Get(i);
2174 if (!item->m_bIsFolder && condition == CONTAINER_HASFILES)
2179 else if (item->m_bIsFolder && !item->IsParentFolder() && condition == CONTAINER_HASFOLDERS)
2187 else if (condition == CONTAINER_STACKED)
2189 CGUIWindow *pWindow = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
2191 bReturn = ((CGUIMediaWindow*)pWindow)->CurrentDirectory().GetProperty("isstacked").asBoolean();
2193 else if (condition == CONTAINER_HAS_THUMB)
2195 CGUIWindow *pWindow = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
2197 bReturn = ((CGUIMediaWindow*)pWindow)->CurrentDirectory().HasArt("thumb");
2199 else if (condition == CONTAINER_HAS_NEXT || condition == CONTAINER_HAS_PREVIOUS || condition == CONTAINER_SCROLLING)
2201 CGUIWindow *window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
2204 const CGUIControl* control = window->GetControl(window->GetViewContainerID());
2206 bReturn = control->GetCondition(condition, 0);
2209 else if (condition == CONTAINER_CAN_FILTER)
2211 CGUIWindow *window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
2213 bReturn = !((CGUIMediaWindow*)window)->CanFilterAdvanced();
2215 else if (condition == CONTAINER_CAN_FILTERADVANCED)
2217 CGUIWindow *window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
2219 bReturn = ((CGUIMediaWindow*)window)->CanFilterAdvanced();
2221 else if (condition == CONTAINER_FILTERED)
2223 CGUIWindow *window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
2225 bReturn = ((CGUIMediaWindow*)window)->IsFiltered();
2227 else if (condition == VIDEOPLAYER_HAS_INFO)
2228 bReturn = ((m_currentFile->HasVideoInfoTag() && !m_currentFile->GetVideoInfoTag()->IsEmpty()) ||
2229 (m_currentFile->HasPVRChannelInfoTag() && !m_currentFile->GetPVRChannelInfoTag()->IsEmpty()));
2230 else if (condition >= CONTAINER_SCROLL_PREVIOUS && condition <= CONTAINER_SCROLL_NEXT)
2232 // no parameters, so we assume it's just requested for a media window. It therefore
2233 // can only happen if the list has focus.
2234 CGUIWindow *pWindow = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
2237 map<int,int>::const_iterator it = m_containerMoves.find(pWindow->GetViewContainerID());
2238 if (it != m_containerMoves.end())
2240 if (condition > CONTAINER_STATIC) // moving up
2241 bReturn = it->second >= std::max(condition - CONTAINER_STATIC, 1);
2243 bReturn = it->second <= std::min(condition - CONTAINER_STATIC, -1);
2247 else if (condition == SLIDESHOW_ISPAUSED)
2249 CGUIWindowSlideShow *slideShow = (CGUIWindowSlideShow *)g_windowManager.GetWindow(WINDOW_SLIDESHOW);
2250 bReturn = (slideShow && slideShow->IsPaused());
2252 else if (condition == SLIDESHOW_ISRANDOM)
2254 CGUIWindowSlideShow *slideShow = (CGUIWindowSlideShow *)g_windowManager.GetWindow(WINDOW_SLIDESHOW);
2255 bReturn = (slideShow && slideShow->IsShuffled());
2257 else if (condition == SLIDESHOW_ISACTIVE)
2259 CGUIWindowSlideShow *slideShow = (CGUIWindowSlideShow *)g_windowManager.GetWindow(WINDOW_SLIDESHOW);
2260 bReturn = (slideShow && slideShow->InSlideShow());
2262 else if (g_application.IsPlaying())
2266 case PLAYER_HAS_MEDIA:
2269 case PLAYER_HAS_AUDIO:
2270 bReturn = g_application.IsPlayingAudio();
2272 case PLAYER_HAS_VIDEO:
2273 bReturn = g_application.IsPlayingVideo();
2275 case PLAYER_PLAYING:
2276 bReturn = !g_application.IsPaused() && (g_application.GetPlaySpeed() == 1);
2279 bReturn = g_application.IsPaused();
2281 case PLAYER_REWINDING:
2282 bReturn = !g_application.IsPaused() && g_application.GetPlaySpeed() < 1;
2284 case PLAYER_FORWARDING:
2285 bReturn = !g_application.IsPaused() && g_application.GetPlaySpeed() > 1;
2287 case PLAYER_REWINDING_2x:
2288 bReturn = !g_application.IsPaused() && g_application.GetPlaySpeed() == -2;
2290 case PLAYER_REWINDING_4x:
2291 bReturn = !g_application.IsPaused() && g_application.GetPlaySpeed() == -4;
2293 case PLAYER_REWINDING_8x:
2294 bReturn = !g_application.IsPaused() && g_application.GetPlaySpeed() == -8;
2296 case PLAYER_REWINDING_16x:
2297 bReturn = !g_application.IsPaused() && g_application.GetPlaySpeed() == -16;
2299 case PLAYER_REWINDING_32x:
2300 bReturn = !g_application.IsPaused() && g_application.GetPlaySpeed() == -32;
2302 case PLAYER_FORWARDING_2x:
2303 bReturn = !g_application.IsPaused() && g_application.GetPlaySpeed() == 2;
2305 case PLAYER_FORWARDING_4x:
2306 bReturn = !g_application.IsPaused() && g_application.GetPlaySpeed() == 4;
2308 case PLAYER_FORWARDING_8x:
2309 bReturn = !g_application.IsPaused() && g_application.GetPlaySpeed() == 8;
2311 case PLAYER_FORWARDING_16x:
2312 bReturn = !g_application.IsPaused() && g_application.GetPlaySpeed() == 16;
2314 case PLAYER_FORWARDING_32x:
2315 bReturn = !g_application.IsPaused() && g_application.GetPlaySpeed() == 32;
2317 case PLAYER_CAN_RECORD:
2318 bReturn = g_application.m_pPlayer->CanRecord();
2320 case PLAYER_CAN_PAUSE:
2321 bReturn = g_application.m_pPlayer->CanPause();
2323 case PLAYER_CAN_SEEK:
2324 bReturn = g_application.m_pPlayer->CanSeek();
2326 case PLAYER_RECORDING:
2327 bReturn = g_application.m_pPlayer->IsRecording();
2329 case PLAYER_DISPLAY_AFTER_SEEK:
2330 bReturn = GetDisplayAfterSeek();
2332 case PLAYER_CACHING:
2333 bReturn = g_application.m_pPlayer->IsCaching();
2335 case PLAYER_SEEKBAR:
2337 CGUIDialog *seekBar = (CGUIDialog*)g_windowManager.GetWindow(WINDOW_DIALOG_SEEK_BAR);
2338 bReturn = seekBar ? seekBar->IsDialogRunning() : false;
2341 case PLAYER_SEEKING:
2342 bReturn = m_playerSeeking;
2344 case PLAYER_SHOWTIME:
2345 bReturn = m_playerShowTime;
2347 case PLAYER_PASSTHROUGH:
2348 bReturn = g_application.m_pPlayer && g_application.m_pPlayer->IsPassthrough();
2350 case MUSICPM_ENABLED:
2351 bReturn = g_partyModeManager.IsEnabled();
2353 case AUDIOSCROBBLER_ENABLED:
2354 bReturn = CLastFmManager::GetInstance()->IsLastFmEnabled();
2356 case LASTFM_RADIOPLAYING:
2357 bReturn = CLastFmManager::GetInstance()->IsRadioEnabled();
2359 case LASTFM_CANLOVE:
2360 bReturn = CLastFmManager::GetInstance()->CanLove();
2363 bReturn = CLastFmManager::GetInstance()->CanBan();
2365 case MUSICPLAYER_HASPREVIOUS:
2367 // requires current playlist be PLAYLIST_MUSIC
2369 if (g_playlistPlayer.GetCurrentPlaylist() == PLAYLIST_MUSIC)
2370 bReturn = (g_playlistPlayer.GetCurrentSong() > 0); // not first song
2373 case MUSICPLAYER_HASNEXT:
2375 // requires current playlist be PLAYLIST_MUSIC
2377 if (g_playlistPlayer.GetCurrentPlaylist() == PLAYLIST_MUSIC)
2378 bReturn = (g_playlistPlayer.GetCurrentSong() < (g_playlistPlayer.GetPlaylist(PLAYLIST_MUSIC).size() - 1)); // not last song
2381 case MUSICPLAYER_PLAYLISTPLAYING:
2384 if (g_application.IsPlayingAudio() && g_playlistPlayer.GetCurrentPlaylist() == PLAYLIST_MUSIC)
2388 case VIDEOPLAYER_USING_OVERLAYS:
2389 bReturn = (g_guiSettings.GetInt("videoplayer.rendermethod") == RENDER_OVERLAYS);
2391 case VIDEOPLAYER_ISFULLSCREEN:
2392 bReturn = g_windowManager.GetActiveWindow() == WINDOW_FULLSCREEN_VIDEO;
2394 case VIDEOPLAYER_HASMENU:
2395 bReturn = g_application.m_pPlayer->HasMenu();
2397 case PLAYLIST_ISRANDOM:
2398 bReturn = g_playlistPlayer.IsShuffled(g_playlistPlayer.GetCurrentPlaylist());
2400 case PLAYLIST_ISREPEAT:
2401 bReturn = g_playlistPlayer.GetRepeat(g_playlistPlayer.GetCurrentPlaylist()) == PLAYLIST::REPEAT_ALL;
2403 case PLAYLIST_ISREPEATONE:
2404 bReturn = g_playlistPlayer.GetRepeat(g_playlistPlayer.GetCurrentPlaylist()) == PLAYLIST::REPEAT_ONE;
2406 case PLAYER_HASDURATION:
2407 bReturn = g_application.GetTotalTime() > 0;
2409 case VIDEOPLAYER_HASTELETEXT:
2410 if (g_application.m_pPlayer->GetTeletextCache())
2413 case VIDEOPLAYER_HASSUBTITLES:
2414 bReturn = g_application.m_pPlayer->GetSubtitleCount() > 0;
2416 case VIDEOPLAYER_SUBTITLESENABLED:
2417 bReturn = g_application.m_pPlayer->GetSubtitleVisible();
2419 case VISUALISATION_LOCKED:
2421 CGUIMessage msg(GUI_MSG_GET_VISUALISATION, 0, 0);
2422 g_windowManager.SendMessage(msg);
2423 if (msg.GetPointer())
2425 CVisualisation *pVis = (CVisualisation *)msg.GetPointer();
2426 bReturn = pVis->IsLocked();
2430 case VISUALISATION_ENABLED:
2431 bReturn = !g_guiSettings.GetString("musicplayer.visualisation").IsEmpty();
2433 case VIDEOPLAYER_HAS_EPG:
2434 if (m_currentFile->HasPVRChannelInfoTag())
2437 bReturn = m_currentFile->GetPVRChannelInfoTag()->GetEPGNow(epgTag);
2440 default: // default, use integer value different from 0 as true
2443 bReturn = GetInt(val, condition) && val != 0;
2452 /// \brief Examines the multi information sent and returns true or false accordingly.
2453 bool CGUIInfoManager::GetMultiInfoBool(const GUIInfo &info, int contextWindow, const CGUIListItem *item)
2455 bool bReturn = false;
2456 int condition = abs(info.m_info);
2458 if (condition >= LISTITEM_START && condition <= LISTITEM_END)
2462 CGUIWindow *window = NULL;
2463 int data1 = info.GetData1();
2464 if (!data1) // No container specified, so we lookup the current view container
2466 window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_HAS_LIST_ITEMS);
2467 if (window && window->IsMediaWindow())
2468 data1 = ((CGUIMediaWindow*)(window))->GetViewContainerID();
2471 if (!window) // If we don't have a window already (from lookup above), get one
2472 window = GetWindowWithCondition(contextWindow, 0);
2476 const CGUIControl *control = window->GetControl(data1);
2477 if (control && control->IsContainer())
2478 item = ((IGUIContainer *)control)->GetListItem(info.GetData2(), info.GetInfoFlag()).get();
2481 if (item) // If we got a valid item, do the lookup
2482 bReturn = GetItemBool(item, condition); // Image prioritizes images over labels (in the case of music item ratings for instance)
2490 bReturn = g_settings.GetSkinBool(info.GetData1());
2495 if (info.GetData2())
2496 bReturn = g_settings.GetSkinString(info.GetData1()).Equals(m_stringParameters[info.GetData2()]);
2498 bReturn = !g_settings.GetSkinString(info.GetData1()).IsEmpty();
2501 case SKIN_HAS_THEME:
2503 CStdString theme = g_guiSettings.GetString("lookandfeel.skintheme");
2505 URIUtils::RemoveExtension(theme);
2506 bReturn = theme.Equals(m_stringParameters[info.GetData1()]);
2509 case STRING_IS_EMPTY:
2510 // note: Get*Image() falls back to Get*Label(), so this should cover all of them
2511 if (item && item->IsFileItem() && info.GetData1() >= LISTITEM_START && info.GetData1() < LISTITEM_END)
2512 bReturn = GetItemImage((const CFileItem *)item, info.GetData1()).IsEmpty();
2514 bReturn = GetImage(info.GetData1(), contextWindow).IsEmpty();
2516 case STRING_COMPARE:
2519 if (info.GetData2() < 0) // info labels are stored with negative numbers
2521 int info2 = -info.GetData2();
2522 if (item && item->IsFileItem() && info2 >= LISTITEM_START && info2 < LISTITEM_END)
2523 compare = GetItemImage((const CFileItem *)item, info2);
2525 compare = GetImage(info2, contextWindow);
2527 else if (info.GetData2() < (int)m_stringParameters.size())
2528 { // conditional string
2529 compare = m_stringParameters[info.GetData2()];
2531 if (item && item->IsFileItem() && info.GetData1() >= LISTITEM_START && info.GetData1() < LISTITEM_END)
2532 bReturn = GetItemImage((const CFileItem *)item, info.GetData1()).Equals(compare);
2534 bReturn = GetImage(info.GetData1(), contextWindow).Equals(compare);
2537 case INTEGER_GREATER_THAN:
2540 if (GetInt(integer, info.GetData1(), contextWindow, item))
2541 bReturn = integer > info.GetData2();
2546 if (item && item->IsFileItem() && info.GetData1() >= LISTITEM_START && info.GetData1() < LISTITEM_END)
2547 value = GetItemImage((const CFileItem *)item, info.GetData1());
2549 value = GetImage(info.GetData1(), contextWindow);
2551 // Handle the case when a value contains time separator (:). This makes IntegerGreaterThan
2552 // useful for Player.Time* members without adding a separate set of members returning time in seconds
2553 if ( value.find_first_of( ':' ) != value.npos )
2554 bReturn = StringUtils::TimeStringToSeconds( value ) > info.GetData2();
2556 bReturn = atoi( value.c_str() ) > info.GetData2();
2561 case STRING_STR_LEFT:
2562 case STRING_STR_RIGHT:
2564 CStdString compare = m_stringParameters[info.GetData2()];
2565 // our compare string is already in lowercase, so lower case our label as well
2566 // as CStdString::Find() is case sensitive
2568 if (item && item->IsFileItem() && info.GetData1() >= LISTITEM_START && info.GetData1() < LISTITEM_END)
2569 label = GetItemImage((const CFileItem *)item, info.GetData1()).ToLower();
2571 label = GetImage(info.GetData1(), contextWindow).ToLower();
2572 if (condition == STRING_STR_LEFT)
2573 bReturn = label.Find(compare) == 0;
2574 else if (condition == STRING_STR_RIGHT)
2575 bReturn = label.Find(compare) == (int)(label.size()-compare.size());
2577 bReturn = label.Find(compare) > -1;
2580 case SYSTEM_ALARM_LESS_OR_EQUAL:
2582 int time = lrint(g_alarmClock.GetRemaining(m_stringParameters[info.GetData1()]));
2583 int timeCompare = atoi(m_stringParameters[info.GetData2()]);
2585 bReturn = timeCompare >= time;
2590 case SYSTEM_IDLE_TIME:
2591 bReturn = g_application.GlobalIdleTime() >= (int)info.GetData1();
2593 case CONTROL_GROUP_HAS_FOCUS:
2595 CGUIWindow *window = GetWindowWithCondition(contextWindow, 0);
2597 bReturn = window->ControlGroupHasFocus(info.GetData1(), info.GetData2());
2600 case CONTROL_IS_VISIBLE:
2602 CGUIWindow *window = GetWindowWithCondition(contextWindow, 0);
2605 // Note: This'll only work for unique id's
2606 const CGUIControl *control = window->GetControl(info.GetData1());
2608 bReturn = control->IsVisible();
2612 case CONTROL_IS_ENABLED:
2614 CGUIWindow *window = GetWindowWithCondition(contextWindow, 0);
2617 // Note: This'll only work for unique id's
2618 const CGUIControl *control = window->GetControl(info.GetData1());
2620 bReturn = !control->IsDisabled();
2624 case CONTROL_HAS_FOCUS:
2626 CGUIWindow *window = GetWindowWithCondition(contextWindow, 0);
2628 bReturn = (window->GetFocusedControlID() == (int)info.GetData1());
2632 if (info.GetData1())
2633 bReturn = ((int)info.GetData1() == m_nextWindowID);
2636 CGUIWindow *window = g_windowManager.GetWindow(m_nextWindowID);
2637 if (window && URIUtils::GetFileName(window->GetProperty("xmlfile").asString()).Equals(m_stringParameters[info.GetData2()]))
2641 case WINDOW_PREVIOUS:
2642 if (info.GetData1())
2643 bReturn = ((int)info.GetData1() == m_prevWindowID);
2646 CGUIWindow *window = g_windowManager.GetWindow(m_prevWindowID);
2647 if (window && URIUtils::GetFileName(window->GetProperty("xmlfile").asString()).Equals(m_stringParameters[info.GetData2()]))
2651 case WINDOW_IS_VISIBLE:
2652 if (info.GetData1())
2653 bReturn = g_windowManager.IsWindowVisible(info.GetData1());
2655 bReturn = g_windowManager.IsWindowVisible(m_stringParameters[info.GetData2()]);
2657 case WINDOW_IS_TOPMOST:
2658 if (info.GetData1())
2659 bReturn = g_windowManager.IsWindowTopMost(info.GetData1());
2661 bReturn = g_windowManager.IsWindowTopMost(m_stringParameters[info.GetData2()]);
2663 case WINDOW_IS_ACTIVE:
2664 if (info.GetData1())
2665 bReturn = g_windowManager.IsWindowActive(info.GetData1());
2667 bReturn = g_windowManager.IsWindowActive(m_stringParameters[info.GetData2()]);
2669 case SYSTEM_HAS_ALARM:
2670 bReturn = g_alarmClock.HasAlarm(m_stringParameters[info.GetData1()]);
2672 case SYSTEM_GET_BOOL:
2673 bReturn = g_guiSettings.GetBool(m_stringParameters[info.GetData1()]);
2675 case SYSTEM_HAS_CORE_ID:
2676 bReturn = g_cpuInfo.HasCoreId(info.GetData1());
2678 case SYSTEM_SETTING:
2680 if ( m_stringParameters[info.GetData1()].Equals("hidewatched") )
2682 CGUIWindow *window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
2684 bReturn = g_settings.GetWatchMode(((CGUIMediaWindow *)window)->CurrentDirectory().GetContent()) == VIDEO_SHOW_UNWATCHED;
2688 case SYSTEM_HAS_ADDON:
2691 bReturn = CAddonMgr::Get().GetAddon(m_stringParameters[info.GetData1()],addon) && addon;
2694 case CONTAINER_SCROLL_PREVIOUS:
2695 case CONTAINER_MOVE_PREVIOUS:
2696 case CONTAINER_MOVE_NEXT:
2697 case CONTAINER_SCROLL_NEXT:
2699 map<int,int>::const_iterator it = m_containerMoves.find(info.GetData1());
2700 if (it != m_containerMoves.end())
2702 if (condition > CONTAINER_STATIC) // moving up
2703 bReturn = it->second >= std::max(condition - CONTAINER_STATIC, 1);
2705 bReturn = it->second <= std::min(condition - CONTAINER_STATIC, -1);
2709 case CONTAINER_CONTENT:
2712 CGUIWindow *window = GetWindowWithCondition(contextWindow, 0);
2715 if (window->GetID() == WINDOW_DIALOG_MUSIC_INFO)
2716 content = ((CGUIDialogMusicInfo *)window)->CurrentDirectory().GetContent();
2717 else if (window->GetID() == WINDOW_DIALOG_VIDEO_INFO)
2718 content = ((CGUIDialogVideoInfo *)window)->CurrentDirectory().GetContent();
2720 if (content.IsEmpty())
2722 window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
2724 content = ((CGUIMediaWindow *)window)->CurrentDirectory().GetContent();
2726 bReturn = m_stringParameters[info.GetData2()].Equals(content);
2730 case CONTAINER_COLUMN:
2731 case CONTAINER_POSITION:
2732 case CONTAINER_HAS_NEXT:
2733 case CONTAINER_HAS_PREVIOUS:
2734 case CONTAINER_SCROLLING:
2735 case CONTAINER_SUBITEM:
2737 const CGUIControl *control = NULL;
2738 if (info.GetData1())
2739 { // container specified
2740 CGUIWindow *window = GetWindowWithCondition(contextWindow, 0);
2742 control = window->GetControl(info.GetData1());
2745 { // no container specified - assume a mediawindow
2746 CGUIWindow *window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
2748 control = window->GetControl(window->GetViewContainerID());
2751 bReturn = control->GetCondition(condition, info.GetData2());
2754 case CONTAINER_HAS_FOCUS:
2755 { // grab our container
2756 CGUIWindow *window = GetWindowWithCondition(contextWindow, 0);
2759 const CGUIControl *control = window->GetControl(info.GetData1());
2760 if (control && control->IsContainer())
2762 CFileItemPtr item = boost::static_pointer_cast<CFileItem>(((IGUIContainer *)control)->GetListItem(0));
2763 if (item && item->m_iprogramCount == info.GetData2()) // programcount used to store item id
2769 case VIDEOPLAYER_CONTENT:
2771 CStdString strContent="movies";
2772 if (!m_currentFile->HasVideoInfoTag() || m_currentFile->GetVideoInfoTag()->IsEmpty())
2773 strContent = "files";
2774 if (m_currentFile->HasVideoInfoTag() && m_currentFile->GetVideoInfoTag()->m_iSeason > -1) // episode
2775 strContent = "episodes";
2776 if (m_currentFile->HasVideoInfoTag() && !m_currentFile->GetVideoInfoTag()->m_artist.empty())
2777 strContent = "musicvideos";
2778 if (m_currentFile->HasVideoInfoTag() && m_currentFile->GetVideoInfoTag()->m_strStatus == "livetv")
2779 strContent = "livetv";
2780 if (m_currentFile->HasPVRChannelInfoTag())
2781 strContent = "livetv";
2782 bReturn = m_stringParameters[info.GetData1()].Equals(strContent);
2785 case CONTAINER_SORT_METHOD:
2787 CGUIWindow *window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
2790 const CGUIViewState *viewState = ((CGUIMediaWindow*)window)->GetViewState();
2792 bReturn = ((unsigned int)viewState->GetSortMethod() == info.GetData1());
2796 case CONTAINER_SORT_DIRECTION:
2798 CGUIWindow *window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
2801 const CGUIViewState *viewState = ((CGUIMediaWindow*)window)->GetViewState();
2803 bReturn = ((unsigned int)viewState->GetDisplaySortOrder() == info.GetData1());
2809 if (info.GetData2() == -1) // info doesn't contain valid startDate
2811 CDateTime date = CDateTime::GetCurrentDateTime();
2812 int currentDate = date.GetMonth()*100+date.GetDay();
2813 int startDate = info.GetData1();
2814 int stopDate = info.GetData2();
2816 if (stopDate < startDate)
2817 bReturn = currentDate >= startDate || currentDate < stopDate;
2819 bReturn = currentDate >= startDate && currentDate < stopDate;
2824 CDateTime time=CDateTime::GetCurrentDateTime();
2825 int currentTime = time.GetMinuteOfDay();
2826 int startTime = info.GetData1();
2827 int stopTime = info.GetData2();
2829 if (stopTime < startTime)
2830 bReturn = currentTime >= startTime || currentTime < stopTime;
2832 bReturn = currentTime >= startTime && currentTime < stopTime;
2835 case MUSICPLAYER_EXISTS:
2837 int index = info.GetData2();
2838 if (info.GetData1() == 1)
2840 if (g_playlistPlayer.GetCurrentPlaylist() != PLAYLIST_MUSIC)
2842 index += g_playlistPlayer.GetCurrentSong();
2844 if (index >= 0 && index < g_playlistPlayer.GetPlaylist(PLAYLIST_MUSIC).size())
2851 return (info.m_info < 0) ? !bReturn : bReturn;
2854 bool CGUIInfoManager::GetMultiInfoInt(int &value, const GUIInfo &info, int contextWindow) const
2856 if (info.m_info >= LISTITEM_START && info.m_info <= LISTITEM_END)
2859 CGUIWindow *window = NULL;
2861 int data1 = info.GetData1();
2862 if (!data1) // No container specified, so we lookup the current view container
2864 window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_HAS_LIST_ITEMS);
2865 if (window && window->IsMediaWindow())
2866 data1 = ((CGUIMediaWindow*)(window))->GetViewContainerID();
2869 if (!window) // If we don't have a window already (from lookup above), get one
2870 window = GetWindowWithCondition(contextWindow, 0);
2874 const CGUIControl *control = window->GetControl(data1);
2875 if (control && control->IsContainer())
2876 item = boost::static_pointer_cast<CFileItem>(((IGUIContainer *)control)->GetListItem(info.GetData2(), info.GetInfoFlag()));
2879 if (item) // If we got a valid item, do the lookup
2880 return GetItemInt(value, item.get(), info.m_info);
2886 /// \brief Examines the multi information sent and returns the string as appropriate
2887 CStdString CGUIInfoManager::GetMultiInfoLabel(const GUIInfo &info, int contextWindow, CStdString *fallback)
2889 if (info.m_info == SKIN_STRING)
2891 return g_settings.GetSkinString(info.GetData1());
2893 else if (info.m_info == SKIN_BOOL)
2895 bool bInfo = g_settings.GetSkinBool(info.GetData1());
2897 return g_localizeStrings.Get(20122);
2899 if (info.m_info >= LISTITEM_START && info.m_info <= LISTITEM_END)
2902 CGUIWindow *window = NULL;
2904 int data1 = info.GetData1();
2905 if (!data1) // No container specified, so we lookup the current view container
2907 window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_HAS_LIST_ITEMS);
2908 if (window && window->IsMediaWindow())
2909 data1 = ((CGUIMediaWindow*)(window))->GetViewContainerID();
2912 if (!window) // If we don't have a window already (from lookup above), get one
2913 window = GetWindowWithCondition(contextWindow, 0);
2917 const CGUIControl *control = window->GetControl(data1);
2918 if (control && control->IsContainer())
2919 item = boost::static_pointer_cast<CFileItem>(((IGUIContainer *)control)->GetListItem(info.GetData2(), info.GetInfoFlag()));
2922 if (item) // If we got a valid item, do the lookup
2923 return GetItemImage(item.get(), info.m_info, fallback); // Image prioritizes images over labels (in the case of music item ratings for instance)
2925 else if (info.m_info == PLAYER_TIME)
2927 return GetCurrentPlayTime((TIME_FORMAT)info.GetData1());
2929 else if (info.m_info == PLAYER_TIME_REMAINING)
2931 return GetCurrentPlayTimeRemaining((TIME_FORMAT)info.GetData1());
2933 else if (info.m_info == PLAYER_FINISH_TIME)
2936 CEpgInfoTag currentTag;
2937 if (GetEpgInfoTag(currentTag))
2938 time = currentTag.EndAsLocalTime();
2941 time = CDateTime::GetCurrentDateTime();
2942 time += CDateTimeSpan(0, 0, 0, GetPlayTimeRemaining());
2944 return LocalizeTime(time, (TIME_FORMAT)info.GetData1());
2946 else if (info.m_info == PLAYER_START_TIME)
2949 CEpgInfoTag currentTag;
2950 if (GetEpgInfoTag(currentTag))
2951 time = currentTag.StartAsLocalTime();
2954 time = CDateTime::GetCurrentDateTime();
2955 time -= CDateTimeSpan(0, 0, 0, (int)GetPlayTime());
2957 return LocalizeTime(time, (TIME_FORMAT)info.GetData1());
2959 else if (info.m_info == PLAYER_TIME_SPEED)
2962 if (g_application.GetPlaySpeed() != 1)
2963 strTime.Format("%s (%ix)", GetCurrentPlayTime((TIME_FORMAT)info.GetData1()).c_str(), g_application.GetPlaySpeed());
2965 strTime = GetCurrentPlayTime();
2968 else if (info.m_info == PLAYER_DURATION)
2970 return GetDuration((TIME_FORMAT)info.GetData1());
2972 else if (info.m_info == PLAYER_SEEKTIME)
2974 return GetCurrentSeekTime((TIME_FORMAT)info.GetData1());
2976 else if (info.m_info == PLAYER_SEEKOFFSET)
2978 CStdString seekOffset = StringUtils::SecondsToTimeString(abs(m_seekOffset), (TIME_FORMAT)info.GetData1());
2979 if (m_seekOffset < 0)
2980 return "-" + seekOffset;
2981 if (m_seekOffset > 0)
2982 return "+" + seekOffset;
2984 else if (info.m_info == PLAYER_ITEM_ART)
2986 return m_currentFile->GetArt(m_stringParameters[info.GetData1()]);
2988 else if (info.m_info == SYSTEM_TIME)
2990 return GetTime((TIME_FORMAT)info.GetData1());
2992 else if (info.m_info == SYSTEM_DATE)
2994 CDateTime time=CDateTime::GetCurrentDateTime();
2995 return time.GetAsLocalizedDate(m_stringParameters[info.GetData1()],false);
2997 else if (info.m_info == CONTAINER_NUM_PAGES || info.m_info == CONTAINER_CURRENT_PAGE ||
2998 info.m_info == CONTAINER_NUM_ITEMS || info.m_info == CONTAINER_POSITION)
3000 const CGUIControl *control = NULL;
3001 if (info.GetData1())
3002 { // container specified
3003 CGUIWindow *window = GetWindowWithCondition(contextWindow, 0);
3005 control = window->GetControl(info.GetData1());
3008 { // no container specified - assume a mediawindow
3009 CGUIWindow *window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
3011 control = window->GetControl(window->GetViewContainerID());
3015 if (control->IsContainer())
3016 return ((IGUIContainer *)control)->GetLabel(info.m_info);
3017 else if (control->GetControlType() == CGUIControl::GUICONTROL_TEXTBOX)
3018 return ((CGUITextBox *)control)->GetLabel(info.m_info);
3021 else if (info.m_info == SYSTEM_GET_CORE_USAGE)
3024 strCpu.Format("%4.2f", g_cpuInfo.GetCoreInfo(atoi(m_stringParameters[info.GetData1()].c_str())).m_fPct);
3027 else if (info.m_info >= MUSICPLAYER_TITLE && info.m_info <= MUSICPLAYER_ALBUM_ARTIST)
3028 return GetMusicPlaylistInfo(info);
3029 else if (info.m_info == CONTAINER_PROPERTY)
3031 CGUIWindow *window = NULL;
3032 if (info.GetData1())
3033 { // container specified
3034 window = GetWindowWithCondition(contextWindow, 0);
3037 { // no container specified - assume a mediawindow
3038 window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
3041 return ((CGUIMediaWindow *)window)->CurrentDirectory().GetProperty(m_stringParameters[info.GetData2()]).asString();
3043 else if (info.m_info == CONTROL_GET_LABEL)
3045 CGUIWindow *window = GetWindowWithCondition(contextWindow, 0);
3048 const CGUIControl *control = window->GetControl(info.GetData1());
3050 return control->GetDescription();
3053 else if (info.m_info == WINDOW_PROPERTY)
3055 CGUIWindow *window = NULL;
3056 if (info.GetData1())
3057 { // window specified
3058 window = g_windowManager.GetWindow(info.GetData1());//GetWindowWithCondition(contextWindow, 0);
3061 { // no window specified - assume active
3062 window = GetWindowWithCondition(contextWindow, 0);
3066 return window->GetProperty(m_stringParameters[info.GetData2()]).asString();
3068 else if (info.m_info == SYSTEM_ADDON_TITLE ||
3069 info.m_info == SYSTEM_ADDON_ICON)
3071 // This logic does not check/care whether an addon has been disabled/marked as broken,
3072 // it simply retrieves it's name or icon that means if an addon is placed on the home screen it
3073 // will stay there even if it's disabled/marked as broken. This might need to be changed/fixed
3076 if (info.GetData2() == 0)
3077 CAddonMgr::Get().GetAddon(const_cast<CGUIInfoManager*>(this)->GetLabel(info.GetData1(), contextWindow),addon,ADDON_UNKNOWN,false);
3079 CAddonMgr::Get().GetAddon(m_stringParameters[info.GetData1()],addon,ADDON_UNKNOWN,false);
3080 if (addon && info.m_info == SYSTEM_ADDON_TITLE)
3081 return addon->Name();
3082 if (addon && info.m_info == SYSTEM_ADDON_ICON)
3083 return addon->Icon();
3086 return StringUtils::EmptyString;
3089 /// \brief Obtains the filename of the image to show from whichever subsystem is needed
3090 CStdString CGUIInfoManager::GetImage(int info, int contextWindow, CStdString *fallback)
3092 if (info >= CONDITIONAL_LABEL_START && info <= CONDITIONAL_LABEL_END)
3093 return GetSkinVariableString(info, true);
3095 if (info >= MULTI_INFO_START && info <= MULTI_INFO_END)
3097 return GetMultiInfoLabel(m_multiInfo[info - MULTI_INFO_START], contextWindow, fallback);
3099 else if (info == WEATHER_CONDITIONS)
3100 return g_weatherManager.GetInfo(WEATHER_IMAGE_CURRENT_ICON);
3101 else if (info == SYSTEM_PROFILETHUMB)
3103 CStdString thumb = g_settings.GetCurrentProfile().getThumb();
3104 if (thumb.IsEmpty())
3105 thumb = "unknown-user.png";
3108 else if (info == MUSICPLAYER_COVER)
3110 if (!g_application.IsPlayingAudio()) return "";
3112 *fallback = "DefaultAlbumCover.png";
3113 return m_currentFile->HasArt("thumb") ? m_currentFile->GetArt("thumb") : "DefaultAlbumCover.png";
3115 else if (info == MUSICPLAYER_RATING)
3117 if (!g_application.IsPlayingAudio()) return "";
3118 return GetItemImage(m_currentFile, LISTITEM_RATING);
3120 else if (info == PLAYER_STAR_RATING)
3122 if (!g_application.IsPlaying()) return "";
3123 return GetItemImage(m_currentFile, LISTITEM_STAR_RATING);
3125 else if (info == VIDEOPLAYER_COVER)
3127 if (!g_application.IsPlayingVideo()) return "";
3129 *fallback = "DefaultVideoCover.png";
3130 if(m_currentMovieThumb.IsEmpty())
3131 return m_currentFile->HasArt("thumb") ? m_currentFile->GetArt("thumb") : "DefaultVideoCover.png";
3132 else return m_currentMovieThumb;
3134 else if (info == CONTAINER_FOLDERTHUMB)
3136 CGUIWindow *window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
3138 return GetItemImage(&const_cast<CFileItemList&>(((CGUIMediaWindow*)window)->CurrentDirectory()), LISTITEM_THUMB, fallback);
3140 else if (info == CONTAINER_TVSHOWTHUMB)
3142 CGUIWindow *window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
3144 return ((CGUIMediaWindow *)window)->CurrentDirectory().GetArt("tvshow.thumb");
3146 else if (info == CONTAINER_SEASONTHUMB)
3148 CGUIWindow *window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_IS_MEDIA_WINDOW);
3150 return ((CGUIMediaWindow *)window)->CurrentDirectory().GetArt("season.thumb");
3152 else if (info == LISTITEM_THUMB || info == LISTITEM_ICON || info == LISTITEM_ACTUAL_ICON ||
3153 info == LISTITEM_OVERLAY || info == LISTITEM_RATING || info == LISTITEM_STAR_RATING)
3155 CGUIWindow *window = GetWindowWithCondition(contextWindow, WINDOW_CONDITION_HAS_LIST_ITEMS);
3158 CFileItemPtr item = window->GetCurrentListItem();
3160 return GetItemImage(item.get(), info, fallback);
3163 return GetLabel(info, contextWindow, fallback);
3166 CStdString CGUIInfoManager::GetDate(bool bNumbersOnly)
3168 CDateTime time=CDateTime::GetCurrentDateTime();
3169 return time.GetAsLocalizedDate(!bNumbersOnly);
3172 CStdString CGUIInfoManager::GetTime(TIME_FORMAT format) const
3174 CDateTime time=CDateTime::GetCurrentDateTime();
3175 return LocalizeTime(time, format);
3178 CStdString CGUIInfoManager::LocalizeTime(const CDateTime &time, TIME_FORMAT format) const
3180 const CStdString timeFormat = g_langInfo.GetTimeFormat();
3181 bool use12hourclock = timeFormat.Find('h') != -1;
3184 case TIME_FORMAT_GUESS:
3185 return time.GetAsLocalizedTime("", false);
3186 case TIME_FORMAT_SS:
3187 return time.GetAsLocalizedTime("ss", true);
3188 case TIME_FORMAT_MM:
3189 return time.GetAsLocalizedTime("mm", true);
3190 case TIME_FORMAT_MM_SS:
3191 return time.GetAsLocalizedTime("mm:ss", true);
3192 case TIME_FORMAT_HH: // this forces it to a 12 hour clock
3193 return time.GetAsLocalizedTime(use12hourclock ? "h" : "HH", false);
3194 case TIME_FORMAT_HH_MM:
3195 return time.GetAsLocalizedTime(use12hourclock ? "h:mm" : "HH:mm", false);
3196 case TIME_FORMAT_HH_MM_XX:
3197 return time.GetAsLocalizedTime(use12hourclock ? "h:mm xx" : "HH:mm", false);
3198 case TIME_FORMAT_HH_MM_SS:
3199 return time.GetAsLocalizedTime("", true);
3201 return time.GetAsLocalizedTime("h", false);
3202 case TIME_FORMAT_H_MM_SS:
3203 return time.GetAsLocalizedTime("h:mm:ss", true);
3204 case TIME_FORMAT_XX:
3205 return use12hourclock ? time.GetAsLocalizedTime("xx", false) : "";
3209 return time.GetAsLocalizedTime("", false);
3212 CStdString CGUIInfoManager::GetDuration(TIME_FORMAT format) const
3214 if (g_application.IsPlayingAudio() && m_currentFile->HasMusicInfoTag())
3216 const CMusicInfoTag& tag = *m_currentFile->GetMusicInfoTag();
3217 if (tag.GetDuration() > 0)
3218 return StringUtils::SecondsToTimeString(tag.GetDuration(), format);
3220 if (g_application.IsPlayingVideo() && !m_currentMovieDuration.IsEmpty())
3221 return m_currentMovieDuration; // for tuxbox
3222 unsigned int iTotal = (unsigned int)g_application.GetTotalTime();
3224 return StringUtils::SecondsToTimeString(iTotal, format);
3228 CStdString CGUIInfoManager::GetMusicPartyModeLabel(int item)
3231 if (item >= MUSICPM_SONGSPLAYED && item <= MUSICPM_RANDOMSONGSPICKED)
3236 case MUSICPM_SONGSPLAYED:
3238 iSongs = g_partyModeManager.GetSongsPlayed();
3241 case MUSICPM_MATCHINGSONGS:
3243 iSongs = g_partyModeManager.GetMatchingSongs();
3246 case MUSICPM_MATCHINGSONGSPICKED:
3248 iSongs = g_partyModeManager.GetMatchingSongsPicked();
3251 case MUSICPM_MATCHINGSONGSLEFT:
3253 iSongs = g_partyModeManager.GetMatchingSongsLeft();
3256 case MUSICPM_RELAXEDSONGSPICKED:
3258 iSongs = g_partyModeManager.GetRelaxedSongs();
3261 case MUSICPM_RANDOMSONGSPICKED:
3263 iSongs = g_partyModeManager.GetRandomSongs();
3269 CStdString strLabel;
3270 strLabel.Format("%i", iSongs);
3276 const CStdString CGUIInfoManager::GetMusicPlaylistInfo(const GUIInfo& info)
3278 PLAYLIST::CPlayList& playlist = g_playlistPlayer.GetPlaylist(PLAYLIST_MUSIC);
3279 if (playlist.size() < 1)
3281 int index = info.GetData2();
3282 if (info.GetData1() == 1)
3283 { // relative index (requires current playlist is PLAYLIST_MUSIC)
3284 if (g_playlistPlayer.GetCurrentPlaylist() != PLAYLIST_MUSIC)
3286 index = g_playlistPlayer.GetNextSong(index);
3288 if (index < 0 || index >= playlist.size())
3290 CFileItemPtr playlistItem = playlist[index];
3291 if (!playlistItem->GetMusicInfoTag()->Loaded())
3293 playlistItem->LoadMusicTag();
3294 playlistItem->GetMusicInfoTag()->SetLoaded();
3296 // try to set a thumbnail
3297 if (!playlistItem->HasArt("thumb"))
3299 CMusicThumbLoader loader;
3300 loader.LoadItem(playlistItem.get());
3301 // still no thumb? then just the set the default cover
3302 if (!playlistItem->HasArt("thumb"))
3303 playlistItem->SetArt("thumb", "DefaultAlbumCover.png");
3305 if (info.m_info == MUSICPLAYER_PLAYLISTPOS)
3307 CStdString strPosition = "";
3308 strPosition.Format("%i", index + 1);
3311 else if (info.m_info == MUSICPLAYER_COVER)
3312 return playlistItem->GetArt("thumb");
3313 return GetMusicTagLabel(info.m_info, playlistItem.get());
3316 CStdString CGUIInfoManager::GetPlaylistLabel(int item) const
3318 if (!g_application.IsPlaying()) return "";
3319 int iPlaylist = g_playlistPlayer.GetCurrentPlaylist();
3322 case PLAYLIST_LENGTH:
3324 CStdString strLength = "";
3325 strLength.Format("%i", g_playlistPlayer.GetPlaylist(iPlaylist).size());
3328 case PLAYLIST_POSITION:
3330 CStdString strPosition = "";
3331 strPosition.Format("%i", g_playlistPlayer.GetCurrentSong() + 1);
3334 case PLAYLIST_RANDOM:
3336 if (g_playlistPlayer.IsShuffled(iPlaylist))
3337 return g_localizeStrings.Get(590); // 590: Random
3339 return g_localizeStrings.Get(591); // 591: Off
3341 case PLAYLIST_REPEAT:
3343 PLAYLIST::REPEAT_STATE state = g_playlistPlayer.GetRepeat(iPlaylist);
3344 if (state == PLAYLIST::REPEAT_ONE)
3345 return g_localizeStrings.Get(592); // 592: One
3346 else if (state == PLAYLIST::REPEAT_ALL)
3347 return g_localizeStrings.Get(593); // 593: All
3349 return g_localizeStrings.Get(594); // 594: Off
3355 CStdString CGUIInfoManager::GetMusicLabel(int item)
3357 if (!g_application.IsPlaying() || !m_currentFile->HasMusicInfoTag()) return "";
3359 SPlayerAudioStreamInfo info;
3360 g_application.m_pPlayer->GetAudioStreamInfo(g_application.m_pPlayer->GetAudioStream(), info);
3364 case MUSICPLAYER_PLAYLISTLEN:
3366 if (g_playlistPlayer.GetCurrentPlaylist() == PLAYLIST_MUSIC)
3367 return GetPlaylistLabel(PLAYLIST_LENGTH);
3370 case MUSICPLAYER_PLAYLISTPOS:
3372 if (g_playlistPlayer.GetCurrentPlaylist() == PLAYLIST_MUSIC)
3373 return GetPlaylistLabel(PLAYLIST_POSITION);
3376 case MUSICPLAYER_BITRATE:
3378 float fTimeSpan = (float)(CTimeUtils::GetFrameTime() - m_lastMusicBitrateTime);
3379 if (fTimeSpan >= 500.0f)
3381 m_MusicBitrate = info.bitrate;
3382 m_lastMusicBitrateTime = CTimeUtils::GetFrameTime();
3384 CStdString strBitrate = "";
3385 if (m_MusicBitrate > 0)
3386 strBitrate.Format("%i", MathUtils::round_int((double)m_MusicBitrate / 1000.0));
3390 case MUSICPLAYER_CHANNELS:
3392 CStdString strChannels = "";
3393 if (info.channels > 0)
3395 strChannels.Format("%i", info.channels);
3400 case MUSICPLAYER_BITSPERSAMPLE:
3402 CStdString strBitsPerSample = "";
3403 if (g_application.m_pPlayer->GetBitsPerSample() > 0)
3405 strBitsPerSample.Format("%i", g_application.m_pPlayer->GetBitsPerSample());
3407 return strBitsPerSample;
3410 case MUSICPLAYER_SAMPLERATE:
3412 CStdString strSampleRate = "";
3413 if (g_application.m_pPlayer->GetSampleRate() > 0)
3415 strSampleRate.Format("%.5g", ((double)g_application.m_pPlayer->GetSampleRate() / 1000.0));
3417 return strSampleRate;
3420 case MUSICPLAYER_CODEC:
3422 CStdString strCodec;
3423 strCodec.Format("%s", info.audioCodecName);
3427 case MUSICPLAYER_LYRICS:
3428 return GetItemLabel(m_currentFile, AddListItemProp("lyrics"));
3430 return GetMusicTagLabel(item, m_currentFile);
3433 CStdString CGUIInfoManager::GetMusicTagLabel(int info, const CFileItem *item)
3435 if (!item->HasMusicInfoTag()) return "";
3436 const CMusicInfoTag &tag = *item->GetMusicInfoTag();
3439 case MUSICPLAYER_TITLE:
3440 if (tag.GetTitle().size()) { return tag.GetTitle(); }
3442 case MUSICPLAYER_ALBUM:
3443 if (tag.GetAlbum().size()) { return tag.GetAlbum(); }
3445 case MUSICPLAYER_ARTIST:
3446 if (tag.GetArtist().size()) { return StringUtils::Join(tag.GetArtist(), g_advancedSettings.m_musicItemSeparator); }
3448 case MUSICPLAYER_ALBUM_ARTIST:
3449 if (tag.GetAlbumArtist().size()) { return StringUtils::Join(tag.GetAlbumArtist(), g_advancedSettings.m_musicItemSeparator); }
3451 case MUSICPLAYER_YEAR:
3452 if (tag.GetYear()) { return tag.GetYearString(); }
3454 case MUSICPLAYER_GENRE:
3455 if (tag.GetGenre().size()) { return StringUtils::Join(tag.GetGenre(), g_advancedSettings.m_musicItemSeparator); }
3457 case MUSICPLAYER_LYRICS:
3458 if (tag.GetLyrics().size()) { return tag.GetLyrics(); }
3460 case MUSICPLAYER_TRACK_NUMBER:
3462 CStdString strTrack;
3463 if (tag.Loaded() && tag.GetTrackNumber() > 0)
3465 strTrack.Format("%02i", tag.GetTrackNumber());
3470 case MUSICPLAYER_DISC_NUMBER:
3471 return GetItemLabel(item, LISTITEM_DISC_NUMBER);
3472 case MUSICPLAYER_RATING:
3473 return GetItemLabel(item, LISTITEM_RATING);
3474 case MUSICPLAYER_COMMENT:
3475 return GetItemLabel(item, LISTITEM_COMMENT);
3476 case MUSICPLAYER_DURATION:
3477 return GetItemLabel(item, LISTITEM_DURATION);
3478 case MUSICPLAYER_CHANNEL_NAME:
3480 CPVRChannel* channeltag = m_currentFile->GetPVRChannelInfoTag();
3482 return channeltag->ChannelName();
3485 case MUSICPLAYER_CHANNEL_NUMBER:
3487 CPVRChannel* channeltag = m_currentFile->GetPVRChannelInfoTag();
3490 CStdString strNumber;
3491 strNumber.Format("%i", channeltag->ChannelNumber());
3496 case MUSICPLAYER_CHANNEL_GROUP:
3498 CPVRChannel* channeltag = m_currentFile->GetPVRChannelInfoTag();
3499 if (channeltag && channeltag->IsRadio())
3500 return g_PVRManager.GetPlayingGroup(true)->GroupName();
3503 case MUSICPLAYER_PLAYCOUNT:
3504 return GetItemLabel(item, LISTITEM_PLAYCOUNT);
3505 case MUSICPLAYER_LASTPLAYED:
3506 return GetItemLabel(item, LISTITEM_LASTPLAYED);
3511 CStdString CGUIInfoManager::GetVideoLabel(int item)
3513 if (!g_application.IsPlaying())
3516 if (item == VIDEOPLAYER_TITLE)
3518 if(g_application.IsPlayingVideo())
3519 return GetLabel(PLAYER_TITLE);
3521 else if (item == VIDEOPLAYER_PLAYLISTLEN)
3523 if (g_playlistPlayer.GetCurrentPlaylist() == PLAYLIST_VIDEO)
3524 return GetPlaylistLabel(PLAYLIST_LENGTH);
3526 else if (item == VIDEOPLAYER_PLAYLISTPOS)
3528 if (g_playlistPlayer.GetCurrentPlaylist() == PLAYLIST_VIDEO)
3529 return GetPlaylistLabel(PLAYLIST_POSITION);
3531 else if (m_currentFile->HasPVRChannelInfoTag())
3533 CPVRChannel* tag = m_currentFile->GetPVRChannelInfoTag();
3538 /* Now playing infos */
3539 case VIDEOPLAYER_ORIGINALTITLE:
3540 return tag->GetEPGNow(epgTag) ?
3542 g_guiSettings.GetBool("epg.hidenoinfoavailable") ?
3543 StringUtils::EmptyString :
3544 g_localizeStrings.Get(19055); // no information available
3545 case VIDEOPLAYER_GENRE:
3546 return tag->GetEPGNow(epgTag) ? StringUtils::Join(epgTag.Genre(), g_advancedSettings.m_videoItemSeparator) : StringUtils::EmptyString;
3547 case VIDEOPLAYER_PLOT:
3548 return tag->GetEPGNow(epgTag) ? epgTag.Plot() : StringUtils::EmptyString;
3549 case VIDEOPLAYER_PLOT_OUTLINE:
3550 return tag->GetEPGNow(epgTag) ? epgTag.PlotOutline() : StringUtils::EmptyString;
3551 case VIDEOPLAYER_STARTTIME:
3552 return tag->GetEPGNow(epgTag) ? epgTag.StartAsLocalTime().GetAsLocalizedTime("", false) : CDateTime::GetCurrentDateTime().GetAsLocalizedTime("", false);
3553 case VIDEOPLAYER_ENDTIME:
3554 return tag->GetEPGNow(epgTag) ? epgTag.EndAsLocalTime().GetAsLocalizedTime("", false) : CDateTime::GetCurrentDateTime().GetAsLocalizedTime("", false);
3556 /* Next playing infos */
3557 case VIDEOPLAYER_NEXT_TITLE:
3558 return tag->GetEPGNext(epgTag) ?
3560 g_guiSettings.GetBool("epg.hidenoinfoavailable") ?
3561 StringUtils::EmptyString :
3562 g_localizeStrings.Get(19055); // no information available
3563 case VIDEOPLAYER_NEXT_GENRE:
3564 return tag->GetEPGNext(epgTag) ? StringUtils::Join(epgTag.Genre(), g_advancedSettings.m_videoItemSeparator) : StringUtils::EmptyString;
3565 case VIDEOPLAYER_NEXT_PLOT:
3566 return tag->GetEPGNext(epgTag) ? epgTag.Plot() : StringUtils::EmptyString;
3567 case VIDEOPLAYER_NEXT_PLOT_OUTLINE:
3568 return tag->GetEPGNext(epgTag) ? epgTag.PlotOutline() : StringUtils::EmptyString;
3569 case VIDEOPLAYER_NEXT_STARTTIME:
3570 return tag->GetEPGNext(epgTag) ? epgTag.StartAsLocalTime().GetAsLocalizedTime("", false) : CDateTime::GetCurrentDateTime().GetAsLocalizedTime("", false);
3571 case VIDEOPLAYER_NEXT_ENDTIME:
3572 return tag->GetEPGNext(epgTag) ? epgTag.EndAsLocalTime().GetAsLocalizedTime("", false) : CDateTime::GetCurrentDateTime().GetAsLocalizedTime("", false);
3573 case VIDEOPLAYER_NEXT_DURATION:
3575 CStdString duration;
3576 if (tag->GetEPGNext(epgTag) && epgTag.GetDuration() > 0)
3577 duration = StringUtils::SecondsToTimeString(epgTag.GetDuration());
3581 case VIDEOPLAYER_PARENTAL_RATING:
3584 if (tag->GetEPGNow(epgTag) && epgTag.ParentalRating() > 0)
3585 rating.Format("%i", epgTag.ParentalRating());
3590 /* General channel infos */
3591 case VIDEOPLAYER_CHANNEL_NAME:
3592 return tag->ChannelName();
3593 case VIDEOPLAYER_CHANNEL_NUMBER:
3595 CStdString strNumber;
3596 strNumber.Format("%i", tag->ChannelNumber());
3599 case VIDEOPLAYER_CHANNEL_GROUP:
3601 if (tag && !tag->IsRadio())
3602 return g_PVRManager.GetPlayingGroup(false)->GroupName();
3606 else if (m_currentFile->HasVideoInfoTag())
3610 case VIDEOPLAYER_ORIGINALTITLE:
3611 return m_currentFile->GetVideoInfoTag()->m_strOriginalTitle;
3613 case VIDEOPLAYER_GENRE:
3614 return StringUtils::Join(m_currentFile->GetVideoInfoTag()->m_genre, g_advancedSettings.m_videoItemSeparator);
3616 case VIDEOPLAYER_DIRECTOR:
3617 return StringUtils::Join(m_currentFile->GetVideoInfoTag()->m_director, g_advancedSettings.m_videoItemSeparator);
3619 case VIDEOPLAYER_RATING:
3621 CStdString strRating;
3622 if (m_currentFile->GetVideoInfoTag()->m_fRating > 0.f)
3623 strRating.Format("%.1f", m_currentFile->GetVideoInfoTag()->m_fRating);
3627 case VIDEOPLAYER_RATING_AND_VOTES:
3629 CStdString strRatingAndVotes;
3630 if (m_currentFile->GetVideoInfoTag()->m_fRating > 0.f)
3632 if (m_currentFile->GetVideoInfoTag()->m_strVotes.IsEmpty())
3633 strRatingAndVotes.Format("%.1f", m_currentFile->GetVideoInfoTag()->m_fRating);
3635 strRatingAndVotes.Format("%.1f (%s %s)", m_currentFile->GetVideoInfoTag()->m_fRating, m_currentFile->GetVideoInfoTag()->m_strVotes, g_localizeStrings.Get(20350));
3637 return strRatingAndVotes;
3640 case VIDEOPLAYER_YEAR:
3643 if (m_currentFile->GetVideoInfoTag()->m_iYear > 0)
3644 strYear.Format("%i", m_currentFile->GetVideoInfoTag()->m_iYear);
3648 case VIDEOPLAYER_PREMIERED:
3651 if (m_currentFile->GetVideoInfoTag()->m_firstAired.IsValid())
3652 dateTime = m_currentFile->GetVideoInfoTag()->m_firstAired;
3653 else if (m_currentFile->GetVideoInfoTag()->m_premiered.IsValid())
3654 dateTime = m_currentFile->GetVideoInfoTag()->m_premiered;
3656 if (dateTime.IsValid())
3657 return dateTime.GetAsLocalizedDate();
3661 case VIDEOPLAYER_PLOT:
3662 return m_currentFile->GetVideoInfoTag()->m_strPlot;
3663 case VIDEOPLAYER_TRAILER:
3664 return m_currentFile->GetVideoInfoTag()->m_strTrailer;
3665 case VIDEOPLAYER_PLOT_OUTLINE:
3666 return m_currentFile->GetVideoInfoTag()->m_strPlotOutline;
3667 case VIDEOPLAYER_EPISODE:
3669 CStdString strEpisode;
3670 if (m_currentFile->GetVideoInfoTag()->m_iSpecialSortEpisode > 0)
3671 strEpisode.Format("S%i", m_currentFile->GetVideoInfoTag()->m_iSpecialSortEpisode);
3672 else if(m_currentFile->GetVideoInfoTag()->m_iEpisode > 0)
3673 strEpisode.Format("%i", m_currentFile->GetVideoInfoTag()->m_iEpisode);
3677 case VIDEOPLAYER_SEASON:
3679 CStdString strSeason;
3680 if (m_currentFile->GetVideoInfoTag()->m_iSpecialSortSeason > 0)
3681 strSeason.Format("%i", m_currentFile->GetVideoInfoTag()->m_iSpecialSortSeason);
3682 else if(m_currentFile->GetVideoInfoTag()->m_iSeason > 0)
3683 strSeason.Format("%i", m_currentFile->GetVideoInfoTag()->m_iSeason);
3687 case VIDEOPLAYER_TVSHOW:
3688 return m_currentFile->GetVideoInfoTag()->m_strShowTitle;
3690 case VIDEOPLAYER_STUDIO:
3691 return StringUtils::Join(m_currentFile->GetVideoInfoTag()->m_studio, g_advancedSettings.m_videoItemSeparator);
3692 case VIDEOPLAYER_COUNTRY:
3693 return StringUtils::Join(m_currentFile->GetVideoInfoTag()->m_country, g_advancedSettings.m_videoItemSeparator);
3694 case VIDEOPLAYER_MPAA:
3695 return m_currentFile->GetVideoInfoTag()->m_strMPAARating;
3696 case VIDEOPLAYER_TOP250:
3698 CStdString strTop250;
3699 if (m_currentFile->GetVideoInfoTag()->m_iTop250 > 0)
3700 strTop250.Format("%i", m_currentFile->GetVideoInfoTag()->m_iTop250);
3704 case VIDEOPLAYER_CAST:
3705 return m_currentFile->GetVideoInfoTag()->GetCast();
3706 case VIDEOPLAYER_CAST_AND_ROLE:
3707 return m_currentFile->GetVideoInfoTag()->GetCast(true);
3708 case VIDEOPLAYER_ARTIST:
3709 return StringUtils::Join(m_currentFile->GetVideoInfoTag()->m_artist, g_advancedSettings.m_videoItemSeparator);
3710 case VIDEOPLAYER_ALBUM:
3711 return m_currentFile->GetVideoInfoTag()->m_strAlbum;
3712 case VIDEOPLAYER_WRITER:
3713 return StringUtils::Join(m_currentFile->GetVideoInfoTag()->m_writingCredits, g_advancedSettings.m_videoItemSeparator);
3714 case VIDEOPLAYER_TAGLINE:
3715 return m_currentFile->GetVideoInfoTag()->m_strTagLine;
3716 case VIDEOPLAYER_LASTPLAYED:
3718 if (m_currentFile->GetVideoInfoTag()->m_lastPlayed.IsValid())
3719 return m_currentFile->GetVideoInfoTag()->m_lastPlayed.GetAsLocalizedDateTime();
3722 case VIDEOPLAYER_PLAYCOUNT:
3724 CStdString strPlayCount;
3725 if (m_currentFile->GetVideoInfoTag()->m_playCount > 0)
3726 strPlayCount.Format("%i", m_currentFile->GetVideoInfoTag()->m_playCount);
3727 return strPlayCount;
3734 int64_t CGUIInfoManager::GetPlayTime() const
3736 if (g_application.IsPlaying())
3738 int64_t lPTS = (int64_t)(g_application.GetTime() * 1000);
3739 if (lPTS < 0) lPTS = 0;
3745 CStdString CGUIInfoManager::GetCurrentPlayTime(TIME_FORMAT format) const
3747 if (format == TIME_FORMAT_GUESS && GetTotalPlayTime() >= 3600)
3748 format = TIME_FORMAT_HH_MM_SS;
3749 if (g_application.IsPlaying())
3750 return StringUtils::SecondsToTimeString((int)(GetPlayTime()/1000), format);
3754 CStdString CGUIInfoManager::GetCurrentSeekTime(TIME_FORMAT format) const
3756 if (format == TIME_FORMAT_GUESS && GetTotalPlayTime() >= 3600)
3757 format = TIME_FORMAT_HH_MM_SS;
3758 float time = GetTotalPlayTime() * g_application.GetSeekHandler()->GetPercent() * 0.01f;
3759 return StringUtils::SecondsToTimeString((int)time, format);
3762 int CGUIInfoManager::GetTotalPlayTime() const
3764 int iTotalTime = (int)g_application.GetTotalTime();
3765 return iTotalTime > 0 ? iTotalTime : 0;
3768 int CGUIInfoManager::GetPlayTimeRemaining() const
3770 int iReverse = GetTotalPlayTime() - (int)g_application.GetTime();
3771 return iReverse > 0 ? iReverse : 0;
3774 CStdString CGUIInfoManager::GetCurrentPlayTimeRemaining(TIME_FORMAT format) const
3776 if (format == TIME_FORMAT_GUESS && GetTotalPlayTime() >= 3600)
3777 format = TIME_FORMAT_HH_MM_SS;
3778 int timeRemaining = GetPlayTimeRemaining();
3779 if (timeRemaining && g_application.IsPlaying())
3780 return StringUtils::SecondsToTimeString(timeRemaining, format);
3784 void CGUIInfoManager::ResetCurrentItem()
3786 m_currentFile->Reset();
3787 m_currentMovieThumb = "";
3788 m_currentMovieDuration = "";
3791 void CGUIInfoManager::SetCurrentItem(CFileItem &item)
3796 SetCurrentSong(item);
3798 SetCurrentMovie(item);
3800 if (item.HasEPGInfoTag())
3801 *m_currentFile->GetEPGInfoTag() = *item.GetEPGInfoTag();
3802 else if (item.HasPVRChannelInfoTag())
3805 if (item.GetPVRChannelInfoTag()->GetEPGNow(tag))
3806 *m_currentFile->GetEPGInfoTag() = tag;
3810 NotifyObservers(ObservableMessageCurrentItem);
3813 void CGUIInfoManager::SetCurrentAlbumThumb(const CStdString thumbFileName)
3815 if (CFile::Exists(thumbFileName))
3816 m_currentFile->SetArt("thumb", thumbFileName);
3819 m_currentFile->SetArt("thumb", "");
3820 m_currentFile->FillInDefaultIcon();
3824 void CGUIInfoManager::SetCurrentSong(CFileItem &item)
3826 CLog::Log(LOGDEBUG,"CGUIInfoManager::SetCurrentSong(%s)",item.GetPath().c_str());
3827 *m_currentFile = item;
3829 m_currentFile->LoadMusicTag();
3830 if (m_currentFile->GetMusicInfoTag()->GetTitle().IsEmpty())
3832 // No title in tag, show filename only
3833 m_currentFile->GetMusicInfoTag()->SetTitle(CUtil::GetTitleFromPath(m_currentFile->GetPath()));
3835 m_currentFile->GetMusicInfoTag()->SetLoaded(true);
3837 // find a thumb for this file.
3838 if (m_currentFile->IsInternetStream())
3840 if (!g_application.m_strPlayListFile.IsEmpty())
3842 CLog::Log(LOGDEBUG,"Streaming media detected... using %s to find a thumb", g_application.m_strPlayListFile.c_str());
3843 CFileItem streamingItem(g_application.m_strPlayListFile,false);
3844 CMusicThumbLoader::FillThumb(streamingItem);
3845 if (streamingItem.HasArt("thumb"))
3846 m_currentFile->SetArt("thumb", streamingItem.GetArt("thumb"));
3851 CMusicThumbLoader loader;
3852 loader.LoadItem(m_currentFile);
3854 m_currentFile->FillInDefaultIcon();
3856 CMusicInfoLoader::LoadAdditionalTagInfo(m_currentFile);
3859 void CGUIInfoManager::SetCurrentMovie(CFileItem &item)
3861 CLog::Log(LOGDEBUG,"CGUIInfoManager::SetCurrentMovie(%s)",item.GetPath().c_str());
3862 *m_currentFile = item;
3864 /* also call GetMovieInfo() when a VideoInfoTag is already present or additional info won't be present in the tag */
3865 if (!m_currentFile->HasPVRChannelInfoTag())
3870 dbs.LoadVideoInfo(item.GetPath(), *m_currentFile->GetVideoInfoTag());
3875 // Find a thumb for this file.
3876 if (!item.HasArt("thumb"))
3878 CVideoThumbLoader loader;
3879 loader.LoadItem(m_currentFile);
3882 // find a thumb for this stream
3883 if (item.IsInternetStream())
3885 // case where .strm is used to start an audio stream
3886 if (g_application.IsPlayingAudio())
3888 SetCurrentSong(item);
3893 if (!g_application.m_strPlayListFile.IsEmpty())
3895 CLog::Log(LOGDEBUG,"Streaming media detected... using %s to find a thumb", g_application.m_strPlayListFile.c_str());
3896 CFileItem thumbItem(g_application.m_strPlayListFile,false);
3897 if (CVideoThumbLoader::FillThumb(thumbItem))
3898 item.SetArt("thumb", thumbItem.GetArt("thumb"));
3902 item.FillInDefaultIcon();
3903 m_currentMovieThumb = item.GetArt("thumb");
3906 string CGUIInfoManager::GetSystemHeatInfo(int info)
3908 if (CTimeUtils::GetFrameTime() - m_lastSysHeatInfoTime >= SYSHEATUPDATEINTERVAL)
3909 { // update our variables
3910 m_lastSysHeatInfoTime = CTimeUtils::GetFrameTime();
3912 g_cpuInfo.getTemperature(m_cpuTemp);
3913 m_gpuTemp = GetGPUTemperature();
3920 case SYSTEM_CPU_TEMPERATURE:
3921 return m_cpuTemp.IsValid() ? m_cpuTemp.ToString() : "?";
3923 case SYSTEM_GPU_TEMPERATURE:
3924 return m_gpuTemp.IsValid() ? m_gpuTemp.ToString() : "?";
3926 case SYSTEM_FAN_SPEED:
3927 text.Format("%i%%", m_fanSpeed * 2);
3929 case SYSTEM_CPU_USAGE:
3930 #if defined(TARGET_DARWIN) || defined(_WIN32)
3931 text.Format("%d%%", g_cpuInfo.getUsedPercentage());
3933 text.Format("%s", g_cpuInfo.GetCoresUsageString());
3940 CTemperature CGUIInfoManager::GetGPUTemperature()
3942 CStdString cmd = g_advancedSettings.m_gpuTempCmd;
3948 if (cmd.IsEmpty() || !(p = popen(cmd.c_str(), "r")))
3949 return CTemperature();
3951 ret = fscanf(p, "%d %c", &value, &scale);
3955 return CTemperature();
3957 if (scale == 'C' || scale == 'c')
3958 return CTemperature::CreateFromCelsius(value);
3959 if (scale == 'F' || scale == 'f')
3960 return CTemperature::CreateFromFahrenheit(value);
3961 return CTemperature();
3964 // Version string MUST NOT contain spaces. It is used
3965 // in the HTTP request user agent.
3966 CStdString CGUIInfoManager::GetVersion()
3970 tmp.Format("%d.%d%s Git:%s", VERSION_MAJOR, VERSION_MINOR, VERSION_TAG, GIT_REV);
3972 tmp.Format("%d.%d%s", VERSION_MAJOR, VERSION_MINOR, VERSION_TAG);
3977 CStdString CGUIInfoManager::GetBuild()
3980 tmp.Format("%s", __DATE__);
3984 void CGUIInfoManager::SetDisplayAfterSeek(unsigned int timeOut, int seekOffset)
3986 g_infoManager.m_performingSeek = false;
3989 m_AfterSeekTimeout = CTimeUtils::GetFrameTime() + timeOut;
3991 m_seekOffset = seekOffset;
3994 m_AfterSeekTimeout = 0;
3997 bool CGUIInfoManager::GetDisplayAfterSeek()
3999 if (CTimeUtils::GetFrameTime() < m_AfterSeekTimeout)
4005 CStdString CGUIInfoManager::GetAudioScrobblerLabel(int item)
4009 case AUDIOSCROBBLER_CONN_STATE:
4010 return CLastfmScrobbler::GetInstance()->GetConnectionState();
4012 case AUDIOSCROBBLER_SUBMIT_INT:
4013 return CLastfmScrobbler::GetInstance()->GetSubmitInterval();
4015 case AUDIOSCROBBLER_FILES_CACHED:
4016 return CLastfmScrobbler::GetInstance()->GetFilesCached();
4018 case AUDIOSCROBBLER_SUBMIT_STATE:
4019 return CLastfmScrobbler::GetInstance()->GetSubmitState();
4026 void CGUIInfoManager::Clear()
4028 CSingleLock lock(m_critInfo);
4029 for (unsigned int i = 0; i < m_bools.size(); ++i)
4033 m_skinVariableStrings.clear();
4036 void CGUIInfoManager::UpdateFPS()
4039 unsigned int curTime = CTimeUtils::GetFrameTime();
4041 float fTimeSpan = (float)(curTime - m_lastFPSTime);
4042 if (fTimeSpan >= 1000.0f)
4044 fTimeSpan /= 1000.0f;
4045 m_fps = m_frameCounter / fTimeSpan;
4046 m_lastFPSTime = curTime;
4051 int CGUIInfoManager::AddListItemProp(const CStdString &str, int offset)
4053 for (int i=0; i < (int)m_listitemProperties.size(); i++)
4054 if (m_listitemProperties[i] == str)
4055 return (LISTITEM_PROPERTY_START+offset + i);
4057 if (m_listitemProperties.size() < LISTITEM_PROPERTY_END - LISTITEM_PROPERTY_START)
4059 m_listitemProperties.push_back(str);
4060 return LISTITEM_PROPERTY_START + offset + m_listitemProperties.size() - 1;
4063 CLog::Log(LOGERROR,"%s - not enough listitem property space!", __FUNCTION__);
4067 int CGUIInfoManager::AddMultiInfo(const GUIInfo &info)
4069 // check to see if we have this info already
4070 for (unsigned int i = 0; i < m_multiInfo.size(); i++)
4071 if (m_multiInfo[i] == info)
4072 return (int)i + MULTI_INFO_START;
4073 // return the new offset
4074 m_multiInfo.push_back(info);
4075 int id = (int)m_multiInfo.size() + MULTI_INFO_START - 1;
4076 if (id > MULTI_INFO_END)
4077 CLog::Log(LOGERROR, "%s - too many multiinfo bool/labels in this skin", __FUNCTION__);
4081 int CGUIInfoManager::ConditionalStringParameter(const CStdString ¶meter, bool caseSensitive /*= false*/)
4083 // check to see if we have this parameter already
4084 for (unsigned int i = 0; i < m_stringParameters.size(); i++)
4085 if (parameter.Equals(m_stringParameters[i], caseSensitive))
4087 // return the new offset
4088 m_stringParameters.push_back(parameter);
4089 return (int)m_stringParameters.size() - 1;
4092 bool CGUIInfoManager::GetItemInt(int &value, const CGUIListItem *item, int info) const
4100 if (info >= LISTITEM_PROPERTY_START && info - LISTITEM_PROPERTY_START < (int)m_listitemProperties.size())
4101 { // grab the property
4102 CStdString property = m_listitemProperties[info - LISTITEM_PROPERTY_START];
4103 CStdString val = item->GetProperty(property).asString();
4110 case LISTITEM_PROGRESS:
4113 if (item->IsFileItem())
4115 const CFileItem *pItem = (const CFileItem *)item;
4116 if (pItem && pItem->HasPVRChannelInfoTag())
4119 if (pItem->GetPVRChannelInfoTag()->GetEPGNow(epgNow))
4120 value = (int) epgNow.ProgressPercentage();
4122 else if (pItem && pItem->HasEPGInfoTag())
4124 value = (int) pItem->GetEPGInfoTag()->ProgressPercentage();
4131 case LISTITEM_PERCENT_PLAYED:
4132 if (item->IsFileItem() && ((const CFileItem *)item)->HasVideoInfoTag() && ((const CFileItem *)item)->GetVideoInfoTag()->m_resumePoint.IsPartWay())
4133 value = (int)(100 * ((const CFileItem *)item)->GetVideoInfoTag()->m_resumePoint.timeInSeconds / ((const CFileItem *)item)->GetVideoInfoTag()->m_resumePoint.totalTimeInSeconds);
4134 else if (item->IsFileItem() && ((const CFileItem *)item)->HasPVRRecordingInfoTag() && ((const CFileItem *)item)->GetPVRRecordingInfoTag()->m_resumePoint.IsPartWay())
4135 value = (int)(100 * ((const CFileItem *)item)->GetPVRRecordingInfoTag()->m_resumePoint.timeInSeconds / ((const CFileItem *)item)->GetPVRRecordingInfoTag()->m_resumePoint.totalTimeInSeconds);
4145 CStdString CGUIInfoManager::GetItemLabel(const CFileItem *item, int info, CStdString *fallback)
4147 if (!item) return "";
4149 if (info >= CONDITIONAL_LABEL_START && info <= CONDITIONAL_LABEL_END)
4150 return GetSkinVariableString(info, false, item);
4152 if (info >= LISTITEM_PROPERTY_START + LISTITEM_ART_OFFSET && info - (LISTITEM_PROPERTY_START + LISTITEM_ART_OFFSET) < (int)m_listitemProperties.size())
4154 std::string art = m_listitemProperties[info - (LISTITEM_PROPERTY_START + LISTITEM_ART_OFFSET)];
4155 return item->GetArt(art);
4158 if (info >= LISTITEM_PROPERTY_START && info - LISTITEM_PROPERTY_START < (int)m_listitemProperties.size())
4159 { // grab the property
4160 CStdString property = m_listitemProperties[info - LISTITEM_PROPERTY_START];
4161 return item->GetProperty(property).asString();
4164 if (info >= LISTITEM_PICTURE_START && info <= LISTITEM_PICTURE_END && item->HasPictureInfoTag())
4165 return item->GetPictureInfoTag()->GetInfo(picture_slide_map[info - LISTITEM_PICTURE_START]);
4169 case LISTITEM_LABEL:
4170 return item->GetLabel();
4171 case LISTITEM_LABEL2:
4172 return item->GetLabel2();
4173 case LISTITEM_TITLE:
4174 if (item->HasPVRChannelInfoTag())
4177 return item->GetPVRChannelInfoTag()->GetEPGNow(epgTag) ?
4179 g_guiSettings.GetBool("epg.hidenoinfoavailable") ?
4180 StringUtils::EmptyString :
4181 g_localizeStrings.Get(19055); // no information available
4183 if (item->HasPVRRecordingInfoTag())
4184 return item->GetPVRRecordingInfoTag()->m_strTitle;
4185 if (item->HasEPGInfoTag())
4186 return item->GetEPGInfoTag()->Title();
4187 if (item->HasPVRTimerInfoTag())
4188 return item->GetPVRTimerInfoTag()->Title();
4189 if (item->HasVideoInfoTag())
4190 return item->GetVideoInfoTag()->m_strTitle;
4191 if (item->HasMusicInfoTag())
4192 return item->GetMusicInfoTag()->GetTitle();
4194 case LISTITEM_ORIGINALTITLE:
4195 if (item->HasVideoInfoTag())
4196 return item->GetVideoInfoTag()->m_strOriginalTitle;
4198 case LISTITEM_PLAYCOUNT:
4200 CStdString strPlayCount;
4201 if (item->HasVideoInfoTag() && item->GetVideoInfoTag()->m_playCount > 0)
4202 strPlayCount.Format("%i", item->GetVideoInfoTag()->m_playCount);
4203 if (item->HasMusicInfoTag() && item->GetMusicInfoTag()->GetPlayCount() > 0)
4204 strPlayCount.Format("%i", item->GetMusicInfoTag()->GetPlayCount());
4205 return strPlayCount;
4207 case LISTITEM_LASTPLAYED:
4210 if (item->HasVideoInfoTag())
4211 dateTime = item->GetVideoInfoTag()->m_lastPlayed;
4212 else if (item->HasMusicInfoTag())
4213 dateTime = item->GetMusicInfoTag()->GetLastPlayed();
4215 if (dateTime.IsValid())
4216 return dateTime.GetAsLocalizedDate();
4219 case LISTITEM_TRACKNUMBER:
4222 if (item->HasMusicInfoTag())
4223 track.Format("%i", item->GetMusicInfoTag()->GetTrackNumber());
4227 case LISTITEM_DISC_NUMBER:
4230 if (item->HasMusicInfoTag() && item->GetMusicInfoTag()->GetDiscNumber() > 0)
4231 disc.Format("%i", item->GetMusicInfoTag()->GetDiscNumber());
4234 case LISTITEM_ARTIST:
4235 if (item->HasVideoInfoTag())
4236 return StringUtils::Join(item->GetVideoInfoTag()->m_artist, g_advancedSettings.m_videoItemSeparator);
4237 if (item->HasMusicInfoTag())
4238 return StringUtils::Join(item->GetMusicInfoTag()->GetArtist(), g_advancedSettings.m_musicItemSeparator);
4240 case LISTITEM_ALBUM_ARTIST:
4241 if (item->HasMusicInfoTag())
4242 return StringUtils::Join(item->GetMusicInfoTag()->GetAlbumArtist(), g_advancedSettings.m_musicItemSeparator);
4244 case LISTITEM_DIRECTOR:
4245 if (item->HasVideoInfoTag())
4246 return StringUtils::Join(item->GetVideoInfoTag()->m_director, g_advancedSettings.m_videoItemSeparator);
4248 case LISTITEM_ALBUM:
4249 if (item->HasVideoInfoTag())
4250 return item->GetVideoInfoTag()->m_strAlbum;
4251 if (item->HasMusicInfoTag())
4252 return item->GetMusicInfoTag()->GetAlbum();
4255 if (item->HasVideoInfoTag())
4257 CStdString strResult;
4258 if (item->GetVideoInfoTag()->m_iYear > 0)
4259 strResult.Format("%i",item->GetVideoInfoTag()->m_iYear);
4262 if (item->HasMusicInfoTag())
4263 return item->GetMusicInfoTag()->GetYearString();
4265 case LISTITEM_PREMIERED:
4266 if (item->HasVideoInfoTag())
4269 if (item->GetVideoInfoTag()->m_firstAired.IsValid())
4270 dateTime = item->GetVideoInfoTag()->m_firstAired;
4271 else if (item->GetVideoInfoTag()->m_premiered.IsValid())
4272 dateTime = item->GetVideoInfoTag()->m_premiered;
4274 if (dateTime.IsValid())
4275 return dateTime.GetAsLocalizedDate();
4279 case LISTITEM_GENRE:
4280 if (item->HasVideoInfoTag())
4281 return StringUtils::Join(item->GetVideoInfoTag()->m_genre, g_advancedSettings.m_videoItemSeparator);
4282 if (item->HasMusicInfoTag())
4283 return StringUtils::Join(item->GetMusicInfoTag()->GetGenre(), g_advancedSettings.m_musicItemSeparator);
4284 if (item->HasPVRChannelInfoTag())
4287 return item->GetPVRChannelInfoTag()->GetEPGNow(epgTag) ? StringUtils::Join(epgTag.Genre(), g_advancedSettings.m_videoItemSeparator) : StringUtils::EmptyString;
4289 if (item->HasPVRRecordingInfoTag())
4290 return StringUtils::Join(item->GetPVRRecordingInfoTag()->m_genre, g_advancedSettings.m_videoItemSeparator);
4291 if (item->HasEPGInfoTag())
4292 return StringUtils::Join(item->GetEPGInfoTag()->Genre(), g_advancedSettings.m_videoItemSeparator);
4294 case LISTITEM_FILENAME:
4295 case LISTITEM_FILE_EXTENSION:
4298 if (item->IsMusicDb() && item->HasMusicInfoTag())
4299 strFile = URIUtils::GetFileName(item->GetMusicInfoTag()->GetURL());
4300 else if (item->IsVideoDb() && item->HasVideoInfoTag())
4301 strFile = URIUtils::GetFileName(item->GetVideoInfoTag()->m_strFileNameAndPath);
4303 strFile = URIUtils::GetFileName(item->GetPath());
4305 if (info==LISTITEM_FILE_EXTENSION)
4307 CStdString strExtension = URIUtils::GetExtension(strFile);
4308 return strExtension.TrimLeft(".");
4314 if (item->HasEPGInfoTag())
4315 return item->GetEPGInfoTag()->StartAsLocalTime().GetAsLocalizedDateTime(false, false);
4316 if (item->HasPVRChannelInfoTag())
4319 return item->GetPVRChannelInfoTag()->GetEPGNow(epgTag) ? epgTag.StartAsLocalTime().GetAsLocalizedDateTime(false, false) : CDateTime::GetCurrentDateTime().GetAsLocalizedDateTime(false, false);
4321 if (item->HasPVRRecordingInfoTag())
4322 return item->GetPVRRecordingInfoTag()->RecordingTimeAsLocalTime().GetAsLocalizedDateTime(false, false);
4323 if (item->HasPVRTimerInfoTag())
4324 return item->GetPVRTimerInfoTag()->Summary();
4325 if (item->m_dateTime.IsValid())
4326 return item->m_dateTime.GetAsLocalizedDate();
4329 if (!item->m_bIsFolder || item->m_dwSize)
4330 return StringUtils::SizeToString(item->m_dwSize);
4332 case LISTITEM_RATING:
4335 if (item->HasVideoInfoTag() && item->GetVideoInfoTag()->m_fRating > 0.f) // movie rating
4336 rating.Format("%.1f", item->GetVideoInfoTag()->m_fRating);
4337 else if (item->HasMusicInfoTag() && item->GetMusicInfoTag()->GetRating() > '0')
4338 { // song rating. Images will probably be better than numbers for this in the long run
4339 rating = item->GetMusicInfoTag()->GetRating();
4343 case LISTITEM_RATING_AND_VOTES:
4345 if (item->HasVideoInfoTag() && item->GetVideoInfoTag()->m_fRating > 0.f) // movie rating
4347 CStdString strRatingAndVotes;
4348 if (item->GetVideoInfoTag()->m_strVotes.IsEmpty())
4349 strRatingAndVotes.Format("%.1f", item->GetVideoInfoTag()->m_fRating);
4351 strRatingAndVotes.Format("%.1f (%s %s)", item->GetVideoInfoTag()->m_fRating, item->GetVideoInfoTag()->m_strVotes, g_localizeStrings.Get(20350));
4352 return strRatingAndVotes;
4356 case LISTITEM_PROGRAM_COUNT:
4359 count.Format("%i", item->m_iprogramCount);
4362 case LISTITEM_DURATION:
4364 CStdString duration;
4365 if (item->HasPVRChannelInfoTag())
4367 const CPVRChannel *channel = item->HasPVRChannelInfoTag() ? item->GetPVRChannelInfoTag() : NULL;
4369 if (channel && channel->GetEPGNow(tag))
4370 return StringUtils::SecondsToTimeString(tag.GetDuration());
4371 return StringUtils::EmptyString;
4373 else if (item->HasPVRRecordingInfoTag())
4375 if (item->GetPVRRecordingInfoTag()->GetDuration() > 0)
4376 duration = StringUtils::SecondsToTimeString(item->GetPVRRecordingInfoTag()->GetDuration());
4378 else if (item->HasEPGInfoTag())
4380 if (item->GetEPGInfoTag()->GetDuration() > 0)
4381 duration = StringUtils::SecondsToTimeString(item->GetEPGInfoTag()->GetDuration());
4383 else if (item->HasVideoInfoTag())
4385 if (item->GetVideoInfoTag()->GetDuration() > 0)
4386 duration.Format("%d", item->GetVideoInfoTag()->GetDuration() / 60);
4388 else if (item->HasMusicInfoTag())
4390 if (item->GetMusicInfoTag()->GetDuration() > 0)
4391 duration = StringUtils::SecondsToTimeString(item->GetMusicInfoTag()->GetDuration());
4396 if (item->HasPVRChannelInfoTag())
4398 const CPVRChannel *channel = item->HasPVRChannelInfoTag() ? item->GetPVRChannelInfoTag() : NULL;
4400 if (channel && channel->GetEPGNow(tag))
4402 return StringUtils::EmptyString;
4404 if (item->HasEPGInfoTag())
4405 return item->GetEPGInfoTag()->Plot();
4406 if (item->HasPVRRecordingInfoTag())
4407 return item->GetPVRRecordingInfoTag()->m_strPlot;
4408 if (item->HasVideoInfoTag())
4410 if (!(!item->GetVideoInfoTag()->m_strShowTitle.IsEmpty() && item->GetVideoInfoTag()->m_iSeason == -1)) // dont apply to tvshows
4411 if (item->GetVideoInfoTag()->m_playCount == 0 && !g_guiSettings.GetBool("videolibrary.showunwatchedplots"))
4412 return g_localizeStrings.Get(20370);
4414 return item->GetVideoInfoTag()->m_strPlot;
4417 case LISTITEM_PLOT_OUTLINE:
4418 if (item->HasPVRChannelInfoTag())
4420 const CPVRChannel *channel = item->HasPVRChannelInfoTag() ? item->GetPVRChannelInfoTag() : NULL;
4422 if (channel && channel->GetEPGNow(tag))
4423 return tag.PlotOutline();
4424 return StringUtils::EmptyString;
4426 if (item->HasEPGInfoTag())
4427 return item->GetEPGInfoTag()->PlotOutline();
4428 if (item->HasPVRRecordingInfoTag())
4429 return item->GetPVRRecordingInfoTag()->m_strPlotOutline;
4430 if (item->HasVideoInfoTag())
4431 return item->GetVideoInfoTag()->m_strPlotOutline;
4433 case LISTITEM_EPISODE:
4434 if (item->HasVideoInfoTag())
4436 CStdString strResult;
4437 if (item->GetVideoInfoTag()->m_iSpecialSortEpisode > 0)
4438 strResult.Format("S%d",item->GetVideoInfoTag()->m_iEpisode);
4439 else if (item->GetVideoInfoTag()->m_iEpisode > 0) // if m_iEpisode = -1 there's no episode detail
4440 strResult.Format("%d",item->GetVideoInfoTag()->m_iEpisode);
4444 case LISTITEM_SEASON:
4445 if (item->HasVideoInfoTag())
4447 CStdString strResult;
4448 if (item->GetVideoInfoTag()->m_iSpecialSortSeason > 0)
4449 strResult.Format("%d",item->GetVideoInfoTag()->m_iSpecialSortSeason);
4450 else if (item->GetVideoInfoTag()->m_iSeason > 0) // if m_iSeason = -1 there's no season detail
4451 strResult.Format("%d",item->GetVideoInfoTag()->m_iSeason);
4455 case LISTITEM_TVSHOW:
4456 if (item->HasVideoInfoTag())
4457 return item->GetVideoInfoTag()->m_strShowTitle;
4459 case LISTITEM_COMMENT:
4460 if (item->HasPVRTimerInfoTag())
4461 return item->GetPVRTimerInfoTag()->GetStatus();
4462 if (item->HasMusicInfoTag())
4463 return item->GetMusicInfoTag()->GetComment();
4465 case LISTITEM_ACTUAL_ICON:
4466 return item->GetIconImage();
4469 CStdString strThumb = item->GetArt("thumb");
4470 if (strThumb.IsEmpty())
4471 strThumb = item->GetIconImage();
4473 *fallback = item->GetIconImage();
4476 case LISTITEM_OVERLAY:
4477 return item->GetOverlayImage();
4478 case LISTITEM_THUMB:
4479 return item->GetArt("thumb");
4480 case LISTITEM_FOLDERPATH:
4481 return CURL(item->GetPath()).GetWithoutUserDetails();
4482 case LISTITEM_FOLDERNAME:
4486 if (item->IsMusicDb() && item->HasMusicInfoTag())
4487 URIUtils::GetDirectory(item->GetMusicInfoTag()->GetURL(), path);
4488 else if (item->IsVideoDb() && item->HasVideoInfoTag())
4490 if( item->m_bIsFolder )
4491 path = item->GetVideoInfoTag()->m_strPath;
4493 URIUtils::GetParentPath(item->GetVideoInfoTag()->m_strFileNameAndPath, path);
4496 URIUtils::GetParentPath(item->GetPath(), path);
4497 path = CURL(path).GetWithoutUserDetails();
4498 if (info==LISTITEM_FOLDERNAME)
4500 URIUtils::RemoveSlashAtEnd(path);
4501 path=URIUtils::GetFileName(path);
4506 case LISTITEM_FILENAME_AND_PATH:
4509 if (item->IsMusicDb() && item->HasMusicInfoTag())
4510 path = item->GetMusicInfoTag()->GetURL();
4511 else if (item->IsVideoDb() && item->HasVideoInfoTag())
4512 path = item->GetVideoInfoTag()->m_strFileNameAndPath;
4514 path = item->GetPath();
4515 path = CURL(path).GetWithoutUserDetails();
4519 case LISTITEM_PICTURE_PATH:
4520 if (item->IsPicture() && (!item->IsZIP() || item->IsRAR() || item->IsCBZ() || item->IsCBR()))
4521 return item->GetPath();
4523 case LISTITEM_STUDIO:
4524 if (item->HasVideoInfoTag())
4525 return StringUtils::Join(item->GetVideoInfoTag()->m_studio, g_advancedSettings.m_videoItemSeparator);
4527 case LISTITEM_COUNTRY:
4528 if (item->HasVideoInfoTag())
4529 return StringUtils::Join(item->GetVideoInfoTag()->m_country, g_advancedSettings.m_videoItemSeparator);
4532 if (item->HasVideoInfoTag())
4533 return item->GetVideoInfoTag()->m_strMPAARating;
4536 if (item->HasVideoInfoTag())
4537 return item->GetVideoInfoTag()->GetCast();
4539 case LISTITEM_CAST_AND_ROLE:
4540 if (item->HasVideoInfoTag())
4541 return item->GetVideoInfoTag()->GetCast(true);
4543 case LISTITEM_WRITER:
4544 if (item->HasVideoInfoTag())
4545 return StringUtils::Join(item->GetVideoInfoTag()->m_writingCredits, g_advancedSettings.m_videoItemSeparator);
4547 case LISTITEM_TAGLINE:
4548 if (item->HasVideoInfoTag())
4549 return item->GetVideoInfoTag()->m_strTagLine;
4551 case LISTITEM_TRAILER:
4552 if (item->HasVideoInfoTag())
4553 return item->GetVideoInfoTag()->m_strTrailer;
4555 case LISTITEM_TOP250:
4556 if (item->HasVideoInfoTag())
4558 CStdString strResult;
4559 if (item->GetVideoInfoTag()->m_iTop250 > 0)
4560 strResult.Format("%i",item->GetVideoInfoTag()->m_iTop250);
4564 case LISTITEM_SORT_LETTER:
4567 g_charsetConverter.wToUTF8(item->GetSortLabel().Left(1).ToUpper(), letter);
4571 case LISTITEM_VIDEO_CODEC:
4572 if (item->HasVideoInfoTag())
4573 return item->GetVideoInfoTag()->m_streamDetails.GetVideoCodec();
4575 case LISTITEM_VIDEO_RESOLUTION:
4576 if (item->HasVideoInfoTag())
4577 return CStreamDetails::VideoDimsToResolutionDescription(item->GetVideoInfoTag()->m_streamDetails.GetVideoWidth(), item->GetVideoInfoTag()->m_streamDetails.GetVideoHeight());
4579 case LISTITEM_VIDEO_ASPECT:
4580 if (item->HasVideoInfoTag())
4581 return CStreamDetails::VideoAspectToAspectDescription(item->GetVideoInfoTag()->m_streamDetails.GetVideoAspect());
4583 case LISTITEM_AUDIO_CODEC:
4584 if (item->HasVideoInfoTag())
4586 return item->GetVideoInfoTag()->m_streamDetails.GetAudioCodec();
4589 case LISTITEM_AUDIO_CHANNELS:
4590 if (item->HasVideoInfoTag())
4592 CStdString strResult;
4593 int iChannels = item->GetVideoInfoTag()->m_streamDetails.GetAudioChannels();
4595 strResult.Format("%i", iChannels);
4599 case LISTITEM_AUDIO_LANGUAGE:
4600 if (item->HasVideoInfoTag())
4601 return item->GetVideoInfoTag()->m_streamDetails.GetAudioLanguage();
4603 case LISTITEM_SUBTITLE_LANGUAGE:
4604 if (item->HasVideoInfoTag())
4605 return item->GetVideoInfoTag()->m_streamDetails.GetSubtitleLanguage();
4607 case LISTITEM_STARTTIME:
4608 if (item->HasPVRChannelInfoTag())
4610 const CPVRChannel *channel = item->HasPVRChannelInfoTag() ? item->GetPVRChannelInfoTag() : NULL;
4612 if (channel && channel->GetEPGNow(tag))
4613 return tag.StartAsLocalTime().GetAsLocalizedTime("", false);
4614 return CDateTime::GetCurrentDateTime().GetAsLocalizedTime("", false);
4616 if (item->HasEPGInfoTag())
4617 return item->GetEPGInfoTag()->StartAsLocalTime().GetAsLocalizedTime("", false);
4618 if (item->HasPVRTimerInfoTag())
4619 return item->GetPVRTimerInfoTag()->StartAsLocalTime().GetAsLocalizedTime("", false);
4620 if (item->HasPVRRecordingInfoTag())
4621 return item->GetPVRRecordingInfoTag()->RecordingTimeAsLocalTime().GetAsLocalizedTime("", false);
4622 if (item->m_dateTime.IsValid())
4623 return item->m_dateTime.GetAsLocalizedTime("", false);
4625 case LISTITEM_ENDTIME:
4626 if (item->HasPVRChannelInfoTag())
4628 const CPVRChannel *channel = item->HasPVRChannelInfoTag() ? item->GetPVRChannelInfoTag() : NULL;
4630 if (channel && channel->GetEPGNow(tag))
4631 return tag.EndAsLocalTime().GetAsLocalizedTime("", false);
4632 return CDateTime::GetCurrentDateTime().GetAsLocalizedTime("", false);
4634 if (item->HasEPGInfoTag())
4635 return item->GetEPGInfoTag()->EndAsLocalTime().GetAsLocalizedTime("", false);
4636 if (item->HasPVRTimerInfoTag())
4637 return item->GetPVRTimerInfoTag()->EndAsLocalTime().GetAsLocalizedTime("", false);
4639 case LISTITEM_STARTDATE:
4640 if (item->HasPVRChannelInfoTag())
4642 const CPVRChannel *channel = item->HasPVRChannelInfoTag() ? item->GetPVRChannelInfoTag() : NULL;
4644 if (channel && channel->GetEPGNow(tag))
4645 return tag.StartAsLocalTime().GetAsLocalizedDate(true);
4646 return CDateTime::GetCurrentDateTime().GetAsLocalizedDate(true);
4648 if (item->HasEPGInfoTag())
4649 return item->GetEPGInfoTag()->StartAsLocalTime().GetAsLocalizedDate(true);
4650 if (item->HasPVRTimerInfoTag())
4651 return item->GetPVRTimerInfoTag()->StartAsLocalTime().GetAsLocalizedDate(true);
4652 if (item->HasPVRRecordingInfoTag())
4653 return item->GetPVRRecordingInfoTag()->RecordingTimeAsLocalTime().GetAsLocalizedDate(true);
4654 if (item->m_dateTime.IsValid())
4655 return item->m_dateTime.GetAsLocalizedDate(true);
4657 case LISTITEM_ENDDATE:
4658 if (item->HasPVRChannelInfoTag())
4660 const CPVRChannel *channel = item->HasPVRChannelInfoTag() ? item->GetPVRChannelInfoTag() : NULL;
4662 if (channel && channel->GetEPGNow(tag))
4663 return tag.EndAsLocalTime().GetAsLocalizedDate(true);
4664 return CDateTime::GetCurrentDateTime().GetAsLocalizedDate(true);
4666 if (item->HasEPGInfoTag())
4667 return item->GetEPGInfoTag()->EndAsLocalTime().GetAsLocalizedDate(true);
4668 if (item->HasPVRTimerInfoTag())
4669 return item->GetPVRTimerInfoTag()->EndAsLocalTime().GetAsLocalizedDate(true);
4671 case LISTITEM_CHANNEL_NUMBER:
4674 if (item->HasPVRChannelInfoTag())
4675 number.Format("%i", item->GetPVRChannelInfoTag()->ChannelNumber());
4676 if (item->HasEPGInfoTag() && item->GetEPGInfoTag()->HasPVRChannel())
4677 number.Format("%i", item->GetEPGInfoTag()->PVRChannelNumber());
4678 if (item->HasPVRTimerInfoTag())
4679 number.Format("%i", item->GetPVRTimerInfoTag()->ChannelNumber());
4684 case LISTITEM_CHANNEL_NAME:
4685 if (item->HasPVRChannelInfoTag())
4686 return item->GetPVRChannelInfoTag()->ChannelName();
4687 if (item->HasEPGInfoTag() && item->GetEPGInfoTag()->HasPVRChannel())
4688 return item->GetEPGInfoTag()->PVRChannelName();
4689 if (item->HasPVRRecordingInfoTag())
4690 return item->GetPVRRecordingInfoTag()->m_strChannelName;
4691 if (item->HasPVRTimerInfoTag())
4692 return item->GetPVRTimerInfoTag()->ChannelName();
4694 case LISTITEM_NEXT_STARTTIME:
4696 const CPVRChannel *channel = item->HasPVRChannelInfoTag() ? item->GetPVRChannelInfoTag() : NULL;
4698 if (channel && channel->GetEPGNext(tag))
4699 return tag.StartAsLocalTime().GetAsLocalizedTime("", false);
4701 return CDateTime::GetCurrentDateTime().GetAsLocalizedTime("", false);
4702 case LISTITEM_NEXT_ENDTIME:
4704 const CPVRChannel *channel = item->HasPVRChannelInfoTag() ? item->GetPVRChannelInfoTag() : NULL;
4706 if (channel && channel->GetEPGNext(tag))
4707 return tag.EndAsLocalTime().GetAsLocalizedTime("", false);
4709 return CDateTime::GetCurrentDateTime().GetAsLocalizedTime("", false);
4710 case LISTITEM_NEXT_STARTDATE:
4712 const CPVRChannel *channel = item->HasPVRChannelInfoTag() ? item->GetPVRChannelInfoTag() : NULL;
4714 if (channel && channel->GetEPGNext(tag))
4715 return tag.StartAsLocalTime().GetAsLocalizedDate(true);
4717 return CDateTime::GetCurrentDateTime().GetAsLocalizedDate(true);
4718 case LISTITEM_NEXT_ENDDATE:
4720 const CPVRChannel *channel = item->HasPVRChannelInfoTag() ? item->GetPVRChannelInfoTag() : NULL;
4722 if (channel && channel->GetEPGNext(tag))
4723 return tag.EndAsLocalTime().GetAsLocalizedDate(true);
4725 return CDateTime::GetCurrentDateTime().GetAsLocalizedDate(true);
4726 case LISTITEM_NEXT_PLOT:
4728 const CPVRChannel *channel = item->HasPVRChannelInfoTag() ? item->GetPVRChannelInfoTag() : NULL;
4730 if (channel && channel->GetEPGNext(tag))
4733 return StringUtils::EmptyString;
4734 case LISTITEM_NEXT_PLOT_OUTLINE:
4736 const CPVRChannel *channel = item->HasPVRChannelInfoTag() ? item->GetPVRChannelInfoTag() : NULL;
4738 if (channel && channel->GetEPGNext(tag))
4739 return tag.PlotOutline();
4741 return StringUtils::EmptyString;
4742 case LISTITEM_NEXT_DURATION:
4744 const CPVRChannel *channel = item->HasPVRChannelInfoTag() ? item->GetPVRChannelInfoTag() : NULL;
4746 if (channel && channel->GetEPGNext(tag))
4747 return StringUtils::SecondsToTimeString(tag.GetDuration());
4749 return StringUtils::EmptyString;
4750 case LISTITEM_NEXT_GENRE:
4752 const CPVRChannel *channel = item->HasPVRChannelInfoTag() ? item->GetPVRChannelInfoTag() : NULL;
4754 if (channel && channel->GetEPGNext(tag))
4755 return StringUtils::Join(tag.Genre(), g_advancedSettings.m_videoItemSeparator);
4757 return StringUtils::EmptyString;
4758 case LISTITEM_NEXT_TITLE:
4760 const CPVRChannel *channel = item->HasPVRChannelInfoTag() ? item->GetPVRChannelInfoTag() : NULL;
4762 if (channel && channel->GetEPGNext(tag))
4765 return StringUtils::EmptyString;
4766 case LISTITEM_PARENTALRATING:
4769 if (item->HasEPGInfoTag() && item->GetEPGInfoTag()->ParentalRating() > 0)
4770 rating.Format("%i", item->GetEPGInfoTag()->ParentalRating());
4774 case LISTITEM_PERCENT_PLAYED:
4777 if (GetItemInt(val, item, info))
4780 str.Format("%d", val);
4785 case LISTITEM_DATE_ADDED:
4786 if (item->HasVideoInfoTag() && item->GetVideoInfoTag()->m_dateAdded.IsValid())
4787 return item->GetVideoInfoTag()->m_dateAdded.GetAsLocalizedDate();
4789 case LISTITEM_DBTYPE:
4790 if (item->HasVideoInfoTag())
4791 return item->GetVideoInfoTag()->m_type;
4794 if (item->HasVideoInfoTag())
4797 dbid.Format("%i", item->GetVideoInfoTag()->m_iDbId);
4800 if (item->HasMusicInfoTag())
4803 dbid.Format("%i", item->GetMusicInfoTag()->GetDatabaseId());
4811 CStdString CGUIInfoManager::GetItemImage(const CFileItem *item, int info, CStdString *fallback)
4813 if (info >= CONDITIONAL_LABEL_START && info <= CONDITIONAL_LABEL_END)
4814 return GetSkinVariableString(info, true, item);
4818 case LISTITEM_RATING: // old song rating format
4821 if (item->HasMusicInfoTag())
4823 rating.Format("songrating%c.png", item->GetMusicInfoTag()->GetRating());
4828 case LISTITEM_STAR_RATING:
4831 if (item->HasVideoInfoTag())
4832 { // rating for videos is assumed 0..10, so convert to 0..5
4833 rating.Format("rating%d.png", (long)((item->GetVideoInfoTag()->m_fRating * 0.5f) + 0.5f));
4835 else if (item->HasMusicInfoTag())
4837 rating.Format("rating%c.png", item->GetMusicInfoTag()->GetRating());
4842 } /* switch (info) */
4844 return GetItemLabel(item, info, fallback);
4847 bool CGUIInfoManager::GetItemBool(const CGUIListItem *item, int condition) const
4849 if (!item) return false;
4850 if (condition >= LISTITEM_PROPERTY_START && condition - LISTITEM_PROPERTY_START < (int)m_listitemProperties.size())
4851 { // grab the property
4852 CStdString property = m_listitemProperties[condition - LISTITEM_PROPERTY_START];
4853 return item->GetProperty(property).asBoolean();
4855 else if (condition == LISTITEM_ISPLAYING)
4857 if (item->HasProperty("playlistposition"))
4858 return (int)item->GetProperty("playlisttype").asInteger() == g_playlistPlayer.GetCurrentPlaylist() && (int)item->GetProperty("playlistposition").asInteger() == g_playlistPlayer.GetCurrentSong();
4859 else if (item->IsFileItem() && !m_currentFile->GetPath().IsEmpty())
4861 if (!g_application.m_strPlayListFile.IsEmpty())
4863 //playlist file that is currently playing or the playlistitem that is currently playing.
4864 return g_application.m_strPlayListFile.Equals(((const CFileItem *)item)->GetPath()) || m_currentFile->IsSamePath((const CFileItem *)item);
4866 return m_currentFile->IsSamePath((const CFileItem *)item);
4869 else if (condition == LISTITEM_ISSELECTED)
4870 return item->IsSelected();
4871 else if (condition == LISTITEM_IS_FOLDER)
4872 return item->m_bIsFolder;
4873 else if (condition == LISTITEM_IS_RESUMABLE)
4875 if (item->IsFileItem())
4877 if (((const CFileItem *)item)->HasVideoInfoTag())
4878 return ((const CFileItem *)item)->GetVideoInfoTag()->m_resumePoint.timeInSeconds > 0;
4879 else if (((const CFileItem *)item)->HasPVRRecordingInfoTag())
4880 return ((const CFileItem *)item)->GetPVRRecordingInfoTag()->m_resumePoint.timeInSeconds > 0;
4883 else if (item->IsFileItem())
4885 const CFileItem *pItem = (const CFileItem *)item;
4886 if (condition == LISTITEM_ISRECORDING)
4888 if (!g_PVRManager.IsStarted())
4891 if (pItem->HasPVRChannelInfoTag())
4893 return pItem->GetPVRChannelInfoTag()->IsRecording();
4895 else if (pItem->HasPVRTimerInfoTag())
4897 const CPVRTimerInfoTag *timer = pItem->GetPVRTimerInfoTag();
4899 return timer->IsRecording();
4901 else if (pItem->HasEPGInfoTag())
4903 CFileItemPtr timer = g_PVRTimers->GetTimerForEpgTag(pItem);
4904 if (timer && timer->HasPVRTimerInfoTag())
4905 return timer->GetPVRTimerInfoTag()->IsRecording();
4908 else if (condition == LISTITEM_HASTIMER)
4910 if (pItem->HasEPGInfoTag())
4912 CFileItemPtr timer = g_PVRTimers->GetTimerForEpgTag(pItem);
4913 if (timer && timer->HasPVRTimerInfoTag())
4914 return timer->GetPVRTimerInfoTag()->IsActive();
4917 else if (condition == LISTITEM_HAS_EPG)
4919 if (pItem->HasPVRChannelInfoTag())
4922 return pItem->GetPVRChannelInfoTag()->GetEPGNow(epgTag);
4926 return pItem->HasEPGInfoTag();
4929 else if (condition == LISTITEM_ISENCRYPTED)
4931 if (pItem->HasPVRChannelInfoTag())
4933 return pItem->GetPVRChannelInfoTag()->IsEncrypted();
4935 else if (pItem->HasEPGInfoTag() && pItem->GetEPGInfoTag()->HasPVRChannel())
4937 return pItem->GetEPGInfoTag()->ChannelTag()->IsEncrypted();
4945 void CGUIInfoManager::ResetCache()
4947 // reset any animation triggers as well
4948 m_containerMoves.clear();
4952 // Called from tuxbox service thread to update current status
4953 void CGUIInfoManager::UpdateFromTuxBox()
4955 if(g_tuxbox.vVideoSubChannel.mode)
4956 m_currentFile->GetVideoInfoTag()->m_strTitle = g_tuxbox.vVideoSubChannel.current_name;
4958 // Set m_currentMovieDuration
4959 if(!g_tuxbox.sCurSrvData.current_event_duration.IsEmpty() &&
4960 !g_tuxbox.sCurSrvData.next_event_description.IsEmpty() &&
4961 !g_tuxbox.sCurSrvData.current_event_duration.Equals("-") &&
4962 !g_tuxbox.sCurSrvData.next_event_description.Equals("-"))
4964 g_tuxbox.sCurSrvData.current_event_duration.Replace("(","");
4965 g_tuxbox.sCurSrvData.current_event_duration.Replace(")","");
4967 m_currentMovieDuration.Format("%s: %s %s (%s - %s)",
4968 g_localizeStrings.Get(180),
4969 g_tuxbox.sCurSrvData.current_event_duration,
4970 g_localizeStrings.Get(12391),
4971 g_tuxbox.sCurSrvData.current_event_time,
4972 g_tuxbox.sCurSrvData.next_event_time);
4976 if (!g_tuxbox.sCurSrvData.current_event_description.IsEmpty() &&
4977 !g_tuxbox.sCurSrvData.next_event_description.IsEmpty() &&
4978 !g_tuxbox.sCurSrvData.current_event_description.Equals("-") &&
4979 !g_tuxbox.sCurSrvData.next_event_description.Equals("-"))
4982 genre.Format("%s %s - (%s: %s)",
4983 g_localizeStrings.Get(143),
4984 g_tuxbox.sCurSrvData.current_event_description,
4985 g_localizeStrings.Get(209),
4986 g_tuxbox.sCurSrvData.next_event_description);
4987 m_currentFile->GetVideoInfoTag()->m_genre = StringUtils::Split(genre, g_advancedSettings.m_videoItemSeparator);
4990 //Set m_currentMovie.m_director
4991 if (!g_tuxbox.sCurSrvData.current_event_details.Equals("-") &&
4992 !g_tuxbox.sCurSrvData.current_event_details.IsEmpty())
4994 m_currentFile->GetVideoInfoTag()->m_director = StringUtils::Split(g_tuxbox.sCurSrvData.current_event_details, g_advancedSettings.m_videoItemSeparator);
4998 CStdString CGUIInfoManager::GetPictureLabel(int info)
5000 if (info == SLIDE_FILE_NAME)
5001 return GetItemLabel(m_currentSlide, LISTITEM_FILENAME);
5002 else if (info == SLIDE_FILE_PATH)
5005 URIUtils::GetDirectory(m_currentSlide->GetPath(), path);
5006 return CURL(path).GetWithoutUserDetails();
5008 else if (info == SLIDE_FILE_SIZE)
5009 return GetItemLabel(m_currentSlide, LISTITEM_SIZE);
5010 else if (info == SLIDE_FILE_DATE)
5011 return GetItemLabel(m_currentSlide, LISTITEM_DATE);
5012 else if (info == SLIDE_INDEX)
5014 CGUIWindowSlideShow *slideshow = (CGUIWindowSlideShow *)g_windowManager.GetWindow(WINDOW_SLIDESHOW);
5015 if (slideshow && slideshow->NumSlides())
5018 index.Format("%d/%d", slideshow->CurrentSlide(), slideshow->NumSlides());
5022 if (m_currentSlide->HasPictureInfoTag())
5023 return m_currentSlide->GetPictureInfoTag()->GetInfo(info);
5027 void CGUIInfoManager::SetCurrentSlide(CFileItem &item)
5029 if (m_currentSlide->GetPath() != item.GetPath())
5031 if (!item.GetPictureInfoTag()->Loaded()) // If picture metadata has not been loaded yet, load it now
5032 item.GetPictureInfoTag()->Load(item.GetPath());
5033 *m_currentSlide = item;
5037 void CGUIInfoManager::ResetCurrentSlide()
5039 m_currentSlide->Reset();
5042 bool CGUIInfoManager::CheckWindowCondition(CGUIWindow *window, int condition) const
5044 // check if it satisfies our condition
5045 if (!window) return false;
5046 if ((condition & WINDOW_CONDITION_HAS_LIST_ITEMS) && !window->HasListItems())
5048 if ((condition & WINDOW_CONDITION_IS_MEDIA_WINDOW) && !window->IsMediaWindow())
5053 CGUIWindow *CGUIInfoManager::GetWindowWithCondition(int contextWindow, int condition) const
5055 CGUIWindow *window = g_windowManager.GetWindow(contextWindow);
5056 if (CheckWindowCondition(window, condition))
5059 // try topmost dialog
5060 window = g_windowManager.GetWindow(g_windowManager.GetTopMostModalDialogID());
5061 if (CheckWindowCondition(window, condition))
5064 // try active window
5065 window = g_windowManager.GetWindow(g_windowManager.GetActiveWindow());
5066 if (CheckWindowCondition(window, condition))
5072 void CGUIInfoManager::SetCurrentVideoTag(const CVideoInfoTag &tag)
5074 *m_currentFile->GetVideoInfoTag() = tag;
5075 m_currentFile->m_lStartOffset = 0;
5078 void CGUIInfoManager::SetCurrentSongTag(const MUSIC_INFO::CMusicInfoTag &tag)
5080 //CLog::Log(LOGDEBUG, "Asked to SetCurrentTag");
5081 *m_currentFile->GetMusicInfoTag() = tag;
5082 m_currentFile->m_lStartOffset = 0;
5085 const CFileItem& CGUIInfoManager::GetCurrentSlide() const
5087 return *m_currentSlide;
5090 const MUSIC_INFO::CMusicInfoTag* CGUIInfoManager::GetCurrentSongTag() const
5092 if (m_currentFile->HasMusicInfoTag())
5093 return m_currentFile->GetMusicInfoTag();
5098 const CVideoInfoTag* CGUIInfoManager::GetCurrentMovieTag() const
5100 if (m_currentFile->HasVideoInfoTag())
5101 return m_currentFile->GetVideoInfoTag();
5106 void GUIInfo::SetInfoFlag(uint32_t flag)
5108 assert(flag >= (1 << 24));
5112 uint32_t GUIInfo::GetInfoFlag() const
5114 // we strip out the bottom 24 bits, where we keep data
5115 // and return the flag only
5116 return m_data1 & 0xff000000;
5119 uint32_t GUIInfo::GetData1() const
5121 // we strip out the top 8 bits, where we keep flags
5122 // and return the unflagged data
5123 return m_data1 & ((1 << 24) -1);
5126 int GUIInfo::GetData2() const
5131 void CGUIInfoManager::SetLibraryBool(int condition, bool value)
5135 case LIBRARY_HAS_MUSIC:
5136 m_libraryHasMusic = value ? 1 : 0;
5138 case LIBRARY_HAS_MOVIES:
5139 m_libraryHasMovies = value ? 1 : 0;
5141 case LIBRARY_HAS_MOVIE_SETS:
5142 m_libraryHasMovieSets = value ? 1 : 0;
5144 case LIBRARY_HAS_TVSHOWS:
5145 m_libraryHasTVShows = value ? 1 : 0;
5147 case LIBRARY_HAS_MUSICVIDEOS:
5148 m_libraryHasMusicVideos = value ? 1 : 0;
5155 void CGUIInfoManager::ResetLibraryBools()
5157 m_libraryHasMusic = -1;
5158 m_libraryHasMovies = -1;
5159 m_libraryHasTVShows = -1;
5160 m_libraryHasMusicVideos = -1;
5161 m_libraryHasMovieSets = -1;
5164 bool CGUIInfoManager::GetLibraryBool(int condition)
5166 if (condition == LIBRARY_HAS_MUSIC)
5168 if (m_libraryHasMusic < 0)
5173 m_libraryHasMusic = (db.GetSongsCount() > 0) ? 1 : 0;
5177 return m_libraryHasMusic > 0;
5179 else if (condition == LIBRARY_HAS_MOVIES)
5181 if (m_libraryHasMovies < 0)
5186 m_libraryHasMovies = db.HasContent(VIDEODB_CONTENT_MOVIES) ? 1 : 0;
5190 return m_libraryHasMovies > 0;
5192 else if (condition == LIBRARY_HAS_MOVIE_SETS)
5194 if (m_libraryHasMovieSets < 0)
5199 m_libraryHasMovieSets = db.HasSets() ? 1 : 0;
5203 return m_libraryHasMovieSets > 0;
5205 else if (condition == LIBRARY_HAS_TVSHOWS)
5207 if (m_libraryHasTVShows < 0)
5212 m_libraryHasTVShows = db.HasContent(VIDEODB_CONTENT_TVSHOWS) ? 1 : 0;
5216 return m_libraryHasTVShows > 0;
5218 else if (condition == LIBRARY_HAS_MUSICVIDEOS)
5220 if (m_libraryHasMusicVideos < 0)
5225 m_libraryHasMusicVideos = db.HasContent(VIDEODB_CONTENT_MUSICVIDEOS) ? 1 : 0;
5229 return m_libraryHasMusicVideos > 0;
5231 else if (condition == LIBRARY_HAS_VIDEO)
5233 return (GetLibraryBool(LIBRARY_HAS_MOVIES) ||
5234 GetLibraryBool(LIBRARY_HAS_TVSHOWS) ||
5235 GetLibraryBool(LIBRARY_HAS_MUSICVIDEOS));
5240 int CGUIInfoManager::RegisterSkinVariableString(const CSkinVariableString* info)
5245 CSingleLock lock(m_critInfo);
5246 m_skinVariableStrings.push_back(*info);
5248 return CONDITIONAL_LABEL_START + m_skinVariableStrings.size() - 1;
5251 int CGUIInfoManager::TranslateSkinVariableString(const CStdString& name, int context)
5253 for (vector<CSkinVariableString>::const_iterator it = m_skinVariableStrings.begin();
5254 it != m_skinVariableStrings.end(); ++it)
5256 if (it->GetName().Equals(name) && it->GetContext() == context)
5257 return it - m_skinVariableStrings.begin() + CONDITIONAL_LABEL_START;
5262 CStdString CGUIInfoManager::GetSkinVariableString(int info,
5263 bool preferImage /*= false*/,
5264 const CGUIListItem *item /*= NULL*/)
5266 info -= CONDITIONAL_LABEL_START;
5267 if (info >= 0 && info < (int)m_skinVariableStrings.size())
5268 return m_skinVariableStrings[info].GetValue(preferImage, item);
5273 bool CGUIInfoManager::ConditionsChangedValues(const std::map<int, bool>& map)
5275 for (std::map<int, bool>::const_iterator it = map.begin() ; it != map.end() ; it++)
5277 if (GetBoolValue(it->first) != it->second)
5283 bool CGUIInfoManager::GetEpgInfoTag(CEpgInfoTag& tag) const
5285 if (m_currentFile->HasEPGInfoTag())
5287 CEpgInfoTag* currentTag = m_currentFile->GetEPGInfoTag();
5288 while (currentTag && !currentTag->IsActive())
5289 currentTag = currentTag->GetNextEvent().get();