home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / Linux / Divers / lyx-0.13.2.tar.gz / lyx-0.13.2.tar / lyx-0.13.2 / src / lyxinset.h < prev    next >
C/C++ Source or Header  |  1998-04-23  |  5KB  |  208 lines
  1. // -*- C++ -*-
  2. /* This file is part of
  3.  * ======================================================
  4.  * 
  5.  *           LyX, The Document Processor
  6.  *      
  7.  *        Copyright (C) 1995 Matthias Ettrich
  8.  *
  9.  *======================================================*/
  10. #ifndef _LYXINSET_H
  11. #define _LYXINSET_H
  12.  
  13. #ifdef __GNUG__
  14. #pragma interface
  15. #endif
  16.  
  17. #include "definitions.h"
  18. #include "gettext.h"
  19. #include "lyxfont.h"
  20. #include "lyxlex.h"
  21. #include "lyxscreen.h"
  22.  
  23. class Buffer;
  24. struct LaTeXFeatures;
  25.  
  26. /// Insets
  27. class Inset {
  28. public:
  29.     /** This is not quite the correct place for this enum, but it is
  30.       better than definitions.h. I think the correct would be to let
  31.       each subclass of Inset declare its own enum code. Actually the
  32.       notion of an Inset::Code should be avoided, but I am not sure how
  33.       this could be done in a cleaner way. */
  34.     enum Code {
  35.         ///
  36.         NO_CODE,
  37.         ///
  38.         TOC_CODE,  // do these insets really need a code? (ale)
  39.         ///
  40.         LOF_CODE,
  41.         ///
  42.         LOT_CODE,
  43.         ///
  44.         LOA_CODE,
  45.         ///
  46.         QUOTE_CODE,
  47.         ///
  48.         MARK_CODE,
  49.         ///
  50.         REF_CODE,
  51.         ///
  52.         URL_CODE,
  53.         ///
  54.         HTMLURL_CODE,
  55.         ///
  56.         SEPARATOR_CODE,
  57.         ///
  58.         ENDING_CODE,
  59.         ///
  60.         LABEL_CODE,
  61.         ///
  62.         IGNORE_CODE,
  63.         ///
  64.         ACCENT_CODE,
  65.         ///
  66.         MATH_CODE,
  67.         ///
  68.         INDEX_CODE,
  69.         ///
  70.         INCLUDE_CODE,
  71.         ///
  72.         GRAPHICS_CODE,
  73.         ///
  74.         PARENT_CODE,
  75.         ///
  76.         BIBTEX_CODE
  77.     };
  78.  
  79.     ///
  80.     virtual ~Inset(){};
  81.     ///
  82.     virtual int Ascent(LyXFont const &font) const=0;
  83.     ///
  84.     virtual int Descent(LyXFont const &font) const=0;
  85.     ///
  86.     virtual int Width(LyXFont const& font) const=0;
  87.     ///
  88.     virtual LyXFont ConvertFont(LyXFont font);
  89.     ///
  90.     virtual void Draw(LyXFont font, LyXScreen &scr, int baseline, float &x)=0;
  91.     ///
  92.     //virtual void setBuffer(Buffer const&) {;}
  93.     /// what appears in the minibuffer when opening
  94.     virtual LString EditMessage() {return _("Opened inset");}
  95.     ///
  96.     virtual void Edit(int, int);
  97.     ///
  98.     virtual unsigned char Editable() const;
  99.     ///
  100.     virtual bool AutoDelete() const;
  101.     ///
  102.     virtual void Write(FILE *file)=0;
  103.     ///
  104.     virtual void Read(LyXLex &lex)=0;
  105.     /** returns the number of rows (\n's) of generated tex code.
  106.      fragile != 0 means, that the inset should take care about
  107.      fragile commands by adding a \protect before.
  108.      */
  109.     virtual int Latex(FILE *file, signed char fragile)=0;
  110.     virtual int Latex(LString &file, signed char fragile)=0;
  111.     /// Updates needed features for this inset.
  112.     virtual void Validate(LaTeXFeatures &features) const;
  113.     ///
  114.     virtual bool Deletable() const;
  115.  
  116.     /// returns LyX code associated with the inset. Used for TOC, ...)
  117.     virtual Inset::Code LyxCode() const = 0;
  118.   
  119.     /// Get the label that appears at screen
  120.     virtual LString getLabel(int) const {
  121.         return LString();
  122.     }
  123.  
  124.     /// used for autocorrection
  125.     virtual bool IsEqual(Inset* /*other*/){
  126.         return false;
  127.     }
  128.  
  129.     ///
  130.     virtual Inset* Clone()=0;
  131.  
  132.     /// returns true to override begin and end inset in file
  133.     virtual bool DirectWrite() const;
  134.  
  135.     /// Returns true if the inset should be centered alone
  136.     virtual bool Display() const { return false; }  
  137.  
  138.     /// Changes the display state of the inset
  139.     virtual void SetDisplay(bool) {  }  
  140.     ///
  141.     virtual int GetNumberOfLabels() const {
  142.         return 0;
  143.     }
  144.  
  145. };
  146.  
  147.  
  148. //  Updatable Insets. These insets can be locked and receive
  149. //  directly user interaction. Currently used only for mathed.
  150. //  Note that all pure methods from Inset class are pure here too.
  151. //  [Alejandro 080596] 
  152.  
  153. /** Extracted from Matthias notes:
  154.   * 
  155.   * An inset can simple call LockInset in it's edit call and *ONLY* 
  156.   * in it's edit call.
  157.   *
  158.   * Unlocking is either done by LyX or the inset itself with a 
  159.   * UnlockInset-call
  160.   *
  161.   * During the lock, all button and keyboard events will be modified
  162.   * and send to the inset through the following inset-features. Note that
  163.   * Inset::InsetUnlock will be called from inside UnlockInset. It is meant
  164.   * to contain the code for restoring the menus and things like this.
  165.   * 
  166.   * If a inset wishes any redraw and/or update it just has to call
  167.   * UpdateInset(this).
  168.   * 
  169.   * It's is completly irrelevant, where the inset is. UpdateInset will
  170.   * find it in any paragraph in any buffer. 
  171.   * Of course the_locking_inset and the insets in the current paragraph/buffer
  172.   *  are checked first, so no performance problem should occur.
  173.   */
  174. class UpdatableInset: public Inset {
  175. public:
  176.     ///
  177.     virtual ~UpdatableInset() { };
  178.     ///
  179.     virtual unsigned char Editable() const;
  180.    
  181.     /// may call ToggleLockedInsetCursor
  182.     virtual void ToggleInsetCursor();
  183.     ///
  184.     virtual void GetCursorPos(int&, int&) { }
  185.     ///
  186.     virtual void InsetButtonPress(int x, int y, int button);
  187.     ///
  188.     virtual void InsetButtonRelease(int x, int y, int button);
  189.     
  190.     ///
  191.     virtual void InsetKeyPress(XKeyEvent *ev);
  192.     ///
  193.     virtual void InsetMotionNotify(int x, int y, int state);
  194.     ///
  195.     virtual void InsetUnlock();
  196.    
  197.     ///  An updatable inset could handle lyx editing commands
  198.     virtual bool LocalDispatch(int, char const*) { return false; };
  199.     //
  200.     bool isCursorVisible() const { return cursor_visible; }
  201. protected:
  202.     ///
  203.     bool cursor_visible;
  204. };
  205.  
  206.  
  207. #endif
  208.