OP/OP_PostIt.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Oleg Samus
 *      Side Effects Software Inc
 *      123 Front Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        OP_PostIt.h (OP Library, C++)
 *
 * COMMENTS:    Defines post it notes.
 * 
 */

#ifndef __OP_PostIt__
#define __OP_PostIt__

#include "OP_API.h"
#include <iostream.h>

#include <SYS/SYS_Types.h>
#include <UT/UT_String.h>
#include <UT/UT_Color.h>
#include <UT/UT_PtrArray.h>

#include "OP_Node.h"
#include "OP_PostItNoteFlags.h"

class OP_Network;
class OP_Stat;
class UT_AutoUndoBlock;

#define OP_POSTIT_DEFAULT_W             2.5F
#define OP_POSTIT_DEFAULT_H             2.5F
#define OP_POSTIT_MINIMUM_W             1.0F
#define OP_POSTIT_MINIMUM_H             1.0F
#define OP_POSTIT_MINIMIZED_W           2.5F
#define OP_POSTIT_MINIMIZED_H           0.11F

#define OP_INVALID_POSTIT_ID    -999

class OP_API OP_PostIt : public OP_NetworkBoxItem
{
public:
    /// Create a network box with the specified name. If a duplicate name is 
    /// passed in, it will be altered to make it unique in the network.
    OP_PostIt(const UT_String &name, OP_Network *net);
    virtual ~OP_PostIt();

    virtual void         setXY(fpreal x, fpreal y);
    virtual fpreal       getX() const;
    virtual fpreal       getY() const;
    virtual fpreal       getW() const;
    virtual fpreal       getH() const;
    fpreal               getMaximizedW() const;
    fpreal               getMaximizedH() const;

    bool setXYWithBoundsChecks(fpreal x, fpreal y);
    bool setWWithBoundsChecks(fpreal h);
    bool setHWithBoundsChecks(fpreal h);

    virtual const OP_PostItNoteFlags    &flags() const
    { return static_cast<const OP_PostItNoteFlags &>(OP_NetworkBoxItem::flags()); }
    virtual OP_PostItNoteFlags  &flags()
    { return static_cast<OP_PostItNoteFlags &>(OP_NetworkBoxItem::flags()); }


    /// Returns true if this box is currently picked
    virtual int          getPicked() const;

    /// Set whether this box is picked; returns true if the picked
    /// status has changed. 
    virtual int          setPicked(int on_off, bool propagate_parent_event = true);

    /// Each netbox has a unique id. This is used primarily for undos, as we
    /// also keep a list of notes in order of id, so lookup by id becomes
    /// quite quick.
    static OP_PostIt            *lookupPostItNote(int unique_id);

    int                          getUniqueId() const { return myUniqueId; }

    /// The name which is used for identification and in displays of this
    /// box. setName() returns true if the name change was successful, and 
    /// alters the name slightly if necessary to make it unique within this 
    /// network.
    bool                         setName(const UT_String &name);
    virtual const UT_String     &getItemName() const { return myName; };

    bool                         setText(const UT_String &text);
    virtual const UT_String     &getText() const { return myText; };

    virtual OP_ItemType          getItemType() const;

    virtual OP_Network  *getParentNetwork() const;


    /// Get and set the width and height of this box. Units are absolute
    /// as opposed to the relative units found in OPUI.
    /// If the width or height specified is smaller than that which will
    /// contain all of the items, the width or height respectively will only
    /// be adjusted to the minimum size required to contain the items. To avoid
    /// this automatic size check, set 'force' to true.
    void                 setW(fpreal w, bool force = false);
    void                 setH(fpreal h, bool force = false);

    /// Calculate the smallest bounds we're willing to accept as our size
    /// given our contents. By default, 'incl_buff_border' is set to add a small
    /// buffer border to make the layout look pretty. NOTE: If we contain no
    /// items, we return an inverted bounding box, see implementation for
    /// further details.
    void                 getItemBounds(fpreal &x1, fpreal &y1, fpreal &x2,
                                       fpreal &y2, bool incl_buff_border = true)
                                       const;

    /// ALWAYS call this with 'resizing' == true before you do any resizing 
    /// operations (e.g. setW()), and call it after you're done resizing with 
    /// 'resizing' == false.  You should only do this once for each group of 
    /// resizing operations on the same netbox. 
    ///
    /// This method: 
    /// 1) ensures we get a proper undo block around all the resize ops, and 
    /// 2) allows you to use setXY() to stretch the box to the left (otherwise,
    ///    setXY() just moves the box)
    void                 setResizing(bool resizing);
    bool                 getResizing();

