internal double ReturnValue(MeasureType type)
        {
            switch (type)
            {
            case MeasureType.Duration:
                return(MediaMonkey.Duration());

            case MeasureType.FileID:
                return(MediaMonkey.FileID());

            case MeasureType.Position:
                return(MediaMonkey.Position());

            case MeasureType.Progress:
                return(MediaMonkey.Progress());

            case MeasureType.Rating:
                int    mmRating = MediaMonkey.Rating();
                double Stars    = MediaMonkeyRatingToStars(mmRating);

                if (Stars == -2.0)
                {
                    API.Log(API.LogType.Error, "MediaMonkey.dll: Invalid was returned for Rating =" + mmRating);
                    return(0.0);
                }
                else
                {
                    return(Stars);
                }

            case MeasureType.Repeat:
                return(MediaMonkey.IsRepeat() ? 1.0 : 0.0);

            case MeasureType.Shuffle:
                return(MediaMonkey.IsShuffle() ? 1.0 : 0.0);

            case MeasureType.State:
                if (MediaMonkey.IsPlaying())
                {
                    return(MediaMonkey.IsPaused() ? 2.0 : 1.0);
                }
                else
                {
                    return((double)0.0);
                }

            case MeasureType.Status:
                return(MediaMonkey.IsRunning() ? 1.0 : 0.0);

            case MeasureType.Volume:
                return(MediaMonkey.Volume());

            case MeasureType.Year:
                return(MediaMonkey.Year());

            default:
                break;
            }
            return(0.0);
        }
        internal void DecreaseVolume(int Volume)
        {
            //Decreases Player volume by the passed percentage

            int CurrentVolume = MediaMonkey.Volume();

            MediaMonkey.SetVolume((CurrentVolume - Volume));
        }
        internal override void ExecuteBang(string args)
        {
            //Some bangs pass multiple parameters, only the first one is
            //needed to identify the correct bang
            string[] argsArray = args.Split(' ');

            switch (argsArray[0].ToLowerInvariant())
            {
            case "play":
                MediaMonkey.Play();
                break;

            case "pause":
                MediaMonkey.Pause();
                break;

            case "playpause":
                MediaMonkey.PlayPause();
                break;

            case "stop":
                MediaMonkey.Stop();
                break;

            case "previous":
                MediaMonkey.Previous();
                break;

            case "next":
                MediaMonkey.Next();
                break;

            case "openplayer":
                MediaMonkey.OpenPlayer();
                break;

            case "closeplayer":
                MediaMonkey.ClosePlayer();
                break;

            case "toggleplayer":
                MediaMonkey.TogglePlayer();
                break;

            case "setrating":
                double argsRating;

                if (double.TryParse(argsArray[1], out argsRating))
                {
                    int mmRating = StarsToMediaMonkeyRating(argsRating);

                    if (mmRating == -2)
                    {
                        API.Log(API.LogType.Error, "MediaMonkey.dll: Invalid parameter for SetRating =" + argsArray[1]);
                    }
                    else
                    {
                        API.Log(API.LogType.Error, "MediaMonkey.dll: call SetRating =" + mmRating);
                        MediaMonkey.SetRating(mmRating);
                    }
                }
                else
                {
                    API.Log(API.LogType.Error, "MediaMonkey.dll: Invalid parameter for SetRating =" + argsArray[1]);
                }
                break;

            case "setposition":
                int argsPosition;

                if (int.TryParse(argsArray[1], out argsPosition))
                {
                    MediaMonkey.SetPosition(argsPosition);
                }
                else
                {
                    API.Log(API.LogType.Error, "MediaMonkey.dll: Invalid parameter for SetPosition =" + argsArray[1]);
                }
                break;

            case "setshuffle":
                int argsShuffle;

                if (int.TryParse(argsArray[1], out argsShuffle))
                {
                    switch (argsShuffle)
                    {
                    case -1:
                    case 0:
                    case 1:
                        MediaMonkey.SetShuffle(argsShuffle);
                        break;

                    default:
                        API.Log(API.LogType.Error, "MediaMonkey.dll: Invalid parameter for SetShuffle =" + argsArray[1]);
                        break;
                    }
                }
                else
                {
                    API.Log(API.LogType.Error, "MediaMonkey.dll: Invalid parameter for SetShuffle =" + argsArray[1]);
                }
                break;

            case "setrepeat":
                int argsRepeat;

                if (int.TryParse(argsArray[1], out argsRepeat))
                {
                    switch (argsRepeat)
                    {
                    case -1:
                    case 0:
                    case 1:
                        MediaMonkey.SetRepeat(argsRepeat);
                        break;

                    default:
                        API.Log(API.LogType.Error, "MediaMonkey.dll: Invalid parameter for SetRepeat =" + argsArray[1]);
                        break;
                    }
                }
                else
                {
                    API.Log(API.LogType.Error, "MediaMonkey.dll: Invalid parameter for SetRepeat =" + argsArray[1]);
                }
                break;

            case "setvolume":
                int argsVolume;

                Match VolumeRegex = Regex.Match(argsArray[1], "([+-]?)(\\d+)");

                if (int.TryParse(VolumeRegex.Groups[2].Value, out argsVolume))
                {
                    if (VolumeRegex.Groups[1].Value == "")
                    {
                        MediaMonkey.SetVolume(argsVolume);
                    }
                    else if (VolumeRegex.Groups[1].Value == "+")
                    {
                        IncreaseVolume(argsVolume);
                    }
                    else if (VolumeRegex.Groups[1].Value == "-")
                    {
                        DecreaseVolume(argsVolume);
                    }
                    else
                    {
                        API.Log(API.LogType.Error, "MediaMonkey.dll: Invalid parameter for SetVolume =" + argsArray[1]);
                    }
                }
                else
                {
                    API.Log(API.LogType.Error, "MediaMonkey.dll: Invalid parameter for SetVolume =" + argsArray[1]);
                }



                break;
            }
        }
        internal string ReturnString(MeasureType type)
        {
            switch (type)
            {
            case MeasureType.Album:
                return(MediaMonkey.Album());

            case MeasureType.AlbumArtist:
                return(MediaMonkey.AlbumArtist());

            case MeasureType.Artist:
                return(MediaMonkey.Artist());

            case MeasureType.Composer:
                return(MediaMonkey.Composer());

            case MeasureType.Conductor:
                return(MediaMonkey.Conductor());

            case MeasureType.Cover:
                EnableArtUpdate = true;
                return(MediaMonkey.Cover());

            case MeasureType.Custom1:
                return(MediaMonkey.Custom1());

            case MeasureType.Custom2:
                return(MediaMonkey.Custom2());

            case MeasureType.Custom3:
                return(MediaMonkey.Custom3());

            case MeasureType.Custom4:
                return(MediaMonkey.Custom4());

            case MeasureType.Custom5:
                return(MediaMonkey.Custom5());

            case MeasureType.Disc:
                return(MediaMonkey.Disc());

            case MeasureType.Duration:
                TimeSpan mmDuration = TimeSpan.FromSeconds(MediaMonkey.Duration());

                string mmDurationFormat;

                if (DisableLeadingZero)
                {
                    mmDurationFormat = mmDuration.ToString(@"m\:ss");
                }
                else
                {
                    mmDurationFormat = mmDuration.ToString(@"mm\:ss");
                }

                return(mmDurationFormat);

            case MeasureType.File:
                return(MediaMonkey.File());

            case MeasureType.FileID:
                return(MediaMonkey.FileID().ToString());


            case MeasureType.Genre:
                return(MediaMonkey.Genre());

            case MeasureType.Grouping:
                return(MediaMonkey.Grouping());

            case MeasureType.Number:
                return(MediaMonkey.Number());

            case MeasureType.Position:
                TimeSpan mmPosition       = TimeSpan.FromSeconds(MediaMonkey.Position());
                string   mmPositionFormat = DisableLeadingZero ? mmPosition.ToString(@"m\:ss") : mmPosition.ToString(@"mm\:ss");

                return(mmPositionFormat);

            case MeasureType.Progress:
                return(MediaMonkey.Progress().ToString());

            case MeasureType.Publisher:
                return(MediaMonkey.Publisher());

            case MeasureType.Rating:
                int    mmRating = MediaMonkey.Rating();
                double Stars    = MediaMonkeyRatingToStars(mmRating);

                if (Stars == -2.0)
                {
                    return("");
                }
                else
                {
                    return(Stars.ToString());
                }

            case MeasureType.Repeat:
                return(MediaMonkey.IsRepeat() ? "1" : "0");

            case MeasureType.Shuffle:
                return(MediaMonkey.IsShuffle() ? "1" : "0");

            case MeasureType.State:
                if (MediaMonkey.IsPlaying())
                {
                    return(MediaMonkey.IsPaused() ? "2" : "1");
                }
                else
                {
                    return("0");
                }

            case MeasureType.Status:
                return(MediaMonkey.IsRunning() ? "1" : "0");

            case MeasureType.Title:
                return(MediaMonkey.Title());

            case MeasureType.Volume:
                return(MediaMonkey.Volume().ToString());

            case MeasureType.Year:
                return(MediaMonkey.Year().ToString());

            default:
                break;
            }

            return("");
        }
 internal override double Update()
 {
     MediaMonkey.Update(EnableArtUpdate);
     return(ReturnValue(Type));
 }