Assignment 3: piggy stack Solution

This  assignment    continues    with    subclassing    and    callbacks.       Its    major    purposes    are    to    have    you    to    stress    your    understanding    of    how    to    arrange    code    (specifically    to    deal    with    subclasses,    callbacks,    and    user    functionality),    as    well    as    to    create    an    execution    stack,    which    is    common    in    UI-­‐based    systems.            

    

We’re  going    to    play    with    the    “piggy”    application.       It    should    still    look    like:    

  

 

    


    

1.    The  top-­‐level    widget    for    the    application    should    remain    a    subclass    of    QMainWindow.        However,    this    time,    we’re    going    to    add    menus.       The    File    menu    should    have    greyed    out    buttons    for    Open,    Save,    and    Save    As....    as    well    as    a    functional    menu    item    for    Quit.       (Notice:       On    the    Mac,    the    Quit    menu    item    will    get    automatically    moved    to    the    menu    item    

for  the    app,    in    this    case,    piggy-­‐stack.)       The    Edit    menu    will    have    Undo    and    Redo;    we’ll    talk    

about  those    below.    This    menu,    or    others,    may    also    have    some    menu    items    automatically    added    by    the    platform.       Finally,    there    will    be    an    Actions    menu,    consisting    of    Increment,    Decrement,    and    Print    Amount.            Increment    should    have    the    shortcut    Command-­‐    or    Cntl-­‐I,    and    Decrement    should    have    the    shortcut    Command–    or    Cntl-­‐D.    Print    Amount    should    

have  the    shortcut    Command-­‐    or    Cntl-­‐    P.    Undo    and    Redo    should    have    shortcuts    Command-­‐    or    Cntl-­‐z    and    Command-­‐    or    Cntl-­‐Y,    respectively.        

2.    You    should    turn    the    piggy    buttons    into    radio    buttons.       That    is,    at    most    one    can    be    “active”    at    a    time.       This    is    a    bit    arcane    in    Qt,    and    this    assignment    is    not    about    the    syntax,    so    the    next    few    paragraphs    walk    you    through    one    way    of    doing    this    –    there    are    multiple    ways.       First,    create    a    QButtonGroup.       You    will    place    all    of    your    QPushButtons    or    subclasses    into    the    button    group    with    an    addButton()    call    (part    of    QButtonGroup).       Call    setCheckable()    for    each    button    and    setChecked(false)    to    each    button    except    the    one    you    want    as    an    

initial  default.       Each    time    a    button    in    the    button    group    is    toggled,    the    button    group    will    throw    a    toggled(bool)    signal.    No    need    to    show    a    message    box    with    nursery    rhymes    when    clicked    like    the    assignment    2.        

3.    Each  button    will    have    a    number    in    front    of    the    name    of    the    button,    which    indicates    the    count    for    that    piggy    button    (starting    at    0).    When    the    user    selects    Increment,    the    value    for    the    active    button    should    be    increased    by    1;    when    the    user    selects    Decrement,    the    value    for    the    active    button    should    be    decremented    by    1.       When    the    user    selects    Print    Amount,    the    current    value    for    the    active    button    should    be    printed    (including    the    button    number    and    value).        You    may    use    a    cout    statement.    

4.    The  Undo    and    Redo    should    be    a    functional    command    execution    stack    that    undoes    and    

redoes    the    most    recent    operation    based    on    a    stack.       The    stack    should    be    infinite    in    

length  (although    the    GSIs    are    unlikely    to    test    this).       Print    Amount    does    not    need    to    be    

undone  or    redone.        

    

The  easiest    way    to    do    this,    although    it    does    require    some    overhead,    is    to    make    sure    your    

commands  into    a    subclass    of    QUndoCommand.          This    is    required.        

    

The  emphasis    in    this    assignment    is,    again,    not    the    syntax,    but    the    basic    abstractions    involved    in    undo/redo    and    actions    overall    and    how    to    arrange    code    between    instances.        Therefore    the    next    few    paragraphs    walk    you    through    what    you    will    need    to    use.       

    

You    can    create    an    undo    stack    for    your    program    by    creating    an    instance    of    QUndoStack.        Then    you    add    can    add    the    menu    items    for    Undo/Redo    with    the    createUndoAction()    and    createRedoAction()    methods,    which    are    part    of    QUndoStack.    

 

You    place    a    subclass    of    QUndoCommand    on    the    stack       with:    

    

undoStack-push(incrementCommand);

        

or  something    similar.       The    undo    stack    then    takes    it    from    there;    you    don’t    have    to    do    anything    else    to    get    undo    and    redo    in    your    program.       Note    that    QUndoCommand    or    subclasses    have    two    methods,    the    first    being    an    undo()    method    and    then    the    redo()    method.       The    redo()    method    will    get    triggered    when    the    QUndoCommand    is    constructed    

–  be    aware    of    this.       You    must    maintain    whatever    state    you    need    (not    much    in    this    case)    

to  restore    state    in    either    direction.    

5.    All  that    should    be    in    your    main()    is    the    constructor    for       your    subclass    of    QMainWindow.    (    The    main    will    also    include    the    bookkeeping    of    creating    a    QApplication,    the    show(),    and    the    main    event    loop.    You    would    not    need    more    than    4    lines    of    code    to    do    this.    )        

6.    You    may    choose    the    margins    for    the    buttons    and    any    white    space.        You    may    take    the    

defaults.  

7.    You    are    not    allowed    to    use    a    GUI    builder    (e.g.,    Qt    Designer)    nor    have    a    ui    file    included    in    

the  project.        You    must    hand-­‐code    this    assignment.    

8.    You    will    be    graded    on    basic    functionality    –    correct    use    of    subclasses,    hooking    in    the    events    (signals    and    slots)    appropriately,    increment/decrement,    undo/redo,    output,    and    correct    layout    (including    the    capability    to    resize    appropriately,    menus).    

9.    You    are    responsible    for    monitoring    the    Canvas    site    for    any    modifications    or    corrections    

of  this    assignment    (or    any    assignment).    

    

This  is    due    Sunday    10/4    at    11:55pm.       You    must    upload    your    code    to    Canvas    to    submit.        Same    rules    as    assignment    1    on    the    naming    and    format    of    the    submission.    

    

This  assignment    is    less    straightforward    than    the    previous    two.       However,    if    anything    is    

taking  a    long    time,    you    should    ask    for    help.    

    

To  startup    in    QtCreator:       See    assignment    1.