    /// Same as setXY(), but here we can force the box to take on these X/Y 
    /// coordinates, even if our contents don't fit us any more.  The
    /// propagate_parent_event tells this method whether or not it should send
    /// and event after moving the network box -- this should normally be set
    /// to true.
    void setXY(fpreal x, fpreal y, bool force, bool propagate_parent_event);

    /// The colour used to display our background. Returns true if the color 
    /// changed.
    virtual bool            setColor(const UT_Color &color);
    virtual const UT_Color *getColor() const { return &myColor; }

    const char* getType(void) const;

    virtual OP_ERROR save(ostream &os, const OP_SaveFlags &sflags, const char *path_prefix);
    virtual OP_ERROR saveIntrinsic(ostream &os, const OP_SaveFlags &sflags);
    /// Load the contents of the stream into the attributes of this post-it 
    /// note; if binary is nonzero, load in binary mode.
    /// Loading doesn't send the OP_POSTIT_NOTE_CREATED message to the network;
    /// the caller is responsible for doing that.
    virtual bool                 load(UT_IStream &is, const char *ext="", const char *path=0);
     
    void clearErrors()
    {
        UTgetErrorManager()->clearAndDestroyErrors();
        myErrorManager.clearAndDestroyErrors(); 
    }

    virtual OP_ERROR     error()
    {
        if( UTgetErrorManager()->getNumErrors() > 0 )
            stealGlobalErrors();
        return myErrorManager.getSeverity();
    }
    void                 opMessage(int code, const char *m=0) const
    { UTaddMessage("OP",code,m);}
    void                 opWarning(int code, const char *m=0) const
    { UTaddWarning("OP",code,m);}
    void                 opError(int code, const char *m=0) const
    { UTaddError("OP", code, m);}

    UT_ErrorManager     &getMyErrorManager() { return myErrorManager; }
    void stealErrors(UT_ErrorManager &src, bool borrow_only);

    virtual OP_ERROR     getErrorSeverity()
    { return myErrorManager.getSeverity(); }

    void getFullPath(UT_String &str) const;
    static void          clearAllPendingUndoFlags(void);

    /// Get whether this box is currently minimized
    bool                 getMinimized() const;

    /// Set whether this box is currently minimized
    /// If update_position is true, then the box is moved to accomodate the
    /// minimized status.  If propagate_parent_event is true, an event is sent
    /// to the network about our minimized state.
    bool                 setMinimized(bool isminimized,
                                      bool update_position,
                                      bool propagate_parent_event);

    /// Used by opscript, this outputs the sequence of hscript commands
    /// necessary to recreate this sticky note.
    int                  saveCommand(ostream &os) const;

private:
    /// This should only be called by our loading mechanism while we load, right
    /// after we get created!
    void                 setUniqueId(int id);

    OP_ERROR             saveIntrinsicError();
    OP_ERROR             saveError();

    bool                 loadPostItFlags(UT_IStream &is, const char *path);
    bool                 loadNetworkBox(UT_IStream &is, const char *path);
    bool                 loadIntrinsic(UT_IStream &is, const char *path);
    virtual bool         loadPacket(UT_IStream &is, short class_id, short signature, const char *path = 0);
    virtual bool         loadPacket(UT_IStream &is, const char *token, const char *path=0);

    void                 stealGlobalErrors();
//    void               stealErrors(OP_Parameters &src);

    OP_ERROR             saveNetworkBox(ostream &os, const OP_SaveFlags &sflags, const char *path_prefix);

    void                 saveForUndoTextChange(void);
    void                 saveForUndoRename(void);
    void                 saveForUndoMinimize(void);
    void                 saveForUndoColor(void);
    void                 saveForUndoLayout(void);
    void                 saveForUndoResize(void);
    void                 setAnyUndoFlag(void);

    void                 clearUndoFlags(void);
    bool                 getAnyUndoPending() const;

    friend class OP_Network;

private:

    UT_ErrorManager      myErrorManager;

    // Note that although netboxes share their namespace with nodes, they do not
    // share their "ID space".
    int                  myUniqueId;

    UT_String            myName; 
    UT_String            myText; 
    OP_Network          *myNetwork;

    /// Keeps info like timestamps for last modification time, creation time,
    /// etc
    OP_Stat              myStats;

    UT_Color             myColor;

    /// ALWAYS set these through accessors to ensure proper undo creation
    fpreal               myX, myY;
    fpreal               myW, myH; 

    bool                 myAnyUndoFlagSet;
    UT_AutoUndoBlock    *myUndoResizeBlock;
};

#endif

---