home *** CD-ROM | disk | FTP | other *** search
/ Acorn User 2 / AUCD2.iso / program / vista.arc / !Vista / h / objects < prev    next >
Text File  |  1996-01-27  |  10KB  |  267 lines
  1. // **************************************************************************
  2. //                     Copyright 1996 David Allison
  3. //
  4. //             VV    VV    IIIIII     SSSSS     TTTTTT       AA
  5. //             VV    VV      II      SS           TT       AA  AA
  6. //             VV    VV      II        SSSS       TT      AA    AA
  7. //              VV  VV       II           SS      TT      AAAAAAAA
  8. //                VV       IIIIII     SSSS        TT      AA    AA
  9. //
  10. //                    MULTI-THREADED C++ WIMP CLASS LIBRARY
  11. //                                for RISC OS
  12. // **************************************************************************
  13. //
  14. //             P U B L I C    D O M A I N    L I C E N C E
  15. //             -------------------------------------------
  16. //
  17. //     This library is copyright. You may not sell the library for
  18. //     profit, but you may sell products which use it providing
  19. //     those products are presented as executable code and are not
  20. //     libraries themselves.  The library is supplied without any
  21. //     warranty and the copyright owner cannot be held responsible for
  22. //     damage resulting from failure of any part of this library.
  23. //
  24. //          See the User Manual for details of the licence.
  25. //
  26. // *************************************************************************
  27.  
  28.  
  29. //
  30. // objects within a window
  31. //
  32.  
  33. #ifndef __objects_h
  34. #define __objects_h
  35.  
  36. #include "Vista:defs.h"
  37.  
  38. #ifndef __menu_h
  39. #include "Vista:menu.h"
  40. #endif
  41.  
  42. class Window ;
  43.  
  44. //
  45. // an object is something within a window.  It knows how to redraw
  46. // itself.
  47. //
  48. // The priority of an object determines the order in which it
  49. // is redrawn within the set of all objects in a window.  The higher
  50. // the priority, the later it is redrawn with respect to other objects.
  51. // A higher priority object can be viewed as being on top of lower
  52. // priority objects (if they overlap).  It is advised to set background
  53. // objects at priority 0 and increase the priority for each "layer"
  54. // in the window.
  55. //
  56.  
  57. class Object
  58.    {
  59.    public:
  60.       Object (Window *w, char *name, int priority = 0, char *menu = 0) ;
  61.       virtual ~Object() ;
  62.       virtual void redraw (int x0, int y0, int x1, int y1) ;      // redraw with background cleared
  63.       virtual void update (int x0, int y0, int x1, int y1) ;      // update with no change to background
  64.       virtual int compare (int x, int y) ;
  65.       virtual void move (int x0, int y0, int x1, int y1) ;
  66.       virtual void move (int dx, int dy) ;
  67.       virtual void drag (int mx, int my, int buttons) ;  // start dragging the object
  68.       virtual void end_drag (int x0, int y0, int x1, int y1, int id) ;
  69.       virtual void click(int mx, int my, int button) ;   // object has been clicked
  70.       virtual void key (int x, int y, int height, int index, int code) ;
  71.       virtual void double_click (int mx, int my, int buttons) ;
  72.       virtual void select() ;                  // select the object
  73.       virtual void unselect() ;                // unselect the object
  74.       virtual int width() { return x1 - x0 ; }                   // read width
  75.       virtual int height() { return y1 - y0 ; }                   // ready height
  76.       virtual void pointer (int entering) ;          // pointer entering or leaving
  77.       virtual void mode_change() ;                   // mode change
  78.       Menu *display_menu (int x, int y, int button, int icon) ;
  79.       virtual void pre_menu(Menu *m, int x, int y, int button, int icon) ;
  80.       virtual char *get_menu (int x, int y, int button, int icon) ;
  81.       virtual char *help (int mx, int my, int buttons) ;   // give help
  82.  
  83.       virtual void menu (MenuItem items[]) ;
  84.  
  85.       int x0 ;  // bounding box min x
  86.       int y0 ;  // bounding box min y
  87.       int x1 ;  // bounding box max x
  88.       int y1 ;  // bounding box max y
  89.       Window *window ;
  90.       Menu *default_menu ;
  91.       Object *next, *prev ;
  92.       char name[32] ;
  93.       int priority ;       // priority for drawing
  94.       int selected ;
  95.    } ;
  96.  
  97. //
  98. // an icon object (plotted)
  99. //
  100.  
  101. class IconObject : public Object
  102.    {
  103.    public:
  104.       IconObject (Window *w, char *name, Icon *icon, int priority = 0, char *menu = 0) ;
  105.       ~IconObject() ;
  106.       void redraw (int x0, int y0, int x1, int y1) ;
  107.    private:
  108.       Icon *icon ;
  109.    } ;
  110.  
  111. //
  112. // a raw sprite object.  This draws the sprite directly to the screen (as opposed to the draw based
  113. // one SpriteObject)
  114. //
  115.  
  116. class RawSpriteObject : public Object
  117.    {
  118.    public:
  119.       RawSpriteObject (Window *w, char *name, char *sprite, void *area, int x, int y, int priority = 0, char *menu = 0) ;
  120.       RawSpriteObject (Window *w, char *name, char *sprite, int x, int y, int priority = 0, char *menu = 0) ;
  121.       ~RawSpriteObject() ;
  122.       void redraw (int x0, int y0, int x1, int y1) ;
  123.    protected:
  124.       char *sprite ;
  125.       void *area ;
  126.       int scale_factors[4] ;
  127.       char *pixel_trans ;
  128.       void init() ;
  129.       int mode ;
  130.    } ;
  131.  
  132. //
  133. // a text object
  134. //
  135.  
  136. // control codes
  137.  
  138. const int TextObject_Colour = 1 ;
  139.  
  140.  
  141. class TextObject : public Object
  142.    {
  143.    struct line
  144.       {
  145.       char *text ;           // actual text
  146.       int length ;           // length in bytes
  147.       } ;
  148.    public:
  149. //      TextObject (Window *w, char *name, char *text, int length, int x, int y, int priority = 0, char *menu = 0) ;
  150.       TextObject (Window *w, char *name, char *text, int x, int y, int priority = 0, char *menu = 0) ;
  151.       TextObject (Window *w, char *name, int x, int y, int priority = 0, char *menu = 0) ;
  152.       virtual ~TextObject() ;
  153.       void redraw (int x0, int y0, int x1, int y1) ;
  154.       void insert_line (char *text, int length) ;
  155.       void insert_line (char *text) ;
  156.    protected:
  157.       char *text ;         // text stored in object
  158.       line *lines ;        // array of lines
  159.       int num_lines ;      // number of lines
  160.       int max_lines ;      // mac line space available
  161.       int max_length ;     // max line length in units
  162.  
  163.    } ;
  164.  
  165. class LineObject : public Object
  166.    {
  167.    public:
  168.       LineObject (Window *w, char *name, int x1, int y1, int x2, int y2, int thickness = 1, int priority = 0) ;
  169.       virtual ~LineObject() ;
  170.       void redraw (int x0, int y0, int x1, int y1) ;
  171.    protected:
  172.       int thickness ;
  173.       int dx ;            // delta to add to x for thickness
  174.       int dy ;            // delta to subtract from y for thickness
  175.    } ;
  176.  
  177. const int FONT_BLOCKING_FACTOR = 100 ;
  178. const int FONT_LINE_GAP = 4000 ;                // millipoints
  179. const int FONT_BORDER = 1000 ;                  // millipoints
  180.  
  181. class FontObject : public Object
  182.    {
  183.    struct line
  184.       {
  185.       char *start ;  // character at start of line
  186.       int y ;        // millipoint offset of bottom of text relative to y1
  187.       int length ;   // line length in bytes
  188.       int height ;   // line height in millipoints
  189.       line *next ;
  190.       int width ;    // width in millipoints
  191.       } ;
  192.  
  193.    public:
  194.       FontObject (Window *w, char *name, int fhandle, int x0, int y0, int width, int priority = 0, char *menu = 0) ;
  195.       virtual ~FontObject() ;
  196.       void redraw (int x0, int y0, int x1, int y1) ;
  197.       void set_colour (int r, int g, int b, int R, int G, int B, int max = 14) ;
  198.       void begin_underline() ;
  199.       void end_underline() ;
  200.       void set_font (int handle) ;
  201.       void add_text (char *text) ;
  202.       void set_indent (int os_units) ;
  203.       void finish() ;
  204.       int width() ;
  205.       int compare (int x, int y) ;
  206.       char *text ;
  207.       int text_length ;
  208.       line *lines ;
  209.       line *last_line ;
  210.       int max_length ;
  211.       void check_buffer(int length) ;
  212.       int font_handle ;
  213.       int end_width ;                 // width in OS units to the end of the last line
  214.       int indent ;                    // indent of first line in millipoints
  215.    } ;
  216.  
  217. //
  218. // DrawFile SWI definitions.  This is from the Acorn PD module DrawFile
  219. //
  220.  
  221. #define DrawFile_Render 0x45540
  222. #define DrawFile_BBox   0x45541
  223. #define DrawFile_DeclareFonts 0x45541
  224.  
  225. const int DRAW_BLOCKING_FACTOR = 100 ;  // number of bytes extra added after data extension
  226.  
  227. class DrawObject : public Object
  228.    {
  229.    public:
  230.       DrawObject(Window *w, char *name, char *data, int length, int x, int y, int priority = 0, char *menu = 0) ;
  231.       DrawObject(Window *w, char *name, char *filename, int x, int y, int priority = 0, char *menu = 0) ;
  232.       DrawObject(Window *w, char *name, int priority = 0, char *menu = 0) ;
  233.       ~DrawObject() ;
  234.       void redraw (int x0, int y0, int x1, int y1) ;
  235.    protected:
  236.       char *data ;                     // draw data (in drawfile format)
  237.       int data_length ;
  238.       int matrix[6] ;                  // translation matrix
  239.       int xoffset, yoffset ;           // draw unit offset to bounding box
  240.       bool dealloc_data ;              // OK to deallocate data in destructor
  241.       int max_length ;                 // max length for dynamic data array
  242.  
  243.       void init(int x, int y) ;                       // init for drawing on screen
  244.       void make_header (int width, int height) ;      // make a file header
  245.       void insert_word (int word) ;                   // insert a word
  246.       void insert_string (char *str) ;                // insert a string
  247.       void insert_byte (char c) ;                     // insert a byte
  248.       void insert_data (void *s, int length) ;        // insert a load of data
  249.       void align() ;                                  // align to next word
  250.       void check_space (int num_bytes) ;              // check space and extend if necessary
  251.    } ;
  252.  
  253. //
  254. // This sprite object uses the draw object to place a sprite at the specified coordinates.
  255. //
  256.  
  257.  
  258. class SpriteObject : public DrawObject
  259.    {
  260.    public:
  261.       SpriteObject (Window *w, char *name, char *sprite, int x, int y, int priority = 0, char *menu = 0) ;
  262.       ~SpriteObject() ;
  263.    } ;
  264.  
  265.  
  266. #endif
  267.