diff options
Diffstat (limited to 'vcl/android/androidinst.cxx')
| -rw-r--r-- | vcl/android/androidinst.cxx | 658 |
1 files changed, 631 insertions, 27 deletions
diff --git a/vcl/android/androidinst.cxx b/vcl/android/androidinst.cxx index a7721438e8c3..16a512551c33 100644 --- a/vcl/android/androidinst.cxx +++ b/vcl/android/androidinst.cxx @@ -29,18 +29,520 @@ #include <android/androidinst.hxx> #include <headless/svpdummies.hxx> #include <generic/gendata.hxx> +#include <jni.h> #include <android/log.h> #include <android/looper.h> -#include <lo-bootstrap.h> +#include <osl/detail/android-bootstrap.h> #include <osl/detail/android_native_app_glue.h> +#include <rtl/strbuf.hxx> + +extern void VCL_DLLPUBLIC plasma_now(const char *msg); + +void plasma_now(const char *msg) +{ + fprintf (stderr, "Skipped plasma '%s' !\n", msg); +} + +class AndroidSalData : public SalGenericData +{ +public: + AndroidSalData( SalInstance *pInstance ) : SalGenericData( SAL_DATA_ANDROID, pInstance ) {} + virtual void ErrorTrapPush() {} + virtual bool ErrorTrapPop( bool ) { return false; } +}; + +static rtl::OString MotionEdgeFlagsToString(int32_t nFlags) +{ + rtl::OStringBuffer aStr; + if (nFlags == AMOTION_EVENT_EDGE_FLAG_NONE) + aStr.append ("no-edge"); + if (nFlags & AMOTION_EVENT_EDGE_FLAG_TOP) + aStr.append (":top"); + if (nFlags & AMOTION_EVENT_EDGE_FLAG_BOTTOM) + aStr.append (":bottom"); + if (nFlags & AMOTION_EVENT_EDGE_FLAG_LEFT) + aStr.append (":left"); + if (nFlags & AMOTION_EVENT_EDGE_FLAG_RIGHT) + aStr.append (":right"); + return aStr.makeStringAndClear(); +} + +static rtl::OString KeyMetaStateToString(int32_t nFlags) +{ + rtl::OStringBuffer aStr; + if (nFlags == AMETA_NONE) + aStr.append ("no-meta"); + if (nFlags & AMETA_ALT_ON) + aStr.append (":alt"); + if (nFlags & AMETA_SHIFT_ON) + aStr.append (":shift"); + if (nFlags & AMETA_SYM_ON) + aStr.append (":sym"); + return aStr.makeStringAndClear(); +} + +static sal_uInt16 KeyMetaStateToCode(AInputEvent *event) +{ + sal_uInt16 nCode = 0; + int32_t nFlags = AKeyEvent_getMetaState(event); + if (nFlags & AMETA_SHIFT_ON) + nCode |= KEY_SHIFT; + if (nFlags & AMETA_SYM_ON) + nCode |= KEY_MOD1; + if (nFlags & AMETA_ALT_ON) + nCode |= KEY_MOD2; + return nCode; +} + +static sal_uInt16 KeyToCode(AInputEvent *event) +{ + sal_uInt16 nCode = 0; + switch (AKeyEvent_getKeyCode(event)) { +#define MAP(a,b) \ + case AKEYCODE_##a: nCode = KEY_##b; break +#define MAP_SAME(a) MAP(a,a) + + MAP_SAME(HOME); + MAP_SAME(0); MAP_SAME(1); MAP_SAME(2); MAP_SAME(3); MAP_SAME(4); + MAP_SAME(5); MAP_SAME(6); MAP_SAME(7); MAP_SAME(8); MAP_SAME(9); + + MAP_SAME(A); MAP_SAME(B); MAP_SAME(C); MAP_SAME(D); + MAP_SAME(E); MAP_SAME(F); MAP_SAME(G); MAP_SAME(H); + MAP_SAME(I); MAP_SAME(J); MAP_SAME(K); MAP_SAME(L); + MAP_SAME(M); MAP_SAME(N); MAP_SAME(O); MAP_SAME(P); + MAP_SAME(Q); MAP_SAME(R); MAP_SAME(S); MAP_SAME(T); + MAP_SAME(U); MAP_SAME(V); MAP_SAME(W); MAP_SAME(X); + MAP_SAME(Y); MAP_SAME(Z); + + MAP_SAME(TAB); MAP_SAME(SPACE); MAP_SAME(COMMA); + + MAP(ENTER,RETURN); + MAP(PAGE_UP, PAGEUP); + MAP(PAGE_DOWN, PAGEDOWN); + MAP(DEL, DELETE); + MAP(PERIOD, POINT); + + case AKEYCODE_BACK: // escape ? + case AKEYCODE_UNKNOWN: + case AKEYCODE_SOFT_LEFT: + case AKEYCODE_SOFT_RIGHT: + case AKEYCODE_CALL: + case AKEYCODE_ENDCALL: + case AKEYCODE_STAR: + case AKEYCODE_POUND: + case AKEYCODE_DPAD_UP: + case AKEYCODE_DPAD_DOWN: + case AKEYCODE_DPAD_LEFT: + case AKEYCODE_DPAD_RIGHT: + case AKEYCODE_DPAD_CENTER: + case AKEYCODE_VOLUME_UP: + case AKEYCODE_VOLUME_DOWN: + case AKEYCODE_POWER: + case AKEYCODE_CAMERA: + case AKEYCODE_CLEAR: + case AKEYCODE_ALT_LEFT: + case AKEYCODE_ALT_RIGHT: + case AKEYCODE_SHIFT_LEFT: + case AKEYCODE_SHIFT_RIGHT: + case AKEYCODE_SYM: + case AKEYCODE_EXPLORER: + case AKEYCODE_ENVELOPE: + case AKEYCODE_GRAVE: + case AKEYCODE_MINUS: + case AKEYCODE_EQUALS: + case AKEYCODE_LEFT_BRACKET: + case AKEYCODE_RIGHT_BRACKET: + case AKEYCODE_BACKSLASH: + case AKEYCODE_SEMICOLON: + case AKEYCODE_APOSTROPHE: + case AKEYCODE_SLASH: + case AKEYCODE_AT: + case AKEYCODE_NUM: + case AKEYCODE_HEADSETHOOK: + case AKEYCODE_FOCUS: // not widget, but camera focus + case AKEYCODE_PLUS: + case AKEYCODE_MENU: + case AKEYCODE_NOTIFICATION: + case AKEYCODE_SEARCH: + case AKEYCODE_MEDIA_PLAY_PAUSE: + case AKEYCODE_MEDIA_STOP: + case AKEYCODE_MEDIA_NEXT: + case AKEYCODE_MEDIA_PREVIOUS: + case AKEYCODE_MEDIA_REWIND: + case AKEYCODE_MEDIA_FAST_FORWARD: + case AKEYCODE_MUTE: + case AKEYCODE_PICTSYMBOLS: + case AKEYCODE_SWITCH_CHARSET: + case AKEYCODE_BUTTON_A: + case AKEYCODE_BUTTON_B: + case AKEYCODE_BUTTON_C: + case AKEYCODE_BUTTON_X: + case AKEYCODE_BUTTON_Y: + case AKEYCODE_BUTTON_Z: + case AKEYCODE_BUTTON_L1: + case AKEYCODE_BUTTON_R1: + case AKEYCODE_BUTTON_L2: + case AKEYCODE_BUTTON_R2: + case AKEYCODE_BUTTON_THUMBL: + case AKEYCODE_BUTTON_THUMBR: + case AKEYCODE_BUTTON_START: + case AKEYCODE_BUTTON_SELECT: + case AKEYCODE_BUTTON_MODE: + fprintf (stderr, "un-mapped keycode %d\n", nCode); + nCode = 0; + break; +#undef MAP_SAME +#undef MAP + } + fprintf (stderr, "mapped %d -> %d\n", AKeyEvent_getKeyCode(event), nCode); + return nCode; +} + +static void BlitFrameRegionToWindow(ANativeWindow_Buffer *pOutBuffer, + const basebmp::BitmapDeviceSharedPtr& aDev, + const ARect &rSrcRect, + int nDestX, int nDestY) +{ + fprintf (stderr, "Blit frame #2 src %d,%d->%d,%d to position %d, %d\n", + rSrcRect.left, rSrcRect.top, rSrcRect.right, rSrcRect.bottom, + nDestX, nDestY); + + basebmp::RawMemorySharedArray aSrcData = aDev->getBuffer(); + basegfx::B2IVector aDevSize = aDev->getSize(); + sal_Int32 nStride = aDev->getScanlineStride(); + unsigned char *pSrc = aSrcData.get(); + + // FIXME: do some cropping goodness on aSrcRect to ensure no overflows etc. + ARect aSrcRect = rSrcRect; + + // FIXME: we have WINDOW_FORMAT_RGB_565 = 4 ... + + for (unsigned int y = 0; y < (unsigned int)(aSrcRect.bottom - aSrcRect.top); y++) + { + unsigned char *sp = ( pSrc + nStride * (aSrcRect.bottom - aSrcRect.top - y - 1) + + aSrcRect.left * 3 /* src pixel size */ ); + + switch (pOutBuffer->format) { + case WINDOW_FORMAT_RGBA_8888: + case WINDOW_FORMAT_RGBX_8888: + { + unsigned char *dp = ( (unsigned char *)pOutBuffer->bits + + pOutBuffer->stride * 4 * (y + nDestY) + + nDestX * 4 /* dest pixel size */ ); + for (unsigned int x = 0; x < (unsigned int)(aSrcRect.right - aSrcRect.left); x++) + { + dp[x*4 + 0] = sp[x*3 + 2]; // R + dp[x*4 + 1] = sp[x*3 + 1]; // G + dp[x*4 + 2] = sp[x*3 + 0]; // B + dp[x*4 + 3] = 255; // A + } + break; + } + case WINDOW_FORMAT_RGB_565: + { + unsigned char *dp = ( (unsigned char *)pOutBuffer->bits + + pOutBuffer->stride * 2 * (y + nDestY) + + nDestX * 2 /* dest pixel size */ ); + for (unsigned int x = 0; x < (unsigned int)(aSrcRect.right - aSrcRect.left); x++) + { + unsigned char b = sp[x*3 + 0]; // B + unsigned char g = sp[x*3 + 1]; // G + unsigned char r = sp[x*3 + 2]; // R + dp[x*2 + 0] = (r & 0xf8) | (g >> 5); + dp[x*2 + 1] = ((g & 0x1c) << 5) | ((b & 0xf8) >> 3); + } + break; + } + default: + fprintf (stderr, "unknown pixel format %d !\n", pOutBuffer->format); + break; + } + } + fprintf (stderr, "done blit!\n"); +} + +void AndroidSalInstance::BlitFrameToWindow(ANativeWindow_Buffer *pOutBuffer, + const basebmp::BitmapDeviceSharedPtr& aDev) +{ + basegfx::B2IVector aDevSize = aDev->getSize(); + ARect aWhole = { 0, 0, aDevSize.getX(), aDevSize.getY() }; + BlitFrameRegionToWindow(pOutBuffer, aDev, aWhole, 0, 0); +} + +void AndroidSalInstance::RedrawWindows(ANativeWindow *pWindow) +{ + if (!pWindow) + return; + + ANativeWindow_Buffer aOutBuffer; + memset ((void *)&aOutBuffer, 0, sizeof (aOutBuffer)); + +// ARect aRect; + fprintf (stderr, "pre lock #3\n"); + int32_t nRet = ANativeWindow_lock(pWindow, &aOutBuffer, NULL); + fprintf (stderr, "locked window %d returned " // rect: %d,%d->%d,%d " + "buffer: %dx%d stride %d, format %d, bits %p\n", + nRet, // aRect.left, aRect.top, aRect.right, aRect.bottom, + aOutBuffer.width, aOutBuffer.height, aOutBuffer.stride, + aOutBuffer.format, aOutBuffer.bits); + if (aOutBuffer.bits != NULL) + { + +#if 1 // pre-'clean' the buffer with cruft: + // hard-code / guess at a format ... + int32_t *p = (int32_t *)aOutBuffer.bits; + for (int32_t y = 0; y < aOutBuffer.height; y++) + { + for (int32_t x = 0; x < aOutBuffer.stride; x++) + *p++ = (y << 24) + (x << 10) + 0xff ; + } +#endif + + std::list< SalFrame* >::const_iterator it; + for ( it = getFrames().begin(); it != getFrames().end(); it++ ) + { + SvpSalFrame *pFrame = static_cast<SvpSalFrame *>(*it); + + if (pFrame->IsVisible()) + { + // FIXME: force a re-draw - this appears not to happen much otherwis + pFrame->PostPaint(true); + BlitFrameToWindow (&aOutBuffer, pFrame->getDevice()); + } + else // Sucky the frame is invisible - why !? + fprintf (stderr, "invisible frame\n"); + } + } + else + fprintf (stderr, "no buffer for locked window\n"); + ANativeWindow_unlockAndPost(pWindow); + + fprintf (stderr, "done render!\n"); + mbQueueReDraw = false; +} + +static const char *app_cmd_name(int cmd) +{ + switch (cmd) { + case APP_CMD_INPUT_CHANGED: return "INPUT_CHANGED"; + case APP_CMD_INIT_WINDOW: return "INIT_WINDOW"; + case APP_CMD_TERM_WINDOW: return "TERM_WINDOW"; + case APP_CMD_WINDOW_RESIZED: return "WINDOW_RESIZED"; + case APP_CMD_WINDOW_REDRAW_NEEDED: return "WINDOW_REDRAW_NEEDED"; + case APP_CMD_CONTENT_RECT_CHANGED: return "CONTENT_RECT_CHANGED"; + case APP_CMD_GAINED_FOCUS: return "GAINED_FOCUS"; + case APP_CMD_LOST_FOCUS: return "LOST_FOCUS"; + case APP_CMD_CONFIG_CHANGED: return "CONFIG_CHANGED"; + case APP_CMD_LOW_MEMORY: return "LOW_MEMORY"; + case APP_CMD_START: return "START"; + case APP_CMD_RESUME: return "RESUME"; + case APP_CMD_SAVE_STATE: return "SAVE_STATE"; + case APP_CMD_PAUSE: return "PAUSE"; + case APP_CMD_STOP: return "STOP"; + case APP_CMD_DESTROY: return "DESTROY"; + default: + static char buf[10]; + sprintf(buf, "%d", cmd); + return buf; + } +} + +void AndroidSalInstance::GetWorkArea( Rectangle& rRect ) +{ + ANativeWindow *pWindow = mpApp->window; + if (!pWindow) + rRect = Rectangle( Point( 0, 0 ), + Size( 800, 600 ) ); + else + rRect = Rectangle( Point( 0, 0 ), + Size( ANativeWindow_getWidth( pWindow ), + ANativeWindow_getHeight( pWindow ) ) ); +} + +void AndroidSalInstance::onAppCmd (struct android_app* app, int32_t cmd) +{ + fprintf (stderr, "app cmd for app %p: %s\n", app, app_cmd_name(cmd)); + ANativeWindow *pWindow = mpApp->window; + switch (cmd) { + case APP_CMD_INIT_WINDOW: + { + ARect aRect = { 0, 0, 0, 0 }; + aRect.right = ANativeWindow_getWidth(pWindow); + aRect.bottom = ANativeWindow_getHeight(pWindow); + int nRet = ANativeWindow_setBuffersGeometry( + pWindow, ANativeWindow_getWidth(pWindow), + ANativeWindow_getHeight(pWindow), + WINDOW_FORMAT_RGBA_8888); + fprintf (stderr, "we have an app window ! %p %dx%x (%d) set %d\n", + pWindow, aRect.right, aRect.bottom, + ANativeWindow_getFormat(pWindow), nRet); + break; + } + case APP_CMD_WINDOW_RESIZED: + { + ARect aRect = { 0, 0, 0, 0 }; + aRect.right = ANativeWindow_getWidth(pWindow); + aRect.bottom = ANativeWindow_getHeight(pWindow); + fprintf (stderr, "app window resized to ! %p %dx%x (%d)\n", + pWindow, aRect.right, aRect.bottom, + ANativeWindow_getFormat(pWindow)); + break; + } + + case APP_CMD_WINDOW_REDRAW_NEEDED: + { + fprintf (stderr, "redraw needed\n"); + mbQueueReDraw = true; + break; + } + + case APP_CMD_CONTENT_RECT_CHANGED: + { + ARect aRect = mpApp->contentRect; + fprintf (stderr, "content rect changed [ k/b popped up etc. ] %d,%d->%d,%d\n", + aRect.left, aRect.top, aRect.right, aRect.bottom); + break; + } + default: + fprintf (stderr, "unhandled app cmd %d\n", cmd); + break; + } +} + +int32_t AndroidSalInstance::onInputEvent (struct android_app* app, AInputEvent* event) +{ + bool bHandled = false; + fprintf (stderr, "input event for app %p, event %p type %d source %d device id %d\n", + app, event, + AInputEvent_getType(event), + AInputEvent_getSource(event), + AInputEvent_getDeviceId(event)); + + switch (AInputEvent_getType(event)) + { + case AINPUT_EVENT_TYPE_KEY: + { + int32_t nAction = AKeyEvent_getAction(event); + fprintf (stderr, "key event keycode %d '%s' %s\n", + AKeyEvent_getKeyCode(event), + nAction == AKEY_EVENT_ACTION_DOWN ? "down" : + nAction == AKEY_EVENT_ACTION_UP ? "up" : "multiple", + KeyMetaStateToString(AKeyEvent_getMetaState(event)).getStr()); + + // FIXME: the whole SALEVENT_KEYMODCHANGE stuff is going to be interesting + // can we really emit that ? no input method madness required though. + sal_uInt16 nEvent; + SalKeyEvent aEvent; + int64_t nNsTime = AKeyEvent_getEventTime(event); + + nEvent = (AKeyEvent_getAction(event) == AKEY_EVENT_ACTION_UP ? + SALEVENT_KEYUP : SALEVENT_KEYINPUT); + aEvent.mnTime = nNsTime / (1000 * 1000); + aEvent.mnCode = KeyToCode(event); + aEvent.mnCode |= KeyMetaStateToCode(event); + aEvent.mnCharCode = 'a'; // the unicode of it all ... + aEvent.mnRepeat = AKeyEvent_getRepeatCount(event); + + SalFrame *pFocus = SvpSalFrame::GetFocusFrame(); + if (pFocus) + bHandled = pFocus->CallCallback( nEvent, &aEvent ); + else + fprintf (stderr, "no focused frame to emit event on\n"); + + fprintf( stderr, "bHandled == %s\n", bHandled? "true": "false" ); + + // FIXME: queueing full re-draw on key events ... + mbQueueReDraw = true; + break; + } + case AINPUT_EVENT_TYPE_MOTION: + { + size_t nPoints = AMotionEvent_getPointerCount(event); + fprintf (stderr, "motion event %d %g,%g %d points: %s\n", + AMotionEvent_getAction(event), + AMotionEvent_getXOffset(event), + AMotionEvent_getYOffset(event), + (int)nPoints, + MotionEdgeFlagsToString(AMotionEvent_getEdgeFlags(event)).getStr()); + for (size_t i = 0; i < nPoints; i++) + fprintf(stderr, "\t%d: %g,%g - pressure %g\n", + (int)i, + AMotionEvent_getX(event, i), + AMotionEvent_getY(event, i), + AMotionEvent_getPressure(event, i)); + + SalMouseEvent aMouseEvent; + sal_uInt16 nEvent = 0; + + // FIXME: all this filing the nEvent and aMouseEvent has to be cleaned up + nEvent = AMotionEvent_getAction(event)? SALEVENT_MOUSEBUTTONUP: SALEVENT_MOUSEBUTTONDOWN; + + aMouseEvent.mnX = AMotionEvent_getXOffset(event); + aMouseEvent.mnY = AMotionEvent_getYOffset(event); + aMouseEvent.mnTime = 0; // FIXME + aMouseEvent.mnCode = 0; // FIXME + aMouseEvent.mnButton = MOUSE_LEFT; // FIXME + + SalFrame *pFocus = SvpSalFrame::GetFocusFrame(); + if (pFocus) + bHandled = pFocus->CallCallback( nEvent, &aMouseEvent ); + else + fprintf (stderr, "no focused frame to emit event on\n"); + + fprintf( stderr, "bHandled == %s\n", bHandled? "true": "false" ); + + break; + } + default: + fprintf (stderr, "unknown input event type %p %d\n", + event, AInputEvent_getType(event)); + break; + } + return bHandled ? 1 : 0; +} + +AndroidSalInstance *AndroidSalInstance::getInstance() +{ + if (!ImplGetSVData()) + return NULL; + AndroidSalData *pData = static_cast<AndroidSalData *>(ImplGetSVData()->mpSalData); + if (!pData) + return NULL; + return static_cast<AndroidSalInstance *>(pData->m_pInstance); +} + +extern "C" { + void onAppCmd_cb (struct android_app *app, int32_t cmd) + { + AndroidSalInstance::getInstance()->onAppCmd(app, cmd); + } + + int32_t onInputEvent_cb (struct android_app *app, AInputEvent *event) + { + return AndroidSalInstance::getInstance()->onInputEvent(app, event); + } +} AndroidSalInstance::AndroidSalInstance( SalYieldMutex *pMutex ) : SvpSalInstance( pMutex ) + , mpApp( NULL ) + , mbQueueReDraw( false ) + , mxDisplay( EGL_NO_DISPLAY ) + , mxSurface( EGL_NO_SURFACE ) + , mxContext( EGL_NO_CONTEXT ) { - app = lo_get_app(); - fprintf (stderr, "created Android Sal Instance for app %p window %p\n", - app, - app ? app->window : NULL); + mpApp = lo_get_app(); + fprintf (stderr, "created Android Sal Instance for app %p window %p thread: %d\n", + mpApp, + mpApp ? mpApp->window : NULL, + (int)pthread_self()); + if (mpApp) + { + pthread_mutex_lock (&mpApp->mutex); + mpApp->onAppCmd = onAppCmd_cb; + mpApp->onInputEvent = onInputEvent_cb; + pthread_mutex_unlock (&mpApp->mutex); + } } AndroidSalInstance::~AndroidSalInstance() @@ -50,8 +552,9 @@ AndroidSalInstance::~AndroidSalInstance() void AndroidSalInstance::Wakeup() { - if (app && app->looper) - ALooper_wake (app->looper); + fprintf (stderr, "Wakeup alooper\n"); + if (mpApp && mpApp->looper) + ALooper_wake (mpApp->looper); else fprintf (stderr, "busted - no global looper\n"); } @@ -61,20 +564,40 @@ void AndroidSalInstance::DoReleaseYield (int nTimeoutMS) // release yield mutex sal_uLong nAcquireCount = ReleaseYieldMutex(); - fprintf (stderr, "DoReleaseYield for %d ms\n", nTimeoutMS); -// int ALooper_pollOnce(timeoutMs, int* outFd, int* outEvents, void** outData); + fprintf (stderr, "DoReleaseYield #3 %d thread: %d ms\n", + nTimeoutMS, (int)pthread_self()); + + struct android_poll_source *pSource = NULL; + int outFd = 0, outEvents = 0; + + if (mbQueueReDraw) + nTimeoutMS = 0; + + int nRet; + nRet = ALooper_pollAll (nTimeoutMS, &outFd, &outEvents, (void**)&pSource); + fprintf (stderr, "ret #6 %d %d %d %p\n", nRet, outFd, outEvents, pSource); // acquire yield mutex again AcquireYieldMutex(nAcquireCount); + + if (nRet >= 0) + { + // Process this event. + if (pSource != NULL) + pSource->process(mpApp, pSource); + } + + if (mbQueueReDraw && mpApp->window) + AndroidSalInstance::getInstance()->RedrawWindows (mpApp->window); } bool AndroidSalInstance::AnyInput( sal_uInt16 nType ) { - (void) nType; - // FIXME: ideally we should check the input queue to avoid being busy ... - fprintf (stderr, "FIXME: AnyInput returns true\n"); - // app->inputQueue ? ... - return true; + if( (nType & VCL_INPUT_TIMER) != 0 ) + return CheckTimeout( false ); + // FIXME: ideally we should check our input queue here ... + fprintf (stderr, "FIXME: AnyInput returns false\n"); + return false; } class AndroidSalSystem : public SvpSalSystem { @@ -84,14 +607,7 @@ public: virtual int ShowNativeDialog( const rtl::OUString& rTitle, const rtl::OUString& rMessage, const std::list< rtl::OUString >& rButtons, - int nDefButton ) - { - (void)rButtons; (void)nDefButton; - __android_log_print(ANDROID_LOG_INFO, "LibreOffice - dialog '%s': '%s'", - rtl::OUStringToOString(rTitle, RTL_TEXTENCODING_ASCII_US).getStr(), - rtl::OUStringToOString(rMessage, RTL_TEXTENCODING_ASCII_US).getStr()); - return 0; - } + int nDefButton ); }; SalSystem *AndroidSalInstance::CreateSalSystem() @@ -99,14 +615,66 @@ SalSystem *AndroidSalInstance::CreateSalSystem() return new AndroidSalSystem(); } -class AndroidSalData : public SalGenericData +class AndroidSalFrame : public SvpSalFrame { public: - AndroidSalData( SalInstance *pInstance ) : SalGenericData( SAL_DATA_ANDROID, pInstance ) {} - virtual void ErrorTrapPush() {} - virtual bool ErrorTrapPop( bool ) { return false; } + AndroidSalFrame( AndroidSalInstance *pInstance, + SalFrame *pParent, + sal_uLong nSalFrameStyle, + SystemParentData *pSysParent ) + : SvpSalFrame( pInstance, pParent, nSalFrameStyle, pSysParent ) + { + } + + virtual void GetWorkArea( Rectangle& rRect ) + { + AndroidSalInstance::getInstance()->GetWorkArea( rRect ); + } + + virtual void UpdateSettings( AllSettings &rSettings ) + { + // Clobber the UI fonts +#if 0 + psp::FastPrintFontInfo aInfo; + aInfo.m_aFamilyName = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Roboto" ) ); + aInfo.m_eItalic = ITALIC_NORMAL; + aInfo.m_eWeight = WEIGHT_NORMAL; + aInfo.m_eWidth = WIDTH_NORMAL; + psp::PrintFontManager::get().matchFont( aInfo, rSettings.GetUILocale() ); +#endif + + // FIXME: is 12 point enough ? + Font aFont( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Roboto" ) ), + Size( 0, 14 ) ); + + StyleSettings aStyleSet = rSettings.GetStyleSettings(); + aStyleSet.SetAppFont( aFont ); + aStyleSet.SetHelpFont( aFont ); + aStyleSet.SetMenuFont( aFont ); + aStyleSet.SetToolFont( aFont ); + aStyleSet.SetLabelFont( aFont ); + aStyleSet.SetInfoFont( aFont ); + aStyleSet.SetRadioCheckFont( aFont ); + aStyleSet.SetPushButtonFont( aFont ); + aStyleSet.SetFieldFont( aFont ); + aStyleSet.SetIconFont( aFont ); + aStyleSet.SetGroupFont( aFont ); + + rSettings.SetStyleSettings( aStyleSet ); + } }; +SalFrame *AndroidSalInstance::CreateChildFrame( SystemParentData* pParent, sal_uLong nStyle ) +{ + return new AndroidSalFrame( this, NULL, nStyle, pParent ); +} + +SalFrame *AndroidSalInstance::CreateFrame( SalFrame* pParent, sal_uLong nStyle ) +{ + return new AndroidSalFrame( this, pParent, nStyle, NULL ); +} + + // All the interesting stuff is slaved from the AndroidSalInstance void InitSalData() {} void DeInitSalData() {} @@ -120,7 +688,7 @@ void SalAbort( const rtl::OUString& rErrorText, bool bDumpCore ) aError = rtl::OUString::createFromAscii("Unknown application error"); ::fprintf( stderr, "%s\n", rtl::OUStringToOString(rErrorText, osl_getThreadTextEncoding()).getStr() ); - __android_log_print(ANDROID_LOG_INFO, "SalAbort: '%s'", + __android_log_print(ANDROID_LOG_INFO, "LibreOffice", "SalAbort: '%s'", rtl::OUStringToOString(aError, RTL_TEXTENCODING_ASCII_US).getStr()); if( bDumpCore ) abort(); @@ -148,6 +716,7 @@ SalData::~SalData() // This is our main entry point: SalInstance *CreateSalInstance() { + fprintf (stderr, "Android: CreateSalInstance!\n"); AndroidSalInstance* pInstance = new AndroidSalInstance( new SalYieldMutex() ); new AndroidSalData( pInstance ); return pInstance; @@ -159,4 +728,39 @@ void DestroySalInstance( SalInstance *pInst ) delete pInst; } +#include <vcl/msgbox.hxx> + +int AndroidSalSystem::ShowNativeDialog( const rtl::OUString& rTitle, + const rtl::OUString& rMessage, + const std::list< rtl::OUString >& rButtons, + int nDefButton ) +{ + (void)rButtons; (void)nDefButton; + fprintf (stderr, "LibreOffice native dialog '%s': '%s'\n", + rtl::OUStringToOString(rTitle, RTL_TEXTENCODING_ASCII_US).getStr(), + rtl::OUStringToOString(rMessage, RTL_TEXTENCODING_ASCII_US).getStr()); + __android_log_print(ANDROID_LOG_INFO, "LibreOffice", "Dialog '%s': '%s'", + rtl::OUStringToOString(rTitle, RTL_TEXTENCODING_ASCII_US).getStr(), + rtl::OUStringToOString(rMessage, RTL_TEXTENCODING_ASCII_US).getStr()); + + if (AndroidSalInstance::getInstance() != NULL) + { + // Does Android have a native dialog ? if not,. we have to do this ... + + // Of course it has. android.app.AlertDialog seems like a good + // choice, it even has one, two or three buttons. Naturally, + // it intended to be used from Java, so some verbose JNI + // horror would be needed to use it directly here. Probably we + // want some easier to use magic wrapper, hmm. + + ErrorBox aVclErrBox( NULL, WB_OK, rTitle ); + aVclErrBox.SetText( rMessage ); + aVclErrBox.Execute(); + } + else + fprintf (stderr, "VCL not initialized\n"); + return 0; +} + + /* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |