284 lines
7.3 KiB
C++
284 lines
7.3 KiB
C++
// Copyright (c) 2009 The Chromium Embedded Framework Authors.
|
|
// Portions copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#include "uiplugin.h"
|
|
#include "cefclient.h"
|
|
#include <gl/gl.h>
|
|
#include <sstream>
|
|
|
|
|
|
// Initialized in NP_Initialize.
|
|
NPNetscapeFuncs* g_uibrowser = NULL;
|
|
|
|
// Global values.
|
|
float g_rotationspeed = 0.0f;
|
|
float g_theta = 0.0f;
|
|
|
|
// Class holding pointers for the client plugin window.
|
|
class ClientPlugin
|
|
{
|
|
public:
|
|
ClientPlugin()
|
|
{
|
|
hWnd = NULL;
|
|
hDC = NULL;
|
|
hRC = NULL;
|
|
}
|
|
|
|
HWND hWnd;
|
|
HDC hDC;
|
|
HGLRC hRC;
|
|
};
|
|
|
|
// Forward declarations of functions included in this code module:
|
|
LRESULT CALLBACK PluginWndProc(HWND hWnd, UINT message, WPARAM wParam,
|
|
LPARAM lParam);
|
|
void EnableOpenGL(HWND hWnd, HDC * hDC, HGLRC * hRC);
|
|
void DisableOpenGL(HWND hWnd, HDC hDC, HGLRC hRC);
|
|
|
|
static
|
|
NPError NPP_New(NPMIMEType plugin_type, NPP instance, uint16 mode, int16 argc,
|
|
char* argn[], char* argv[], NPSavedData* saved) {
|
|
if (instance == NULL)
|
|
return NPERR_INVALID_INSTANCE_ERROR;
|
|
|
|
ClientPlugin *plugin = new ClientPlugin;
|
|
instance->pdata = reinterpret_cast<void*>(plugin);
|
|
|
|
return NPERR_NO_ERROR;
|
|
}
|
|
|
|
static
|
|
NPError NPP_Destroy(NPP instance, NPSavedData** save) {
|
|
ClientPlugin *plugin = reinterpret_cast<ClientPlugin*>(instance->pdata);
|
|
|
|
if (plugin) {
|
|
if(plugin->hWnd) {
|
|
DestroyWindow(plugin->hWnd);
|
|
DisableOpenGL(plugin->hWnd, plugin->hDC, plugin->hRC);
|
|
}
|
|
delete plugin;
|
|
g_rotationspeed = 0.0f;
|
|
g_theta = 0.0f;
|
|
}
|
|
|
|
return NPERR_NO_ERROR;
|
|
}
|
|
|
|
static
|
|
NPError NPP_SetWindow(NPP instance, NPWindow* window_info) {
|
|
if (instance == NULL)
|
|
return NPERR_INVALID_INSTANCE_ERROR;
|
|
|
|
if (window_info == NULL)
|
|
return NPERR_GENERIC_ERROR;
|
|
|
|
ClientPlugin *plugin = reinterpret_cast<ClientPlugin*>(instance->pdata);
|
|
HWND parent_hwnd = reinterpret_cast<HWND>(window_info->window);
|
|
|
|
if (plugin->hWnd == NULL)
|
|
{
|
|
WNDCLASS wc;
|
|
HINSTANCE hInstance = GetModuleHandle(NULL);
|
|
|
|
// Register the window class.
|
|
wc.style = CS_OWNDC;
|
|
wc.lpfnWndProc = PluginWndProc;
|
|
wc.cbClsExtra = 0;
|
|
wc.cbWndExtra = 0;
|
|
wc.hInstance = hInstance;
|
|
wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
|
|
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
|
|
wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
|
|
wc.lpszMenuName = NULL;
|
|
wc.lpszClassName = L"ClientUIPlugin";
|
|
RegisterClass(&wc);
|
|
|
|
// Create the main window.
|
|
plugin->hWnd = CreateWindow(L"ClientUIPlugin", L"Client UI Plugin",
|
|
WS_CHILD, 0, 0, 0, 0, parent_hwnd, NULL, hInstance, NULL);
|
|
|
|
// Enable OpenGL drawing for the window.
|
|
EnableOpenGL(plugin->hWnd, &(plugin->hDC), &(plugin->hRC));
|
|
}
|
|
|
|
// Position the window and make sure it's visible.
|
|
RECT parent_rect;
|
|
GetClientRect(parent_hwnd, &parent_rect);
|
|
SetWindowPos(plugin->hWnd, NULL, parent_rect.left, parent_rect.top,
|
|
parent_rect.right - parent_rect.left,
|
|
parent_rect.bottom - parent_rect.top, SWP_SHOWWINDOW);
|
|
|
|
UpdateWindow(plugin->hWnd);
|
|
ShowWindow(plugin->hWnd, SW_SHOW);
|
|
|
|
return NPERR_NO_ERROR;
|
|
}
|
|
|
|
NPError API_CALL NP_UIGetEntryPoints(NPPluginFuncs* pFuncs)
|
|
{
|
|
pFuncs->newp = NPP_New;
|
|
pFuncs->destroy = NPP_Destroy;
|
|
pFuncs->setwindow = NPP_SetWindow;
|
|
return NPERR_NO_ERROR;
|
|
}
|
|
|
|
NPError API_CALL NP_UIInitialize(NPNetscapeFuncs* pFuncs)
|
|
{
|
|
g_uibrowser = pFuncs;
|
|
return NPERR_NO_ERROR;
|
|
}
|
|
|
|
NPError API_CALL NP_UIShutdown(void)
|
|
{
|
|
g_uibrowser = NULL;
|
|
return NPERR_NO_ERROR;
|
|
}
|
|
|
|
// Send the notification to the browser as a JavaScript function call.
|
|
static void NotifyNewRotation(float value)
|
|
{
|
|
std::wstringstream buf;
|
|
buf << L"notifyNewRotation(" << value << L");";
|
|
AppGetBrowser()->GetMainFrame()->ExecuteJavaScript(buf.str(), std::wstring(),
|
|
0);
|
|
}
|
|
|
|
void ModifyRotation(float value)
|
|
{
|
|
g_rotationspeed += value;
|
|
NotifyNewRotation(g_rotationspeed);
|
|
}
|
|
|
|
void ResetRotation()
|
|
{
|
|
g_rotationspeed = 0.0;
|
|
NotifyNewRotation(g_rotationspeed);
|
|
}
|
|
|
|
// Nice little fly polygon borrowed from the OpenGL Red Book.
|
|
const GLubyte fly[] = {
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x03, 0x80, 0x01, 0xC0, 0x06, 0xC0, 0x03, 0x60,
|
|
0x04, 0x60, 0x06, 0x20, 0x04, 0x30, 0x0C, 0x20,
|
|
0x04, 0x18, 0x18, 0x20, 0x04, 0x0C, 0x30, 0x20,
|
|
0x04, 0x06, 0x60, 0x20, 0x44, 0x03, 0xC0, 0x22,
|
|
0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22,
|
|
0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22,
|
|
0x44, 0x01, 0x80, 0x22, 0x44, 0x01, 0x80, 0x22,
|
|
0x66, 0x01, 0x80, 0x66, 0x33, 0x01, 0x80, 0xCC,
|
|
0x19, 0x81, 0x81, 0x98, 0x0C, 0xC1, 0x83, 0x30,
|
|
0x07, 0xe1, 0x87, 0xe0, 0x03, 0x3f, 0xfc, 0xc0,
|
|
0x03, 0x31, 0x8c, 0xc0, 0x03, 0x33, 0xcc, 0xc0,
|
|
0x06, 0x64, 0x26, 0x60, 0x0c, 0xcc, 0x33, 0x30,
|
|
0x18, 0xcc, 0x33, 0x18, 0x10, 0xc4, 0x23, 0x08,
|
|
0x10, 0x63, 0xC6, 0x08, 0x10, 0x30, 0x0c, 0x08,
|
|
0x10, 0x18, 0x18, 0x08, 0x10, 0x00, 0x00, 0x08};
|
|
|
|
|
|
// Plugin window procedure.
|
|
LRESULT CALLBACK PluginWndProc(HWND hWnd, UINT message, WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
HDC hDC;
|
|
int width, height;
|
|
|
|
switch(message)
|
|
{
|
|
case WM_CREATE:
|
|
// Start the timer that's used for redrawing.
|
|
SetTimer(hWnd, 1, 1, NULL);
|
|
return 0;
|
|
|
|
case WM_DESTROY:
|
|
// Stop the timer that's used for redrawing.
|
|
KillTimer(hWnd, 1);
|
|
return 0;
|
|
|
|
case WM_LBUTTONDOWN:
|
|
// Decrement rotation speed.
|
|
ModifyRotation(-2.0f);
|
|
return 0;
|
|
|
|
case WM_RBUTTONDOWN:
|
|
// Increment rotation speed.
|
|
ModifyRotation(2.0f);
|
|
return 0;
|
|
|
|
case WM_SIZE:
|
|
// Resize the OpenGL viewport to match the window size.
|
|
width = LOWORD(lParam);
|
|
height = HIWORD(lParam);
|
|
glViewport(0, 0, width, height);
|
|
break;
|
|
|
|
case WM_ERASEBKGND:
|
|
return 0;
|
|
|
|
case WM_TIMER:
|
|
// Adjust the theta value and redraw the display when the timer fires.
|
|
hDC = GetDC(hWnd);
|
|
|
|
glClearColor(1.0f, 1.0f, 1.0f, 0.0f);
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
glPushMatrix();
|
|
glEnable(GL_POLYGON_STIPPLE);
|
|
glPolygonStipple(fly);
|
|
|
|
glRotatef(g_theta, 0.0f, 0.0f, 1.0f);
|
|
glBegin(GL_QUADS);
|
|
glColor3f(1.0f, 0.0f, 0.0f); glVertex2f(0.7f, 0.7f);
|
|
glColor3f(0.0f, 1.0f, 0.0f); glVertex2f(0.7f, -0.7f);
|
|
glColor3f(0.0f, 0.0f, 1.0f); glVertex2f(-0.7f, -0.7f);
|
|
glColor3f(1.0f, 0.0f, 1.0f); glVertex2f(-0.7f, 0.7f);
|
|
glEnd();
|
|
|
|
glDisable(GL_POLYGON_STIPPLE);
|
|
glPopMatrix();
|
|
|
|
SwapBuffers(hDC);
|
|
ReleaseDC(hWnd, hDC);
|
|
|
|
g_theta -= g_rotationspeed;
|
|
}
|
|
|
|
return DefWindowProc(hWnd, message, wParam, lParam);
|
|
}
|
|
|
|
// Enable OpenGL.
|
|
void EnableOpenGL(HWND hWnd, HDC * hDC, HGLRC * hRC)
|
|
{
|
|
PIXELFORMATDESCRIPTOR pfd;
|
|
int format;
|
|
|
|
// Get the device context.
|
|
*hDC = GetDC(hWnd);
|
|
|
|
// Set the pixel format for the DC.
|
|
ZeroMemory(&pfd, sizeof(pfd));
|
|
pfd.nSize = sizeof(pfd);
|
|
pfd.nVersion = 1;
|
|
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
|
|
pfd.iPixelType = PFD_TYPE_RGBA;
|
|
pfd.cColorBits = 24;
|
|
pfd.cDepthBits = 16;
|
|
pfd.iLayerType = PFD_MAIN_PLANE;
|
|
format = ChoosePixelFormat(*hDC, &pfd);
|
|
SetPixelFormat(*hDC, format, &pfd);
|
|
|
|
// Create and enable the render contex.
|
|
*hRC = wglCreateContext(*hDC);
|
|
wglMakeCurrent(*hDC, *hRC);
|
|
}
|
|
|
|
// Disable OpenGL.
|
|
void DisableOpenGL(HWND hWnd, HDC hDC, HGLRC hRC)
|
|
{
|
|
wglMakeCurrent(NULL, NULL);
|
|
wglDeleteContext(hRC);
|
|
ReleaseDC(hWnd, hDC);
|
|
}
|