471 lines
18 KiB
C++
471 lines
18 KiB
C++
/* Copyright (c) 2006-2010, Linden Research, Inc.
|
|
*
|
|
* LLQtWebKit Source Code
|
|
* The source code in this file ("Source Code") is provided by Linden Lab
|
|
* to you under the terms of the GNU General Public License, version 2.0
|
|
* ("GPL"), unless you have obtained a separate licensing agreement
|
|
* ("Other License"), formally executed by you and Linden Lab. Terms of
|
|
* the GPL can be found in GPL-license.txt in this distribution, or online at
|
|
* http://secondlifegrid.net/technology-programs/license-virtual-world/viewerlicensing/gplv2
|
|
*
|
|
* There are special exceptions to the terms and conditions of the GPL as
|
|
* it is applied to this Source Code. View the full text of the exception
|
|
* in the file FLOSS-exception.txt in this software distribution, or
|
|
* online at
|
|
* http://secondlifegrid.net/technology-programs/license-virtual-world/viewerlicensing/flossexception
|
|
*
|
|
* By copying, modifying or distributing this software, you acknowledge
|
|
* that you have read and understood your obligations described above,
|
|
* and agree to abide by those obligations.
|
|
*
|
|
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
|
|
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
|
|
* COMPLETENESS OR PERFORMANCE.
|
|
*/
|
|
|
|
#ifndef LLQTWEBKIT_H
|
|
#define LLQTWEBKIT_H
|
|
|
|
#if defined _MSC_VER && _MSC_VER < 1600
|
|
// no pstdint.h in the client where this header is used
|
|
typedef unsigned long uint32_t;
|
|
#else
|
|
#include <stdint.h> // Use the C99 official header
|
|
#endif
|
|
|
|
#include <string>
|
|
#include <map>
|
|
#include <vector>
|
|
|
|
class LLEmbeddedBrowser;
|
|
class LLEmbeddedBrowserWindow;
|
|
|
|
// Use this to conditionalize code that depends on particular changes to the llqtwebkit API.
|
|
// This can be useful for times when we're waiting for a rebuild on one platform or another.
|
|
// When you bump this number, please note what the changes were in a comment below the #define,
|
|
// and keep the existing comments as history.
|
|
#define LLQTWEBKIT_API_VERSION 16
|
|
// version 16:
|
|
// Added LLQtWebKit::enableLoadingOverlay()
|
|
// version 15:
|
|
// Added LLQtWebKit::setPageZoomFactor()
|
|
// version 14:
|
|
// Added LLEmbeddedBrowserWindowObserver::onQtDebugMessage
|
|
// version 13:
|
|
// Added LLEmbeddedBrowserWindowObserver::onCertError
|
|
// version 12:
|
|
// Pass over value to indicate if host for current URL is trusted as per whitelist regex or not
|
|
// version 11:
|
|
// Added initial support for url/host whitelist via a regex
|
|
// version 10:
|
|
// Added initial support for creating and displaying the Qt Web Inspector
|
|
// version 9:
|
|
// Added initial support for exposing certain Second Life viewer/agent variables to JavaScript
|
|
// version 8:
|
|
// Removed calls to set/clear 404 redirects and made the API now emit an event that the
|
|
// consumer can catch and decide what to do when an HTTP status code after navigate is 400-499
|
|
// version 7:
|
|
// Added LLEmbeddedBrowserWindowEvent::setNavigationType() && LLEmbeddedBrowserWindowEvent::getNavigationType()
|
|
// Used to pass (and retrieve) the type of navigation event that caused a link to be activated.
|
|
// version 6:
|
|
// Added LLQtWebKit::addCAFile()
|
|
// version 5:
|
|
// Added LLEmbeddedBrowserWindowObserver::onLinkHovered
|
|
// version 4:
|
|
// Added LLEmbeddedBrowserWindowObserver::onAuthRequest
|
|
// version 3:
|
|
// Added setIgnoreSSLCertErrors and getIgnoreSSLCertErrors
|
|
// version 2:
|
|
// Changed the usage of the event parameters in onClickLinkHref and onClickLinkNoFollow events slightly.
|
|
// The clicked URI for both should now be retrieved with getEventUri() instead of getStringValue().
|
|
// The "target" string in onClickLinkHref is now retrieved with getStringValue() instead of getStringValue2().
|
|
// The contents of getStringValue2() in the onClickLinkHref event is now a unique ID for the window proxy the click targets.
|
|
// Removed the "link target type" concept, since it doesn't really belong here.
|
|
// Removed most of the construtor variants in LLEmbeddedBrowserWindowEvent and added setters in their place.
|
|
// Removed setCaretColor, since it's done nothing for some time now.
|
|
// Added LLEmbeddedBrowserWindowObserver::onWindowGeometryChangeRequested
|
|
// Added
|
|
// version 1:
|
|
// Added the LLQTWEBKIT_API_VERSION define.
|
|
// Added LLEmbeddedBrowserWindowObserver::onWindowCloseRequested
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// data class that is passed with an event
|
|
class LLEmbeddedBrowserWindowEvent
|
|
{
|
|
public:
|
|
LLEmbeddedBrowserWindowEvent(int window_id) :
|
|
mEventWindowId(window_id)
|
|
{
|
|
};
|
|
|
|
virtual ~LLEmbeddedBrowserWindowEvent() {}
|
|
|
|
void setEventUri(const std::string &uri) { mEventUri = uri; }
|
|
void setNavigationType(const std::string &type) { mNavigationType = type; }
|
|
void setTrustedHost(const bool trusted) { mTrustedHost = trusted; }
|
|
void setIntValue(int val) { mIntVal = val; }
|
|
void setStringValue(const std::string &val) { mStringVal = val; }
|
|
void setStringValue2(const std::string &val) { mStringVal2 = val; }
|
|
void setRectValue(int x, int y, int width, int height)
|
|
{
|
|
mXVal = x;
|
|
mYVal = y;
|
|
mWidthVal = width;
|
|
mHeightVal = height;
|
|
}
|
|
|
|
int getEventWindowId() const { return mEventWindowId; }
|
|
std::string getEventUri() const { return mEventUri; }
|
|
std::string getNavigationType() const { return mNavigationType; }
|
|
bool getTrustedHost() const { return mTrustedHost; }
|
|
int getIntValue() const { return mIntVal; };
|
|
std::string getStringValue() const { return mStringVal; }
|
|
std::string getStringValue2() const { return mStringVal2; }
|
|
void getRectValue(int& x, int& y, int& width, int& height) const
|
|
{
|
|
x = mXVal;
|
|
y = mYVal;
|
|
width = mWidthVal;
|
|
height = mHeightVal;
|
|
};
|
|
|
|
private:
|
|
int mEventWindowId;
|
|
std::string mEventUri;
|
|
std::string mNavigationType;
|
|
bool mTrustedHost;
|
|
int mIntVal;
|
|
std::string mStringVal;
|
|
std::string mStringVal2;
|
|
int mXVal;
|
|
int mYVal;
|
|
int mWidthVal;
|
|
int mHeightVal;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// derrive from this class and override these methods to observe these events
|
|
#ifdef __GNUC__
|
|
#pragma GCC visibility push(default)
|
|
#endif
|
|
class LLEmbeddedBrowserWindowObserver
|
|
{
|
|
public:
|
|
virtual ~LLEmbeddedBrowserWindowObserver();
|
|
typedef LLEmbeddedBrowserWindowEvent EventType;
|
|
|
|
virtual void onCursorChanged(const EventType& event);
|
|
virtual void onPageChanged(const EventType& event);
|
|
virtual void onNavigateBegin(const EventType& event);
|
|
virtual void onNavigateComplete(const EventType& event);
|
|
virtual void onNavigateErrorPage(const EventType& event);
|
|
virtual void onUpdateProgress(const EventType& event);
|
|
virtual void onStatusTextChange(const EventType& event);
|
|
virtual void onTitleChange(const EventType& event);
|
|
virtual void onLocationChange(const EventType& event);
|
|
virtual void onClickLinkHref(const EventType& event);
|
|
virtual void onClickLinkNoFollow(const EventType& event);
|
|
virtual void onCookieChanged(const EventType& event);
|
|
// mStringVal will be the cookie in RFC 2109 string format
|
|
// mEventUri will be the url that caused the cookie change
|
|
// mIntVal will be true if the cookie is dead (i.e. being deleted), false otherwise
|
|
virtual std::string onRequestFilePicker(const EventType& event);
|
|
virtual void onWindowCloseRequested(const EventType& event);
|
|
virtual void onWindowGeometryChangeRequested(const EventType& event);
|
|
|
|
// This should return true to attempt auth, or false to cancel.
|
|
virtual bool onAuthRequest(const std::string &in_url, const std::string &in_realm, std::string &out_username, std::string &out_password);
|
|
|
|
// This should return true to continue after cert error, or false to cancel and abort.
|
|
virtual bool onCertError(const std::string &in_url, const std::string &in_msg);
|
|
|
|
virtual void onLinkHovered(const EventType& event);
|
|
// mEventURI will be the link
|
|
// mStringVal will be the title
|
|
// mStringVal2 will be the text
|
|
|
|
// catch qDebug() messages from Qt and pipe them back to host application
|
|
virtual void onQtDebugMessage( const std::string& msg, const std::string& msg_type);
|
|
};
|
|
#ifdef __GNUC__
|
|
#pragma GCC visibility pop
|
|
#endif
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// main library class
|
|
|
|
#ifdef __GNUC__
|
|
#pragma GCC visibility push(default)
|
|
#endif
|
|
class LLQtWebKit
|
|
{
|
|
public:
|
|
typedef enum e_cursor
|
|
{
|
|
C_ARROW,
|
|
C_IBEAM,
|
|
C_SPLITV,
|
|
C_SPLITH,
|
|
C_POINTINGHAND
|
|
} ECursor;
|
|
|
|
typedef enum e_user_action
|
|
{
|
|
UA_EDIT_CUT,
|
|
UA_EDIT_COPY,
|
|
UA_EDIT_PASTE,
|
|
UA_NAVIGATE_STOP,
|
|
UA_NAVIGATE_BACK,
|
|
UA_NAVIGATE_FORWARD,
|
|
UA_NAVIGATE_RELOAD
|
|
} EUserAction;
|
|
|
|
typedef enum e_key_event
|
|
{
|
|
KE_KEY_DOWN,
|
|
KE_KEY_REPEAT,
|
|
KE_KEY_UP
|
|
}EKeyEvent;
|
|
|
|
typedef enum e_mouse_event
|
|
{
|
|
ME_MOUSE_MOVE,
|
|
ME_MOUSE_DOWN,
|
|
ME_MOUSE_UP,
|
|
ME_MOUSE_DOUBLE_CLICK
|
|
}EMouseEvent;
|
|
|
|
typedef enum e_mouse_button
|
|
{
|
|
MB_MOUSE_BUTTON_LEFT,
|
|
MB_MOUSE_BUTTON_RIGHT,
|
|
MB_MOUSE_BUTTON_MIDDLE,
|
|
MB_MOUSE_BUTTON_EXTRA_1,
|
|
MB_MOUSE_BUTTON_EXTRA_2,
|
|
}EMouseButton;
|
|
|
|
typedef enum e_keyboard_modifier
|
|
{
|
|
KM_MODIFIER_NONE = 0x00,
|
|
KM_MODIFIER_SHIFT = 0x01,
|
|
KM_MODIFIER_CONTROL = 0x02,
|
|
KM_MODIFIER_ALT = 0x04,
|
|
KM_MODIFIER_META = 0x08
|
|
}EKeyboardModifier;
|
|
|
|
virtual ~LLQtWebKit();
|
|
|
|
// singleton access
|
|
static LLQtWebKit* getInstance();
|
|
|
|
// housekeeping
|
|
bool init(std::string application_directory,
|
|
std::string component_directory,
|
|
std::string profile_directory,
|
|
void* native_window_handle);
|
|
bool reset();
|
|
bool clearCache();
|
|
int getLastError();
|
|
std::string getVersion();
|
|
void setBrowserAgentId(std::string id);
|
|
bool enableProxy(bool enabled, std::string host_name, int port);
|
|
|
|
void enableCookies(bool enabled);
|
|
bool clearAllCookies();
|
|
|
|
// The following two functions accept and return cookies in the same format that's used for the Set-Cookie: HTTP header
|
|
// as defined in RFC 2109 ( http://www.ietf.org/rfc/rfc2109.txt ). The string should not contain the literal "Set-Cookie:",
|
|
// just the cookie itself.
|
|
// Multiple cookies within the string are separated by a newline character ('\n')
|
|
void setCookies(const std::string &cookies);
|
|
std::string getAllCookies();
|
|
|
|
void enablePlugins(bool enabled);
|
|
void enableJavaScript(bool enabled);
|
|
|
|
// Web inspector - Firebug-esque debugger
|
|
bool showWebInspector(bool show);
|
|
|
|
// updates value of 'hostLanguage' in JavaScript 'Navigator' obect that
|
|
// embedded pages can query to see what language the host app is set to
|
|
void setHostLanguage(const std::string& host_language);
|
|
|
|
// browser window - creation/deletion, mutation etc.
|
|
int createBrowserWindow(int width, int height, const std::string target = std::string(""));
|
|
void proxyWindowOpened(int browser_window_id, const std::string target, const std::string uuid);
|
|
void proxyWindowClosed(int browser_window_id, const std::string uuid);
|
|
bool destroyBrowserWindow(int browser_window_id);
|
|
bool setSize(int browser_window_id, int width, int height);
|
|
bool scrollByLines(int browser_window_id, int lines);
|
|
bool setBackgroundColor(int browser_window_id, const int red, const int green, const int blue);
|
|
bool setEnabled(int browser_window_id, bool enabled);
|
|
|
|
// add/remove yourself as an observer on browser events - see LLEmbeddedBrowserWindowObserver declaration
|
|
bool addObserver(int browser_window_id, LLEmbeddedBrowserWindowObserver* subject);
|
|
bool remObserver(int browser_window_id, LLEmbeddedBrowserWindowObserver* subject);
|
|
|
|
// navigation - self explanatory
|
|
bool navigateTo(int browser_window_id, const std::string uri);
|
|
bool userAction(int browser_window_id, EUserAction action);
|
|
bool userActionIsEnabled(int browser_window_id, EUserAction action);
|
|
|
|
// javascript access/control
|
|
std::string evaluateJavaScript(int browser_window_id, const std::string script);
|
|
|
|
// set/clear URL to redirect to when a 404 page is reached
|
|
bool set404RedirectUrl(int browser_window_in, std::string redirect_url);
|
|
bool clr404RedirectUrl(int browser_window_in);
|
|
|
|
// access to rendered bitmap data
|
|
const unsigned char* grabBrowserWindow(int browser_window_id); // renders page to memory and returns pixels
|
|
const unsigned char* getBrowserWindowPixels(int browser_window_id); // just returns pixels - no render
|
|
bool flipWindow(int browser_window_id, bool flip); // optionally flip window (pixels) you get back
|
|
int getBrowserWidth(int browser_window_id); // current browser width (can vary slightly after page is rendered)
|
|
int getBrowserHeight(int browser_window_id); // current height
|
|
int getBrowserDepth(int browser_window_id); // depth in bytes
|
|
int getBrowserRowSpan(int browser_window_id); // width in pixels * depth in bytes
|
|
|
|
// mouse/keyboard interaction
|
|
bool mouseEvent(int browser_window_id, EMouseEvent mouse_event, int button, int x, int y, EKeyboardModifier modifiers); // send a mouse event to a browser window at given XY in browser space
|
|
bool scrollWheelEvent(int browser_window_id, int x, int y, int scroll_x, int scroll_y, EKeyboardModifier modifiers);
|
|
bool keyboardEvent(
|
|
int browser_window_id,
|
|
EKeyEvent key_event,
|
|
uint32_t key_code,
|
|
const char *utf8_text,
|
|
EKeyboardModifier modifiers,
|
|
uint32_t native_scan_code = 0,
|
|
uint32_t native_virtual_key = 0,
|
|
uint32_t native_modifiers = 0);
|
|
|
|
bool focusBrowser(int browser_window_id, bool focus_browser); // set/remove focus to given browser window
|
|
|
|
// accessor/mutator for scheme that browser doesn't follow - e.g. secondlife.com://
|
|
void setNoFollowScheme(int browser_window_id, std::string scheme);
|
|
std::string getNoFollowScheme(int browser_window_id);
|
|
|
|
void pump(int max_milliseconds);
|
|
|
|
void prependHistoryUrl(int browser_window_id, std::string url);
|
|
void clearHistory(int browser_window_id);
|
|
std::string dumpHistory(int browser_window_id);
|
|
|
|
// Specify a path to a .pem file containing a list of CA certificates the browser should trust.
|
|
// NOTE that this will replace the default list of root certs (not add to it).
|
|
// If the file isn't found or doesn't contain any certs in the correct format, this call will have no effect and will return false.
|
|
// NOTE: Using this function causes strange cert verification issues on the Mac.
|
|
// Using addCAFile() instead seems to work better.
|
|
bool setCAFile(const std::string &ca_file);
|
|
|
|
// This behaves similarly, but instead of replacing the entire list it appends additional trusted root certs to the current list.
|
|
bool addCAFile(const std::string &ca_file);
|
|
|
|
// Set a flag causing all SSL cert errors to be ignored.
|
|
// NOTE: this should only be used for testing, as it negates the security model of https.
|
|
void setIgnoreSSLCertErrors(bool ignore);
|
|
bool getIgnoreSSLCertErrors();
|
|
|
|
const std::vector< std::string > getInstalledCertsList();
|
|
|
|
void enableQtMessageHandler( bool enable );
|
|
|
|
void enableLoadingOverlay( int browser_window_id, bool enable);
|
|
|
|
// Copied from indra_constants.h.
|
|
// The key_code argument to keyboardEvent should either be one of these or a 7-bit ascii character.
|
|
enum keyCodes
|
|
{
|
|
// Leading zeroes ensure that these won't sign-extend when assigned to a larger type.
|
|
KEY_RETURN = 0x0081,
|
|
KEY_LEFT = 0x0082,
|
|
KEY_RIGHT = 0x0083,
|
|
KEY_UP = 0x0084,
|
|
KEY_DOWN = 0x0085,
|
|
KEY_ESCAPE = 0x0086,
|
|
KEY_BACKSPACE = 0x0087,
|
|
KEY_DELETE = 0x0088,
|
|
KEY_SHIFT = 0x0089,
|
|
KEY_CONTROL = 0x008A,
|
|
KEY_ALT = 0x008B,
|
|
KEY_HOME = 0x008C,
|
|
KEY_END = 0x008D,
|
|
KEY_PAGE_UP = 0x008E,
|
|
KEY_PAGE_DOWN = 0x008F,
|
|
KEY_HYPHEN = 0x0090,
|
|
KEY_EQUALS = 0x0091,
|
|
KEY_INSERT = 0x0092,
|
|
KEY_CAPSLOCK = 0x0093,
|
|
KEY_TAB = 0x0094,
|
|
KEY_ADD = 0x0095,
|
|
KEY_SUBTRACT = 0x0096,
|
|
KEY_MULTIPLY = 0x0097,
|
|
KEY_DIVIDE = 0x0098,
|
|
KEY_F1 = 0x00A1,
|
|
KEY_F2 = 0x00A2,
|
|
KEY_F3 = 0x00A3,
|
|
KEY_F4 = 0x00A4,
|
|
KEY_F5 = 0x00A5,
|
|
KEY_F6 = 0x00A6,
|
|
KEY_F7 = 0x00A7,
|
|
KEY_F8 = 0x00A8,
|
|
KEY_F9 = 0x00A9,
|
|
KEY_F10 = 0x00AA,
|
|
KEY_F11 = 0x00AB,
|
|
KEY_F12 = 0x00AC,
|
|
|
|
KEY_PAD_UP = 0x00C0,
|
|
KEY_PAD_DOWN = 0x00C1,
|
|
KEY_PAD_LEFT = 0x00C2,
|
|
KEY_PAD_RIGHT = 0x00C3,
|
|
KEY_PAD_HOME = 0x00C4,
|
|
KEY_PAD_END = 0x00C5,
|
|
KEY_PAD_PGUP = 0x00C6,
|
|
KEY_PAD_PGDN = 0x00C7,
|
|
KEY_PAD_CENTER = 0x00C8, // the 5 in the middle
|
|
KEY_PAD_INS = 0x00C9,
|
|
KEY_PAD_DEL = 0x00CA,
|
|
KEY_PAD_RETURN = 0x00CB,
|
|
KEY_PAD_ADD = 0x00CC,
|
|
KEY_PAD_SUBTRACT = 0x00CD,
|
|
KEY_PAD_MULTIPLY = 0x00CE,
|
|
KEY_PAD_DIVIDE = 0x00CF,
|
|
|
|
KEY_NONE = 0x00FF // not sent from keyboard. For internal use only.
|
|
};
|
|
|
|
// set the regex used to determine if a page is trusted or not
|
|
void setWhiteListRegex( int browser_window_id, const std::string& regex );
|
|
|
|
// Second Life specific functions
|
|
// (Note, this is a departure from the generic nature of this library)
|
|
void setSLObjectEnabled( bool enabled ); // enable or disaable feature
|
|
void setAgentLanguage( const std::string& agent_language ); // viewer language selected by agent
|
|
void setAgentRegion( const std::string& agent_region ); // name of region where agent is located
|
|
void setAgentLocation( double x, double y, double z ); // agent's x,y,z location within a region
|
|
void setAgentGlobalLocation( double x, double y, double z ); // agent's x,y,z location within the current grid
|
|
void setAgentOrientation( double angle ); // direction (0..359) agent is facing
|
|
void setAgentMaturity( const std::string& agent_maturity ); // selected maturity level of agent
|
|
void emitLocation();
|
|
void emitMaturity();
|
|
void emitLanguage();
|
|
|
|
// set the zoom factor for web pages ( can be less than 0.0)
|
|
void setPageZoomFactor( double factor );
|
|
|
|
private:
|
|
LLQtWebKit();
|
|
LLEmbeddedBrowserWindow* getBrowserWindowFromWindowId(int browser_window_id);
|
|
static LLQtWebKit* sInstance;
|
|
const int mMaxBrowserWindows;
|
|
typedef std::map< int, LLEmbeddedBrowserWindow* > BrowserWindowMap;
|
|
typedef std::map< int, LLEmbeddedBrowserWindow* >::iterator BrowserWindowMapIter;
|
|
BrowserWindowMap mBrowserWindowMap;
|
|
};
|
|
|
|
#ifdef __GNUC__
|
|
#pragma GCC visibility pop
|
|
#endif
|
|
|
|
#endif // LLQTWEBKIT_H
|