anchor.diff:      State#state{is_paused = not(queue:is_empty(State#state.queue))}.
   
   init(_Args) ->
  -    start_ticker(), %% always run the ticker, just reset it when we start a new song
       process_flag(trap_exit, true), %% so that we get an opportunity to run terminate().
       {ok, act_on(load_state())}.
   
  -start_ticker() ->
  -    register(ticker, spawn(fun () ->
  -          ticker(true)
  -      end)),
  -    ok.
  -
  -ticker(Tick) ->
  -    timer:sleep(1000),
  -    receive
  -        stop ->
  -            NewTick = false;
  -        continue ->
  -            NewTick = true
  -    after 0 ->
  -        NewTick = Tick
  -    end,
  -    if 
  -        NewTick ->
  -            gen_server:cast(player, elapsed_tick);
  -        true -> ok
  -    end,
  -    ticker(NewTick).
  +get_secs() ->
  +    {MegaSecs, Secs, _} = erlang:now(),
  +    MegaSecs * 1000000 + Secs.
   
   handle_call({enqueue, AtTop, Q}, _From, State) ->
       Q1 = expand_m3us_and_cache(Q),
  
positive.code:     {reply, {ok, SkippedEntry, summarise_state(NewState)}, NewState};
  handle_call({pause, On}, _From, State) ->
      case State#state.status of
  	{playing, PlayerPid} -> send_pause(PlayerPid, On);
  	_ -> ok
      end,
      act_and_reply(State#state{is_paused = On});
  handle_call(clear_queue, _From, State) ->
      act_and_reply(State#state{queue = queue:new()}).
  
  handle_cast(elapsed_tick, State) ->
      NewState = State#state{elapsed_time = State#state.elapsed_time + 1},
      {noreply, NewState};
  handle_cast(_Message, State) ->
      {noreply, State}.
  
  
negative.code: 	    State#state{status = cache(Url, IsPaused),
  			current_entry = Entry,
  			queue = TQ1,
              elapsed_acc = 0,
              last_et_event = get_secs()}
      end;
  act_on(State) -> State.
  
  summarise_state(State = #state{queue = Q, current_entry = Entry, is_paused = IsPaused,
                                 elapsed_acc = ElapsedAcc, last_et_event = LastEtEvent}) ->
      StatusSymbol = case State#state.status of
  		       idle -> idle;
  		       {Other, _PlayerDetails} -> Other
  		   end,
      case IsPaused of
          true ->
              Elapsed = ElapsedAcc;
          false ->
              Elapsed = ElapsedAcc + get_secs() - LastEtEvent
      end,
      {StatusSymbol, Q, Entry, IsPaused, Elapsed}.
  
  act_and_reply(State) ->
      State1 = act_on(State),
  