/*  Part of XPCE --- The SWI-Prolog GUI toolkit

    Author:        Jan Wielemaker and Anjo Anjewierden
    E-mail:        jan@swi.psy.uva.nl
    WWW:           http://www.swi.psy.uva.nl/projects/xpce/
    Copyright (c)  2005-2011, University of Amsterdam
    All rights reserved.

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
    are met:

    1. Redistributions of source code must retain the above copyright
       notice, this list of conditions and the following disclaimer.

    2. Redistributions in binary form must reproduce the above copyright
       notice, this list of conditions and the following disclaimer in
       the documentation and/or other materials provided with the
       distribution.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    POSSIBILITY OF SUCH DAMAGE.
*/

:- module(pce_progress,
          [ progress_checklist/3        % :Goal, +List, +Title
          ]).
:- meta_predicate(progress_checklist(:,+,+)).

:- use_module(library(pce)).
:- use_module(library(lists)).

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
This module defines primitives for progress-bars.  Classes:

        * progress_bar
        Creates a progress bar with given length and scale (=100% value).
        User must supply the current value using ->value.  The latter
        forces a display synchronisation.

        * listening_progress_bar
        Similar to class progress_bar, but designed to interact with
        procedures using the broadcasting service to send the current
        value.  The advantage of this approach is that the computing
        routine need not know whether there is a progress bar associated
        to it.  The `Id' argument denotes the progress bar.  The cumputing
        routine must use the following broadcast messages:

                broadcast(progress(Id, start(Scale)))
                broadcast(progress(Id, at(Here)))

        The first one indicates the start and defines the length of the
        scale (a number).  The second must be send repeatetly to update
        the value.  When using a background thread, use

                in_pce_thread(broadcast(progress(Id, at(Here))))

        * progress_dialog
        Dialog to act as placeholder for one or more progress-bars.  Of
        course they can also be placed in a custom dialog.

EXAMPLE:

        new(B, listening_progress_bar(progress, read_file)),
        new(D, progress_dialog('Processing file', B)),
        send(D, open),
        process_file(File),
        send(D, destroy).

process_file(File) :-
        size_file(File, Size),
        broadcast(progress(read_file, start(Size))),
        open(File, read, In),
        ....
        character_count(In, Here),
        broadcast(progress(read_file, at(Here)),
        ....

BUGS:

There is some code dealing with aborting  the slow task. This however is
not completed. I do not yet have a  clear view on how to implement that.
One option is to  raise  an  exception   on  the  next  update, but this
wouldn't work using the background thread id.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

:- pce_begin_class(progress_bar, label_box,
                   "Show progress to the user").

variable(scale,  'int|real',      get, "100% value").
variable(value,  'int|real' := 0, get, "Current value").
variable(length, int,             get, "Width of the slider-part").

class_variable(length,     int,    200).
class_variable(bar_colour, colour, mediumblue).

initialise(PB, Name:name=[name],
           Scale:scale=[int|real], Length:length='[0..]') :->
    send_super(PB, initialise, Name),
    default(Scale, 100, TheScale),
    (   Length \== @default
    ->  send(PB, slot, length, Length)
    ;   true
    ),
    send(PB, scale, TheScale),
    send(PB, solid, @on),
    (   Name == @default
    ->  send(PB, show_label, @off),
        send(PB, reference, point(0,PB?height))
    ;   true
    ).

bar(PB, Bar:box) :<-
    "Get access to the box realising the bar"::
    get(PB, member, figure, Fig1),
    get(Fig1, member, figure, Fig2),
    get(Fig2, member, box, Bar).

scale(PB, Scale:[int|real]) :->
    "Set the scale"::
    send(PB, slot, scale, Scale),
    send(PB, clear),
    get(PB, bar_colour, C),
    send(PB, append, new(F, figure)),
    get(PB, label_font, LF),
    get(LF, descent, Descent),
    send(F, attribute, reference, point(0, 20-Descent-2)),
    send(F, elevation, elevation(@nil, -1, white, background := C)),
    get(PB, length, Len),
    Height = 20,
    send(F, display, graphical(0,0,Len,Height)),
    send(F, display, new(F2, figure)),
    send(F2, border, 1),
    send(F2, background, C),
    send(F2, elevation, elevation(@nil, 1)),
    send(F2, display, new(B, box(0,Height-4)), point(2,2)),
    send(B, pen, 0),
    send(B, fill_pattern, C).

value(BP, Val:[int|real]) :->
    "Set progress"::
    (   get(BP, value, Val)
    ->  true
    ;   send(BP, slot, value, Val),
        get(BP, bar, Box),
        get(BP, length, Len),
        get(BP, scale, Scale),
        PixVal is round((Len-4)*(Val/Scale)),
        send(Box, width, PixVal)
    ),
    send(BP, synchronise).          % Flush?

open(BP) :->
    "Open on behalf of a client"::
    new(D, progress_dialog(BP, BP?name)),
    send(D, open).

:- pce_end_class(progress_bar).


:- pce_begin_class(listening_progress_bar, progress_bar,
                   "Progress bar listening to broadcast messages").

initialise(PB, Name:name=[name],
           Id:prolog, Length:length='[0..]') :->
    send_super(PB, initialise, Name),
    (   Length \== @default
    ->  send(PB, slot, length, Length)
    ;   true
    ),
    send(PB, scale, 100),
    send(PB, solid, @on),
    (   Name == @default
    ->  send(PB, show_label, @off),
        send(PB, reference, point(0,PB?height))
    ;   true
    ),
    listen(PB, progress(Id, Message),
           send(PB, progress, Message)).

unlink(PB) :->
    unlisten(PB),
    send_super(PB, unlink).

id(PB, Id:prolog) :->
    "Prepare to listen to another channal"::
    unlisten(PB),
    listen(PB, progress(Id, Message),
           send(PB, progress, Message)),
    send(PB, value, 0).

progress(PB, Message:prolog) :->
    (   Message = start(Scale)
    ->  send(PB, scale, Scale)
    ;   Message = at(Here)
    ->  send(PB, value, Here)
    ;   true
    ).

:- pce_end_class(listening_progress_bar).



:- pce_begin_class(progress_dialog, dialog,
                   "Dialog for monitoring progress").

variable(can_abort, bool := @off, both, "Can user abort progress?").

initialise(PD, Title:name, PBS:progress_bar ...) :->
    send_super(PD, initialise, Title?label_name),
    (   PBS = [One]
    ->  send(One, show_label, @off),
        send(PD, append, One)
    ;   forall(member(PB, PBS), send(PD, append, PB))
    ),
    send(PD, done_message, message(PD, abort)),
    (   CanAbort == @on
    ->  send(PD, can_abort, CanAbort)
    ;   true
    ).

open(PD) :->
    "Make transient for current frame"::
    send(PD, update_can_abort),
    (   send(@event, instance_of, event),
        get(@event?window, frame, Frame)
    ->  send(PD, transient_for, Frame),
        send(PD, open_centered, Frame?area?center)
    ;   send(PD, open_centered)
    ),
    send(PD, wait).

resize(PD) :->
    send(PD, layout, PD?area?size).

update_can_abort(PD) :->
    (   get(PD, can_abort, @on)
    ->  (   get(PD, member, abort, _)
        ->  true
        ;   send(PD, append, new(B, button(abort))),
            send(B, alignment, right)
        )
    ;   (   get(PD, member, abort, B)
        ->  free(B)
        ;   true
        )
    ).

abort(PD) :->
    (   get(PD, can_abort, @on)
    ->  send(PD, destroy)
    ;   send(PD, report, warning, 'Cannot abort')
    ).

:- pce_end_class(progress_dialog).


                 /*******************************
                 *  HIGH-LEVEL PROLOG INTERFACE *
                 *******************************/

%!  progress_checklist(:Goal, +List, +Options)
%
%   As checklist/2, but show a progress-bar while processing the
%   elements of the list.

progress_checklist(Goal, List, Options) :-
    strip_module(Goal, M, G),
    do_progress_checklist(M:G, List, Options).

do_progress_checklist(Goal, List, Options) :-
    length(List, Len),
    UpdateStep is max(1, Len//100),
    option(title(Title), Options, progress),
    option(abort(Abort), Options, @off),
    new(PD, progress_dialog(Title,
                            new(PB, progress_bar(Title, Len)))),
    send(PD, can_abort, Abort),
    send(PD, open),
    (   catch(pchecklist(List, Goal, 0, UpdateStep, PB),
              E, true)
    ->  premove(PB),
        (   nonvar(E)
        ->  (   E = error(existence_error(pce(object), PB), _Context)
            ->  throw(aborted)
            ;   throw(E)
            )
        ;   true
        )
    ;   premove(PB),
        fail
    ).

option(Term, List, _Default) :-
    memberchk(Term, List),
    !.
option(Term, _, Default) :-
    arg(1, Term, Default).

premove(PB) :-
    object(PB),
    !,
    send(PB?frame, destroy).
premove(_).


pchecklist([], _, _, _, _).
pchecklist([Elem|Tail], Goal, N, Step, PB) :-
    call(Goal, Elem),
    NN is N + 1,
    (   0 =:= NN mod Step
    ->  send(PB, value, NN)
    ;   true
    ),
    pchecklist(Tail, Goal, NN, Step, PB).


