1 /*******************************************************************************

     2  * Copyright (c) 2005, 2010 Nokia Corporation and/or its subsidiary(-ies).

     3  * All rights reserved. This program and the accompanying materials

     4  * are made available under the terms of the Eclipse Public License v1.0

     5  * which accompanies this distribution, and is available at

     6  * http://www.eclipse.org/legal/epl-v10.html

     7  *

     8  * Contributors:

     9  *     Nokia Corporation - S60 implementation

    10  *******************************************************************************/

    11 

    12 

    13 #include <gulutil.h>

    14 #include "org_eclipse_swt_internal_symbian_OS.h"

    15 #include "eswtwidgetscore.h"

    16 #include "swtimagedata.h"

    17 #include "templatehelpers.h"

    18 #include "utils.h"

    19 #include "swtimagedataloader.h"

    20 #include "swtdialogbroker.h"

    21 

    22 

    23 // ======== LOCAL FUNCTIONS ========

    24 

    25 

    26 template<class C>

    27 static jint NewCoreWidget(JNIEnv* aJniEnv,

    28                           C*(MSwtFactory::*aMethodL)(MSwtDisplay&, TSwtPeer, MSwtComposite&, TInt) const,

    29                           jobject aPeer,

    30                           jint aParent,

    31                           jint aStyle)

    32 {

    33     CSwtDisplay& display = CSwtDisplay::Current();

    34     const MSwtFactory& factory = display.Factory();

    35     return NewWidget(aJniEnv, &factory, aMethodL, display, aPeer, aParent, aStyle);

    36 }

    37 

    38 

    39 extern "C"

    40 {

    41 

    42     /*

    43      *  Class Device

    44      */

    45     JNIEXPORT jobject JNICALL Java_org_eclipse_swt_internal_symbian_OS_Device_1GetBounds(JNIEnv* aJniEnv, jclass, jint aHandle)

    46     {

    47         ASSERT(aHandle!=0);

    48         const MSwtDevice* device = reinterpret_cast<MSwtDevice*>(aHandle);

    49         TRect       bounds(TRect::EUninitialized);

    50         CallMethod(bounds, device, &MSwtDevice::Bounds);

    51         return NewJavaRectangle(aJniEnv, bounds);

    52     }

    53 

    54     JNIEXPORT jobject JNICALL Java_org_eclipse_swt_internal_symbian_OS_Device_1GetClientArea(JNIEnv* aJniEnv, jclass, jint aHandle)

    55     {

    56         ASSERT(aHandle!=0);

    57         const MSwtDevice* device = reinterpret_cast<MSwtDevice*>(aHandle);

    58         TRect       clientArea(TRect::EUninitialized);

    59         CallMethod(clientArea, device, &MSwtDevice::ClientArea);

    60         return NewJavaRectangle(aJniEnv, clientArea);

    61     }

    62 

    63     JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_symbian_OS_Device_1GetDepth(JNIEnv* , jclass, jint aHandle)

    64     {

    65         ASSERT(aHandle!=0);

    66         const MSwtDevice* device = reinterpret_cast<MSwtDevice*>(aHandle);

    67         TInt        depth;

    68         CallMethod(depth, device, &MSwtDevice::Depth);

    69         return depth;

    70     }

    71 

    72     JNIEXPORT jobject JNICALL Java_org_eclipse_swt_internal_symbian_OS_Device_1GetDPI(JNIEnv* aJniEnv, jclass, jint aHandle)

    73     {

    74         ASSERT(aHandle!=0);

    75         const MSwtDevice* device = reinterpret_cast<MSwtDevice*>(aHandle);

    76         TSize       dpi(TSize::EUninitialized);

    77         CallMethod(dpi, device, &MSwtDevice::Dpi);

    78         return NewJavaPoint(aJniEnv, TPoint(dpi.iWidth, dpi.iHeight));

    79     }

    80 

    81     static TInt ConvertFontStyle(const TFontStyle& aFontStyle)

    82     {

    83         TInt result = KSwtNormal;

    84 

    85         if (aFontStyle.StrokeWeight() == EStrokeWeightBold)

    86             result |= KSwtBold;

    87 

    88         if (aFontStyle.Posture() == EPostureItalic)

    89             result |= KSwtItalic;

    90 

    91         return result;

    92     }

    93 

    94     static jobjectArray Device_GetFontListL(JNIEnv* aJniEnv, const MSwtDevice* aDevice, jstring aFaceName, TBool aScalable)

    95     {

    96         HBufC* faceName = ConvertStringLC(aJniEnv, aFaceName);

    97         TDesC& nameDesc = const_cast<TDesC&>((faceName!=NULL) ? static_cast<const TDesC&>(*faceName) : KNullDesC());

    98         CArrayFixFlat<TSwtFontData>* fontDataArray = NULL;

    99         CallMethodL(fontDataArray, aDevice, &MSwtDevice::GetFontListL, nameDesc, aScalable);

   100         if (faceName!=NULL)

   101             CleanupStack::PopAndDestroy(faceName);

   102 

   103         // Construct the array of Java Fontdata

   104         jobjectArray javaFontDataArray = NULL;

   105         TInt nbFontData = fontDataArray->Count();

   106         if (nbFontData > 0)

   107         {

   108             jclass fontDataClass = aJniEnv->FindClass("org/eclipse/swt/graphics/FontData");

   109             if (fontDataClass != NULL)

   110             {

   111                 javaFontDataArray = aJniEnv->NewObjectArray(nbFontData, fontDataClass, NULL);

   112                 if (javaFontDataArray != NULL)

   113                 {

   114                     jmethodID constructId = aJniEnv->GetMethodID(fontDataClass, "<init>", "(Ljava/lang/String;II)V");

   115                     if (constructId != NULL)

   116                     {

   117                         for (TInt i=0; i<nbFontData; ++i)

   118                         {

   119                             // Construct a Java Fontdata object

   120                             const TFontSpec& fontSpec = (*fontDataArray)[i].iFontSpec;

   121                             jstring fontDataName   = NewJavaString(aJniEnv, fontSpec.iTypeface.iName);

   122                             jint    heightInPoints = FontUtils::PointsFromTwips(fontSpec.iHeight);

   123                             jint    style          = ConvertFontStyle(fontSpec.iFontStyle);

   124                             jobject fontDataObj    = aJniEnv->NewObject(fontDataClass, constructId, fontDataName, heightInPoints, style);

   125                             aJniEnv->DeleteLocalRef(fontDataName);

   126 

   127                             // Append to font data array

   128                             aJniEnv->SetObjectArrayElement(javaFontDataArray, i, fontDataObj); //lint !e613

   129                             aJniEnv->DeleteLocalRef(fontDataObj);

   130                         }

   131                     }

   132                 }

   133                 aJniEnv->DeleteLocalRef(fontDataClass);

   134             }

   135         }

   136 

   137         DeleteInUiHeap(fontDataArray);

   138 

   139         return javaFontDataArray;

   140     }

   141 

   142     JNIEXPORT jobjectArray JNICALL Java_org_eclipse_swt_internal_symbian_OS_Device_1GetFontList(JNIEnv* aJniEnv, jclass, jint aHandle, jstring aFaceName, jboolean aScalable)

   143     {

   144         ASSERT(aHandle!=0);

   145         const MSwtDevice* device = reinterpret_cast<MSwtDevice*>(aHandle);

   146         jobjectArray      result = NULL;

   147         TRAPD(error, (result=Device_GetFontListL(aJniEnv, device, aFaceName, aScalable)));

   148         ThrowIfError(error, aJniEnv);

   149         return result;

   150     }

   151 

   152     JNIEXPORT jobject JNICALL Java_org_eclipse_swt_internal_symbian_OS_Device_1GetSystemColor(JNIEnv* aJniEnv, jclass, jint aHandle, jint aId)

   153     {

   154         ASSERT(aHandle!=0);

   155         const MSwtDevice* device = reinterpret_cast<MSwtDevice*>(aHandle);

   156         TSwtColorId colorId(static_cast<TSwtColorId>(aId));

   157         TRgb rgb;

   158         CallMethod(rgb, device, &MSwtDevice::GetSystemColor, colorId);

   159         return NewJavaRgb(aJniEnv, rgb);

   160     }

   161 

   162     JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_symbian_OS_Device_1GetSystemFont(JNIEnv*, jclass, jint aHandle)

   163     {

   164         CSwtDisplay* display = DisplayFromDevice(aHandle);

   165         const MSwtDevice* device = reinterpret_cast<MSwtDevice*>(aHandle);

   166         const MSwtFont* font;

   167         CallMethod(font, device, &MSwtDevice::GetSystemFont, display);

   168         ASSERT(font!=NULL);

   169         return reinterpret_cast<jint>(font);

   170     }

   171 

   172 

   173     /*

   174      * Class Display

   175      */

   176     JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_symbian_OS_Display_1New(JNIEnv* aJniEnv, jclass, jobject aPeer, jint aDisplayParameter)

   177     {

   178         CSwtDisplay* display = NULL;

   179         TRAPD(error, (display=CSwtDisplay::NewL(*aJniEnv, aPeer, aDisplayParameter)));

   180         ThrowIfError(error, aJniEnv);

   181         return reinterpret_cast<jint>(display);

   182     }

   183 

   184     JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_symbian_OS_Display_1DeviceHandle(JNIEnv*, jclass, jint aHandle)

   185     {

   186         ASSERT(aHandle!=0);

   187         return reinterpret_cast<jint>(static_cast<MSwtDevice*>(reinterpret_cast<CSwtDisplay*>(aHandle)));

   188     }

   189 

   190     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Display_1Dispose(JNIEnv* aJniEnv, jclass, jint aHandle)

   191     {

   192         ASSERT(aHandle!=0);

   193         if (!aHandle)

   194             return;

   195 

   196         CSwtDisplay* display = reinterpret_cast<CSwtDisplay*>(aHandle);

   197 

   198 #if defined(__WINS__) && defined(_DEBUG)

   199         display->iInstanceCounts.CheckForLeaks();

   200 #endif

   201 

   202         display->Dispose(*aJniEnv);

   203     }

   204 

   205     static void Display_SetAppNameL(JNIEnv* aJniEnv, jstring aString)

   206     {

   207         MSwtDisplay* display = CSwtDisplay::CurrentOrNull();

   208         if (display)

   209         {

   210             HBufC* buf = ConvertStringLC(aJniEnv, aString);

   211             CallMethodL(&display->UiUtils(), &MSwtUiUtils::SetAppNameL, buf);

   212             CallMethodL(display, &MSwtDisplay::SetNameInTaskListL, buf);

   213             if (buf)

   214             {

   215                 CleanupStack::PopAndDestroy(buf);

   216             }

   217         }

   218     }

   219 

   220     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Display_1SetAppName(

   221         JNIEnv* aJniEnv, jclass, jstring aString)

   222     {

   223         TRAPD(error, Display_SetAppNameL(aJniEnv, aString));

   224         ThrowIfError(error, aJniEnv);

   225     }

   226 

   227     JNIEXPORT jboolean JNICALL Java_org_eclipse_swt_internal_symbian_OS_Display_1Sleep(JNIEnv*, jclass, jint aHandle)

   228     {

   229         ASSERT(aHandle!=0);

   230         TBool result = reinterpret_cast<CSwtDisplay*>(aHandle)->Sleep(); //lint !e613

   231         return ConvertBoolean(result);

   232     }

   233 

   234     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Display_1Wake(JNIEnv*, jclass, jint aHandle)

   235     {

   236         ASSERT(aHandle!=0);

   237         reinterpret_cast<CSwtDisplay*>(aHandle)->Wake();

   238     }

   239 

   240     JNIEXPORT jboolean JNICALL Java_org_eclipse_swt_internal_symbian_OS_Display_1ReadAndDispatch(JNIEnv* aJniEnv, jclass, jint aHandle)

   241     {

   242         ASSERT(aHandle!=0);

   243         TBool result = reinterpret_cast<CSwtDisplay*>(aHandle)->ReadAndDispatch(*aJniEnv);

   244         return ConvertBoolean(result);

   245     }

   246 

   247     JNIEXPORT jobject JNICALL Java_org_eclipse_swt_internal_symbian_OS_Display_1GetActiveShell(JNIEnv*, jclass, jint)

   248     {

   249         const MSwtUiUtils& utils = CSwtDisplay::Current().UiUtils();

   250         TSwtPeer peer;

   251         CallMethod(peer, &utils, &MSwtUiUtils::GetActiveShellPeer);

   252         return peer;

   253     }

   254 

   255     JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_symbian_OS_Display_1getDoubleClickTime(JNIEnv *, jclass, jint)

   256     {

   257         const ASwtDisplayBase& display = CSwtDisplay::Current();

   258         TInt result;

   259 

   260         CallMethod(result, &display, &ASwtDisplayBase::GetDoubleClickTime);

   261         return result;

   262     }

   263 

   264     JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_symbian_OS_Display_1getIconDepth(JNIEnv *, jclass, jint)

   265     {

   266         const ASwtDisplayBase& display = CSwtDisplay::Current();

   267         TInt result;

   268 

   269         CallMethod(result, &display, &ASwtDisplayBase::GetIconDepth);

   270         return result;

   271     }

   272 

   273     JNIEXPORT jobjectArray JNICALL Java_org_eclipse_swt_internal_symbian_OS_Display_1GetShells(JNIEnv* aJniEnv, jclass, jint)

   274     {

   275         const MSwtUiUtils& utils = CSwtDisplay::Current().UiUtils();

   276 

   277         CSwtPeerArray* shells  = NULL;

   278         TRAPD(error, CallMethodL(shells, &utils, &MSwtUiUtils::GetShellPeersL));

   279         if (error)

   280         {

   281             Throw(error, aJniEnv);

   282             return NULL;

   283         }

   284 

   285         jobjectArray result = NewJavaControlArray(aJniEnv, shells);

   286         DeleteInUiHeap(shells);

   287 

   288         return result;

   289     }

   290 

   291     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Display_1Beep(JNIEnv *, jclass, jint)

   292     {

   293         const ASwtDisplayBase& display = CSwtDisplay::Current();

   294         CallMethod(&display, &ASwtDisplayBase::Beep);

   295     }

   296 

   297     JNIEXPORT jobject JNICALL Java_org_eclipse_swt_internal_symbian_OS_Display_1GetFocusControl(JNIEnv *, jclass, jint)

   298     {

   299         const MSwtUiUtils& utils = CSwtDisplay::Current().UiUtils();

   300         TSwtPeer peer;

   301 

   302         CallMethod(peer, &utils, &MSwtUiUtils::GetFocusControl);

   303         return peer;

   304     }

   305 

   306     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Display_1StartTimer(JNIEnv* aJniEnv, jclass, jint, jint aDelayInMilliSeconds, jint aTimerHandle)

   307     {

   308         ASwtDisplayBase& display = CSwtDisplay::Current();

   309 

   310         TRAPD(error, CallMethodL(&display, &ASwtDisplayBase::AddTimerL, aDelayInMilliSeconds, aTimerHandle));

   311         ThrowIfError(error, aJniEnv);

   312     }

   313 

   314 

   315     JNIEXPORT jboolean JNICALL Java_org_eclipse_swt_internal_symbian_OS_Display_1Post

   316     (JNIEnv*, jclass, jint aEventType, jchar aEventCharacter, jint aEventKeyCode, jint aEventStateMask)

   317     {

   318         ASwtDisplayBase& display = CSwtDisplay::Current();

   319         TSwtKeyEventData data;

   320         data.iType           = static_cast<TSwtEventType>(aEventType);

   321         data.iCharacter      = aEventCharacter;

   322         data.iKeyCode        = aEventKeyCode;

   323         data.iStateMask      = aEventStateMask;

   324         TRAPD(ignore, CallMethodL(&display, &ASwtDisplayBase::PostL, data));

   325         return ConvertBoolean(ignore == KErrNone);

   326     }

   327 

   328     JNIEXPORT jboolean JNICALL Java_org_eclipse_swt_internal_symbian_OS_Display_1MousePost

   329     (JNIEnv* aJniEnv, jclass, jint aEventType, jint xPos, jint yPos, jint aEventStateMask)

   330     {

   331         ASwtDisplayBase& display = CSwtDisplay::Current();

   332 

   333         TPoint point;

   334         point=TPoint(xPos, yPos);

   335         TSwtKeyEventData data;

   336         data.iType           = static_cast<TSwtEventType>(aEventType);

   337         data.iStateMask      = aEventStateMask;

   338         TBool results;

   339         TRAPD(error, CallMethodL(results, &display, &ASwtDisplayBase::MousePostL, data, point));

   340         ThrowIfError(error, aJniEnv);

   341         return ConvertBoolean(results);

   342     }

   343 

   344     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Display_1SetAppUID

   345     (JNIEnv* , jclass, jint aUID)

   346     {

   347         MSwtDisplay* display = CSwtDisplay::CurrentOrNull();

   348         if (display)

   349         {

   350             CallMethod(display, &MSwtDisplay::SetUIDInTaskList, aUID);

   351         }

   352     }

   353 

   354     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Display_1SetAppVisible

   355     (JNIEnv *, jclass, jboolean aVisible)

   356     {

   357         MSwtDisplay* display = CSwtDisplay::CurrentOrNull();

   358         if (display)

   359         {

   360             CallMethod(display, &MSwtDisplay::SetAppVisible, aVisible);

   361         }

   362     }

   363 

   364     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Display_1SetOptimizedPaint

   365     (JNIEnv *, jclass, jint aHandle, jboolean aStatus)

   366     {

   367         CSwtDisplay* display = reinterpret_cast<CSwtDisplay*>(aHandle);

   368         if (display)

   369         {

   370             CSwtEventQueue* queue = display->EventQueue();

   371             if (queue)

   372             {

   373                 CallMethod(queue, &CSwtEventQueue::SetOptimizedPaint, aStatus);

   374             }

   375         }

   376     }

   377 

   378     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Display_1NotifyFirstPaintComplete

   379     (JNIEnv *, jclass, jboolean aTopShell)

   380     {

   381         MSwtDisplay* display = CSwtDisplay::CurrentOrNull();

   382         if (display)

   383         {

   384             CallMethod(display, &MSwtDisplay::SetUiReady, aTopShell);

   385         }

   386     }

   387 

   388     /*

   389      * Class DisplayExtension

   390      */

   391     JNIEXPORT jobject JNICALL Java_org_eclipse_swt_internal_symbian_OS_DisplayExtension_1getBestImageSize

   392     (JNIEnv* aJniEnv, jclass, jint aImageType)

   393     {

   394         MSwtUiUtils& utils = CSwtDisplay::Current().UiUtils();

   395         TSize       imageSize(TSize::EUninitialized);

   396         CallMethod(imageSize, &utils, &MSwtUiUtils::GetBestImageSize, aImageType);

   397         return NewJavaPoint(aJniEnv, TPoint(imageSize.iWidth, imageSize.iHeight));

   398     }

   399 

   400     /*

   401      * Class Canvas

   402      */

   403     JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_symbian_OS_Canvas_1New(JNIEnv* aJniEnv, jclass, jobject aPeer, jint aParent, jint aStyle)

   404     {

   405         jint handle = NewCoreWidget(aJniEnv, &MSwtFactory::NewCanvasL, aPeer, aParent, aStyle);

   406         INCREASE_INSTANCE_COUNT(handle, Canvas);

   407         return handle;

   408     }

   409 

   410     JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_symbian_OS_Canvas_1CompositeHandle(JNIEnv*, jclass, jint aHandle)

   411     {

   412         MSwtCanvas*    canvas = reinterpret_cast<MSwtCanvas*>(aHandle);

   413         MSwtComposite* result;

   414         CallMethod(result, canvas, &MSwtCanvas::Composite);

   415         return reinterpret_cast<jint>(result);

   416     }

   417 

   418     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Canvas_1Scroll(JNIEnv*, jclass, jint aHandle, jint aDestX, jint aDestY, jint aX, jint aY, jint aWidth, jint aHeight, jboolean aAll)

   419     {

   420         MSwtCanvas* canvas = reinterpret_cast<MSwtCanvas*>(aHandle);

   421         TPoint      dest(aDestX, aDestY);

   422         TRect       rect(TPoint(aX,aY), TSize(aWidth,aHeight));

   423         CallMethod(canvas, &MSwtCanvas::Scroll, dest, rect, aAll);

   424     }

   425 

   426 

   427     /*

   428      * Class Color

   429      */

   430     JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_symbian_OS_Color_1New(JNIEnv* aJniEnv, jclass, jint aDevice, jint aRed, jint aGreen, jint aBlue)

   431     {

   432         CSwtDisplay* display = DisplayFromDevice(aDevice);

   433         MSwtDevice*  device  = reinterpret_cast<MSwtDevice*>(aDevice);

   434         TRgb         rgb(aRed, aGreen, aBlue);

   435         MSwtColor*   result = NULL;

   436         TRAPD(error, CallMethodL(result, &(display->Factory()), &MSwtFactory::NewColorL, *device, rgb, display));

   437         ThrowIfError(error, aJniEnv);

   438 

   439         INCREASE_INSTANCE_COUNT_USE_DISPLAY(result, Color, display);

   440 

   441         return reinterpret_cast<jint>(result);

   442     }

   443 

   444     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Color_1Dispose(JNIEnv*, jclass, jint aDevice, jint aHandle)

   445     {

   446         CSwtDisplay* display = DisplayFromDevice(aDevice);

   447         MSwtColor* color = reinterpret_cast<MSwtColor*>(aHandle);

   448         CallMethod(color, &MSwtColor::Dispose, display);

   449 

   450         DECREASE_INSTANCE_COUNT_USE_DISPLAY(Color, display);

   451     }

   452 

   453     JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_symbian_OS_Color_1RgbValue(JNIEnv*, jclass, jint aDevice, jint aHandle)

   454     {

   455         CSwtDisplay* display = DisplayFromDevice(aDevice);

   456         const MSwtColor* color = reinterpret_cast<MSwtColor*>(aHandle);

   457         TRgb       rgb;

   458         CallMethod(rgb, color, &MSwtColor::RgbValue, display);

   459         return rgb.Value();

   460     }

   461 

   462 

   463     /*

   464      * Class Composite

   465      */

   466     JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_symbian_OS_Composite_1New(JNIEnv* aJniEnv, jclass, jobject aPeer, jint aParent, jint aStyle)

   467     {

   468         jint result = NewCoreWidget(aJniEnv, &MSwtFactory::NewCompositeL, aPeer, aParent, aStyle);

   469         INCREASE_INSTANCE_COUNT(result, Composite);

   470         return result;

   471     }

   472 

   473     JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_symbian_OS_Composite_1ScrollableHandle(JNIEnv*, jclass, jint aHandle)

   474     {

   475         MSwtComposite*  composite = reinterpret_cast<MSwtComposite*>(aHandle);

   476         MSwtScrollable* result;

   477         CallMethod(result, composite, &MSwtComposite::Scrollable);

   478         return reinterpret_cast<jint>(result);

   479     }

   480 

   481     JNIEXPORT jobjectArray JNICALL Java_org_eclipse_swt_internal_symbian_OS_Composite_1GetChildren(JNIEnv* aJniEnv, jclass, jint aHandle)

   482     {

   483         MSwtComposite* composite = reinterpret_cast<MSwtComposite*>(aHandle);

   484         CSwtPeerArray* children  = NULL;

   485         TRAPD(error, CallMethodL(children, composite, &MSwtComposite::GetChildrenPeersL));

   486         if (error)

   487         {

   488             Throw(error, aJniEnv);

   489             return NULL;

   490         }

   491 

   492         jobjectArray result = NewJavaControlArray(aJniEnv, children);

   493         DeleteInUiHeap(children);

   494         return result;

   495     }

   496 

   497     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Composite_1SetTabList(JNIEnv* aJniEnv, jclass, jint aHandle, jintArray aList)

   498     {

   499         jboolean isCopy;

   500         TInt* intList = NULL;

   501         TInt  count   = 0;

   502         if (aList != NULL)

   503         {

   504             intList = aJniEnv->GetIntArrayElements(aList, &isCopy);

   505             count   = aJniEnv->GetArrayLength(aList);

   506         }

   507 

   508         MSwtComposite* composite = reinterpret_cast<MSwtComposite*>(aHandle);

   509         // This cast are safe : in JAVA side the array are fill with the handle 's control.

   510         MSwtControl**  ctrlList  = reinterpret_cast<MSwtControl**>(intList); //lint !e740

   511         TRAPD(error, CallMethodL(composite, &MSwtComposite::SetTabListL, ctrlList, count));

   512 

   513         if (intList != NULL)

   514             aJniEnv->ReleaseIntArrayElements(aList, intList, JNI_ABORT);

   515 

   516         ThrowIfError(error, aJniEnv);

   517     }

   518 

   519     JNIEXPORT jobjectArray JNICALL Java_org_eclipse_swt_internal_symbian_OS_Composite_1GetTabList(JNIEnv* aJniEnv, jclass, jint aHandle)

   520     {

   521         const MSwtComposite* composite = reinterpret_cast<MSwtComposite*>(aHandle);

   522         CSwtPeerArray*       tabList   = NULL;

   523         TRAPD(error, CallMethodL(tabList, composite, &MSwtComposite::GetTabListL));

   524         if (error)

   525         {

   526             Throw(error, aJniEnv);

   527             return NULL;

   528         }

   529 

   530         jobjectArray result = NewJavaControlArray(aJniEnv, tabList);

   531         DeleteInUiHeap(tabList);

   532         return result;

   533     }

   534 

   535     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Composite_1SetScrolledCompositeContent(JNIEnv* aJniEnv, jclass, jint aHandle, jint aContentHandle)

   536     {

   537         MSwtComposite* composite = reinterpret_cast<MSwtComposite*>(aHandle);

   538         MSwtControl* content = reinterpret_cast<MSwtControl*>(aContentHandle);

   539         TRAPD(error, CallMethodL(composite, &MSwtComposite::SetScrolledCompositeContentL, content));

   540         ThrowIfError(error, aJniEnv);

   541     }

   542 

   543     /*

   544      * Class Control

   545      */

   546     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1Dispose(JNIEnv* aJniEnv, jclass, jint aHandle)

   547     {

   548         MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   549         TSwtPeer     peerRef;

   550         CallMethod(peerRef, control, &MSwtControl::Dispose);

   551 

   552         ReleasePeer(aJniEnv, peerRef);

   553 

   554 #if defined(__WINS__) && defined(_DEBUG)

   555         ++(CSwtDisplay::Current().iInstanceCounts.iDisposedControls);

   556 #endif

   557     }

   558 

   559     JNIEXPORT jboolean JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1SetFocus(JNIEnv*, jclass, jint aHandle)

   560     {

   561         MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   562         TBool        isFocused;

   563         CallMethod(isFocused, control, &MSwtControl::SetSwtFocus, KSwtFocusByApi);

   564         return ConvertBoolean(isFocused);

   565     }

   566 

   567     JNIEXPORT jboolean JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1ForceFocus(JNIEnv*, jclass, jint aHandle)

   568     {

   569         MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   570         TBool        isFocused;

   571         CallMethod(isFocused, control, &MSwtControl::SetSwtFocus, KSwtFocusByForce);

   572         return ConvertBoolean(isFocused);

   573     }

   574 

   575     JNIEXPORT jboolean JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1GetEnabled(JNIEnv*, jclass, jint aHandle)

   576     {

   577         const MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   578         TBool              isEnabled;

   579         CallMethod(isEnabled, control, &MSwtControl::GetEnabled);

   580         return ConvertBoolean(isEnabled);

   581     }

   582 

   583     JNIEXPORT jboolean JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1GetVisible(JNIEnv*, jclass, jint aDevice, jint aHandle)

   584     {

   585         CSwtDisplay* display = DisplayFromDevice(aDevice);

   586         const MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   587         TBool              isVisible;

   588         CallMethod(isVisible, control, &MSwtControl::GetVisible, display);

   589         return ConvertBoolean(isVisible);

   590     }

   591 

   592     JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1GetBackground(JNIEnv*, jclass, jint aHandle)

   593     {

   594         const MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   595         TRgb result;

   596         CallMethod(result, control, &MSwtControl::GetBackground);

   597         return result.Value();

   598     }

   599 

   600     JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1GetForeground(JNIEnv*, jclass, jint aHandle)

   601     {

   602         const MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   603         TRgb result;

   604         CallMethod(result, control, &MSwtControl::GetForeground);

   605         return result.Value();

   606     }

   607 

   608     JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1GetFont(JNIEnv*, jclass, jint aHandle)

   609     {

   610         const MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   611         const MSwtFont* result;

   612         CallMethod(result, control, &MSwtControl::GetFont);

   613         ASSERT(result!=NULL);

   614         return reinterpret_cast<jint>(result);

   615     }

   616 

   617     JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1GetBorderWidth(JNIEnv*, jclass, jint aHandle)

   618     {

   619         const MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   620         TInt result;

   621         CallMethod(result, control, &MSwtControl::GetBorderWidth);

   622         return result;

   623     }

   624 

   625     JNIEXPORT jobject JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1GetBounds(JNIEnv* aJniEnv, jclass, jint aHandle)

   626     {

   627         const MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   628         TRect        boundResult(TRect::EUninitialized);

   629         CallMethod(boundResult, control, &MSwtControl::GetBounds);

   630         return NewJavaRectangle(aJniEnv, boundResult);

   631     }

   632 

   633     JNIEXPORT jobject JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1GetClientArea(JNIEnv* aJniEnv, jclass, jint aHandle)

   634     {

   635         const MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   636         TRect clientRect(TRect::EUninitialized);

   637         CallMethod(clientRect, control, &MSwtControl::ClientRect);

   638         return NewJavaRectangle(aJniEnv, TRect(clientRect.Size()));

   639     }

   640 

   641     JNIEXPORT jobject JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1GetSize(JNIEnv* aJniEnv, jclass, jint aHandle)

   642     {

   643         const MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   644         TSize              controlSize(TSize::EUninitialized);

   645         CallMethod(controlSize, control, &MSwtControl::GetWidgetSize);

   646         return NewJavaPoint(aJniEnv, controlSize.AsPoint());

   647     }

   648 

   649     JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1GetStyle(JNIEnv*, jclass, jint aHandle)

   650     {

   651         const MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   652         TInt result;

   653         CallMethod(result, control, &MSwtControl::Style);

   654         return result;

   655     }

   656 

   657     JNIEXPORT jboolean JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1HasDoNotDrawFlag(JNIEnv*, jclass, jint aHandle)

   658     {

   659         const MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   660         TBool hasDoNotDrawFlag;

   661         CallMethod(hasDoNotDrawFlag, control, &MSwtControl::HasDoNotDrawFlag);

   662         return ConvertBoolean(hasDoNotDrawFlag);

   663     }

   664 

   665     JNIEXPORT jobject JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1GetLocation(JNIEnv* aJniEnv, jclass, jint aHandle)

   666     {

   667         const MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   668         TPoint             controlLocation(TPoint::EUninitialized);

   669         CallMethod(controlLocation, control, &MSwtControl::GetLocation);

   670         return NewJavaPoint(aJniEnv, controlLocation);

   671     }

   672 

   673     JNIEXPORT jboolean JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1IsFocusControl(JNIEnv*, jclass, jint aHandle)

   674     {

   675         MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   676         TBool isFocused;

   677         CallMethod(isFocused,control, &MSwtControl::IsFocusControl);

   678         return ConvertBoolean(isFocused);

   679     }

   680 

   681     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1MoveAbove(JNIEnv*, jclass, jint aHandle, jint aControlHandle)

   682     {

   683         MSwtControl* control1 = reinterpret_cast<MSwtControl*>(aHandle);

   684         MSwtControl* control2 = reinterpret_cast<MSwtControl*>(aControlHandle);

   685         CallMethod(control1, &MSwtControl::MoveAbove, control2);

   686     }

   687 

   688     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1MoveBelow(JNIEnv*, jclass, jint aHandle, jint aControlHandle)

   689     {

   690         MSwtControl* control1 = reinterpret_cast<MSwtControl*>(aHandle);

   691         MSwtControl* control2 = reinterpret_cast<MSwtControl*>(aControlHandle);

   692         CallMethod(control1, &MSwtControl::MoveBelow, control2);

   693     }

   694 

   695     JNIEXPORT jboolean JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1PostTraverseEvent

   696     (JNIEnv*, jclass, jint aHandle, jint aTraversal)

   697     {

   698         MSwtControl*  control = reinterpret_cast<MSwtControl*>(aHandle);

   699         TBool         doIt    = ETrue;

   700         TSwtTraversal traversal(static_cast<TSwtTraversal>(aTraversal));

   701         TBool result;

   702         CallMethod(result, control, &MSwtControl::ForceTraverseEvent, traversal, doIt);

   703         return ConvertBoolean(result);

   704     }

   705 

   706     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1Paint(

   707         JNIEnv* aJniEnv, jclass, jint aDevice, jint aHandle, jint aX, jint aY, jint aWidth,

   708         jint aHeight, jboolean aPaintNatively, jint aGcHandle, jintArray aIntParams, jint aIntCount,

   709         jstring aStrParams)

   710     {

   711         CSwtDisplay* display = DisplayFromDevice(aDevice);

   712         const MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   713         MSwtGc* gc = reinterpret_cast<MSwtGc*>(aGcHandle);

   714         TRect rect(TPoint(aX,aY), TSize(aWidth,aHeight));

   715         TInt* ints = NULL;

   716         if (aIntParams)

   717         {

   718             ints = JavaIntRegionToInts(aJniEnv, aIntParams, 0, aIntCount);

   719         }

   720         HBufC* strings = NULL;

   721         if (aStrParams)

   722         {

   723             // If this fails we proceed without strings

   724             TRAP_IGNORE(strings = ConvertStringL(aJniEnv, aStrParams));

   725         }

   726         CallMethod(control, &MSwtControl::Paint, rect, aPaintNatively, gc, ints, aIntCount, strings, display);

   727         delete[] ints;

   728         delete strings;

   729     }

   730 

   731     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1Redraw(JNIEnv*, jclass, jint aHandle)

   732     {

   733         MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   734         CallMethod(control, &MSwtControl::Redraw);

   735     }

   736 

   737     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1RedrawRegion(JNIEnv*, jclass, jint aHandle, jint aX, jint aY, jint aWidth, jint aHeight)

   738     {

   739         MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   740         TRect rect(TPoint(aX,aY), TSize(aWidth,aHeight));

   741         CallMethod(control, &MSwtControl::RedrawRegion, rect);

   742     }

   743 

   744     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1SetRedraw(JNIEnv*, jclass, jint aHandle, jboolean aRedraw)

   745     {

   746         MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   747         CallMethod(control, &MSwtControl::SetRedraw, aRedraw);

   748     }

   749 

   750     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1SetCapture(JNIEnv*, jclass, jint aHandle, jboolean aCapture)

   751     {

   752         MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   753         CallMethod(control, &MSwtControl::SetCapture, aCapture);

   754     }

   755 

   756     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1SetFont(JNIEnv* aJniEnv, jclass, jint aHandle, jint aFontHandle)

   757     {

   758         MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   759         MSwtFont*    font    = reinterpret_cast<MSwtFont*>(aFontHandle);

   760         TRAPD(error, CallMethodL(control, &MSwtControl::SetFontL, font));

   761         ThrowIfError(error, aJniEnv);

   762     }

   763 

   764     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1SetBackground(JNIEnv* aJniEnv, jclass, jint aHandle, jint aColorHandle)

   765     {

   766         MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   767         MSwtColor*   color   = reinterpret_cast<MSwtColor*>(aColorHandle);

   768         TRAPD(error, CallMethodL(control, &MSwtControl::SetBackgroundL, color));

   769         ThrowIfError(error, aJniEnv);

   770     }

   771 

   772     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1SetForeground(JNIEnv* aJniEnv, jclass, jint aHandle, jint aColorHandle)

   773     {

   774         MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   775         MSwtColor*   color   = reinterpret_cast<MSwtColor*>(aColorHandle);

   776         TRAPD(error, CallMethodL(control, &MSwtControl::SetForegroundL, color));

   777         ThrowIfError(error, aJniEnv);

   778     }

   779 

   780     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1SetVisible(JNIEnv*, jclass, jint aHandle, jboolean aVisible)

   781     {

   782         MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   783         CallMethod(control, &MSwtControl::SetVisible, aVisible);

   784     }

   785 

   786     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1SetLocation(JNIEnv*, jclass, jint aHandle, jint aX, jint aY)

   787     {

   788         MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   789         TPoint       point(aX, aY);

   790         CallMethod(control, &MSwtControl::SetLocation, point);

   791     }

   792 

   793     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1SetSize(JNIEnv*, jclass, jint aHandle, jint aWidth, jint aHeight)

   794     {

   795         MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   796         TSize        size(aWidth, aHeight);

   797         CallMethod(control, &MSwtControl::SetWidgetSize, size);

   798     }

   799 

   800     JNIEXPORT jobject JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1ComputeSize(JNIEnv* aJniEnv, jclass, jint aHandle, jint aWHint, jint aHHint)

   801     {

   802         MSwtControl* theControl = reinterpret_cast<MSwtControl*>(aHandle);

   803         TSize size(0,0);

   804         TRAPD(error, CallMethodL(size, theControl, &MSwtControl::ComputeSizeL, aWHint, aHHint));

   805         if (error == KErrNone)

   806         {

   807             return NewJavaPoint(aJniEnv, size.AsPoint());

   808         }

   809         else

   810         {

   811             Throw(error, aJniEnv);

   812             return 0;

   813         }

   814     }

   815 

   816     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1SetEnabled(JNIEnv*, jclass, jint aHandle, jboolean aEnabled)

   817     {

   818         MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   819         CallMethod(control, &MSwtControl::SetEnabled, aEnabled);

   820     }

   821 

   822     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1SetBounds(JNIEnv*, jclass, jint aHandle, jint aX, jint aY, jint aWidth, jint aHeight)

   823     {

   824         MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   825         TRect        rect(TPoint(aX,aY), TSize(aWidth,aHeight));

   826         CallMethod(control, &MSwtControl::SetBounds, rect);

   827     }

   828 

   829     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1SetMenu(JNIEnv* aJniEnv, jclass, jint aHandle, jint aMenuHandle)

   830     {

   831         MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   832         MSwtMenu* menu = reinterpret_cast<MSwtMenu*>(aMenuHandle);

   833         TRAPD(error, CallMethodL(control, &MSwtControl::SetPopupMenuL, menu));

   834         ThrowIfError(error, aJniEnv);

   835     }

   836 

   837     JNIEXPORT jobject JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1ToControl(JNIEnv* aJniEnv, jclass, jint aHandle, jint aX, jint aY)

   838     {

   839         const MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   840         TPoint point(aX, aY);

   841         TPoint result(TPoint::EUninitialized);

   842         CallMethod(result, control, &MSwtControl::ToControl, point);

   843         return NewJavaPoint(aJniEnv, result);

   844     }

   845 

   846     JNIEXPORT jobject JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1ToDisplay(JNIEnv* aJniEnv, jclass, jint aHandle, jint aX, jint aY)

   847     {

   848         const MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   849         TPoint point(aX, aY);

   850         TPoint result(TPoint::EUninitialized);

   851         CallMethod(result, control, &MSwtControl::ToDisplay, point);

   852         return NewJavaPoint(aJniEnv, result);

   853     }

   854 

   855     static void Control_Update(JNIEnv* aJniEnv, MSwtControl* aControl)

   856     {

   857         ASSERT(aControl);

   858         CSwtDisplay::Current().PopAndDispatchPaintEvents(*aJniEnv, aControl);

   859 

   860         // check disposal of Display from java-side-paint-listener

   861         if (!CSwtDisplay::CurrentOrNull())

   862         {

   863             return;

   864         }

   865 

   866         MSwtComposite* composite = aControl->CompositeInterface();

   867 

   868         if (composite)

   869         {

   870             const RSwtControlArray* children = composite->Children();

   871             if (children)

   872             {

   873                 for (TInt i = 0; i < children->Count(); ++i)

   874                 {

   875                     MSwtControl* child = (*children)[i];

   876                     Control_Update(aJniEnv, child);

   877 

   878                     // check disposal of Display from java-side-paint-listener

   879                     if (!CSwtDisplay::CurrentOrNull())

   880                     {

   881                         return;

   882                     }

   883                 }

   884             }

   885         }

   886     }

   887 

   888     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Control_1Update(JNIEnv* aJniEnv, jclass, jint aHandle)

   889     {

   890         MSwtControl* control = reinterpret_cast<MSwtControl*>(aHandle);

   891         Control_Update(aJniEnv, control);

   892     }

   893 

   894 

   895     /*

   896      * Class Decorations

   897      */

   898     JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_symbian_OS_Decorations_1New(JNIEnv* aJniEnv, jclass, jobject aPeer, jint aParent, jint aStyle)

   899     {

   900         jint handle = NewCoreWidget(aJniEnv, &MSwtFactory::NewDecorationsL, aPeer, aParent, aStyle);

   901         INCREASE_INSTANCE_COUNT(handle, Decorations);

   902         return handle;

   903     }

   904 

   905     JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_symbian_OS_Decorations_1CanvasHandle(JNIEnv*, jclass, jint aHandle)

   906     {

   907         MSwtDecorations* decorations = reinterpret_cast<MSwtDecorations*>(aHandle);

   908         MSwtCanvas*      result;

   909         CallMethod(result, decorations, &MSwtDecorations::Canvas);

   910         return reinterpret_cast<jint>(result);

   911     }

   912 

   913     JNIEXPORT jstring JNICALL Java_org_eclipse_swt_internal_symbian_OS_Decorations_1GetText(JNIEnv* aJniEnv, jclass, jint aHandle)

   914     {

   915         const MSwtDecorations* decorations = reinterpret_cast<MSwtDecorations*>(aHandle);

   916         const TDesC* title;

   917         CallMethod(title, decorations, &MSwtDecorations::GetText);

   918         return NewJavaString(aJniEnv, (title!=NULL) ? *title : KNullDesC());

   919     }

   920 

   921     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Decorations_1SetImage(JNIEnv* aJniEnv, jclass, jint aHandle, jint aImageHandle)

   922     {

   923         MSwtImage* image = reinterpret_cast<MSwtImage*>(aImageHandle);

   924         MSwtDecorations* decorations = reinterpret_cast<MSwtDecorations*>(aHandle);

   925         TInt error = KErrNone;

   926         TRAP(error, CallMethodL(decorations, &MSwtDecorations::SetImageL, image));

   927         ThrowIfError(error, aJniEnv);

   928     }

   929 

   930     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Decorations_1SetMaximized(JNIEnv*, jclass, jint aHandle, jboolean aMaximized)

   931     {

   932         MSwtDecorations* decorations = reinterpret_cast<MSwtDecorations*>(aHandle);

   933         CallMethod(decorations, &MSwtDecorations::SetMaximized, aMaximized);

   934     }

   935 

   936     JNIEXPORT jboolean JNICALL Java_org_eclipse_swt_internal_symbian_OS_Decorations_1GetMaximized(JNIEnv*, jclass, jint aHandle)

   937     {

   938         return ConvertBoolean(CallNonLeavingGetter(aHandle, &MSwtDecorations::GetMaximized));

   939     }

   940 

   941     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Decorations_1SetMinimized(JNIEnv*, jclass, jint aHandle, jboolean aMinimized)

   942     {

   943         MSwtDecorations* decorations = reinterpret_cast<MSwtDecorations*>(aHandle);

   944         CallMethod(decorations, &MSwtDecorations::SetMinimized, aMinimized);

   945     }

   946 

   947     JNIEXPORT jboolean JNICALL Java_org_eclipse_swt_internal_symbian_OS_Decorations_1GetMinimized(JNIEnv*, jclass, jint aHandle)

   948     {

   949         return ConvertBoolean(CallNonLeavingGetter(aHandle, &MSwtDecorations::GetMinimized));

   950     }

   951 

   952     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Decorations_1SetMenuBar(JNIEnv*, jclass, jint aHandle, jint aMenuHandle)

   953     {

   954         MSwtDecorations*  decorations = reinterpret_cast<MSwtDecorations*>(aHandle);

   955         MSwtMenu*         menuBar     = reinterpret_cast<MSwtMenu*>(aMenuHandle);

   956         CallMethod(decorations, &MSwtDecorations::SetMenuBar, menuBar);

   957     }

   958 

   959     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Decorations_1SetText(JNIEnv* aJniEnv, jclass, jint aHandle, jstring aTitle)

   960     {

   961         CallTextMethodThrow(aJniEnv, aHandle, &MSwtDecorations::SetTextL, aTitle);

   962     }

   963 

   964     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Decorations_1SetDefaultButton(JNIEnv* , jclass, jint aHandle, jint aDefaultButtonHandle)

   965     {

   966         MSwtDecorations*    decorations     = reinterpret_cast<MSwtDecorations*>(aHandle);

   967         MSwtButton* defaultButton   = reinterpret_cast<MSwtButton*>(aDefaultButtonHandle);

   968         CallMethod(decorations, &MSwtDecorations::SetDefaultButton, defaultButton);

   969     }

   970 

   971     JNIEXPORT jobject JNICALL Java_org_eclipse_swt_internal_symbian_OS_Decorations_1GetDefaultButton(JNIEnv*, jclass, jint aHandle)

   972     {

   973         const MSwtDecorations* decorations = reinterpret_cast<MSwtDecorations*>(aHandle);

   974         TSwtPeer peer;

   975         CallMethod(peer, decorations, &MSwtDecorations::GetDefaultButton);

   976         return peer;

   977     }

   978 

   979     /*

   980      * Interface Drawable

   981      */

   982     JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_symbian_OS_Drawable_1NewGc(JNIEnv* aJniEnv, jclass, jint aHandle)

   983     {

   984         MSwtDrawable* drawable = reinterpret_cast<MSwtDrawable*>(aHandle);

   985         MSwtGc*       result   = NULL;

   986 

   987         // GCs are always constructed in the UI thread.

   988         // If there is no display pointer in the TLS then this is not a UI thread

   989         // and we must throw an exception.

   990         CSwtDisplay* display = CSwtDisplay::CurrentOrNull();

   991         if (!display)

   992         {

   993             Throw(ESwtErrorThreadInvalidAccess, aJniEnv);

   994             return NULL;

   995         }

   996 

   997         TRAPD(error, CallMethodL(result, drawable, &MSwtDrawable::NewGcL, display));

   998         ThrowIfError(error, aJniEnv);

   999 

  1000         INCREASE_INSTANCE_COUNT(result, Gc);

  1001 

  1002         return reinterpret_cast<jint>(result);

  1003     }

  1004 

  1005 

  1006     /*

  1007      * Class Font

  1008      */

  1009     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Font_1Dispose(JNIEnv*, jclass, jint aDevice, jint aHandle)

  1010     {

  1011         ASSERT(aHandle!=0);

  1012         CSwtDisplay* display = DisplayFromDevice(aDevice);

  1013         MSwtFont* font = reinterpret_cast<MSwtFont*>(aHandle);

  1014         CallMethod(font, &MSwtFont::Dispose, display);

  1015 

  1016         DECREASE_INSTANCE_COUNT_USE_DISPLAY(Font, display);

  1017     }

  1018 

  1019     JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_symbian_OS_Font_1GetHeight(JNIEnv*, jclass, jint aHandle)

  1020     {

  1021         ASSERT(aHandle!=0);

  1022         const MSwtFont* font = reinterpret_cast<MSwtFont*>(aHandle);

  1023         TInt height = 0;

  1024         CallMethod(height, font, &MSwtFont::DesignHeightInPoints);

  1025         return height;

  1026     }

  1027 

  1028     JNIEXPORT jstring JNICALL Java_org_eclipse_swt_internal_symbian_OS_Font_1GetName(JNIEnv* aJniEnv, jclass, jint aHandle)

  1029     {

  1030         ASSERT(aHandle!=0);

  1031         const MSwtFont* font = reinterpret_cast<MSwtFont*>(aHandle);

  1032         HBufC* name = NULL;

  1033         TRAPD(error, CallMethodL(name, font, &MSwtFont::GetNameL));

  1034         ThrowIfError(error, aJniEnv);

  1035         jstring javaName = (name!=NULL) ? NewJavaString(aJniEnv,*name) : NULL;

  1036         DeleteInUiHeap(name);

  1037         return javaName;

  1038     }

  1039 

  1040     JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_symbian_OS_Font_1GetStyle(JNIEnv*, jclass, jint aHandle)

  1041     {

  1042         ASSERT(aHandle!=0);

  1043         const MSwtFont* font = reinterpret_cast<MSwtFont*>(aHandle);

  1044         TInt Style = 0;

  1045         CallMethod(Style, font, &MSwtFont::Style);

  1046         return Style;

  1047     }

  1048 

  1049     static MSwtFont* Font_NewL(JNIEnv* aJniEnv, MSwtDevice* aDevice, const jstring aTypefaceName, TInt aHeight, TInt aStyle)

  1050     {

  1051         HBufC* typefaceName = ConvertStringLC(aJniEnv, aTypefaceName);

  1052         CSwtDisplay* display = DisplayFromDevice(reinterpret_cast<jint>(aDevice));

  1053         const MSwtFactory& factory = display->Factory();

  1054         MSwtFont* font;

  1055         CallMethodL(font, &factory, &MSwtFactory::NewFontL, *aDevice, *typefaceName, aHeight, aStyle, display);

  1056         CleanupStack::PopAndDestroy(typefaceName);

  1057         return font;

  1058     }

  1059 

  1060     JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_symbian_OS_Font_1New(JNIEnv* aJniEnv, jclass, jint aDevice, jstring aTypefaceName, jint aHeight, jint aStyle)

  1061     {

  1062         ASSERT(aDevice!=0);

  1063         CSwtDisplay* display = DisplayFromDevice(aDevice);

  1064         MSwtDevice*  device  = reinterpret_cast<MSwtDevice*>(aDevice);

  1065         MSwtFont*    font = NULL;

  1066         TRAPD(error, (font=Font_NewL(aJniEnv, device, aTypefaceName, aHeight, aStyle)));

  1067         ThrowIfError(error, aJniEnv);

  1068 

  1069         INCREASE_INSTANCE_COUNT_USE_DISPLAY(font, Font, display);

  1070 

  1071         return reinterpret_cast<jint>(font);

  1072     }

  1073 

  1074     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Font_1AddRef(JNIEnv *, jclass, jint aHandle)

  1075     {

  1076         ASSERT(aHandle);

  1077         const MSwtFont* font = reinterpret_cast<MSwtFont*>(aHandle);

  1078         CallMethod(static_cast<const MSwtRefCounted*>(font), &MSwtFont::AddRef);

  1079     }

  1080 

  1081     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_Font_1RemoveRef(JNIEnv *, jclass, jint aHandle)

  1082     {

  1083         ASSERT(aHandle);

  1084         const MSwtFont* font = reinterpret_cast<MSwtFont*>(aHandle);

  1085         CallMethod(static_cast<const MSwtRefCounted*>(font), &MSwtFont::RemoveRef);

  1086     }

  1087 

  1088 

  1089     /*

  1090      * Class GC

  1091      */

  1092     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_GC_1CopyAreaToImage(JNIEnv* aJniEnv, jclass, jint aDevice, jint aHandle, jint aImageHandle, jint aX, jint aY)

  1093     {

  1094         CSwtDisplay* display = DisplayFromDevice(aDevice);

  1095         const MSwtGc* gc = reinterpret_cast<MSwtGc*>(aHandle);

  1096         MSwtImage*    image = reinterpret_cast<MSwtImage*>(aImageHandle);

  1097         TPoint        pos(aX, aY);

  1098         TRAPD(error, CallMethodL(gc, &MSwtGc::CopyAreaL, *image, pos, display));

  1099         ThrowIfError(error, aJniEnv);

  1100     }

  1101 

  1102     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_GC_1CopyArea(JNIEnv*, jclass, jint aDevice, jint aHandle, jint aSrcX, jint aSrcY, jint aWidth, jint aHeight, jint aDestX, jint aDestY)

  1103     {

  1104         CSwtDisplay* display = DisplayFromDevice(aDevice);

  1105         MSwtGc* gc = reinterpret_cast<MSwtGc*>(aHandle);

  1106         TRect   rectSource(TPoint(aSrcX, aSrcY), TSize(aWidth, aHeight));

  1107         TPoint  pointDest(aDestX, aDestY);

  1108         CallMethod(gc, &MSwtGc::CopyArea, rectSource, pointDest, display);

  1109     }

  1110 

  1111     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_GC_1Dispose(JNIEnv* aJniEnv, jclass, jint aHandle)

  1112     {

  1113         MSwtGc* gc = reinterpret_cast<MSwtGc*>(aHandle);

  1114 

  1115         // GC is always disposed in the UI-thread so TLS can be used to get the display.

  1116         // If there is no display pointer in the TLS then this is not a UI thread

  1117         // and we must throw an exception.

  1118         CSwtDisplay* display = CSwtDisplay::CurrentOrNull();

  1119         if (!display)

  1120         {

  1121             Throw(ESwtErrorThreadInvalidAccess, aJniEnv);

  1122             return;

  1123         }

  1124 

  1125         // When display pointer is not passed here then TLS will be used.

  1126         CallMethod(gc, &MSwtGc::Dispose);

  1127 

  1128         DECREASE_INSTANCE_COUNT(Gc);

  1129     }

  1130 

  1131     JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_symbian_OS_GC_1SetAlpha(JNIEnv*, jclass, jint aDevice, jint aHandle, jint aAlpha)

  1132     {

  1133         CSwtDisplay* display = DisplayFromDevice(aDevice);

  1134         MSwtGc* gc       = reinterpret_cast<MSwtGc*>(aHandle);