basic.h

Wxpython Implemented on Windows CE, Source code

  // to override sizing behaviour.
  virtual void OnSizingDragLeft(wxControlPoint* pt, bool draw, double x, double y, int keys=0, int attachment = 0); // Erase if draw false
  virtual void OnSizingBeginDragLeft(wxControlPoint* pt, double x, double y, int keys=0, int attachment = 0);
  virtual void OnSizingEndDragLeft(wxControlPoint* pt, double x, double y, int keys=0, int attachment = 0);

  virtual void MakeControlPoints();
  virtual void DeleteControlPoints(wxDC *dc = NULL);
  virtual void ResetControlPoints();

  inline wxShapeEvtHandler *GetEventHandler() { return m_eventHandler; }
  inline void SetEventHandler(wxShapeEvtHandler *handler) { m_eventHandler = handler; }

  // Mandatory control points, e.g. the divided line moving handles
  // should appear even if a child of the 'selected' image
  virtual void MakeMandatoryControlPoints();
  virtual void ResetMandatoryControlPoints();

  inline virtual bool Recompute() { return true; };
  // Calculate size recursively, if size changes. Size might depend on children.
  inline virtual void CalculateSize() { };
  virtual void Select(bool select = true, wxDC* dc = NULL);
  virtual void SetHighlight(bool hi = true, bool recurse = false);
  inline virtual bool IsHighlighted() const { return m_highlighted; };
  virtual bool Selected() const;
  virtual bool AncestorSelected() const;
  void SetSensitivityFilter(int sens = OP_ALL, bool recursive = false);
  int GetSensitivityFilter() const { return m_sensitivity; }
  void SetDraggable(bool drag, bool recursive = false);
  inline  void SetFixedSize(bool x, bool y) { m_fixedWidth = x; m_fixedHeight = y; };
  inline  void GetFixedSize(bool *x, bool *y) const { *x = m_fixedWidth; *y = m_fixedHeight; };
  inline  bool GetFixedWidth() const { return m_fixedWidth; }
  inline  bool GetFixedHeight() const { return m_fixedHeight; }
  inline  void SetSpaceAttachments(bool sp) { m_spaceAttachments = sp; };
  inline  bool GetSpaceAttachments() const { return m_spaceAttachments; };
  void SetShadowMode(int mode, bool redraw = false);
  inline int GetShadowMode() const { return m_shadowMode; }
  virtual bool HitTest(double x, double y, int *attachment, double *distance);
  inline void SetCentreResize(bool cr) { m_centreResize = cr; }
  inline bool GetCentreResize() const { return m_centreResize; }
  inline void SetMaintainAspectRatio(bool ar) { m_maintainAspectRatio = ar; }
  inline bool GetMaintainAspectRatio() const { return m_maintainAspectRatio; }
  inline wxList& GetLines() const { return (wxList&) m_lines; }
  inline void SetDisableLabel(bool flag) { m_disableLabel = flag; }
  inline bool GetDisableLabel() const { return m_disableLabel; }
  inline void SetAttachmentMode(int mode) { m_attachmentMode = mode; }
  inline int GetAttachmentMode() const { return m_attachmentMode; }
  inline void SetId(long i) { m_id = i; }
  inline long GetId() const { return m_id; }

  void SetPen(const wxPen *pen);
  void SetBrush(const wxBrush *brush);

  virtual void Show(bool show);
  virtual bool IsShown() const { return m_visible; }
  virtual void Move(wxDC& dc, double x1, double y1, bool display = true);
  virtual void Erase(wxDC& dc);
  virtual void EraseContents(wxDC& dc);
  virtual void Draw(wxDC& dc);
  virtual void Flash();
  virtual void MoveLinks(wxDC& dc);
  virtual void DrawContents(wxDC& dc);  // E.g. for drawing text label
  virtual void SetSize(double x, double y, bool recursive = true);
  virtual void SetAttachmentSize(double x, double y);
  void Attach(wxShapeCanvas *can);
  void Detach();

  inline virtual bool Constrain() { return false; } ;

  void AddLine(wxLineShape *line, wxShape *other,
               int attachFrom = 0, int attachTo = 0,
               // The line ordering
               int positionFrom = -1, int positionTo = -1);

  // Return the zero-based position in m_lines of line.
  int GetLinePosition(wxLineShape* line);

  void AddText(const wxString& string);

  inline wxPen *GetPen() const { return wx_const_cast(wxPen*, m_pen); }
  inline wxBrush *GetBrush() const { return wx_const_cast(wxBrush*, m_brush); }

  /*
   * Region-specific functions (defaults to the default region
   * for simple objects
   */

  // Set the default, single region size to be consistent
  // with the object size
  void SetDefaultRegionSize();
  virtual void FormatText(wxDC& dc, const wxString& s, int regionId = 0);
  virtual void SetFormatMode(int mode, int regionId = 0);
  virtual int GetFormatMode(int regionId = 0) const;
  virtual void SetFont(wxFont *font, int regionId = 0);
  virtual wxFont *GetFont(int regionId = 0) const;
  virtual void SetTextColour(const wxString& colour, int regionId = 0);
  virtual wxString GetTextColour(int regionId = 0) const;
  virtual inline int GetNumberOfTextRegions() const { return m_regions.GetCount(); }
  virtual void SetRegionName(const wxString& name, int regionId = 0);

  // Get the name representing the region for this image alone.
  // I.e. this image's region ids go from 0 to N-1.
  // But the names might be "0.2.0", "0.2.1" etc. depending on position in composite.
  // So the last digit represents the region Id, the others represent positions
  // in composites.
  virtual wxString GetRegionName(int regionId);

  // Gets the region corresponding to the name, or -1 if not found.
  virtual int GetRegionId(const wxString& name);

  // Construct names for regions, unique even for children of a composite.
  virtual void NameRegions(const wxString& parentName = wxEmptyString);

  // Get list of regions
  inline wxList& GetRegions() const { return (wxList&) m_regions; }

  virtual void AddRegion(wxShapeRegion *region);

  virtual void ClearRegions();

  // Assign new ids to this image and children (if composite)
  void AssignNewIds();

  // Returns actual image (same as 'this' if non-composite) and region id
  // for given region name.
  virtual wxShape *FindRegion(const wxString& regionName, int *regionId);

  // Finds all region names for this image (composite or simple).
  // Supply empty string list.
  virtual void FindRegionNames(wxStringList& list);

  virtual void ClearText(int regionId = 0);
  void RemoveLine(wxLineShape *line);

