* @brief This is the implementation for the _UiAppImpl class.
*/
+#include <bundle.h>
#include <appsvc/appsvc.h>
#include <bundle.h>
#include <glib.h>
#include <FUi_ControlImplManager.h>
#include <FUi_KeyEventManager.h>
#include <FUi_WindowImpl.h>
-#include <FUi_EcoreEvasMgr.h>
-#include <FUi_EcoreEvas.h>
+//#include <FUi_EcoreEvasMgr.h>
+//#include <FUi_EcoreEvas.h>
#include <FUi_UiNotificationEvent.h>
+#include <FUiAnim_Looper.h>
+#include <FUiAnim_AnimationManager.h>
+#include <FUiAnim_GlDisplayManager.h>
#include <FUi_UiEventManager.h>
#include <FUiCtrl_FrameImpl.h>
#include <FSys_PowerManagerImpl.h>
#include <FSys_SettingInfoImpl.h>
+#include "FUiAnim_GlLayer.h"
+#include "FUiAnim_DisplayContextImpl.h"
+
#include "FApp_AppFrame.h"
#include "FApp_AppInfo.h"
#include "FApp_AppImpl.h"
using namespace Tizen::Base::Collection;
using namespace Tizen::Base::Runtime;
using namespace Tizen::Ui;
+using namespace Tizen::Ui::Animations;
using namespace Tizen::Ui::Controls;
using namespace Tizen::System;
using namespace Tizen::Graphics;
+//#define PRINT printf
+#define PRINT
-extern "C" int appsvc_request_transient_app(bundle*, Ecore_X_Window, appsvc_host_res_fn, void*);
+//extern "C" int appsvc_request_transient_app(bundle*, Ecore_X_Window, appsvc_host_res_fn, void*);
extern "C" int appcore_set_app_state(int);
namespace Tizen { namespace App
void
_UiAppImpl::RaiseFrame(Frame& frame)
{
+
_FrameImpl* pFrameImpl = _FrameImpl::GetInstance(frame);
if (pFrameImpl)
{
+#ifdef VE_EFL
// [N_SE-39536] Window raise is requested as synchronous due to B/S issue
_EcoreEvas* pEvas = GetEcoreEvasMgr()->GetEcoreEvas();
if (pEvas)
{
pEvas->ActivateWindow(pFrameImpl->GetCore());
}
+#endif
}
}
_UiAppImpl::GetTargetWindowHandle(void) const
{
result r = E_SUCCESS;
-
+#ifdef VE_EFL
_EcoreEvasMgr* pEcoreEvasMgr = GetEcoreEvasMgr();
r = GetLastResult();
SysTryReturn(NID_APP, pEcoreEvasMgr, -1, r, "Propagating.");
}
return targetWindow? targetWindow: -1;
+#endif
}
+
static int
TransientResponseCb(void* pData)
{
void
_UiAppImpl::OnService(service_s* service, bool initial)
{
+
Frame* pFrame = dynamic_cast<Frame*>(__pFrameList->GetAt(0));
+#ifdef BUILD_BREAK
_EcoreEvas* pEvas = GetEcoreEvasMgr()->GetEcoreEvas();
// make OnForeground event
}
}
}
+#endif
}
return E_SUCCESS;
}
-
+#ifdef VE_EFL
long
_UiAppImpl::OnWindowHandleRequest(void)
{
handle = (pEvas) ? static_cast<long>(pEvas->GetXWindow()) : -1;
}
+
return handle;
}
+#endif
+
+void
+_UiAppImpl::OnDeviceOrientationChanged(app_device_orientation_e orientation)
+{
+ SysLog(NID_APP, "System device orientation event.");
+ _ControlImplManager* pControlImplManager = _ControlImplManager::GetInstance();
+ if (pControlImplManager == null)
+ {
+ SysLog(NID_APP, "Device orientation event arrived too early.");
+ return;
+ }
+
+ pControlImplManager->OnScreenRotated(orientation);
+}
+
+
+long
+_UiAppImpl::OnWindowHandleRequest(void)
+{
+ Frame* pFrame = GetFrameAt(0);
+ if(pFrame && pFrame->GetDisplayContext())
+ {
+ _DisplayContextImpl* pImpl= _DisplayContextImpl::GetInstance(*pFrame->GetDisplayContext());
+ if(pImpl)
+ {
+ _GlLayer* pLayer = dynamic_cast<_GlLayer*>(pImpl->GetNativeLayer());
+ if(pLayer)
+ {
+ return pLayer->GetNativeWindow();
+ }
+ }
+ }
+ return -1;
+}
+
+void
+_UiAppImpl::OnMainLoop(void)
+{
+ result r = E_SUCCESS;
+// r = _AnimationManager::CreateInstance();
+// SysAssertf(r == E_SUCCESS, "Failed to create animation manager!");
+
+// r = _GlDisplayManager::CreateInstance();
+// SysAssertf(r == E_SUCCESS, "Failed to create display manager!");
+
+
+ _AppImpl::OnCreate(__pAppImpl);
+
+ _AppImpl::OnService(null, null);
+ _Looper* pLooper = _Looper::GetInstance();
+
+// pLooper->AddRawEventHandler(this);
+// PRINT("OnMainLoop: Enter (%#x)\n", (unsigned int)pLooper);
+
+
+// PRINT("ecore_main_loop_begin\n");
+// ecore_main_loop_begin();
+//#else
+ for (;;)
+ {
+ _RawEvent rawEvent;
+
+ if (!pLooper->GetRawEvent(rawEvent, -1))
+ continue;
+
+ PRINT("OnMainLoop:event(%d) \n",rawEvent.type);
+
+#if 0
+ if (rawEvent.type == _RawEvent::RAWEVENT_KEYPRESS && rawEvent.data.keyPress.keySymbol == XK_Escape)
+ break;
+#endif
+
+ pLooper->DispatchRawEvent(rawEvent);
+ }
+
+}
result
_UiAppImpl::AddFrame(const Frame& frame)
{
SysLog(NID_APP, "Defering frame update for IME app.");
pFrame->SetShowState(false);
+#ifdef BUILD_BREAK
appcore_set_app_state(3);
+#endif
}
}
#ifndef _FAPP_INTERNAL_UI_APP_IMPL_H_
#define _FAPP_INTERNAL_UI_APP_IMPL_H_
+#include <app.h>
+
#include <FAppUiApp.h>
#include <FBaseRtIEventListener.h>
#include <FSysISettingEventListener.h>
virtual void OnTerminate(void);
/**
+ * Called when an orintation event occurs.
+ *
+ * @since 2.1
+ * @param[in] orientation The information about the orientation event
+ */
+ virtual void OnDeviceOrientationChanged(app_device_orientation_e orientation);
+
+ /**
* Called when the window is requested to be raised
*/
virtual result OnFrameRaiseRequested(void);
*/
virtual long OnWindowHandleRequest(void);
+ virtual void OnMainLoop(void);
+
/**
* Called when the application's state change to Tizen::App::AppState::TERMINATING. @n
*
Window
GetEvasWindow(void)
{
+#ifdef VE_EFL
Ecore_Evas* pEcoreEvas = static_cast<Ecore_Evas*>(Tizen::Graphics::_GetDefaultFrameEcoreEvasHandle());
if (pEcoreEvas == null)
}
return (Window) ecore_evas_window_get(pEcoreEvas);
- }
+#endif
+ }
}
namespace Tizen { namespace Graphics
void
_FlushCanvas(void)
{
+#ifdef VE_EFL
Ecore_Evas* pEcoreEvas = static_cast<Ecore_Evas*>(_GetDefaultFrameEcoreEvasHandle());
if (pEcoreEvas)
{
ecore_evas_manual_render(pEcoreEvas);
}
+#endif
}
bool
return false;
}
}
-
+#ifdef VE_EFL
Ecore_Evas* pEcoreEvas = static_cast<Ecore_Evas*>(_GetDefaultFrameEcoreEvasHandle());
if (pEcoreEvas == null)
XCloseDisplay(pHdisplay);
return false;
+ #endif
}
}} // Tizen::Graphics
}
#if defined(FGRAPHICS_INTERNAL_USE_RESTORE_CONTEXT)
- _RestoreContext();
+// _RestoreContext();
#endif
return true;
}
#if defined(FGRAPHICS_INTERNAL_USE_RESTORE_CONTEXT)
- _RestoreContext();
+// _RestoreContext();
#endif
return true;
BufferInfo bufferInfo;
bufferInfo.width = width;
bufferInfo.height = height;
- bufferInfo.bitsPerPixel = ecore_x_default_depth_get(ecore_x_display_get(), ecore_x_default_screen_get());
+ bufferInfo.bitsPerPixel;// = ecore_x_default_depth_get(ecore_x_display_get(), ecore_x_default_screen_get());
for (int i = 0; i < _VIDEO_TEXTURE_BUFFER_MAX; i++)
{
result
InputConnection::Construct(const Control* pControl, IInputConnectionEventListener& listener, IInputConnectionProvider& provider)
{
+#ifdef VE_EFL
SysTryReturnResult(NID_UI, pControl, E_INVALID_ARG, "The argument is invalid.");
__pInputConnectionImpl = _InputConnectionImpl::CreateInputConnectionImplN(this);
+// __pInputConnectionImpl = _NewInputConnectionImpl::CreateInputConnectionImplN(this);
result r = GetLastResult();
SysTryReturn(NID_UI, __pInputConnectionImpl, r, r, "[%s] Propagating.", GetErrorMessage(r));
delete __pInputConnectionImpl;
__pInputConnectionImpl = null;
return r;
+#endif
}
result
InputConnection::Construct(const Control* pControl, IInputConnectionEventListenerF& listener, IInputConnectionProvider& provider)
{
+#ifdef VE_EFL
SysTryReturnResult(NID_UI, pControl, E_INVALID_ARG, "The argument is invalid.");
__pInputConnectionImpl = _InputConnectionImpl::CreateInputConnectionImplN(this);
+// __pInputConnectionImpl = _NewInputConnectionImpl::CreateInputConnectionImplN(this);
result r = GetLastResult();
SysTryReturn(NID_UI, __pInputConnectionImpl, r, r, "[%s] Propagating.", GetErrorMessage(r));
delete __pInputConnectionImpl;
__pInputConnectionImpl = null;
return r;
+#endif
}
result
InputConnection::BindInputMethod(void)
{
- result r = E_SUCCESS;
+ result r = E_SUCCESS;
+#ifdef VE_EFL
SysAssertf(__pInputConnectionImpl, "Not yet constructed. Construct() should be called before use.");
r = __pInputConnectionImpl->BindInputMethod();
SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
-
+#endif
return r;
}
void
InputConnection::UnbindInputMethod(void)
{
+#ifdef VE_EFL
SysAssertf(__pInputConnectionImpl, "Not yet constructed. Construct() should be called before use.");
__pInputConnectionImpl->UnbindInputMethod();
-
+#endif
return;
}
result
InputConnection::ShowInputPanel(void)
{
- result r = E_SUCCESS;
+ result r = E_SUCCESS;
+#ifdef VE_EFL
SysAssertf(__pInputConnectionImpl, "Not yet constructed. Construct() should be called before use.");
r = __pInputConnectionImpl->ShowInputPanel();
SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
-
+#endif
return r;
}
result
InputConnection::HideInputPanel(void)
{
- result r = E_SUCCESS;
+ result r = E_SUCCESS;
+#ifdef VE_EFL
SysAssertf(__pInputConnectionImpl, "Not yet constructed. Construct() should be called before use.");
r = __pInputConnectionImpl->HideInputPanel();
SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
-
+#endif
return r;
}
void
InputConnection::SetInputPanelStyle(InputPanelStyle style)
{
+#ifdef VE_EFL
SysAssertf(__pInputConnectionImpl, "Not yet constructed. Construct() should be called before use.");
__pInputConnectionImpl->SetInputPanelStyle(style);
-
+#endif
return;
}
void
InputConnection::SetAutoCapitalizationMode(AutoCapitalizationMode autoCapitalizationMode)
{
+#ifdef VE_EFL
SysAssertf(__pInputConnectionImpl, "Not yet constructed. Construct() should be called before use.");
__pInputConnectionImpl->SetAutoCapitalizationMode(autoCapitalizationMode);
-
+#endif
return;
}
result
InputConnection::FinishTextComposition(void)
{
- result r = E_SUCCESS;
+ result r = E_SUCCESS;
+#ifdef VE_EFL
SysAssertf(__pInputConnectionImpl, "Not yet constructed. Construct() should be called before use.");
r = __pInputConnectionImpl->FinishTextComposition();
SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
-
+#endif
return r;
}
void
InputConnection::SetInputPanelAction(InputPanelAction inputPanelAction)
{
+#ifdef VE_EFL
SysAssertf(__pInputConnectionImpl, "Not yet constructed. Construct() should be called before use.");
__pInputConnectionImpl->SetInputPanelAction(inputPanelAction);
-
+#endif
return;
}
void
InputConnection::SetInputPanelActionEnabled(bool enable)
{
+#ifdef VE_EFL
SysAssertf(__pInputConnectionImpl, "Not yet constructed. Construct() should be called before use.");
__pInputConnectionImpl->SetInputPanelActionEnabled(enable);
-
+#endif
return;
}
result
InputConnection::SetInputPanelLanguage(LanguageCode languageCode)
{
+#ifdef VE_EFL
SysAssertf(__pInputConnectionImpl, "Not yet constructed. Construct() should be called before use.");
return __pInputConnectionImpl->SetInputPanelLanguage(languageCode);
+#endif
}
result
InputConnection::SetCursorPosition(int position)
{
- result r = E_SUCCESS;
+ result r = E_SUCCESS;
+#ifdef VE_EFL
SysAssertf(__pInputConnectionImpl, "Not yet constructed. Construct() should be called before use.");
r = __pInputConnectionImpl->SetCursorPosition(position);
SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
-
+#endif
return r;
+
}
result
InputConnection::SetCursorBounds(const Rectangle& rect)
{
- result r = E_SUCCESS;
+ result r = E_SUCCESS;
+#ifdef VE_EFL
SysAssertf(__pInputConnectionImpl, "Not yet constructed. Construct() should be called before use.");
r = __pInputConnectionImpl->SetCursorBounds(rect);
SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
-
+#endif
return r;
+
}
result
InputConnection::SetCursorBounds(const FloatRectangle& rect)
{
- result r = E_SUCCESS;
+ result r = E_SUCCESS;
+#ifdef VE_EFL
SysAssertf(__pInputConnectionImpl, "Not yet constructed. Construct() should be called before use.");
r = __pInputConnectionImpl->SetCursorBounds(rect);
SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
-
+#endif
return r;
+
}
Rectangle
InputConnection::GetInputPanelBounds(void) const
{
+#ifdef VE_EFL
result r = E_SUCCESS;
SysAssertf(__pInputConnectionImpl, "Not yet constructed. Construct() should be called before use.");
SysTryReturn(NID_UI, r == E_SUCCESS, Rectangle(0, 0, 0, 0), r, "[%s] Propagating.", GetErrorMessage(r));
return bounds;
+ #endif
}
FloatRectangle
InputConnection::GetInputPanelBoundsF(void) const
{
+#ifdef VE_EFL
result r = E_SUCCESS;
SysAssertf(__pInputConnectionImpl, "Not yet constructed. Construct() should be called before use.");
SysTryReturn(NID_UI, r == E_SUCCESS, FloatRectangle(0.0f, 0.0f, 0.0f, 0.0f), r, "[%s] Propagating.", GetErrorMessage(r));
return bounds;
+ #endif
}
void
InputConnection::SetTextPredictionEnabled(bool enable)
{
+#ifdef VE_EFL
SysAssertf(__pInputConnectionImpl, "Not yet constructed. Construct() should be called before use.");
__pInputConnectionImpl->SetTextPredictionEnabled(enable);
-
+#endif
return;
}
void
InputConnection::SendOpaqueCommand(const String& command)
{
+#ifdef VE_EFL
SysAssertf(__pInputConnectionImpl, "Not yet constructed. Construct() should be called before use.");
__pInputConnectionImpl->SendOpaqueCommand(command);
-
+#endif
return;
}
result
_Clipboard::CopyItem(const _ClipboardItem& item)
{
+#ifdef BUILD_BREAK
SysTryReturn(NID_UI, IsValidDataType(item.GetDataType()), E_INVALID_ARG, E_INVALID_ARG,
"[E_INVALID_ARG] The data type is invalid.");
}
return r;
+#endif
}
IList*
_Clipboard::RetrieveItemsN(unsigned long dataTypes)
{
+#ifdef BUILD_BREAK
SysTryReturn(NID_UI, IsValidDataType(dataTypes), null, E_INVALID_ARG,
"[E_INVALID_ARG] The data type is invalid.");
CATCH:
delete pList;
return null;
+#endif
}
const _ClipboardItem*
_Clipboard::RetrieveLatestItemN(unsigned long dataTypes)
{
+#ifdef BUILD_BREAK
SysTryReturn(NID_UI, IsValidDataType(dataTypes), null, E_INVALID_ARG,
"[E_INVALID_ARG] The data type is invalid.");
free(pData);
return null;
+#endif
}
result
_Clipboard::ShowPopup(unsigned long dataTypes, const IClipboardPopupEventListener &listener)
{
+#ifdef BUILD_BREAK
SysTryReturn(NID_UI, IsPopupVisible() == false, E_INVALID_OPERATION, E_INVALID_OPERATION,
"[E_INVALID_OPERATION] The popup is already shown.");
pEcoreEvas->OpenClipboard(clipFormats);
return r;
+#endif
}
result
_Clipboard::HidePopup(void)
{
+#ifdef BUILD_BREAK
SysTryReturn(NID_UI, IsPopupVisible() == true, E_INVALID_OPERATION, E_INVALID_OPERATION,
"[E_INVALID_OPERATION] The popup is not shown.");
}
return E_SUCCESS;
+#endif
}
bool
_Clipboard::IsPopupVisible(void)
{
+#ifdef BUILD_BREAK
_EcoreEvas* pEcoreEvas = GetEcoreEvasMgr()->GetEcoreEvas();
bool opened = pEcoreEvas->IsClipboardOpened();
SetLastResult(E_SUCCESS);
return opened;
+#endif
}
void
result
_Clipboard::RemoveUnnecessaryImageFiles(void)
{
+#ifdef BUILD_BREAK
_EcoreEvas* pEcoreEvas = GetEcoreEvasMgr()->GetEcoreEvas();
SysTryReturn(NID_UI, pEcoreEvas, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
}
return r;
+#endif
}
result
if (pWinObj)
{
+#ifdef VE_EFL
elm_win_rotation_with_resize_set(pWinObj, rotation);
+#endif
}
OrientationStatus status = ORIENTATION_STATUS_NONE;
return __pKeyEventListeners;
}
+_Control*
+_KeyEventManager::GetCapturingControl(_KeyCode keyCode) const
+{
+ _ControlManager* pControlManager = _ControlManager::GetInstance();
+ SysAssert(pControlManager != null);
+
+ _ControlHandle handle;
+ __pKeyCapturingMap->GetValue(keyCode, handle);
+ return pControlManager->GetObject(handle);
+}
+
+void
+_KeyEventManager::SetCapturingControl(const _Control& control, _KeyCode keyCode, bool captureAllowed)
+{
+ if (captureAllowed)
+ {
+ bool exist = false;
+ __pKeyCapturingMap->ContainsKey(keyCode, exist);
+
+ if (exist)
+ {
+ __pKeyCapturingMap->Remove(keyCode);
+ }
+
+ __pKeyCapturingMap->Add(keyCode, control.GetHandle());
+ }
+ else
+ {
+ __pKeyCapturingMap->Add(keyCode, _ControlHandle());
+ }
+}
+
} } //Tizen::Ui
_ModalLoopManager::BeginMainLoop(void)
{
__nestedMainLoop++;
+#ifdef BUILD_BREAK
::GetEcoreEvasMgr()->BeginMainLoop();
+#endif
return __nestedMainLoop;
}
__lastExitCode = -2;
}
}
+#ifdef BUILD_BREAK
::GetEcoreEvasMgr()->EndMainLoop();
+#endif
__nestedMainLoop--;
}
* @file FUi_NativeObjectHandler.cpp
* @brief This is the implementation file for the _NativeObjectHandler class.
*/
-
+#ifdef BUILD_BREAK
#include <Evas.h>
+#endif
#include "FUiAnimDisplayContext.h"
#include "FUiAnimVisualElement.h"
#include "FUiAnim_VisualElementImpl.h"
#include "FUiAnim_DisplayContextImpl.h"
+#ifdef BUILD_BREAK
#include "FUiAnim_EflNode.h"
#include "FUiAnim_EflLayer.h"
+#endif
#include <FUiControl.h>
#include "FUi_ControlImpl.h"
Handle
_NativeObjectHandler::CreateNativeImageObjectN(const DisplayContext* pDisplayContext, int width, int height)
{
+#ifdef BUILD_BREAK
// * @exception E_SUCCESS The method is successful.
// * @exception E_INVALID_ARG The specified @c pDisplayContext is invalid.
// * @exception E_UNSUPPORTED_OPERATION This operation is not supported.
// evas_object_show(pImage);
return reinterpret_cast<Handle>(pImage);
+#endif
}
result
_NativeObjectHandler::SetNativeObjectToVisualElement(VisualElement* pVisualElement, Handle nativeObjectHandle)
{
+#ifdef BUILD_BREAK
// * @exception E_SUCCESS The method is successful.
// * @exception E_INVALID_ARG The specified @c pNativeObject is @c null.
// * @exception E_UNSUPPORTED_OPERATION This operation is not supported.
evas_object_image_size_get(pNative, &imageWidth, &imageHeight);
evas_object_image_data_update_add(pNative, 0, 0, imageWidth, imageHeight);
}
+#endif
return E_SUCCESS;
}
result
_NativeObjectHandler::SetNativeObjectShowState(Handle nativeObjectHandle, bool show)
{
+#ifdef BUILD_BREAK
// * @exception E_SUCCESS The method is successful.
// * @exception E_INVALID_ARG The specified @c pVisualElement or @c pNativeObject is invalid.
// * @exception E_UNSUPPORTED_OPERATION This operation is not supported.
}
return E_SUCCESS;
+#endif
}
result
_NativeObjectHandler::DestroyNativeObject(VisualElement* pVisualElement, Handle nativeObjectHandle)
{
+#ifdef BUILD_BREAK
// * @exception E_SUCCESS The method is successful.
// * @exception E_UNSUPPORTED_OPERATION This operation is not supported.
}
return E_SUCCESS;
+#endif
}
}} // namespace Tizen { namespace Ui {
{
return;
}
-
+#ifdef BUILD_BREAK
_EcoreEvas* pEcoreEvas = GetEcoreEvasMgr()->GetEcoreEvas();
if (!pEcoreEvas)
{
return;
}
+#endif
bool autoMode = false;
}
__status = status;
-
+#ifdef BUILD_BREAK
pEcoreEvas->AllowSetWindowBounds(false);
FireEvent(status);
pEcoreEvas->AllowSetWindowBounds(true);
-
+#endif
// For the form to be made by Ui-Builder
if ((draw == true) && (__statusChanged == true))
{
// Invalidate
SysLog(NID_UI, "[Window Manager Rotation] ---------- UpdateOrientation : START ----------");
-
+#ifdef BUILD_BREAK
_EcoreEvas* pEcoreEvas = GetEcoreEvasMgr()->GetEcoreEvas();
if (!pEcoreEvas)
{
SysLog(NID_UI, "[Window Manager Rotation][Window : 0x%x, rot = %d, %d, %d, %d, %d] Update Orientation.", pRootWindow->GetNativeHandle(), rotation, bounds.x, bounds.y, bounds.width, bounds.height);
SysLog(NID_UI, "[Window Manager Rotation] ---------- UpdateOrientation : END ----------");
+#endif
}
void
{
return;
}
-
+#ifdef BUILD_BREAK
_EcoreEvas* pEcoreEvas = GetEcoreEvasMgr()->GetEcoreEvas();
if (!pEcoreEvas)
{
return;
}
-
+#endif
_ControlOrientation coreOrientation =
(status == ORIENTATION_STATUS_PORTRAIT || status == ORIENTATION_STATUS_PORTRAIT_REVERSE) ?
_CONTROL_ORIENTATION_PORTRAIT : _CONTROL_ORIENTATION_LANDSCAPE;
if (pOwnee->GetVisibleState() == true)
{
+#ifdef BUILD_BREAK
pEcoreEvas->SetOwner(*pOwnee, pImpl->GetCore());
+#endif
}
}
}
if (pOwnee->GetVisibleState() == true)
{
+#ifdef BUILD_BREAK
pEcoreEvas->SetOwner(*pOwnee, *pParent);
+#endif
}
}
}
void
_OrientationAgent::SetRotation(const _Window& window, Orientation orientation)
{
+#ifdef BUILD_BREAK
_EcoreEvas* pEcoreEvas = GetEcoreEvasMgr()->GetEcoreEvas();
if (!pEcoreEvas)
{
default:
break;
}
+#endif
}
}} // Tizen::Ui
result
_SystemUtilImpl::GenerateKeyEvent(Tizen::Ui::KeyEventType keyEvent, Tizen::Ui::_KeyCode keyCode)
{
+#ifdef BUILD_BREAK
result r = E_SUCCESS;
Display* pDisplay = (Display*)ecore_x_display_get();
SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
return r;
+#endif
}
result
result
_SystemUtilImpl::GenerateTouchEvent(TouchEventType touchEvent, const Tizen::Graphics::FloatPoint& point)
{
+#ifdef BUILD_BREAK
result r = E_SUCCESS;
Display* pDisplay = (Display*)ecore_x_display_get();
SysTryReturn(NID_UI, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
return r;
+#endif
}
Tizen::Graphics::Bitmap*
_SystemUtilImpl::SendKeyStopMessage(void)
{
bool r = false;
- int num;
- Ecore_X_Window *_keygrab_win = null;
+#ifdef BUILD_BREAK
+ Ecore_X_Atom type = ecore_x_atom_get("_HWKEY_EMULATION");
char msg_data[] = "PxXF86Stop";
Ecore_X_Atom type = ecore_x_atom_get("_HWKEY_EMULATION");
r = ecore_x_client_message8_send(xWindow, type, msg_data, sizeof(msg_data));
SysTryReturn(NID_UI, r == true, E_OPERATION_FAILED, E_OPERATION_FAILED, "ecore_x_client_message8_send failed.");
}
-
+#endif
return E_SUCCESS;
}
__pLongPressInfoList = new (std::nothrow) ArrayListT<_LongPressInfo*>;
SysTryReturnVoidResult(NID_UI, __pLongPressInfoList, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory allocation failed.");
-
+#ifdef VE_EFL
int __duration = static_cast<int>(elm_config_longpress_timeout_get() * 1000);
+#else
+ int __duration;
+#endif
+
if (__duration == 0)
{
__duration = 500;
autoRotateLock = false;
SysLog(NID_UI, "It's failed to get the flag of auto-rotate.");
}
-
+#ifdef BUILD_BREAK
app_device_orientation_e deviceOrientation = app_get_device_orientation();
bool isHorizontal = (deviceOrientation == APP_DEVICE_ORIENTATION_90) || (deviceOrientation == APP_DEVICE_ORIENTATION_270);
{
__pUiBuilder->SetUiBuilderRotateState(UIBUIDER_SCREEN_VERTICAL);
}
+#endif
}
if (__pUiBuilder->GetUiBuilderRotateState() == UIBUIDER_SCREEN_HORIZONTAL)
#include "FUi_IKeyEventListener.h"
#include "FUi_ITouchEventListener.h"
#include "FUi_IFocusEventListener.h"
-#include "FUi_EflUiEventManager.h"
+#include "FUi_XUiEventManager.h"
#include "FUi_Control.h"
#include "FUi_ControlManager.h"
#include "FUi_TouchManager.h"
}
void
+_UiEventManager::SetKeyCapture(const _Control& control, _KeyCode keyCode)
+{
+ __pEventManager->SetKeyCapture(control, keyCode);
+
+ _KeyEventManager* pKeyEventManager = _KeyEventManager::GetInstance();
+ SysAssert(pKeyEventManager != null);
+
+ pKeyEventManager->SetCapturingControl(control, keyCode, true);
+}
+
+void
+_UiEventManager::ReleaseKeyCapture(const _Control& control, _KeyCode keyCode)
+{
+ __pEventManager->ReleaseKeyCapture(control, keyCode);
+
+ _KeyEventManager* pKeyEventManager = _KeyEventManager::GetInstance();
+ SysAssert(pKeyEventManager != null);
+
+ pKeyEventManager->SetCapturingControl(control, keyCode, false);
+}
+
+void
_UiEventManager::RemoveAllEventListenerList(Tizen::Base::Collection::HashMapT<_UiEventType, Tizen::Base::Collection::LinkedListT<_IUiEventListener*>*>* pMap)
{
Tizen::Base::Collection::IMapEnumeratorT<_UiEventType, Tizen::Base::Collection::LinkedListT<_IUiEventListener*>*>* pMapEnumerator = pMap->GetMapEnumeratorN();
}
_UiEventManager::_UiEventManager(void)
- : __pEventManager(new (std::nothrow) _EflUiEventManager)
+ : __pEventManager(new (std::nothrow) _XUiEventManager)
{
unique_ptr<HashMapT<_UiEventType, LinkedListT<_IUiEventListener*>*> > pEventListenerMap(new (std::nothrow) HashMapT<_UiEventType, LinkedListT<_IUiEventListener*>*>);
SysTryReturnVoidResult(NID_UI, pEventListenerMap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
#include <FGrpFloatRectangle.h>
#include "FUi_LayoutImpl.h"
#include "FUi_LayoutLayoutMaker.h"
-#include "FUi_EcoreEvasMgr.h"
-#include "FUi_EcoreEvas.h"
+//#include "FUi_EcoreEvasMgr.h"
+//#include "FUi_EcoreEvas.h"
#include "FUi_ControlImplManager.h"
#include "FUi_OrientationAgent.h"
#include "FUi_ImeOrientationAgent.h"
}
return;
}
-
+#ifdef VE_EFL
_EcoreEvas* pEcoreEvas = GetEcoreEvasMgr()->GetEcoreEvas();
SysTryReturnVoidResult(NID_UI_CTRL, pEcoreEvas, E_SYSTEM, "[E_SYSTEM] Unable to get evas.");
-
+#endif
GetCore().SetFormStyle(formStyle);
FloatRectangle indicatorBounds(0.0f, 0.0f, 0.0f, 0.0f);
//Set rect
(pControl->GetAttribute(UIBUILDER_ATTRIBUTE_PORTRAIT))->SetRect(0.0f, 0.0f, screenSize.width, screenSize.height);
(pControl->GetAttribute(UIBUILDER_ATTRIBUTE_LANDSCAPE))->SetRect(0.0f, 0.0f, screenSize.height, screenSize.width);
-
+#ifdef BUILD_BREAK
// Get device orientation
app_device_orientation_e deviceOrientation = app_get_device_orientation();
bool isHorizontal = (deviceOrientation == APP_DEVICE_ORIENTATION_90) || (deviceOrientation == APP_DEVICE_ORIENTATION_270);
+#endif
+ bool isHorizontal = false;
if (isHorizontal)
{
#include "FUi_UiNotificationEvent.h"
#include "FUi_UiEventManager.h"
#include "FUi_ControlManager.h"
+#ifdef VE_EFL
#include "FUi_EcoreEvasMgr.h"
#include "FUi_EcoreEvas.h"
+#endif
#include "FUi_TouchManager.h"
#include "FUi_CoordinateSystemUtils.h"
#include "FUiCtrl_Frame.h"
#include "FUiCtrl_FrameImpl.h"
#include "FUiAnim_VisualElement.h"
#include "FUiAnim_RootVisualElement.h"
+#include "FUiAnim_GlLayer.h"
+#ifdef VE_EFL
#include "FUiAnim_EflLayer.h"
+#endif
#include "FUi_AccessibilityManager.h"
using namespace Tizen::App;
{
result r = E_SUCCESS;
_RootVisualElement* pRootVE = null;
+
+ _GlLayer* pLayer = null;
+#ifdef VE_EFL
_EflLayer* pLayer = null;
+#endif
int appType = _AppInfo::GetAppType();
_Frame* pFrame = new (std::nothrow) _Frame;
pRootVE = pFrame->GetRootVisualElement();
SysAssert(pRootVE);
-
+#ifdef VE_EFL
pLayer = static_cast<_EflLayer*>(pRootVE->GetNativeLayer());
+#else
+ pLayer = static_cast<_GlLayer*>(pRootVE->GetNativeLayer());
+#endif
SysAssert(pLayer);
if (!(appType & _APP_TYPE_IME_APP))
}
else if (*pType == _ACTIVATE_FRAME)
{
+#ifdef BUILD_BREAK
_EcoreEvas* pEcoreEvas = GetEcoreEvasMgr()->GetEcoreEvas();
if (pEcoreEvas)
{
pEcoreEvas->ActivateWindow(*this);
}
+#endif
pArgs->RemoveAll(true);
delete pArgs;
if (GetChildCount() < 1)
{
+#ifdef BUILD_BREAK
_EcoreEvas* pEcoreEvas = GetEcoreEvasMgr()->GetEcoreEvas();
SysTryReturnVoidResult(NID_UI_CTRL, pEcoreEvas, E_SYSTEM, "[E_SYSTEM] Unable to get evas");
{
pEcoreEvas->SetIndicatorShowState(*GetRootWindow(), false);
}
+#endif
}
}
result
_Frame::SetShowMode(FrameShowMode showMode)
{
+#ifdef BUILD_BREAK
_EcoreEvas* pEcoreEvas = GetEcoreEvasMgr()->GetEcoreEvas();
SysTryReturnResult(NID_UI_CTRL, pEcoreEvas, E_SYSTEM, "The method cannot proceed due to a severe system error.");
+#endif
if (showMode == FRAME_SHOW_MODE_MINIMIZED)
{
{
return E_SUCCESS;
}
-
+#ifdef BUILD_BREAK
pEcoreEvas->MinimizeWindow(*GetRootWindow());
+#endif
__minimized = true;
return E_SUCCESS;
case FRAME_SHOW_MODE_FULL_SCREEN:
if (oldShowMode == FRAME_SHOW_MODE_PARTIAL_SCREEN_FLOATING)
{
+#ifdef BUILD_BREAK
r = pEcoreEvas->SetFloatingMode(*GetRootWindow(), false);
SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
+#endif
}
if (oldShowMode != FRAME_SHOW_MODE_FULL_SCREEN)
case FRAME_SHOW_MODE_PARTIAL_SCREEN:
if (oldShowMode == FRAME_SHOW_MODE_PARTIAL_SCREEN_FLOATING)
{
+#ifdef BUILD_BREAK
r = pEcoreEvas->SetFloatingMode(*GetRootWindow(), false);
SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
+#endif
}
if (oldShowMode == FRAME_SHOW_MODE_FULL_SCREEN)
}
else if (oldShowMode == FRAME_SHOW_MODE_PARTIAL_SCREEN_FLOATING)
{
- pEcoreEvas->SetWindowBounds(*GetRootWindow(), _CoordinateSystemUtils::ConvertToInteger(__floatingBounds));
+ SetBounds(__floatingBounds);
+// pEcoreEvas->SetWindowBounds(*GetRootWindow(), _CoordinateSystemUtils::ConvertToInteger(__floatingBounds));
}
break;
case FRAME_SHOW_MODE_PARTIAL_SCREEN_FLOATING:
if (oldShowMode != FRAME_SHOW_MODE_PARTIAL_SCREEN_FLOATING)
{
+#ifdef BUILD_BREAK
r = pEcoreEvas->SetFloatingMode(*GetRootWindow(), true);
SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
+#endif
}
if (oldShowMode == FRAME_SHOW_MODE_FULL_SCREEN)
}
else
{
+#ifdef BUILD_BREAK
_EcoreEvas* pEcoreEvas = GetEcoreEvasMgr()->GetEcoreEvas();
SysTryReturnVoidResult(NID_UI_CTRL, pEcoreEvas, E_SYSTEM, "[E_SYSTEM] Unable to get evas");
pEcoreEvas->SetIndicatorShowState(*GetRootWindow(), false);
+#endif
}
}
{
return E_SUCCESS;
}
-
+#ifdef BUILD_BREAK
_EcoreEvas* pEcoreEvas = GetEcoreEvasMgr()->GetEcoreEvas();
SysTryReturn(NID_UI, pEcoreEvas, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A system error occurred.");
SysTryReturn(NID_UI_CTRL, r == E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
return r;
+#endif
}
result
_Frame::OnAttached(void)
{
+#ifdef BUILD_BREAK
_EcoreEvas* pEcoreEvas = GetEcoreEvasMgr()->GetEcoreEvas();
SysAssert(pEcoreEvas);
pEcoreEvas->SetWindowVisibleState(*GetRootWindow(), true);
-
+#endif
return E_SUCCESS;
}
{
_RootVisualElement* pRootVE = GetRootVisualElement();
SysAssert(pRootVE);
-
+#ifdef VE_EFL
_EflLayer* pLayer = static_cast<_EflLayer*>(pRootVE->GetNativeLayer());
+#else
+ _GlLayer* pLayer = static_cast<_GlLayer*>(pRootVE->GetNativeLayer());
+#endif
SysAssert(pLayer);
byte alpha = backgroundColor.GetAlpha();
SetShowMode(FRAME_SHOW_MODE_FULL_SCREEN);
SetShowMode(showMode);
-
+#ifdef VE_EFL
_EcoreEvas* pEcoreEvas = GetEcoreEvasMgr()->GetEcoreEvas();
if (!pEcoreEvas)
{
default:
break;
}
+#endif
}
void
if (__pPixmapEventHandler)
{
- ecore_event_handler_del(__pPixmapEventHandler);
+// ecore_event_handler_del(__pPixmapEventHandler);
__pPixmapEventHandler = null;
}
if (__pixmapDamageHandle)
{
- ecore_x_damage_free(__pixmapDamageHandle);
+// ecore_x_damage_free(__pixmapDamageHandle);
__pixmapDamageHandle = 0;
}
if (__pixmap != 0)
{
- XFreePixmap((Display*)ecore_x_display_get(), __pixmap);
+// XFreePixmap((Display*)ecore_x_display_get(), __pixmap);
__pixmap = 0;
}
if (__pShmInfo)
{
- XShmDetach((Display*)ecore_x_display_get(), __pShmInfo);
+// XShmDetach((Display*)ecore_x_display_get(), __pShmInfo);
shmdt(__pShmInfo->shmaddr);
shmctl(__pShmInfo->shmid, IPC_RMID, NULL);
__pShmInfo = null;
if (__pImageObject)
{
- evas_object_del(__pImageObject);
+// evas_object_del(__pImageObject);
__pImageObject = null;
}
}
int width = 0;
int height = 0;
+#ifdef VE_EFL
evas_object_geometry_get(__pImageObject, NULL, NULL, &width, &height);
-
+#endif
bufferInfo.width = width;
bufferInfo.pitch = width;
bufferInfo.height = height;
result
_OverlayAgent::GrabXvPort(void)
{
- Display* pDisplay = (Display*)ecore_x_display_get();
+ Display* pDisplay;// = (Display*)ecore_x_display_get();
SysTryReturnResult(NID_UI_CTRL, pDisplay != null, E_SYSTEM, "The current value of Display is null");
int baseXvPort = -1;
if (__isPortGrabbed[__xvPort - __baseXvPort])
{
- Display* pDisplay = (Display*) ecore_x_display_get();
+ Display* pDisplay;// = (Display*) ecore_x_display_get();
Atom atom = XInternAtom(pDisplay, "_USER_WM_PORT_ATTRIBUTE_STREAM_OFF", False);
XvSetPortAttribute(pDisplay, __xvPort, atom, 1);
XvUngrabPort(pDisplay, __xvPort, 0);
{
SysTryReturnResult(NID_UI_CTRL, __pixmap != 0, E_SYSTEM, "The current value of pixmap is null");
- Display* pDisplay = (Display*)ecore_x_display_get();
+ Display* pDisplay;// = (Display*)ecore_x_display_get();
SysTryReturnResult(NID_UI_CTRL, pDisplay != null, E_SYSTEM, "The current value of Display is null");
if (__pXvImage == null || __needToRellaocImage)
int imageWidth = 0;
int imageHeight = 0;
- evas_object_image_size_get(__pImageObject, &imageWidth, &imageHeight);
+// evas_object_image_size_get(__pImageObject, &imageWidth, &imageHeight);
GC gc= DefaultGCOfScreen(DefaultScreenOfDisplay(pDisplay));
XvShmPutImage(pDisplay, __xvPort, __pixmap, gc, __pXvImage, 0, 0, __currentSourceBufferSize.width, __currentSourceBufferSize.height, 0, 0, imageWidth, imageHeight, False);
__pCurrentSourceBuffer = null;
void* pImageData = (void*)(__pConvertedSourceBuffer->GetPointer());
SysTryReturnResult(NID_UI_CTRL, pImageData != null, E_SYSTEM, "The converted image data for Overlay Renderer VisualElement is invalid.");
-
+#ifdef VE_EFL
evas_object_image_size_set(__pImageObject, __currentSourceBufferSize.width, __currentSourceBufferSize.height);
evas_object_image_data_set(__pImageObject, pImageData);
evas_object_image_data_update_add(__pImageObject, 0, 0, __currentSourceBufferSize.width, __currentSourceBufferSize.height);
evas_object_show(__pImageObject);
-
+#endif
if (__needToRellaocImage)
{
SysSecureLog(NID_UI_CTRL, "The current value of source buffer bounds is [%d,%d,%d, %d]", 0, 0, __currentSourceBufferSize.width, __currentSourceBufferSize.height);
r = __pParentVE->SetSurfaceOpaque(true);
SysTryReturnResult(NID_UI_CTRL, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
+#ifdef VE_EFL
// Get and Set ImageObject of Renderer VisualElement
_EflNode* pEflNode = dynamic_cast<_EflNode*>(pRendererVE->GetNativeNode());
{
evas_object_image_pixels_get_callback_set(__pImageObject, OnEvasImageDamaged,(void*)this);
}
-
+#endif
return r;
}
E_SYSTEM, "input size (%d, %d) is too small to create a pixmap",pixmapSize.width, pixmapSize.height);
// Create pixmap
+#ifdef VE_EFL
Display *pDisplay = (Display*)ecore_x_display_get();
SysTryReturnResult(NID_UI_CTRL, pDisplay != null, E_SYSTEM, "The current value of Display is null");
XFillRectangle(pDisplay, __pixmap, gc, 0, 0, pixmapSize.width, pixmapSize.height);
XSync(pDisplay, 0);
XFreeGC(pDisplay, gc);
-
+#endif
//Set evas native surface
Evas_Native_Surface evasNativeSuface = {0,};
evasNativeSuface.version = EVAS_NATIVE_SURFACE_VERSION;
evasNativeSuface.type = EVAS_NATIVE_SURFACE_X11;
+#ifdef VE_EFL
evasNativeSuface.data.x11.visual = ecore_x_default_visual_get(ecore_x_display_get(), ecore_x_default_screen_get());
+#endif
evasNativeSuface.data.x11.pixmap = __pixmap;
+#ifdef VE_EFL
evas_object_lower(__pImageObject);
evas_object_image_native_surface_set(__pImageObject, &evasNativeSuface);
XFreePixmap((Display*)ecore_x_display_get(), __pixmap);
__pixmap = 0;
}
-
+#endif
return E_SYSTEM;
}
int screenWidth = _Screen::GetWidth();
int screenHeight = _Screen::GetHeight();
SysTryReturnResult(NID_UI_CTRL, screenWidth > 0 && screenHeight > 0, E_SYSTEM, "The value of screen size is invalid.");
-
+#ifdef VE_EFL
//If orientation status of screen is landscape mode, swap width and height.
{
_EcoreEvas* pEcoreEvas = GetEcoreEvasMgr()->GetEcoreEvas();
SysSecureLog(NID_UI_CTRL, "The current value of device screen width is %d, device screen height is %d and orientation is %d", screenWidth, screenHeight, orientation);
}
}
+#endif
int physicalMaxWidth= screenWidth - (screenWidth % widthUnit);
int physicalMaxHeight = screenHeight - (screenHeight % heightUnit);
}
+
// Get style of OverlayPanel
_OverlayAgentStyle overlayAgentType = _OVERLAY_AGENT_STYLE_NONE;
{
+ #ifdef VE_EFL
String preferredEngineConfig(elm_config_preferred_engine_get());
if(preferredEngineConfig.Equals("opengl_x11", true))
{
SysLog(NID_UI_CTRL,"The current value of HwAcceleration is Off (System Default)");
}
}
+ #endif
}
+
// Create Overlay Agent
__pOverlayAgent = _OverlayAgent::CreateInstanceN(overlayAgentType, *this, logicalBoundsF, physicalBounds);
r = GetLastResult();
_OverlayAgentStyle overlayAgentType = _OVERLAY_AGENT_STYLE_REGION_SW;
{
+#ifdef VE_EFL
String preferredEngineConfig(elm_config_preferred_engine_get());
if(preferredEngineConfig.Equals("opengl_x11", true))
{
SysLog(NID_UI_CTRL,"The current value of HwAcceleration is Off (System Default)");
}
}
+#endif
}
std::unique_ptr<_OverlayAgent> pOverlayAgent(_OverlayAgent::CreateInstanceN(overlayAgentType, *pParentForm, overlayLogRect, finalPhyRect));
_ScrollPanelImpl::CloseOverlayWindow(void)
{
ClearLastResult();
-
+#ifdef VE_EFL
const _Control* pControl = GetCore().GetControlKeypadBinding();
_Edit* pKeypadBindingEdit = dynamic_cast <_Edit*>(const_cast <_Control*>(pControl));
result r = pKeypadBindingEdit->HideKeypad();
SysTryReturn(NID_UI_CTRL, r != E_SUCCESS, r, r, "[%s] Propagating.", GetErrorMessage(r));
-
+#endif
return E_SUCCESS;
}
_TableViewItem::OnCanvasRequestedN(const Tizen::Graphics::FloatRectangle& bounds)
{
Canvas* pCanvas = null;
-
+#ifdef VE_EFL
if(__pBitmapVisualElement != null && __pBitmapVisualElement->GetImageSource().IsEmpty())
{
Bitmap* pDrawBitmap = __pItemBgBitmap[__drawingStatus];
DrawBitmap(*pCanvas, FloatRectangle(0.0f, 0.0f, bounds.width, bounds.height), *pDrawBitmap);
}
}
+#endif
CATCH:
public:
class EditAreaSizeInfo : public _ControlImpl::SizeInfo
{
- virtual Tizen::Graphics::Dimension GetDefaultMinimumSize(Tizen::Ui::_ControlOrientation orientation) const;
- virtual Tizen::Graphics::FloatDimension GetDefaultMinimumSizeF(Tizen::Ui::_ControlOrientation orientation) const;
+ virtual Tizen::Graphics::Dimension GetDefaultMinimumSize(Tizen::Ui::_ControlOrientation orientation) const {}
+ virtual Tizen::Graphics::FloatDimension GetDefaultMinimumSizeF(Tizen::Ui::_ControlOrientation orientation) const {}
};
public:
virtual result UnregisterKeyEventHandler(const _Control& control) = 0;
virtual result UnregisterTouchEventHandler(const _Control& control) = 0;
virtual result PostEvent(const _UiEvent& event) = 0;
+
+ virtual void SetKeyCapture(const _Control& control, _KeyCode keyCode) = 0;
+ virtual void ReleaseKeyCapture(const _Control& control, _KeyCode keyCode) = 0;
}; // _IUiEventManager
}} // Tizen::Ui
*/
Tizen::Base::Collection::LinkedListT<Tizen::Ui::_IKeyEventListener*>* GetKeyEventListener(void) const;
+ _Control* GetCapturingControl(_KeyCode keyCode) const;
+
+ void SetCapturingControl(const _Control& control, _KeyCode keyCode, bool captureAllowed);
+
static void InitializeInstance(void);
static void ReleaseInstance(void);
_IUiEventManager* GetEventManager(void) const;
+ void SetKeyCapture(const _Control& control, _KeyCode keyCode);
+ void ReleaseKeyCapture(const _Control& control, _KeyCode keyCode);
+
private:
static void InitInstance(void);
result AddEventListener(_UiEventType eventType, bool postListener, const _IUiEventListener& listener);
_ControlImpl::SizeInfo&
SizeInfo::GetEditFieldSizeInfo(bool isSmallStyle, EditFieldTitleStyle titleStlye)
{
+#ifdef BUILD_BREAK
static _EditFieldImpl::EditFieldSizeInfo editFieldSizeInfo;
editFieldSizeInfo.SetSmallStyle(isSmallStyle);
editFieldSizeInfo.SetTitleStyle(titleStlye);
return editFieldSizeInfo;
+#endif
}
_ControlImpl::SizeInfo&
projects / framework / osp / uifw.git / commitdiff