kwqkhtmlpart.h

手机浏览器源码程序,功能强大

/*
 * Copyright (C) 2003 Apple Computer, Inc.  All rights reserved.
 * Portions Copyright (c) 2005 Nokia Corporation, Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef KWQKHTMLPart_H
#define KWQKHTMLPart_H

#include "khtml_part.h"

#include "dom/dom2_range.h"
#include "xml/dom_nodeimpl.h"
#include "dom_nodeimpl.h"
#include "html_formimpl.h"
#include "html_tableimpl.h"

#include "WebCoreKeyboardAccess.h"
#include "WebCoreKeyValuePair.h"

#include <e32base.h>
#include <w32std.h>

#include "KWQDict.h"
#include "KWQClipboard.h"

class KHTMLPartPrivate;
class KWQClipboard;
class KWQWindowWidget;

namespace khtml {
    class RenderObject;
}

namespace KJS {
    class SavedProperties;
    class SavedBuiltins;
    class ScheduledAction;
}

class CWebCoreBridge;
class CWebScriptObject;

class CurrentEvent;

enum KWQSelectionDirection {
    KWQSelectingNext,
    KWQSelectingPrevious
};

enum KWQFindResult {
 KWQFindNoMatches   = 0x1,
 KWQFindWrapArround = 0x2,
 KWQFindAllMatches  = 0x4,
 KWQFindAMatch      = 0x8
};

class KWQKHTMLPart : public KHTMLPart
{
public:

    KWQKHTMLPart();
    ~KWQKHTMLPart();

    void clear();

    void setBridge(CWebCoreBridge *p);
    CWebCoreBridge *bridge() const { return _bridge; }
    void setView(KHTMLView *view);
    KHTMLView *view() const;

    void provisionalLoadStarted();

    virtual bool openURL(const KURL &);
    virtual bool closeURL();
    void didNotOpenURL(const KURL &);

    void openURLRequest(const KURL &, const KParts::URLArgs &);
    void submitForm(const KURL &, const KParts::URLArgs &);

    void scheduleHistoryNavigation( int steps );

    bool activateEvent();
    void activateNodeAtPoint(const QPoint &point);

    void deActivateEvent(bool acceptChanges);

    void scrollToAnchor(const KURL &);
    void jumpToSelection();

    void setEncoding(const QString &encoding, bool userChosen);
    void addData(const char *bytes, int length);

    void setTitle(const DOM::DOMString &);
    void setStatusBarText(const QString &status);

    void urlSelected(const KURL &url, int button, int state, const KParts::URLArgs &args);
    bool requestObject(khtml::RenderPart *frame, const QString &url, const QString &serviceType, const QStringList &args);
    KParts::ReadOnlyPart *createPart(const khtml::ChildFrame &child, const KURL &url, const QString &mimeType);

    void scheduleClose();

    void unfocusWindow();

    QMap<int, KJS::ScheduledAction*> *pauseActions(const void *key);
    void resumeActions(QMap<int, KJS::ScheduledAction*> *actions, const void *key);

    bool canCachePage();
    void saveWindowProperties(KJS::SavedProperties *windowProperties);
    void saveLocationProperties(KJS::SavedProperties *locationProperties);
    void restoreWindowProperties(KJS::SavedProperties *windowProperties);
    void restoreLocationProperties(KJS::SavedProperties *locationProperties);
    void saveInterpreterBuiltins(KJS::SavedBuiltins &interpreterBuiltins);
    void restoreInterpreterBuiltins(const KJS::SavedBuiltins &interpreterBuiltins);

//    void openURLFromPageCache(KWQPageState *state);

    void saveDocumentState();
    void restoreDocumentState();

    bool isFrameSet() const;

    void updatePolicyBaseURL();

//    NSView *nextKeyView(DOM::NodeImpl *startingPoint, KWQSelectionDirection);
//    NSView *nextKeyViewInFrameHierarchy(DOM::NodeImpl *startingPoint, KWQSelectionDirection);
//    static NSView *nextKeyViewForWidget(QWidget *startingPoint, KWQSelectionDirection);
//    static bool currentEventIsKeyboardOptionTab();
//    static bool handleKeyboardOptionTabInView(NSView *view);

//    virtual bool tabsToLinks() const;
//    virtual bool tabsToAllControls() const;

    static bool currentEventIsMouseDownInWidget(QWidget *candidate);

    static void setDocumentFocus(QWidget *);
    static void clearDocumentFocus(QWidget *);

    void runJavaScriptAlert(const QString &message);
    bool runJavaScriptConfirm(const QString &message, const QString &yes, const QString &no);
    bool runJavaScriptPrompt(const QString &message, const QString &defaultValue, QString &result);
    bool locationbarVisible();
    bool menubarVisible();
    bool personalbarVisible();
    bool scrollbarsVisible();
    bool statusbarVisible();
    bool toolbarVisible();

    void addMessageToConsole(const QString &message,  unsigned int lineNumber, const QString &sourceID);
    using KHTMLPart::xmlDocImpl;
    khtml::RenderObject *renderer() const;
    void forceLayout();
    void forceLayoutWithPageWidthRange(int minPageWidth, int maxPageWidth);
    void sendResizeEvent();
    void sendScrollEvent();
    void paint(QPainter *, const QRect &);

    void adjustPageHeight(int *newBottom, int oldTop, int oldBottom, int bottomLimit);

    void createEmptyDocument();

    static CWebCoreBridge *bridgeForWidget(const QWidget *);
    static KWQKHTMLPart *partForWidget(const QWidget *);

    QString requestedURLString() const;
    QString incomingReferrer() const;
    QString userAgent() const;

    QString mimeTypeForFileName(const QString &) const;

    DOM::NodeImpl *selectionStart() const;
    int selectionStartOffset() const;
    DOM::NodeImpl *selectionEnd() const;
    int selectionEndOffset() const;

    QRect selectionRect() const;
//    NSRect visibleSelectionRect() const;
//    NSImage *selectionImage() const;
//    NSImage *snapshotDragImage(DOM::Node node, NSRect *imageRect, NSRect *elementRect) const;

//    NSFont *fontForCurrentPosition() const;

//    NSFileWrapper *fileWrapperForElement(DOM::ElementImpl *);
//    NSAttributedString *attributedString(DOM::NodeImpl *startNode, int startOffset, DOM::NodeImpl *endNode, int endOffset);

    void addMetaData(const QString &key, const QString &value);

    void MouseDown(TPointerEvent);
    void MouseDragged(TPointerEvent);
    void MouseUp(TPointerEvent);
    void MouseMoved(TPointerEvent);
    bool KeyEvent(const TKeyEvent& event, bool up);
    //bool LastEventIsMouseUp();


    //Methods to update focusable node list
    void updateFocusableRectList();
    //Method to determine the cursor position
    bool determineCursorPositon(QRect &searchRect, QPoint &newCursorPosition);

    void dragSourceMovedTo(const QPoint &loc);
    void dragSourceEndedAt(const QPoint &loc);

    bool tryCut();
    bool tryCopy();
    bool tryPaste();

//    bool sendContextMenuEvent(NSEvent *);

    void clearTimers();
    static void clearTimers(KHTMLView *);

    bool passSubframeEventToSubframe(DOM::NodeImpl::MouseEvent &);

    void redirectionTimerStartedOrStopped();

    static const QPtrList<KWQKHTMLPart> &instances() { return mutableInstances(); }

    void clearRecordedFormValues();
    void recordFormValue(const QString &name, const QString &value, DOM::HTMLFormElementImpl *element);
    DOM::HTMLFormElementImpl *currentForm() const;

//    NSString *searchForLabelsAboveCell(QRegExp *regExp, DOM::HTMLTableCellElementImpl *cell);
//    NSString *searchForLabelsBeforeElement(NSArray *labels, DOM::ElementImpl *element);
//    NSString *matchLabelsAgainstElement(NSArray *labels, DOM::ElementImpl *element);

    TInt FindString(const TDesC& str, TBool forward, TBool caseSensitive, TBool wrap, TBool sameStr = false);
    TInt FindStringAgain(const TDesC& str, TBool forward, TBool caseSensitive, TBool wrap);
    void ClearFind();

    void setSettings(KHTMLSettings *);

    KWQWindowWidget *topLevelWidget();

    QString overrideMediaType();

    void setMediaType(const QString &);

    void setUsesInactiveTextBackgroundColor(bool u) { _usesInactiveTextBackgroundColor = u; }
    bool usesInactiveTextBackgroundColor() const { return _usesInactiveTextBackgroundColor; }

    void setShowsFirstResponder(bool flag);
    bool showsFirstResponder() const { return _showsFirstResponder; }

    // Convenience, to avoid repeating the code to dig down to get this.
    QChar backslashAsCurrencySymbol() const;

    TRgb BodyBackgroundColor() const;

    TWebCoreKeyboardUIMode keyboardUIMode() const;

    void setName(const QString &name);

    void didTellBridgeAboutLoad(const QString &urlString);
    bool haveToldBridgeAboutLoad(const QString &urlString);

//    KJS::Bindings::Instance *getEmbedInstanceForView (NSView *aView);
//    KJS::Bindings::Instance *getAppletInstanceForView (NSView *aView);
//    void addPluginRootObject(const KJS::Bindings::RootObject *root);
    void cleanupPluginRootObjects();

    void registerCommandForUndo(const khtml::EditCommandPtr &);
    void registerCommandForRedo(const khtml::EditCommandPtr &);
    void clearUndoRedoOperations();
    bool interceptEditingKeyEvent();
    void issueUndoCommand();
    void issueRedoCommand();
    void issueCutCommand();
    void issueCopyCommand();
    void issuePasteCommand();
    void issuePasteAndMatchStyleCommand();
    void respondToChangedSelection(const khtml::Selection &oldSelection, bool closeTyping);
    void respondToChangedContents();
    virtual bool isContentEditable() const;
    virtual bool shouldBeginEditing(const DOM::Range &) const;
    virtual bool shouldEndEditing(const DOM::Range &) const;

//    KJS::Bindings::RootObject *executionContextForDOM();

    CWebScriptObject *windowScriptObject();

    void partClearedInBegin();

    // Implementation of CSS property -khtml-user-drag == auto
    bool shouldDragAutoNode(DOM::NodeImpl*) const;

    struct MarkedTextUnderline {
        MarkedTextUnderline(unsigned _startOffset, unsigned _endOffset, const QColor &_color, bool _thick)
            : startOffset(_startOffset)
            , endOffset(_endOffset)
            , color(_color)
            , thick(_thick)
        {}
        unsigned startOffset;
        unsigned endOffset;
        QColor color;
        bool thick;
    };

    //void setMarkedTextRange(const DOM::Range &, NSArray *attributes, NSArray *ranges);
    DOM::Range markedTextRange() const;
    bool markedTextUsesUnderlines() const;
    QValueList<MarkedTextUnderline> markedTextUnderlines() const;

    bool canGoBackOrForward(int distance) const;

    void dashboardRegionsChanged();

private:
    virtual void khtmlMousePressEvent(khtml::MousePressEvent *);
    virtual void khtmlMouseDoubleClickEvent(khtml::MouseDoubleClickEvent *);
    virtual void khtmlMouseMoveEvent(khtml::MouseMoveEvent *);
    virtual void khtmlMouseReleaseEvent(khtml::MouseReleaseEvent *);

    bool passWidgetMouseDownEventToWidget(khtml::MouseEvent *);
    bool passWidgetMouseDownEventToWidget(khtml::RenderWidget *);
    bool passWidgetMouseDownEventToWidget(QWidget *);

    void setPolicyBaseURL(const DOM::DOMString &);

//    NSView *mouseDownViewIfStillGood();

    QString generateFrameName();

//    NSView *nextKeyViewInFrame(DOM::NodeImpl *startingPoint, KWQSelectionDirection);
    static DOM::NodeImpl *nodeForWidget(const QWidget *);
    static KWQKHTMLPart *partForNode(DOM::NodeImpl *);
//    static NSView *documentViewForNode(DOM::NodeImpl *);

    bool dragHysteresisExceeded(float dragLocationX, float dragLocationY) const;
    bool dispatchCPPEvent(int eventId, KWQClipboard::AccessPolicy policy);
    bool dispatchDragSrcEvent(int eventId, const QPoint &loc) const;

//    NSImage *imageFromRect(NSRect rect) const;

    void freeClipboard();

    virtual bool isKHTMLPart() const;

    CWebCoreBridge *_bridge;

    //List of focusable nodes in the document
    QValueList<QRect> *_focusableNodeList;

    KWQSignal _started;
    KWQSignal _completed;
    KWQSignal _completedWithBool;

//    NSView *_mouseDownView;
    bool _mouseDownWasInSubframe;
    bool _sendingEventToSubview;
    bool _mouseDownMayStartDrag;
    bool _mouseDownMayStartSelect;
    // in our window's coords
    int _mouseDownWinX, _mouseDownWinY;
    // in our view's coords
    int _mouseDownX, _mouseDownY;

   static CurrentEvent *_currentEvent;
//    static NSResponder *_firstResponderAtMouseDownTime;

    KURL _submittedFormURL;

	CArrayFixFlat<TWebCoreKeyValuePair> *_formValuesAboutToBeSubmitted;
//    ObjCDOMElement *_formAboutToBeSubmitted;

    static QPtrList<KWQKHTMLPart> &mutableInstances();

    KWQWindowWidget *_windowWidget;

    bool _usesInactiveTextBackgroundColor;
    bool _showsFirstResponder;
    mutable bool _drawSelectionOnly;
    bool _haveUndoRedoOperations;

    QDict<char> urlsBridgeKnowsAbout;

    friend class KHTMLPart;

//    KJS::Bindings::RootObject *_bindingRoot;  // The root object used for objects
                                            // bound outside the context of a plugin.
//    QPtrList<KJS::Bindings::RootObject> rootObjects;
    CWebScriptObject *_windowScriptObject;

    DOM::Node _dragSrc;     // element that may be a drag source, for the current mouse gesture
    bool _dragSrcIsLink;
    bool _dragSrcIsImage;
    bool _dragSrcInSelection;
    bool _dragSrcMayBeDHTML, _dragSrcMayBeUA;   // Are DHTML and/or the UserAgent allowed to drag out?
    bool _dragSrcIsDHTML;
    KWQClipboard *_dragClipboard;   // used on only the source side of dragging

    mutable DOM::Node _elementToDraw;

    DOM::Range m_markedTextRange;
    bool m_markedTextUsesUnderlines;
    QValueList<MarkedTextUnderline> m_markedTextUnderlines;

};

inline KWQKHTMLPart *KWQ(KHTMLPart *part) { return static_cast<KWQKHTMLPart *>(part); }
inline const KWQKHTMLPart *KWQ(const KHTMLPart *part) { return static_cast<const KWQKHTMLPart *>(part); }

#endif