#if wxUSE_PROLOGIO
  // I/O
  virtual void WriteAttributes(wxExpr *clause);
  virtual void ReadAttributes(wxExpr *clause);

  // In case the object has constraints it needs to read in in a different pass
  inline virtual void ReadConstraints(wxExpr *WXUNUSED(clause), wxExprDatabase *WXUNUSED(database)) { };
  virtual void WriteRegions(wxExpr *clause);
  virtual void ReadRegions(wxExpr *clause);
#endif

  // Attachment code
  virtual bool GetAttachmentPosition(int attachment, double *x, double *y,
                                     int nth = 0, int no_arcs = 1, wxLineShape *line = NULL);
  virtual int GetNumberOfAttachments() const;
  virtual bool AttachmentIsValid(int attachment) const;
  virtual wxList& GetAttachments() { return m_attachmentPoints; }

  // Only get the attachment position at the _edge_ of the shape, ignoring
  // branching mode. This is used e.g. to indicate the edge of interest, not the point
  // on the attachment branch.
  virtual bool GetAttachmentPositionEdge(int attachment, double *x, double *y,
                                     int nth = 0, int no_arcs = 1, wxLineShape *line = NULL);

  // Assuming the attachment lies along a vertical or horizontal line,
  // calculate the position on that point.
  virtual wxRealPoint CalcSimpleAttachment(const wxRealPoint& pt1, const wxRealPoint& pt2,
    int nth, int noArcs, wxLineShape* line);

  // Returns true if pt1 <= pt2 in the sense that one point comes before another on an
  // edge of the shape.
  // attachmentPoint is the attachment point (= side) in question.
  virtual bool AttachmentSortTest(int attachmentPoint, const wxRealPoint& pt1, const wxRealPoint& pt2);

  virtual void EraseLinks(wxDC& dc, int attachment = -1, bool recurse = false);
  virtual void DrawLinks(wxDC& dc, int attachment = -1, bool recurse = false);

  virtual bool MoveLineToNewAttachment(wxDC& dc, wxLineShape *to_move,
                                       double x, double y);

  // Reorders the lines coming into the node image at this attachment
  // position, in the order in which they appear in linesToSort.
  virtual void SortLines(int attachment, wxList& linesToSort);

  // Apply an attachment ordering change
  void ApplyAttachmentOrdering(wxList& ordering);

  // Can override this to prevent or intercept line reordering.
  virtual void OnChangeAttachment(int attachment, wxLineShape* line, wxList& ordering);

  //// New banching attachment code, 24/9/98

  //
  //             |________|
  //                 | <- root
  //                 | <- neck
  // shoulder1 ->---------<- shoulder2
  //             | | | | |<- stem
  //                      <- branching attachment point N-1

  // This function gets the root point at the given attachment.
  virtual wxRealPoint GetBranchingAttachmentRoot(int attachment);

  // This function gets information about where branching connections go (calls GetBranchingAttachmentRoot)
  virtual bool GetBranchingAttachmentInfo(int attachment, wxRealPoint& root, wxRealPoint& neck,
    wxRealPoint& shoulder1, wxRealPoint& shoulder2);

  // n is the number of the adjoining line, from 0 to N-1 where N is the number of lines
  // at this attachment point.
  // attachmentPoint is where the arc meets the stem, and stemPoint is where the stem meets the
  // shoulder.
  virtual bool GetBranchingAttachmentPoint(int attachment, int n, wxRealPoint& attachmentPoint,
    wxRealPoint& stemPoint);

  // Get the number of lines at this attachment position.
  virtual int GetAttachmentLineCount(int attachment) const;

  // Draw the branches (not the actual arcs though)
  virtual void OnDrawBranches(wxDC& dc, int attachment, bool erase = false);
  virtual void OnDrawBranches(wxDC& dc, bool erase = false);

  // Branching attachment settings
  inline void SetBranchNeckLength(int len) { m_branchNeckLength = len; }
  inline int GetBranchNeckLength() const { return m_branchNeckLength; }

  inline void SetBranchStemLength(int len) { m_branchStemLength = len; }
  inline int GetBranchStemLength() const { return m_branchStemLength; }

  inline void SetBranchSpacing(int len) { m_branchSpacing = len; }
  inline int GetBranchSpacing() const { return m_branchSpacing; }

  // Further detail on branching style, e.g. blobs on interconnections
  inline void SetBranchStyle(long style) { m_branchStyle = style; }
  inline long GetBranchStyle() const { return m_branchStyle; }

  // Rotate the standard attachment point from physical (0 is always North)
  // to logical (0 -> 1 if rotated by 90 degrees)
  virtual int PhysicalToLogicalAttachment(int physicalAttachment) const;

  // Rotate the standard attachment point from logical
  // to physical (0 is always North)
  virtual int LogicalToPhysicalAttachment(int logicalAttachment) const;

  // This is really to distinguish between lines and other images.
  // For lines, want to pass drag to canvas, since lines tend to prevent
  // dragging on a canvas (they get in the way.)
  virtual bool Draggable() const { return true; }

  // Returns true if image is a descendant of this image
  bool HasDescendant(wxShape *image);

  // Creates a copy of this shape.
  wxShape *CreateNewCopy(bool resetMapping = true, bool recompute = true);

  // Does the copying for this object
  virtual void Copy(wxShape& copy);

  // Does the copying for this object, including copying event
  // handler data if any. Calls the virtual Copy function.
  void CopyWithHandler(wxShape& copy);