/* This file is part of the KDE libraries
Copyright (C) 1997 Martin Jones (mjones@kde.org)
(C) 1997 Torben Weis (weis@kde.org)
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
*/
//----------------------------------------------------------------------------
//
// KDE HTML Widget
// $Id: html.h,v 1.68.4.1 1999/03/15 10:03:09 knoll Exp $
#ifndef HTML_H
#define HTML_H
#define KHTMLW_VERSION 1303 // 00.13.03
#define KHTMLW_MAX_URL 1024 // Maximum length of a URL
#define KHTMLW_MAX_TARGET 256 // Maximum length of a target window name
#include <qpainter.h>
#include <qstrlist.h>
#include <qpixmap.h>
#include <qstack.h>
#include <qfont.h>
#include <qtimer.h>
#include <qlist.h>
#include <kurl.h>
#include <qdict.h>
#include <qstring.h>
#include <qbuffer.h>
class KHTMLWidget;
class HTMLIterator;
struct SavedPage;
#include "drag.h"
#include "htmldata.h"
#include "htmlobj.h"
#include "htmlclue.h"
#include "htmlform.h"
#include "htmltoken.h"
#include "htmlframe.h"
#include "htmlview.h"
#include "jscript.h"
// Default borders between widgets frame and displayed text
#define LEFT_BORDER 10
#define RIGHT_BORDER 20
#define TOP_BORDER 10
#define BOTTOM_BORDER 10
//#define TORBENSDEBUG
//#define MARTINSDEBUG
class KCharsetConverter;
void debugT( const char *msg , ...);
void debugM( const char *msg , ...);
enum ScrollType {SCROLL_NONE, SCROLL_LEFT, SCROLL_RIGHT, SCROLL_UP, SCROLL_DOWN};
struct HTMLPendingFile
{
public:
HTMLPendingFile();
HTMLPendingFile( const char *_url, HTMLObject *_obj );
QBuffer m_buffer;
QString m_strURL;
QList<HTMLObject> m_lstClients;
};
struct FrameLayout
{
QString rows;
QString cols;
int frameBorder;
bool allowResize;
};
struct SavedPage
{
SavedPage();
~SavedPage();
QString frameName;
bool isFrame;
int scrolling;
int frameborder;
int marginwidth;
int marginheight;
bool allowresize;
bool isFrameSet;
QString url;
QString title;
int xOffset;
int yOffset;
FrameLayout *frameLayout;
QList<SavedPage> *frames;
};
typedef void (KHTMLWidget::*parseFunc)(HTMLClueV *_clue, const char *str);
/**
* @short Basic HTML Widget. Does not handle scrollbars or frames.
*
* This widget is good for use in your custom application which does not
* necessarily want to handle frames, or want custom control of scrollbars.
* To add content to the widget you should do the follwing:
* <PRE>
* view->begin( "file:/tmp/test.html" );
* view->parse();
* view->write( "<HTML><TITLE>...." );
* .....
* view->end();
* view->show();
* </PRE>
* The widget will take care of resize events and paint events.
* Have a look at the set of signals emitted by this widget. You should connect
* to most of them.
*
* Note: All HTML is parsed in the background using Qt timers, so you will not
* see any content displayed until the event loop is running.
*/
class KHTMLWidget : public KDNDWidget
{
Q_OBJECT
public:
/**
* Create a new HTML widget. The widget is empty by default.
* You must use @ref #begin, @ref #write, @ref #end and @ref #parse
* to fill the widget with content.
*
* @param _name is the name of the widget. Usually this name is only
* meaningful for Qt but in this case it is the name of
* the HTML window. This means you can reference this name
* in the < href=... target=... > tag. If this argument
* is 0L then a unique default name is chosen.
*
* Note: pixdir should not be used - it is provided only for backward
* compatability and has no effect.
*/
KHTMLWidget( QWidget *parent = 0L, const char *name = 0L,
const char *pixdir = 0L );
virtual ~KHTMLWidget();
/**
* Clears the widget and prepares it for new content. If you display
* for example "file:/tmp/test.html", you can use the following code
* to get a value for '_url':
* <PRE>
* KURL u( "file:/tmp/test.html" );
* view->begin( u.directoryURL() );
* </PRE>
*
* @param _url is the url of the document to be displayed. Even if you
* are generating the HTML on the fly, it may be useful to specify
* a directory so that any pixmaps are found.
* @param _dx is the initial horizontal scrollbar value. Usually you don't
* want to use this.
* @param _dy is the initial vertical scrollbar value. Usually you don't
* want to use this.
*/
void begin( const char *_url = 0L, int _x_offset = 0, int _y_offset = 0 );
/**
* Writes another part of the HTML code to the widget. You may call
* this function many times in sequence. But remember: The less calls
* the faster the widget is.
*/
void write( const char * );
/**
* Call this after your last call to @ref #write.
*/
void end();
/**
* Begin parsing any HTML that has been written using the @ref #write
* method.
*
* You may call this function immediately after calling @ref #begin.
* In this case the HTML will be passed and displayed whenever the
* event loop is active. This allows background parsing and display
* of the HTML as it arrives.
*/
void parse();
/**
* Stop parsing the HTML immediately.
*/
void stopParser();
/**
* Print current HTML page to the printer.
*/
void print();
/**
* Recalculate the size and position of objects in the page.
* This is mainly intended for internal use.
*/
void calcSize();
/**
* Selects all objects which refer to _url. All selected ojects
* are redrawn if they changed their selection mode.
*/
virtual void selectByURL( QPainter *_painter, const char *_url, bool _select );
/**
* Selects/Unselects all objects with an associated URL.
* This is usually used to disable
* a selection. All objects are redrawn afterwards if they changed
* their selection mode.
*/
virtual void select( QPainter *_painter, bool _select );
/**
* Selects all objects with an associated URL in this rectangle and
* deselects all objects outside the rectangle.
*
* @param _rect is a rectangle in display coordinates. This means
* that the point (0,0) is the upper/left most point of
* the widget but must not be this one for the HTML page.
* This happens if the widget is being scrolled.
*/
virtual void select( QPainter * _painter, QRect &_rect );
/**
* Select all objects with a URL matching the regular expression.
*
* If _painter is null a new painter is created.
*/
virtual void select( QPainter *_painter, QRegExp& _pattern, bool _select );
/**
* Gets a list of all selected URLs. The list may be Null.
* You can test this using list.isNull().
*/
virtual void getSelected( QStrList &_list );
/**
* Selects all text between ( _x1, _y1 ) and ( _x2, y2 ). The selection
* area selects text line by line, NOT by bounding rectangle.
*/
virtual void selectText( int _x1, int _y1, int _x2, int _y2 );
/**
* Get the text the user has marked.
*
* @param _str is the QString which will contain the text the user
* selected. The selected text is appended to any text currently in
* _str.
*/
virtual void getSelectedText( QString &_str );
/**
* Has the user selected any text? Call @ref #getSelectedText to
* retrieve the selected text.
*
* @return true if there is text selected.
*/
bool isTextSelected() const
{ return bIsTextSelected; }
/**
* Initiate a text search.
*/
void findTextBegin();
/**
* Find the next occurrance of the expression.
*/
bool findTextNext( const QRegExp &exp );
/**
* end a text search.
*/
void findTextEnd();
/**
* Checks out whether there is a URL under the point and returns a pointer
* to this URL or 0L if there is none.
*
* @param _point the point to test for the presence of a URL. The
* point is relative to this widget.
*/
const char* getURL( QPoint &_point );
/**
* @return the width of the parsed HTML code. Remember that
* the documents width depends on the width of the widget.
*/
int docWidth() const;
/**
* @return the height of the parsed HTML code. Remember that
* the documents height depends on the width of the widget.
*/
int docHeight() const;
/**
* @return the url of this document
*/
KURL &getDocumentURL()
{ return actualURL; }
/**
* @return the base URL of this document
*/
KURL &getBaseURL()
{ return baseURL; }
/**
* @return the horizontal position the view has been scrolled to.
*/
int xOffset() const { return x_offset; }
/**
* @return the vertical position the view has been scrolled to.
*/
int yOffset() const { return y_offset; }
/**
* Find the default anchor. If the anchor is found, the widget
* scrolls to the closest position. Returns TRUE if the anchor has
* been found.
*/
bool gotoAnchor();
/**
* Find the anchor named '_name'. If the anchor is found, the widget
* scrolls to the closest position. Returns TRUE if the anchor has
* been found. If the anchor could not be found it is retried when a
* new part of the document arrives.
*/
bool gotoAnchor( const char *_name );
/**
* Jumps to position _x_offset, _y_offset.
* Returns TRUE if the position was available
*/
bool gotoXY( int _x_offset, int _y_offset );
/**
* Causes the widget contents to scroll automatically. Call
* @ref #stopAutoScrollY to stop. Stops automatically when the
* top or bottom of the document is reached.
*
* @param _delay Time in milliseconds to wait before scrolling the
* document again.
* @param _dy The amount to scroll the document when _delay elapses.
*/
void autoScrollY( int _delay, int _dy );
/**
* Stops the document from @ref #autoScrollY ing.
*/
void stopAutoScrollY();
/**
* Returns if the widget is currently auto scrolling.
*/
bool isAutoScrollingY()
{ return autoScrollYTimer.isActive(); }
/**
* If this widget belongs to a @ref HTMLView, then this function
* is used to tell the widget about its owner.
*
* @see #htmlView
* @see #getView
*/
void setView( KHTMLView *_view ) { htmlView = _view; }
/**
* @return the @ref KHTMLView this widget belongs to.
*
* @see #setView
*/
KHTMLView* getView() { return htmlView; }
/**
* @return TRUE if the currently displayed document is a frame set.
*/
bool isFrameSet() { return bIsFrameSet; }
/**
* Tells this widget that it displays a frameset.
* For internal use only.
*/
void setIsFrameSet( bool _b );
/**
* @return a pointer to the currently selected frame ( @ref KHTMLView ) if
* we are displaying a frameset, otherwise 0L. If this widget is the
* selected one then @ref htmlView is returned. Otherwise all
* @ref HTMLFrameSet instances are asked.
*/
KHTMLView* getSelectedFrame();
/**
* @return TRUE if the currently displayed document is a frame.
*/
bool isFrame() { return bIsFrame; }
/**
* Tell the widget wether it is a frame or not.
* For internal use only.
*
* @see #isFrame
*/
void setIsFrame( bool _frame);
/**
* Sets the margin width in pixels. This function is used to implement the
* <tt><frame marginwidth=... ></tt> tag.
* It is called from @ref KHTMLView and is for INTERNAL USE ONLY.
*
* @see #leftBorder
* @see #rightBorder
* @see KHTMLView::setMarginWidth
*/
void setMarginWidth( int _w ) { leftBorder = _w; rightBorder = _w + 4; }
/**
* Sets the margin height in pixels. This function is used
* to implement the
* <tt><frame marginheight=... ></tt> tag.
* It is called from @ref KHTMLView and is for INTERNAL USE ONLY.
*
* @see #topBorder
* @see #bottomBorder
* @see KHTMLView::setMarginHeight
*/
void setMarginHeight( int _h ) { topBorder = _h; bottomBorder = _h; }
/**
* @return if the user selected this widget.
*
* @see #bIsSelected
* @see #setSelected
*/
bool isSelected()
{
return bIsSelected;
}
/**
* Switches the 'selected state' of this widget. This results in the
* drawing or deleting of the black border around the widget.
*
* @see #isSelected
*/
void setSelected( bool _active );
/**
* Sets the base font size ( range: 2-5, default: 3 ).
*
* Note that font sizes are not defined in points.
* Font sizes range from 1 (smallest) to 7 (biggest).
*/
void setDefaultFontBase( int size )
{ if ( size < 2 ) size = 2;
else if ( size > 5 ) size = 5;
defaultSettings->fontBaseSize = size - 1;
}
//
// The new interface:
// use:
// int newFontSizes[7];
//
void setFontSizes(const int *newFontSizes);
void getFontSizes(int *newFontSizes);
void resetFontSizes( void );
/**
* Sets the standard font style.
*
* @param name is the font name to use for standard text.
*/
void setStandardFont( const char *name )
{ defaultSettings->fontBaseFace = name; }
/**
* Sets the fixed font style.
*
* @param name is the font name to use for fixed text, e.g.
* the <tt><pre></tt> tag.
*/
void setFixedFont( const char *name )
{ defaultSettings->fixedFontFace = name; }
/**
* Sets the default background color to use when one isn't specified
* explicitly by <tt><body bgcolor=...></tt>
*/
void setDefaultBGColor( const QColor &col )
{ defaultSettings->bgColor = col; }
/**
* Sets the default text colors.
*/
void setDefaultTextColors( const QColor &normal, const QColor &link,
const QColor &vlink )
{
defaultSettings->fontBaseColor = normal;
defaultSettings->linkColor = link;
defaultSettings->vLinkColor = vlink;
}
/**
* Set whether links are drawn in underlined text.
*/
void setUnderlineLinks( bool ul )
{ defaultSettings->underlineLinks = ul; }
/**
* Sets the cursor to use when the cursor is on a link.
*/
void setURLCursor( const QCursor &c )
{ linkCursor = c; }
/**
* Force use of user defined colors
*/
void setForceDefault( bool force )
{ defaultSettings->forceDefault = force; }
/**
* Cryptic? This is used to set the number of tokens to parse
* in one timeslice during background processing.
*
* You probably don't need to touch this.
*/
void setGranularity( int g )
{ granularity = g; }
/*
* If a HTMLObject object needs a file from the web, it
* calls this function.
*/
void requestFile( HTMLObject *_obj, const char *_url );
/*
* Cancels a previous @ref requestFile.
*/
void cancelRequestFile( HTMLObject *_obj );
/*
* Cancels all @ref requestFile.
*/
void cancelAllRequests();
// This function is called to download the background image from the web
void requestBackgroundImage( const char *_url );
/*
* This function is used to repaint images that have been loaded from the
* web.
*/
void paintSingleObject( HTMLObject *_obj );
/*
* Internal function to paint a single object with a known chain.
*/
void paint( HTMLChain *_chain, int x, int y, int w, int h );
/*
* Internal function to paint a cell
*/
void paint( HTMLCellInfo * );
/*
* Schedule a paint event. This is used internally to force a paint
* event when, for example, an image has been loaded and the document
* has been layed out again.
*/
void scheduleUpdate( bool clear );
/**
* Internal use - calculates the absolute position of the objects.
*/
void calcAbsolutePos();
/*
* return the map matching mapurl
* For internal use only
*/
HTMLMap *getMap( const char *mapurl );
// Registers QImageIO handlers for JPEG and GIF
static void registerFormats();
/**
* @return a pointer to the @ref JSEnvironment instance used by this widget.
* Every call to this function will result in the same pointer.
*
* @see #jsEnvironment
*/
JSEnvironment* getJSEnvironment();
/**
* A convenience function to access the @ref JSWindowObject of this html
* widget.
*
* @see #getJSEvironment
*/
JSWindowObject* getJSWindowObject();
/**
* @return a list of all frames.
*
* @see #frameList
*/
QList<KHTMLWidget>* getFrameList() { return &frameList; }
/**
* Set document charset.
*
* Any <META ...> setting charsets overrides this setting
*
* @return TRUE if successfull
*
*/
bool setCharset(const char *name);
/**
* set a charset, which will override the <meta ...> setting
*/
void setOverrideCharset(const char *name = 0);
//-----------------------------------------------------------
// FUNCTIONS used for KFM Extension
// -----------------------------------------------------------
bool setMarker( const char *_url );
bool selectFromMarker( const char *_url );
bool cellDown( bool select );
bool cellUp( bool select );
bool cellLeft( bool select );
bool cellRight( bool select );
void cellSelected();
void cellActivated();
void cellContextMenu();
void cellSequenceChanged(); // DF
// reset the current key sequence (for instance when changing directory). DF
void resetCurrentKeySeq() { currentKeySeq = ""; }
//-----------------------------------------------------------
// End KFM Extensions
// -----------------------------------------------------------
// Another option to feed image data into the HTML Widget
void data( const char *_url, const char *_data, int _len, bool _eof );
//for saving and restoring pages
SavedPage *saveYourself(SavedPage *p = 0);
void restore(SavedPage *);
void restorePosition( int x, int y );
protected:
void buildFrameSet(SavedPage *p, QString *s);
void buildFrameTree(SavedPage *p, HTMLFrameSet *f);
int initialXPos;
int initialYPos;
public:
signals:
/**
* This signal is emitted whenever the Widget wants to
* change the window's title. Usually this is the text
* enclosed in <tt><title>....</title></tt>.
*/
void setTitle( const char * );
/**
* The user pressed ALT + Up
*/
void goUp();
/**
* The user pressed ALT + Left
*/
void goLeft();
/**
* The user pressed ALT + Right
*/
void goRight();
/**
* The user double clicked on a URL.
*
* @param _url the URL that the user clicked on.
* @param _button the mouse button that was used.
*/
void doubleClick( const char * _url, int _button);
/**
* Tells the parent, that the widget has scrolled. This may happen if
* the user selects an <tt><a href="#anchor"></tt>.
*/
void scrollVert( int _y );
/**
* Tells the parent, that the widget has scrolled. This may happen if
* the user selects an <a href="#anchor">.
*/
void scrollHorz( int _x );
/**
* Signals that a URL has been selected using a single click.
*
* @param _url is the URL clicked on.
* @param _button is the mouse button clicked.
*/
void URLSelected( const char *_url, int _button );
/**
* Signals that a URL has been selected using a single click.
*
* @param _url is the URL clicked on.
* @param _button is the mouse button clicked.
* @param _target is the target window or 0L if there is none.
* ( Used to implement frames ).
*/
void URLSelected( const char *_url, int _button, const char *_target );
/**
* Signals that the mouse cursor has moved on or off a URL.
*
* @param _url is the URL that the mouse cursor has moved onto.
* _url is null if the cursor moved off a URL.
*/
void onURL( const char *_url );
/**
* Signal that the user has selected text or the existing selection has
* become unselected. The text may be retrieved using
* @ref #getSelectedText. This is a good signal to connect to for
* enabling/disabling the Copy menu item or calling XSetSelectionOwner().
*
* @param _selected is true if the user has selected text or false if
* the current selection has been removed.
*/
void textSelected( bool _selected );
/**
* Indicates the document has changed due to new URL loaded
* or progressive update. This signal may be emitted several times
* while the document is being parsed. It is an ideal opportunity
* to update any scrollbars.
*/
void documentChanged();
/**
* This signal is emitted if the widget got a call to @ref #parse
* or @ref #begin. This indicates that the widget is working.
* In a Web Browser you can use this to start an animated logo
* like netscape does. The signal @ref #documentDone will tell
* you that the widget finished its job.
*
* @see #documentDone
*/
void documentStarted();
/**
* This signal is emitted when document is finished parsing
* and all required images arrived.
*
* @see #documentStarted
*/
void documentDone();
/// Emitted if the user pressed the right mouse button
/**
* If the user pressed the right mouse button over a URL than _url
* points to this URL, otherwise _url will be null.
* The position is in global coordinates.
*/
void popupMenu( const char *_url, const QPoint & );
/**
* This signal is emitted if the user presses the mouse. If he clicks on
* a link you get the URL in '_url'.
*
* @param _url is the clicked URL or null is there was none.
* @param _target is the target frame if one is mentioned otherwise 0L.
* @param _ev the @ref QMouseEvent.
*/
void mousePressed( const char *_url, const char *_target, QMouseEvent *_ev );
// The widget requests to load a file
/**
* KHTMLWidget can only load files from your local disk. If it
* finds a object which requires a remote file, it will emit this
* signal. If the file is loaded at some time, call @ref #slotFileLoaded.
*
* If the file is not needed any more, the signal @ref #cancelFileRequest
* is emitted.
*
* @param _url is the URL of the image that needs to be loaded.
*/
void fileRequest( const char *_url );
// Cancels a file that has been requested.
void cancelFileRequest( const char *_url );
// signal when user has submitted a form
void formSubmitted( const char *_method, const char *_url, const char *_data );
// signal that the HTML Widget has changed size
void resized( const QSize &size );
/**
* used for url redirection
*/
void redirect( int delay, const char * url );
public slots:
/**
* Scrolls the document to _y.
*
* This is usually connected to a scrollbar.
*/
void slotScrollVert( int _y );
/**
* Scrolls the document to _x.
*
* This is usually connected to a scrollbar.
*/
void slotScrollHorz( int _x );
/**
* Call when a file requested by @ref #fileRequest has been loaded.
*
* @param _url is the URL of the file that was requested.
* @param _filename is the name of the file that has been stored on
* the local filesystem.
*/
void slotFileLoaded( const char *_url, const char *_filename );
protected slots:
// void slotTimeout();
void scrollBlobTimeout ();
/*
* INTERNAL
*
* Called when the widget needs an update.
*/
void slotUpdate();
/*
* INTERNAL
*
* Called by timer event when the widget is due to autoscroll.
*/
void slotAutoScrollY();
/*
* INTERNAL
*
* Used to update the selection when the user has caused autoscrolling
* by dragging the mouse out of the widget bounds.
*/
void slotUpdateSelectText( int newy );
/*
* INTERNAL
*
* Called when the user submitted a form.
*/
void slotFormSubmitted( const char *_method, const char *_url, const char *_data );
/*
* INTERNAL
*
* Called if this widget displays a frameset and the user selected
* one of the frames. In this case we have to unselect the
* currently selected frame if there is one.
*/
void slotFrameSelected( KHTMLView *_view );
public:
enum ListNumType { Numeric = 0, LowAlpha, UpAlpha, LowRoman, UpRoman };
enum ListType { Unordered, UnorderedPlain, Ordered, Menu, Dir };
protected:
virtual void mousePressEvent( QMouseEvent * );
virtual void mouseMoveEvent( QMouseEvent * );
void setBlob (QPoint pos);
void clearBlob ();
/**
* This function emits the 'doubleClick' signal when the user
* double clicks a <a href=...> tag.
*/
virtual void mouseDoubleClickEvent( QMouseEvent * );
/**
* Overload this method if you dont want any drag actions.
*/
virtual void dndMouseMoveEvent( QMouseEvent * _mouse );
/**
* This function emits the 'URLSelected' signal when the user
* pressed a <a href=...> tag.
*/
virtual void dndMouseReleaseEvent( QMouseEvent * );
virtual void dragEndEvent();
/**
* Called when a URL is encountered. Overload this method to indicate
* which links have been visited previously.
*
* @return true if the URL has been visited previously. If true is
* returned the URL will be rendered in the vlink color. If false
* is returned the URL will be rendered in the link color.
*/
virtual bool URLVisited( const char *_url );
virtual void paintEvent( QPaintEvent * );
virtual void resizeEvent( QResizeEvent * );
virtual void keyPressEvent( QKeyEvent * );
virtual void timerEvent( QTimerEvent * );
// we don't want global palette changes affecting us
virtual void setPalette( const QPalette & ) {}
// reimplemented to prevent flicker
virtual void focusInEvent( QFocusEvent * ) { }
virtual void focusOutEvent( QFocusEvent * ) { }
// flush key presses from the event queue
void flushKeys();
// do </a> if necessary
void closeAnchor()
{
if ( url )
{
popColor();
popFont();
}
url = 0;
target = 0;
}
/*
* This function creates a new flow adds it to '_clue' and sets 'flow'
*/
void newFlow(HTMLClue *_clue);
void insertText(char *str, const HTMLFont * fp);
/*
* This function is called after <body> usually. You can
* call it for every rectangular area: For example a tables cell
* or for a menus <li> tag. ht gives you one token after another.
* _clue points to a VBox. All HTMLObjects created by this
* function become direct or indirect children of _clue.
* The last two parameters define which token signals the end
* of the section this function should parse, for example </body>.
* You can specify two tokens, for example </li> and </menu>.
* You may even set the second one to "" if you dont need it.
*/
const char* parseBody( HTMLClueV *_clue, const char *[], bool toplevel = FALSE );
const char* parseOneToken( HTMLClueV *_clue, const char *str );
/*
* Parse marks starting with character, e.g.
* <img ... is processed by KHTMLWidget::parseI()
* </ul> is processed by KHTMLWidget::parseU()
*/
void parseA( HTMLClueV *_clue, const char *str );
void parseB( HTMLClueV *_clue, const char *str );
void parseC( HTMLClueV *_clue, const char *str );
void parseD( HTMLClueV *_clue, const char *str );
void parseE( HTMLClueV *_clue, const char *str );
void parseF( HTMLClueV *_clue, const char *str );
void parseG( HTMLClueV *_clue, const char *str );
void parseH( HTMLClueV *_clue, const char *str );
void parseI( HTMLClueV *_clue, const char *str );
void parseJ( HTMLClueV *_clue, const char *str );
void parseK( HTMLClueV *_clue, const char *str );
void parseL( HTMLClueV *_clue, const char *str );
void parseM( HTMLClueV *_clue, const char *str );
void parseN( HTMLClueV *_clue, const char *str );
void parseO( HTMLClueV *_clue, const char *str );
void parseP( HTMLClueV *_clue, const char *str );
void parseQ( HTMLClueV *_clue, const char *str );
void parseR( HTMLClueV *_clue, const char *str );
void parseS( HTMLClueV *_clue, const char *str );
void parseT( HTMLClueV *_clue, const char *str );
void parseU( HTMLClueV *_clue, const char *str );
void parseV( HTMLClueV *_clue, const char *str );
void parseW( HTMLClueV *_clue, const char *str );
void parseX( HTMLClueV *_clue, const char *str );
void parseY( HTMLClueV *_clue, const char *str );
void parseZ( HTMLClueV *_clue, const char *str );
/*
* This function is called after the <cell> tag.
*/
const char* parseCell( HTMLClue *_clue, const char *attr );
/*
* parse table
*/
const char* parseTable( HTMLClue *_clue, int _max_width, const char * );
/*
* parse input
*/
const char* parseInput( const char * );
/*
* This function is used for convenience only. It inserts a vertical space
* if this has not already been done. For example
* <h1>Hello</h1><p>How are you ?
* would insert a VSpace behind </h1> and one in front of <p>. This is one
* VSpace too much. So we use 'space_inserted' to avoid this. Look at
* 'parseBody' to see how to use this function.
* Assign the return value to 'space_inserted'.
*/
bool insertVSpace( HTMLClueV *_clue, bool _space_inserted );
public:
/*
* draw background area
*/
void drawBackground( int _xval, int _yval, int _x, int _y, int _w, int _h,
QPainter *p = 0 );
protected:
/*
* position form elements (widgets) on the page
*/
void positionFormElements();
/*
* The current string formed by the sequence of key pressed
*/
QString currentKeySeq;
/*
* The <title>...</title>.
*/
QString title;
/*
* If we are in an <a href=..> ... </a> tag then the href
* is stored in this string.
*/
char *url;
/*
* If we are in an <a target=..> ... </a> tag then this points to the
* target.
*/
char *target;
/*
* This is the URL that the cursor is currently over
*/
QString overURL;
/*
* Reference (anchor) to jump to once it becomes available
*/
QString reference;
/*
* overrides the document charset as specified by <meta> if set.
*/
QString overrideCharset;
/*
* This painter is created at need, for example to draw
* a selection or for font metrics stuff.
*/
QPainter *painter;
/*
* This is the pointer to the tree of HTMLObjects.
*/
HTMLClueV *clue;
/*
* This is the scroll offset. The upper left corner is (0,0).
*/
int x_offset, y_offset;
/*
* The amount to auto scroll by.
*/
int autoScrollDY;
/*
* The delay to wait before auto scrolling autoScrollDY
*/
int autoScrollYDelay;
/*
* Timer for autoscroll stuff
*/
QTimer autoScrollYTimer;
/*
* Timer used to schedule paint events
*/
QTimer updateTimer;
/*
* This object contains the complete text. This text is referenced
* by HTMLText objects for example. So you may not delete
* 'ht' until you have delete the complete tree 'clue' is
* pointing to.
*/
HTMLTokenizer *ht;
QArray<char *> memPool;
int memPoolMax;
/*
* This is used generally for processing the contents of < ... >
* We keep a class global instance of this object to reduce the
* number of new/deletes performed. If your function may be
* called recursively, or somehow from a function using this
* tokenizer, you should construct your own.
*/
StringTokenizer *stringTok;
/*
* Selects a new font adding _relative_font_size to fontBase
* to get the new size.
*/
void selectFont( int _relative_font_size );
/*
* Selects a new font using current settings
*/
void selectFont();
/*
* Makes the font specified by parameters the actual font
*/
void selectFont( const char *_fontfamily, int _size, int _weight, bool _italic );
/*
* Pops the top font form the stack and makes the new
* top font the actual one. If the stack is empty ( should never
* happen! ) the default font is pushed on the stack.
*/
void popFont();
const HTMLFont *currentFont() { return font_stack.top(); }
void popColor();
// List of all objects waiting to get a remote file loaded
// XXXX QList<HTMLObject> waitingFileList;
/*
* The font stack. The font on top of the stack is the currently
* used font. Poping a font from the stack deletes the font.
* So use top() to get the actual font. There must always be at least
* one font on the stack.
*/
QStack<HTMLFont> font_stack;
/*
* The weight currently selected. This is affected by <b>..</b>
* for example.
*/
int weight;
/*
* The fonts italic flag. This is affected by <i>..</i>
* for example.
*/
bool italic;
/*
* The fonts underline flag. This is affected by <u>..</u>
* for example.
*/
bool underline;
/*
* The fonts underline flag. This is affected by <u>..</u>
* for example.
*/
bool strikeOut;
/*
* Used for drag and drop.
*/
bool pressed;
int press_x, press_y;
/*
* When the user presses the mouse over an URL, this URL is stored
* here. We might need it if the user just started a drag.
*/
QString pressedURL;
/**
* If the user pressed the mouse button over an URL then this is the name
* of the target window for this hyper link. Used to implement frames.
*
* @see #pressedURL
*/
QString pressedTarget;
/*
* If the user drags a URL out of the widget, by default this pixmap
* is used for the dragged icon. The pixmap is loaded in the constructor.
*/
QPixmap dndDefaultPixmap;
/*
* Start of selection
*/
QPoint selectPt1;
/*
* End of selection
*/
QPoint selectPt2;
/*
* is any text currently selected
*/
bool bIsTextSelected;
/*
* This is the URL which is visible on the screen. This URL
* is needed to complete URLs like <a href="classes.html"> since
* for example 'URLSelected' should provide a complete URL.
*/
KURL actualURL;
KURL baseURL; // this will do for now - MRJ
// actually we need something like this to implement
// <base ...>
/*
* This sets the baseURL given a URL. It strips of any filename.
*/
void setBaseURL( const char *_url);
/*
* from <BASE TARGET="...">
*/
QString baseTarget;
/*
* Current text color is at the top of the stack
*/
QStack<QColor> colorStack;
/*
* A color context for the current page so that we can free the colors
* when we close the page.
*/
int colorContext;
class HTMLStackElem;
typedef void (KHTMLWidget::*blockFunc)(HTMLClueV *_clue, HTMLStackElem *stackElem);
class HTMLStackElem
{
public:
HTMLStackElem( int _id,
int _level,
blockFunc _exitFunc,
int _miscData1,
int _miscData2,
HTMLStackElem * _next
)
: id(_id),
level(_level),
exitFunc(_exitFunc),
miscData1(_miscData1),
miscData2(_miscData2),
next(_next)
{ }
int id;
int level;
blockFunc exitFunc;
int miscData1;
int miscData2;
HTMLStackElem *next;
};
HTMLStackElem *blockStack;
void pushBlock( int _id, int _level,
blockFunc _exitFunc = 0,
int _miscData1 = 0,
int _miscData2 = 0);
void popBlock( int _id, HTMLClueV *_clue);
void freeBlock( void);
/*
* Code for closing-tag to restore font
* miscData1: bool - if true terminate current flow
*/
void blockEndFont(HTMLClueV *_clue, HTMLStackElem *stackElem);
/*
* Code for closing-tag to end PRE tag
*/
void blockEndPre(HTMLClueV *_clue, HTMLStackElem *stackElem);
/*
* Code for closing-tag to restore font and font-color
*/
void blockEndColorFont(HTMLClueV *_clue, HTMLStackElem *stackElem);
/*
* Code for closing-tag to restore indentation
* miscData1: int - previous indentation
*/
void blockEndIndent(HTMLClueV *_clue, HTMLStackElem *stackElem);
/*
* Code for remove item from listStack and restore indentation
* miscData1: int - previous indentation
* miscData2: bool - if true insert vspace
*/
void blockEndList(HTMLClueV *_clue, HTMLStackElem *stackElem);
/* code to restore old alignment after <div></div> */
void blockEndDiv( HTMLClueV *_clue, HTMLStackElem *Elem);
/*
* Timer to parse html in background
*/
int timerId;
/*
* begin() has been called, but not end()
*/
bool writing;
/*
* Is the widget currently parsing
*/
bool parsing;
/*
* Have we parsed <body> yet?
*/
bool bodyParsed;
/*
* size of current indenting
*/
int indent;
class HTMLList
{
public:
HTMLList( ListType t, ListNumType nt = Numeric )
{ type = t; numType = nt; itemNumber = 1; }
ListType type;
ListNumType numType;
int itemNumber;
};
/*
* Stack of lists currently active.
* The top affects whether a bullet or numbering is used by <li>
*/
QStack<HTMLList> listStack;
enum GlossaryEntry { GlossaryDL, GlossaryDD };
/*
* Stack of glossary entries currently active
*/
QStack<GlossaryEntry> glossaryStack;
/*
* The current alignment, set by <DIV > or <CENTER>
*/
HTMLClue::HAlign divAlign;
/*
* Number of tokens parsed in the current time-slice
*/
int parseCount;
int granularity;
/*
* Used to avoid inserting multiple vspaces
*/
bool vspace_inserted;
/*
* The current flow box to add objects to
*/
HTMLClue *flow;
/*
* Array of paser functions, e.g.
* <img ... is processed by KHTMLWidget::parseI() - parseFuncArray[8]()
* </ul> is processed by KHTMLWidget::parseU() - parseFuncArray[20]()
*/
static parseFunc parseFuncArray[26];
/*
* This list holds strings which are displayed in the view,
* but are not actually contained in the HTML source.
* e.g. The numbers in an ordered list.
*/
QStrList tempStrings;
/*
* This list holds all <a href= urls in the document.
*/
QStrList parsedURLs;
QStrList parsedTargets;
QPixmap bgPixmap;
/*
* This is the cusor to use when over a link
*/
QCursor linkCursor;
/*
* Current fontbase, colors, etc.
*/
HTMLSettings *settings;
/*
* Default settings.
*/
HTMLSettings *defaultSettings;
// should the background be painted?
bool bDrawBackground;
/*
* The URL of the not loaded!! background image
* If we are waiting for a background image then this is its URL.
* If the image is already loaded or if we don't have one this variable
* contains 0. You can write bgPixmapURL.isNull() to test wether we are
* waiting for a background pixmap.
*/
QString bgPixmapURL;
// true if the current text is destined for <title>
bool inTitle;
// List of forms in the page
QList<HTMLForm> formList;
// Current form
HTMLForm *form;
// Current select form element
HTMLSelect *formSelect;
// true if the current text is destined for a <SELECT><OPTION>
bool inOption;
// Current textarea form element
HTMLTextArea *formTextArea;
// true if the current text is destined for a <TEXTAREA>...</TEXTAREA>
bool inTextArea;
// true if the current text is destined for a <PRE>...</PRE>
bool inPre;
// the text to be put in a form element
QString formText;
/*
* Image maps used in this document
*/
QList<HTMLMap> mapList;
/*
* The toplevel frame set if we have frames otherwise 0L.
*/
HTMLFrameSet *frameSet;
/*
* Stack of framesets used during parsing.
*/
QList<HTMLFrameSet> framesetStack;
/*
* List of all framesets we are currently showing.
* This list is not cleared after parsing like @ref #framesetStack.
*/
QList<HTMLFrameSet> framesetList;
/*
* List of all frames appearing in this window. They are stored in
* source order. JavaScript uses this list to implement its
* frames array.
*/
QList<KHTMLWidget> frameList;
/*
* @return TRUE if the current document is a framed document.
*/
bool bIsFrameSet;
/*
* @return TRUE if the widget is a frame of a frameset.
*/
bool bIsFrame;
/*
* Is TRUE if we parsed the complete frame set.
*/
bool bFramesComplete;
/*
* is true if were between <noframes> and </noframes>
*/
bool bInNoframes;
/*
* If the owner of this widget is a @ref HTMLView then this is a
* pointert to the owner, otherwise 0L.
*/
KHTMLView *htmlView;
/*
* This is a pointer to the selectede frame. This means that the frame
* gets a black inner border.
*/
KHTMLView *selectedFrame;
/*
* Flag that indicates wether the user selected this widget. This is only of
* interest if the widget is a frame in a frameset. Try Netscape to see
* what I mean.
*
* @see #selectedFrame
*/
bool bIsSelected;
/*
* Holds the amount of pixel for the left border. This variable is used
* to implement the
* <tt><frame marginwidth=... ></tt> tag.
*
* @see #rightBorder
* @see #setMarginWidth
*/
int leftBorder;
/*
* Holds the amount of pixel for the right border. This variable is used
* to implement the
* <tt><frame marginwidth=... ></tt> tag.
*
* @see #leftBorder
* @see #setMarginWidth
*/
int rightBorder;
/*
* Holds the amount of pixel for the top border. This variable is used
* to implement the
* <tt><frame marginheight=... ></tt> tag.
*
* @see #bottomBorder
* @see #setMarginHeight
*/
int topBorder;
/*
* Holds the amount of pixel for the bottom border. This variable is used
* to implement the
* <tt><frame marginheight=... ></tt> tag.
*
* @see #setMarginHeight
* @see #topBorder
*/
int bottomBorder;
/*
* This pointer is per default 0L. An instance of @ref JSEnvironment is
* created if someone calls @ref #getJSEnvironment. This instance is used
* to run java script.
*/
JSEnvironment *jsEnvironment;
KCharsetConverter *charsetConverter;
/*
* Iterator used to find text within the document
*/
HTMLIterator *textFindIter;
/**
* Keeps a list of all pending file.
*/
QDict<HTMLPendingFile> mapPendingFiles;
QPixmap scrollBlobPixmap;
QWidget *scrollBlob;
QTimer *scrollBlobTimer;
enum ScrollType scrollBlobType;
};
#endif // HTML
Documentation generated by root@darkstar.lst.de on Wed Sep 8 17:38:46 CEST 1999