This is for prepare Aurum 1.0 version release.
namespaces - Aurum for public classes
AurumInternal for internal headers such as atspi, impl classes
AurumInternal::Mock for Mock wrapper.
We will add more namespace if we added other back-end instead of ATSPI,
or other Node type needed.
Change-Id: Ia47ff40387d322e3e0932b3b0cda45b0d4a5f19a
#include "bitmask.h"
#include <string>
+namespace Aurum {
+
/**
* @class A11yEvent
*
const std::string mPkg;
};
+}
+
#endif
#include <memory>
+namespace Aurum {
+
/**
* @class AccessibleApplication
*
std::shared_ptr<AccessibleNode> mNode;
};
+}
+
#endif
#include "Rect.h"
#include "config.h"
+namespace Aurum {
+
/**
* @brief AccessibleNodeInterface enum class
*
mutable std::mutex mLock;
};
+}
+
#endif
#include "config.h"
+namespace Aurum {
+
/**
* @class AccessibleWatcher
*
std::mutex mLock;
};
+}
+
#endif
#include <string>
#include <memory>
+namespace Aurum {
+
class AccessibleApplication;
/**
std::shared_ptr<AccessibleNode> mNode;
};
+}
+
#endif
#ifndef _IEVENT_CONSUMER_H_
#define _IEVENT_CONSUMER_H_
+namespace Aurum {
+
/**
* @class EventType
*
virtual void notify(int type1, int type2, void *src) = 0;
};
+}
+
#endif
#include "IEventConsumer.h"
#include <memory>
+namespace Aurum {
+
/**
* @class IEventSource
*
virtual void notifyAll(int type1, int type2, void *src) = 0;
};
+}
+
#endif
#include <memory>
#include <vector>
+namespace Aurum {
+
/**
* @class Comparer
*
bool mEarlyReturn;
};
+}
+
#endif
#include <memory>
#include <atspi/atspi.h>
+using namespace Aurum;
+
+namespace AurumInternal {
+
/**
* @internal
*
std::string getPackageName(void) override;
};
+}
+
#endif
#include "AccessibleNode.h"
#include <atspi/atspi.h>
+using namespace Aurum;
+
+namespace AurumInternal {
+
/**
* @brief AtspiAccessibleNode is inherited from AccessibleNode class.
* It manages object informations which from atspi server.
AtspiAccessible *mNode;
};
+}
+
#endif
#include <set>
#include <map>
+using namespace Aurum;
+
+namespace AurumInternal {
+
/**
* @internal
*
static std::mutex mMutex;
};
+}
+
#endif
#include "AccessibleWindow.h"
+using namespace Aurum;
+
+namespace AurumInternal {
+
/**
* @internal
*
};
+}
+
#endif
#include <atspi/atspi.h>
#include <mutex>
+namespace AurumInternal {
+
/**
* @internal
*
static std::recursive_mutex mMutex;
};
+}
+
#endif
#include <memory>
+using namespace Aurum;
+
+namespace AurumInternal {
+
+namespace Mock {
+
class MockAccessibleApplication : public AccessibleApplication, public std::enable_shared_from_this<MockAccessibleApplication> {
public:
/**
std::vector<std::shared_ptr<AccessibleWindow>> mWindowList;
};
+}
+
+}
+
#endif
#include <mutex>
#include <set>
+using namespace Aurum;
+
+namespace AurumInternal {
+
+namespace Mock {
+
class MockAccessibleNode : public AccessibleNode {
public:
/**
std::mutex mLock;
};
+}
+
+}
+
#endif
#include <memory>
#include <vector>
+using namespace Aurum;
+
+namespace AurumInternal {
+
+namespace Mock {
+
class MockAccessibleWatcher : public AccessibleWatcher {
public:
/**
std::map<AtspiAccessible *, std::shared_ptr<AccessibleApplication>> mActiveAppMap;
};
+}
+
+}
+
#endif
#include "AccessibleWindow.h"
#include "MockAccessibleNode.h"
+using namespace Aurum;
+
+namespace AurumInternal {
+
+namespace Mock {
+
class MockAccessibleApplication;
class MockAccessibleWindow : public AccessibleWindow {
std::shared_ptr<MockAccessibleNode> mMockNode;
};
+}
+
+}
+
#endif
\ No newline at end of file
#include <vector>
#include <map>
+using namespace Aurum;
+
+namespace AurumInternal {
+
+namespace Mock {
+
enum class MockKeyType {
BACK,
HOME,
Size2D<int> mScreenSize;
};
+}
+
+}
+
#endif
#include <set>
#include <efl_util.h>
+using namespace Aurum;
+
+namespace AurumInternal {
+
class TizenDeviceImpl : public IDevice {
public:
TizenDeviceImpl();
Size2D<int> mScreenSize;
};
+}
+
#endif
\ No newline at end of file
#define _IDEVICE_H_
#include "config.h"
-#include "Rect.h"
#include "Size2D.h"
#include <string>
+namespace Aurum {
+
/**
* @brief TimeRequestType enum class.
*
virtual const Size2D<int> getScreenSize() = 0;
};
+}
+
#endif
#include <memory>
#include <vector>
+namespace Aurum {
+
class UiObject;
/**
const std::shared_ptr<UiSelector> selector) const = 0;
};
+}
+
#endif
#ifndef _POINT2D_H_
#define _POINT2D_H_
+namespace Aurum {
+
/**
* @class Point2D
*
T y;
};
+}
+
#endif
#include "Point2D.h"
+namespace Aurum {
+
/**
* @class Rect
*
Point2D<T> mBottomRight;
};
+}
+
#endif
#ifndef _SIZE2D_H_
#define _SIZE2D_H_
+namespace Aurum {
+
/**
* @brief Size2D Class.
* This class for represent specific obejct's size as width and height.
T height;
};
+}
+
#endif
#include <type_traits>
+namespace Aurum {
+
template<typename E>
struct enable_bitmask_operators{
static const bool enable=false;
return lhs;
}
+}
+
#endif
#include "AccessibleNode.h"
#include "UiSelector.h"
+namespace Aurum {
+
/**
* @class PartialMatch
*
std::list<std::shared_ptr<PartialMatch>> mPartialMatches;
};
+}
+
#endif
#ifndef _RUNNABLE_H_
#define _RUNNABLE_H_
+namespace Aurum {
+
/**
* @class Runnable
*
virtual void run() const = 0;
};
+}
+
#endif
#include "Runnable.h"
+namespace Aurum {
+
/**
* @class SendKeyRunnable
*
void run() const override;
};
+}
+
#endif
#include "UiSelector.h"
+namespace Aurum {
+
/**
* @class Sel
*
static std::shared_ptr<UiSelector> depth(int depth);
};
+}
+
#endif
#include <functional>
#include <string>
+namespace Aurum {
+
/**
* @class UiDevice
*
const Waiter *mWaiter;
};
+}
+
#endif
#include <memory>
#include <vector>
+namespace Aurum {
+
class UiDevice;
/**
static const unsigned int LOGNCLICK_INTERVAL = 500;
};
+}
+
#endif
#include "UiObject.h"
#include <memory>
+
+namespace Aurum {
+
/**
* @brief UiScrollable class
* @since_tizen 5.5
int mScrollStep;
};
+}
+
#endif
#include <vector>
#include <memory>
+namespace Aurum {
+
/**
* @class UiSelector
*
std::shared_ptr<UiSelector> mParent;
};
+}
+
#endif
#include "ISearchable.h"
#include "UiSelector.h"
+namespace Aurum {
+
/**
* @class Until
*
const bool isCheckable);
};
+}
+
#endif
#include <functional>
+namespace Aurum {
+
/**
* @class Waiter
*
const int WAIT_TIMEOUT_MS;
};
+}
+
#endif
#include <unordered_map>
+using namespace Aurum;
+
A11yEventInfo::A11yEventInfo() : A11yEventInfo(A11yEvent::EVENT_NONE, nullptr, nullptr) {}
A11yEventInfo::~A11yEventInfo() {}
#include <algorithm>
+using namespace Aurum;
+
AccessibleApplication::AccessibleApplication(std::shared_ptr<AccessibleNode> node)
: mNode{node}
{
#include "config.h"
#include <sstream>
+using namespace Aurum;
+
AccessibleNode::~AccessibleNode()
{
}
#include <utility>
#include <algorithm>
+using namespace Aurum;
+using namespace AurumInternal;
+
AccessibleWatcher::AccessibleWatcher()
:mSources{}, mLock{}
{
#include "Aurum.h"
+using namespace Aurum;
+
AccessibleWindow::AccessibleWindow(std::shared_ptr<AccessibleApplication> app, std::shared_ptr<AccessibleNode> node)
: mApp{app}, mNode{node}
{
#include "Aurum.h"
+using namespace Aurum;
+
Comparer::Comparer(const std::shared_ptr<UiDevice> device, const std::shared_ptr<UiSelector> selector,
const bool &earlyReturn)
: mDevice(device), mSelector(selector), mEarlyReturn(earlyReturn)
#include <algorithm>
#include <vector>
+using namespace Aurum;
+using namespace AurumInternal;
+
AtspiAccessibleApplication::AtspiAccessibleApplication(std::shared_ptr<AccessibleNode> node)
: AccessibleApplication(node)
{
#include <gio/gio.h>
+using namespace Aurum;
+using namespace AurumInternal;
+
AtspiAccessibleNode::AtspiAccessibleNode(AtspiAccessible *node)
: mNode{node}
{
#include <thread>
#include <iostream>
+using namespace Aurum;
+using namespace AurumInternal;
+
#define COMPARE(A, B) \
(B != A11yEvent::EVENT_NONE) && ((A & B) == B)
#include "AtspiAccessibleWindow.h"
#include "AtspiWrapper.h"
+using namespace Aurum;
+using namespace AurumInternal;
+
AtspiAccessibleWindow::AtspiAccessibleWindow(std::shared_ptr<AccessibleApplication> app, std::shared_ptr<AccessibleNode> node)
: AccessibleWindow(app, node)
{
#include "AtspiWrapper.h"
+using namespace AurumInternal;
+
std::recursive_mutex AtspiWrapper::mMutex = std::recursive_mutex{};
GArray *AtspiWrapper::Atspi_state_set_get_states(AtspiStateSet *set)
#include <algorithm>
+using namespace Aurum;
+using namespace AurumInternal::Mock;
+
MockAccessibleApplication::MockAccessibleApplication(std::shared_ptr<AccessibleNode> node)
: AccessibleApplication(node), mWindowList{}
{
#include <algorithm>
#include <iostream>
+using namespace Aurum;
+using namespace AurumInternal::Mock;
+
MockAccessibleNode::MockAccessibleNode(std::shared_ptr<AccessibleNode> parent, std::string text, std::string pkg, std::string role, std::string res, std::string type, std::string style,std::string automationId, Rect<int> screenBoundingBox, int supportingIfaces,int featureProperty)
: mParentNode(parent), mChildrenList{}, mActionSet{}
{
#include "MockAccessibleApplication.h"
#include "MockAccessibleNode.h"
+using namespace Aurum;
+using namespace AurumInternal::Mock;
+
MockAccessibleWatcher::MockAccessibleWatcher()
{
}
#include "MockAccessibleApplication.h"
#include "MockAccessibleNode.h"
+using namespace Aurum;
+using namespace AurumInternal::Mock;
+
MockAccessibleWindow::MockAccessibleWindow(std::shared_ptr<MockAccessibleApplication> app, std::shared_ptr<MockAccessibleNode> node)
: AccessibleWindow(app, node), mMockNode{node}
{
#include <chrono>
#include <thread>
+using namespace Aurum;
+using namespace AurumInternal::Mock;
+
#define NANO_SEC 1000000000.0
#define MICRO_SEC 1000000
#include <tbm_surface.h>
#include <system_info.h>
+using namespace Aurum;
+using namespace AurumInternal;
+
#define NANO_SEC 1000000000.0
#define MICRO_SEC 1000000
#include <regex>
#include <sstream>
+using namespace Aurum;
+
bool PartialMatch::checkCriteria(const std::string textA, const std::string textB)
{
std::regex re(textA);
#include "Aurum.h"
+using namespace Aurum;
+
SendKeyRunnable::SendKeyRunnable(std::string keycode)
: mKeycode{keycode}
{
#include "Aurum.h"
#include <utility>
+using namespace Aurum;
+
std::shared_ptr<UiSelector> Sel::text(std::string text)
{
std::shared_ptr<UiSelector> sel = std::make_shared<UiSelector>();
#include <algorithm>
#include <iostream>
+using namespace Aurum;
+using namespace AurumInternal;
+
UiDevice::UiDevice() : UiDevice(nullptr) {}
UiDevice::UiDevice(IDevice *impl)
#include <chrono>
#include <thread>
+using namespace Aurum;
+
UiObject::UiObject() : UiObject(nullptr, nullptr, nullptr) {}
UiObject::~UiObject()
#include "Aurum.h"
+using namespace Aurum;
+
UiScrollable::UiScrollable(std::shared_ptr<UiSelector> selector)
: mSelector{selector}, mMaxSearchSwipe{100}, mScrollStep{50}
{
bool UiScrollable::scrollForward(int steps)
{
-
//TODO Check Scree Size here
return true;
#include <string>
#include <sstream>
+using namespace Aurum;
+
UiSelector::UiSelector()
: mId{}, mAutomationId{}, mRole{}, mText{}, mPkg{}, mType{}, mStyle{},
mMatchId{}, mMatchAutomationId{}, mMatchRole{}, mMatchText{}, mMatchPkg{}, mMatchType{}, mMatchStyle{},
#include "Aurum.h"
+using namespace Aurum;
+
std::function<bool(const ISearchable *)> Until::hasObject(
const std::shared_ptr<UiSelector> selector)
{
#include <chrono>
#include <thread>
+using namespace Aurum;
+
Waiter::Waiter() : Waiter(nullptr) {}
Waiter::~Waiter() {}
#include "UiObject.h"
+using namespace Aurum;
+
class ObjectMapper {
private:
std::map<std::string, std::shared_ptr<UiObject>> mObjectMap;
#include "MockAccessibleWindow.h"
#include "MockAccessibleNode.h"
-
class AurumTestMisc : public ::testing::Test {
public:
AurumTestMisc(){
#include "MockAccessibleWindow.h"
#include "MockAccessibleNode.h"
+using namespace Aurum;
+using namespace AurumInternal::Mock;
class AurumTestSel : public ::testing::Test {
public:
#include "MockAccessibleWindow.h"
#include "MockAccessibleNode.h"
+using namespace Aurum;
+using namespace AurumInternal::Mock;
class AurumTestUiDevice : public ::testing::Test {
public:
#include "MockAccessibleWindow.h"
#include "MockAccessibleNode.h"
+using namespace Aurum;
+using namespace AurumInternal::Mock;
class AurumTestUiObject : public ::testing::Test {
public:
#include <iostream>
#include <algorithm>
-
-
#include "MockAccessibleWatcher.h"
#include "MockAccessibleApplication.h"
#include "MockAccessibleWindow.h"
#include "MockAccessibleNode.h"
+using namespace Aurum;
+using namespace AurumInternal::Mock;
class AurumTestUiSelector : public ::testing::Test {
public:
projects / platform / core / uifw / aurum.git / commitdiff