| /* |
| * Copyright 2008, The Android Open Source Project |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * 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 THE COPYRIGHT HOLDERS ``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. |
| */ |
| |
| #include "FormPlugin.h" |
| |
| #include <stdio.h> |
| #include <sys/time.h> |
| #include <time.h> |
| #include <math.h> |
| #include <string.h> |
| |
| extern NPNetscapeFuncs* browser; |
| extern ANPLogInterfaceV0 gLogI; |
| extern ANPCanvasInterfaceV0 gCanvasI; |
| extern ANPPaintInterfaceV0 gPaintI; |
| extern ANPTypefaceInterfaceV0 gTypefaceI; |
| extern ANPWindowInterfaceV0 gWindowI; |
| |
| |
| static void inval(NPP instance) { |
| browser->invalidaterect(instance, NULL); |
| } |
| |
| static uint16 rnd16(float x, int inset) { |
| int ix = (int)roundf(x) + inset; |
| if (ix < 0) { |
| ix = 0; |
| } |
| return static_cast<uint16>(ix); |
| } |
| |
| static void inval(NPP instance, const ANPRectF& r, bool doAA) { |
| const int inset = doAA ? -1 : 0; |
| |
| PluginObject *obj = reinterpret_cast<PluginObject*>(instance->pdata); |
| NPRect inval; |
| inval.left = rnd16(r.left, inset); |
| inval.top = rnd16(r.top, inset); |
| inval.right = rnd16(r.right, -inset); |
| inval.bottom = rnd16(r.bottom, -inset); |
| browser->invalidaterect(instance, &inval); |
| } |
| |
| static void drawPlugin(SubPlugin* plugin, const ANPBitmap& bitmap, const ANPRectI& clip) { |
| ANPCanvas* canvas = gCanvasI.newCanvas(&bitmap); |
| |
| ANPRectF clipR; |
| clipR.left = clip.left; |
| clipR.top = clip.top; |
| clipR.right = clip.right; |
| clipR.bottom = clip.bottom; |
| gCanvasI.clipRect(canvas, &clipR); |
| |
| plugin->draw(canvas); |
| gCanvasI.deleteCanvas(canvas); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| FormPlugin::FormPlugin(NPP inst) : SubPlugin(inst) { |
| |
| m_hasFocus = false; |
| m_activeInput = NULL; |
| |
| memset(&m_usernameInput, 0, sizeof(m_usernameInput)); |
| memset(&m_passwordInput, 0, sizeof(m_passwordInput)); |
| |
| m_usernameInput.text[0] = '\0'; |
| m_usernameInput.charPtr = 0; |
| |
| m_passwordInput.text[0] = '\0'; |
| m_passwordInput.charPtr = 0; |
| |
| m_paintInput = gPaintI.newPaint(); |
| gPaintI.setFlags(m_paintInput, gPaintI.getFlags(m_paintInput) | kAntiAlias_ANPPaintFlag); |
| gPaintI.setColor(m_paintInput, 0xFFFFFFFF); |
| |
| m_paintActive = gPaintI.newPaint(); |
| gPaintI.setFlags(m_paintActive, gPaintI.getFlags(m_paintActive) | kAntiAlias_ANPPaintFlag); |
| gPaintI.setColor(m_paintActive, 0xFFFFFF00); |
| |
| m_paintText = gPaintI.newPaint(); |
| gPaintI.setFlags(m_paintText, gPaintI.getFlags(m_paintText) | kAntiAlias_ANPPaintFlag); |
| gPaintI.setColor(m_paintText, 0xFF000000); |
| gPaintI.setTextSize(m_paintText, 18); |
| |
| ANPTypeface* tf = gTypefaceI.createFromName("serif", kItalic_ANPTypefaceStyle); |
| gPaintI.setTypeface(m_paintText, tf); |
| gTypefaceI.unref(tf); |
| |
| //register for key and visibleRect events |
| ANPEventFlags flags = kKey_ANPEventFlag | kVisibleRect_ANPEventFlag; |
| NPError err = browser->setvalue(inst, kAcceptEvents_ANPSetValue, &flags); |
| if (err != NPERR_NO_ERROR) { |
| gLogI.log(inst, kError_ANPLogType, "Error selecting input events."); |
| } |
| } |
| |
| FormPlugin::~FormPlugin() { |
| gPaintI.deletePaint(m_paintInput); |
| gPaintI.deletePaint(m_paintActive); |
| gPaintI.deletePaint(m_paintText); |
| } |
| |
| void FormPlugin::draw(ANPCanvas* canvas) { |
| NPP instance = this->inst(); |
| PluginObject *obj = (PluginObject*) instance->pdata; |
| |
| const float inputWidth = 60; |
| const float inputHeight = 30; |
| const int W = obj->window->width; |
| const int H = obj->window->height; |
| |
| // color the plugin canvas |
| gCanvasI.drawColor(canvas, (m_hasFocus) ? 0xFFCDCDCD : 0xFF545454); |
| |
| // draw the username box (5 px from the top edge) |
| m_usernameInput.rect.left = 5; |
| m_usernameInput.rect.top = 5; |
| m_usernameInput.rect.right = W - 5; |
| m_usernameInput.rect.bottom = m_usernameInput.rect.top + inputHeight; |
| gCanvasI.drawRect(canvas, &m_usernameInput.rect, getPaint(&m_usernameInput)); |
| drawText(canvas, m_usernameInput); |
| |
| // draw the password box (5 px from the bottom edge) |
| m_passwordInput.rect.left = 5; |
| m_passwordInput.rect.top = H - (inputHeight + 5); |
| m_passwordInput.rect.right = W - 5; |
| m_passwordInput.rect.bottom = m_passwordInput.rect.top + inputHeight; |
| gCanvasI.drawRect(canvas, &m_passwordInput.rect, getPaint(&m_passwordInput)); |
| drawPassword(canvas, m_passwordInput); |
| |
| //invalidate the canvas |
| //inval(instance); |
| } |
| |
| ANPPaint* FormPlugin::getPaint(TextInput* input) { |
| return (input == m_activeInput) ? m_paintActive : m_paintInput; |
| } |
| |
| void FormPlugin::drawText(ANPCanvas* canvas, TextInput textInput) { |
| |
| // get font metrics |
| ANPFontMetrics fontMetrics; |
| gPaintI.getFontMetrics(m_paintText, &fontMetrics); |
| |
| gCanvasI.drawText(canvas, textInput.text, textInput.charPtr, |
| textInput.rect.left + 5, |
| textInput.rect.bottom - fontMetrics.fBottom, m_paintText); |
| } |
| |
| void FormPlugin::drawPassword(ANPCanvas* canvas, TextInput passwordInput) { |
| |
| // get font metrics |
| ANPFontMetrics fontMetrics; |
| gPaintI.getFontMetrics(m_paintText, &fontMetrics); |
| |
| // comput the circle dimensions and initial location |
| float initialX = passwordInput.rect.left + 5; |
| float ovalBottom = passwordInput.rect.bottom - 2; |
| float ovalTop = ovalBottom - (fontMetrics.fBottom - fontMetrics.fTop); |
| float ovalWidth = ovalBottom - ovalTop; |
| float ovalSpacing = 3; |
| |
| // draw circles instead of the actual text |
| for (uint32_t x = 0; x < passwordInput.charPtr; x++) { |
| ANPRectF oval; |
| oval.left = initialX + ((ovalWidth + ovalSpacing) * (float) x); |
| oval.right = oval.left + ovalWidth; |
| oval.top = ovalTop; |
| oval.bottom = ovalBottom; |
| gCanvasI.drawOval(canvas, &oval, m_paintText); |
| } |
| } |
| |
| int16 FormPlugin::handleEvent(const ANPEvent* evt) { |
| NPP instance = this->inst(); |
| |
| switch (evt->eventType) { |
| case kDraw_ANPEventType: |
| switch (evt->data.draw.model) { |
| case kBitmap_ANPDrawingModel: |
| drawPlugin(this, evt->data.draw.data.bitmap, evt->data.draw.clip); |
| return 1; |
| default: |
| break; // unknown drawing model |
| } |
| break; |
| |
| case kLifecycle_ANPEventType: |
| if (evt->data.lifecycle.action == kLoseFocus_ANPLifecycleAction) { |
| gLogI.log(instance, kDebug_ANPLogType, "----%p Loosing Focus", instance); |
| |
| if (m_activeInput) { |
| // hide the keyboard |
| gWindowI.showKeyboard(instance, false); |
| |
| //reset the activeInput |
| m_activeInput = NULL; |
| } |
| |
| m_hasFocus = false; |
| inval(instance); |
| return 1; |
| } |
| else if (evt->data.lifecycle.action == kGainFocus_ANPLifecycleAction) { |
| gLogI.log(instance, kDebug_ANPLogType, "----%p Gaining Focus", instance); |
| m_hasFocus = true; |
| inval(instance); |
| return 1; |
| } |
| break; |
| |
| case kMouse_ANPEventType: { |
| |
| int x = evt->data.mouse.x; |
| int y = evt->data.mouse.y; |
| if (kDown_ANPMouseAction == evt->data.mouse.action) { |
| |
| TextInput* currentInput = validTap(x,y); |
| |
| if (currentInput) |
| gWindowI.showKeyboard(instance, true); |
| else if (m_activeInput) |
| gWindowI.showKeyboard(instance, false); |
| |
| if (currentInput != m_activeInput) |
| switchActiveInput(currentInput); |
| |
| return 1; |
| } |
| break; |
| } |
| |
| case kKey_ANPEventType: |
| if (evt->data.key.action == kDown_ANPKeyAction) { |
| |
| //handle navigation keys |
| if (evt->data.key.nativeCode >= kDpadUp_ANPKeyCode |
| && evt->data.key.nativeCode <= kDpadCenter_ANPKeyCode) { |
| return handleNavigation(evt->data.key.nativeCode) ? 1 : 0; |
| } |
| |
| if (m_activeInput) { |
| handleTextInput(m_activeInput, evt->data.key.nativeCode, |
| evt->data.key.unichar); |
| inval(instance, m_activeInput->rect, true); |
| } |
| return 1; |
| } |
| break; |
| |
| case kVisibleRect_ANPEventType: { |
| |
| int oldScreenW = m_visibleRect.right - m_visibleRect.left; |
| int oldScreenH = m_visibleRect.bottom - m_visibleRect.top; |
| |
| m_visibleRect = evt->data.visibleRect.rect; |
| |
| int newScreenW = m_visibleRect.right - m_visibleRect.left; |
| int newScreenH = m_visibleRect.bottom - m_visibleRect.top; |
| |
| if (m_activeInput && (oldScreenW != newScreenW || oldScreenH != newScreenH)) |
| scrollIntoView(m_activeInput); |
| |
| return 1; |
| } |
| |
| default: |
| break; |
| } |
| return 0; // unknown or unhandled event |
| } |
| |
| void FormPlugin::switchActiveInput(TextInput* newInput) { |
| NPP instance = this->inst(); |
| |
| if (m_activeInput) |
| inval(instance, m_activeInput->rect, true); // inval the old |
| |
| m_activeInput = newInput; // set the new active input |
| |
| if (m_activeInput) |
| inval(instance, m_activeInput->rect, true); // inval the new |
| } |
| |
| bool FormPlugin::handleNavigation(ANPKeyCode keyCode) { |
| NPP instance = this->inst(); |
| |
| gLogI.log(instance, kDebug_ANPLogType, "----%p Recvd Nav Key %d", instance, keyCode); |
| |
| if (!m_activeInput) { |
| switchActiveInput(&m_usernameInput); |
| scrollIntoView(m_activeInput); |
| return true; |
| } |
| else if (m_activeInput == &m_usernameInput) { |
| if (keyCode == kDpadDown_ANPKeyCode) { |
| switchActiveInput(&m_passwordInput); |
| scrollIntoView(m_activeInput); |
| return true; |
| } |
| } |
| else if (m_activeInput == &m_passwordInput) { |
| if (keyCode == kDpadUp_ANPKeyCode) { |
| switchActiveInput(&m_usernameInput); |
| scrollIntoView(m_activeInput); |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| void FormPlugin::handleTextInput(TextInput* input, ANPKeyCode keyCode, int32_t unichar) { |
| NPP instance = this->inst(); |
| |
| //make sure the input field is in view |
| scrollIntoView(input); |
| |
| //handle the delete operation |
| if (keyCode == kDel_ANPKeyCode) { |
| if (input->charPtr > 0) { |
| input->charPtr--; |
| } |
| return; |
| } |
| |
| //check to see that the input is not full |
| if (input->charPtr >= (sizeof(input->text) - 1)) |
| return; |
| |
| //add the character |
| input->text[input->charPtr] = static_cast<char>(unichar); |
| input->charPtr++; |
| |
| gLogI.log(instance, kDebug_ANPLogType, "----%p Text: %c", instance, unichar); |
| } |
| |
| void FormPlugin::scrollIntoView(TextInput* input) { |
| NPP instance = this->inst(); |
| PluginObject *obj = (PluginObject*) instance->pdata; |
| NPWindow *window = obj->window; |
| |
| // find the textInput's global rect coordinates |
| ANPRectI inputRect; |
| inputRect.left = window->x + input->rect.left; |
| inputRect.top = window->y + input->rect.top; |
| inputRect.right = inputRect.left + (input->rect.right - input->rect.left); |
| inputRect.bottom = inputRect.top + (input->rect.bottom - input->rect.top); |
| |
| // if the rect is contained within visible window then do nothing |
| if (inputRect.left > m_visibleRect.left |
| && inputRect.right < m_visibleRect.right |
| && inputRect.top > m_visibleRect.top |
| && inputRect.bottom < m_visibleRect.bottom) { |
| return; |
| } |
| |
| // find the global (x,y) coordinates for center of the textInput |
| int inputCenterX = inputRect.left + ((inputRect.right - inputRect.left)/2); |
| int inputCenterY = inputRect.top + ((inputRect.bottom - inputRect.top)/2); |
| |
| gLogI.log(instance, kDebug_ANPLogType, "---- %p Input Center: %d,%d : %d,%d", |
| instance, inputCenterX, inputCenterY, window->x, window->y); |
| |
| //find global (x,y) coordinates for center of the visible screen |
| int screenCenterX = m_visibleRect.left + ((m_visibleRect.right - m_visibleRect.left)/2); |
| int screenCenterY = m_visibleRect.top + ((m_visibleRect.bottom - m_visibleRect.top)/2); |
| |
| gLogI.log(instance, kDebug_ANPLogType, "---- %p Screen Center: %d,%d : %d,%d", |
| instance, screenCenterX, screenCenterY, m_visibleRect.left, m_visibleRect.top); |
| |
| //compute the delta of the two coordinates |
| int deltaX = inputCenterX - screenCenterX; |
| int deltaY = inputCenterY - screenCenterY; |
| |
| gLogI.log(instance, kDebug_ANPLogType, "---- %p Centering: %d,%d : %d,%d", |
| instance, deltaX, deltaY, m_visibleRect.left + deltaX, m_visibleRect.top + deltaY); |
| |
| //move the visible screen |
| gWindowI.scrollTo(instance, m_visibleRect.left + deltaX, m_visibleRect.top + deltaY); |
| |
| } |
| |
| TextInput* FormPlugin::validTap(int x, int y) { |
| |
| if (x > m_usernameInput.rect.left && x < m_usernameInput.rect.right && |
| y > m_usernameInput.rect.top && y < m_usernameInput.rect.bottom) |
| return &m_usernameInput; |
| else if (x >m_passwordInput.rect.left && x < m_passwordInput.rect.right && |
| y > m_passwordInput.rect.top && y < m_passwordInput.rect.bottom) |
| return &m_passwordInput; |
| else |
| return NULL; |
| } |
