static void updateWebMouseEventFromWebCoreMouseEvent(const MouseRelatedEvent& event, const Widget& widget, const WebCore::RenderObject& renderObject, WebMouseEvent& webEvent)
{
webEvent.timeStampSeconds = event.timeStamp() / millisPerSecond;
webEvent.modifiers = getWebInputModifiers(event);
ScrollView* view = widget.parent();
IntPoint windowPoint = view->contentsToWindow(IntPoint(event.absoluteLocation().x(), event.absoluteLocation().y()));
webEvent.globalX = event.screenX();
webEvent.globalY = event.screenY();
webEvent.windowX = windowPoint.x();
webEvent.windowY = windowPoint.y();
IntPoint localPoint = convertAbsoluteLocationForRenderObject(event.absoluteLocation(), renderObject);
webEvent.x = localPoint.x();
webEvent.y = localPoint.y();
}
void QiangHLayer::initExtraUi()
{
ScrollView *scroll = ScrollView::create();
if(NULL != scroll)
{
scroll->setAnchorPoint(CCPointZero);
scroll->setPosition(ccp(15,15));
//scroll->f = &QiangHLayer::flushLeft;
this->addChild(scroll);
}
spt_img = CCSprite::create("c1.png");
spt_img->setAnchorPoint(CCPointZero);
spt_img->setPosition(ccp(380,260));
addChild(spt_img);
}
void ScrollViewReader::setPropsFromJsonDictionary(Widget *widget, const rapidjson::Value &options)
{
LayoutReader::setPropsFromJsonDictionary(widget, options);
ScrollView* scrollView = static_cast<ScrollView*>(widget);
float innerWidth = DICTOOL->getFloatValue_json(options, P_InnerWidth,200);
float innerHeight = DICTOOL->getFloatValue_json(options, P_InnerHeight,200);
scrollView->setInnerContainerSize(Size(innerWidth, innerHeight));
int direction = DICTOOL->getFloatValue_json(options, P_Direction,1);
scrollView->setDirection((ScrollView::Direction)direction);
scrollView->setBounceEnabled(DICTOOL->getBooleanValue_json(options, P_BounceEnable));
LayoutReader::setColorPropsFromJsonDictionary(widget, options);
}
/* ECMAScript constructor */
Handle<Value> ScrollView::New(const Arguments& args)
{
HandleScope scope;
if (!args.IsConstructCall()) {
return ThrowException(Exception::TypeError(
String::New("Use the new operator to create instances of this object."))
);
}
// Creates a new instance object of this type and wraps it.
ScrollView* obj = new ScrollView();
obj->Wrap(args.This());
return scope.Close(args.This());
}
static int tolua_cocos2dx_ScrollView_setDelegate(lua_State* tolua_S)
{
if (nullptr == tolua_S)
return 0;
int argc = 0;
ScrollView* self = nullptr;
#if COCOS2D_DEBUG >= 1
tolua_Error tolua_err;
if (!tolua_isusertype(tolua_S,1,"cc.ScrollView",0,&tolua_err)) goto tolua_lerror;
#endif
self = (ScrollView*) tolua_tousertype(tolua_S,1,0);
#if COCOS2D_DEBUG >= 1
if (nullptr == self)
{
tolua_error(tolua_S,"invalid 'self' in function 'tolua_cocos2dx_ScrollView_setDelegate'\n", nullptr);
return 0;
}
#endif
argc = lua_gettop(tolua_S) - 1;
if (0 == argc)
{
LuaScrollViewDelegate* delegate = new (std::nothrow) LuaScrollViewDelegate();
if (nullptr == delegate)
return 0;
self->setUserObject(delegate);
self->setDelegate(delegate);
delegate->release();
return 0;
}
luaL_error(tolua_S, "'setDelegate' function of ScrollView wrong number of arguments: %d, was expecting %d\n", argc, 0);
return 0;
#if COCOS2D_DEBUG >= 1
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'setDelegate'.",&tolua_err);
return 0;
#endif
}
void PluginView::updatePluginWidget()
{
if (!parent() || !m_private)
return;
ASSERT(parent()->isFrameView());
FrameView* frameView = toFrameView(parent());
IntRect oldWindowRect = m_windowRect;
IntRect oldClipRect = m_clipRect;
m_windowRect = IntRect(frameView->contentsToWindow(frameRect().location()), frameRect().size());
ScrollView* theRoot = root();
if (!theRoot)
return; // ASSERT(parent()->isFrameView()) should prevent this but check just in case
// Map rect to content coordinate space of main frame.
m_windowRect.move(theRoot->scrollOffset());
m_clipRect = calculateClipRect();
// Notify the plugin if it may or may not be on/offscreen.
handleScrollEvent();
bool zoomFactorChanged = ((NPSetWindowCallbackStruct*)m_npWindow.ws_info)->zoomFactor
!= frameView->hostWindow()->platformPageClient()->currentZoomFactor();
if (!zoomFactorChanged && m_windowRect == oldWindowRect && m_clipRect == oldClipRect)
return;
// Do not call setNPWindowIfNeeded immediately, will be called on paint().
m_private->m_hasPendingGeometryChange = true;
// (i) In order to move/resize the plugin window at the same time as the
// rest of frame during e.g. scrolling, we set the window geometry
// in the paint() function, but as paint() isn't called when the
// plugin window is outside the frame which can be caused by a
// scroll, we need to move/resize immediately.
// (ii) If we are running layout tests from DRT, paint() won't ever get called
// so we need to call setNPWindowIfNeeded() if window geometry has changed.
if (m_clipRect.isEmpty() || (platformPluginWidget() && (m_windowRect != oldWindowRect || m_clipRect != oldClipRect || zoomFactorChanged)))
setNPWindowIfNeeded();
// Make sure we get repainted afterwards. This is necessary for downward
// scrolling to move the plugin widget properly.
invalidate();
}
void WebPage::gestureWillBegin(const WebCore::IntPoint& point, bool& canBeginPanning)
{
m_gestureReachedScrollingLimit = false;
bool hitScrollbar = false;
HitTestRequest request(HitTestRequest::ReadOnly);
for (Frame* childFrame = m_page->mainFrame(); childFrame; childFrame = EventHandler::subframeForTargetNode(m_gestureTargetNode.get())) {
ScrollView* scollView = childFrame->view();
if (!scollView)
break;
RenderView* renderView = childFrame->document()->renderView();
if (!renderView)
break;
RenderLayer* layer = renderView->layer();
if (!layer)
break;
HitTestResult result = scollView->windowToContents(point);
layer->hitTest(request, result);
m_gestureTargetNode = result.innerNode();
if (!hitScrollbar)
hitScrollbar = result.scrollbar();
}
if (hitScrollbar) {
canBeginPanning = false;
return;
}
if (!m_gestureTargetNode) {
canBeginPanning = false;
return;
}
for (RenderObject* renderer = m_gestureTargetNode->renderer(); renderer; renderer = renderer->parent()) {
if (renderer->isBox() && toRenderBox(renderer)->canBeScrolledAndHasScrollableArea()) {
canBeginPanning = true;
return;
}
}
canBeginPanning = false;
}
bool HelpScene::init()
{
if (!LayerColor::initWithColor(Color4B()))
{
return false;
}
Sprite* s = Sprite::create("box.png");
s->setPosition(100, 100);
ScrollView* view = ScrollView::create();
view->addChild(s);
this->addChild(view);
return true;
}
static int tolua_Cocos2dx_ScrollView_addEventListenerScrollView00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"ScrollView",0,&tolua_err) ||
!toluafix_isfunction(tolua_S,2,"LUA_FUNCTION",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
ScrollView* self = (ScrollView*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addEventListenerScrollView'", NULL);
#endif
LuaCocoStudioEventListener* listener = LuaCocoStudioEventListener::create();
if (NULL == listener)
{
tolua_error(tolua_S,"LuaCocoStudioEventListener create fail\n", NULL);
return 0;
}
LUA_FUNCTION handler = ( toluafix_ref_function(tolua_S,2,0));
listener->setHandler(handler);
CCDictionary* dict = static_cast<CCDictionary*>(self->getScriptObjectDict());
if (NULL == dict)
{
dict = CCDictionary::create();
self->setScriptObjectDict(dict);
}
dict->setObject(listener, "scrollViewEventListener");
self->addEventListenerScrollView(listener, scrollvieweventselector(LuaCocoStudioEventListener::eventCallbackFunc));
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'addEventListenerScrollView'.",&tolua_err);
return 0;
#endif
}
virtual void frameRectsChanged()
{
if (!platformWidget())
return;
IntRect windowRect = convertToContainingWindow(IntRect(0, 0, frameRect().width(), frameRect().height()));
platformWidget()->setGeometry(windowRect);
ScrollView* parentScrollView = parent();
if (!parentScrollView)
return;
ASSERT(parentScrollView->isFrameView());
IntRect clipRect(static_cast<FrameView*>(parentScrollView)->windowClipRect());
clipRect.move(-windowRect.x(), -windowRect.y());
clipRect.intersect(platformWidget()->rect());
platformWidget()->setMask(QRegion(clipRect.x(), clipRect.y(), clipRect.width(), clipRect.height()));
}
DateTimePickerRecipe::DateTimePickerRecipe(Container *parent) :
CustomControl(parent)
{
// The recipe Container.
ScrollView *scrollView = new ScrollView();
ScrollViewProperties* scrollViewProp = scrollView->scrollViewProperties();
scrollViewProp->setScrollMode(ScrollMode::Vertical);
Container *recipeContainer = new Container();
recipeContainer->setLayout(StackLayout::create().top(50.0f));
recipeContainer->setMinHeight(1024.0f);
// The recipe title, we add it to a Container in order to get some padding around it.
Container *titleContainer = new Container();
titleContainer->setLayout(StackLayout::create().left(20.0f).bottom(20.0f));
QDateTime date = QDateTime::currentDateTime();
Label *title = new Label(titleContainer);
title->setText("Today is: " + date.toString("M/d/yy"));
title->textStyle()->setBase(SystemDefaults::TextStyles::bodyText());
// This is where we create the DateTimePicker, we set the mode so that we
// can change the date and update the state of the fruit depending on that.
DateTimePicker *datePicker = new DateTimePicker();
datePicker->setTitle("Banana at date:");
datePicker->setMode(DateTimePickerMode::Date);
datePicker->setLayoutProperties(StackLayoutProperties::create().horizontal(HorizontalAlignment::Center));
connect(datePicker, SIGNAL(valueChanged(QDateTime )), this, SLOT(onValueChanged(QDateTime )));
// An image of a fruit is used to show how one can use the QDateTime value
// reported by the picker.
mTimeWarpFruit = ImageView::create("asset:///images/picker/banana_new.png");
mTimeWarpFruit ->setTopMargin(20.0f);
recipeContainer->add(titleContainer);
recipeContainer->add(datePicker);
recipeContainer->add(mTimeWarpFruit);
// Add the scrollable content to the ScrollView.
scrollView->setContent(recipeContainer);
setRoot(scrollView);
}
// Generate a synthetic WebMouseEvent given a TouchEvent (eg. for emulating a mouse
// with touch input for plugins that don't support touch input).
WebMouseEventBuilder::WebMouseEventBuilder(const Widget* widget, const WebCore::RenderObject* renderObject, const TouchEvent& event)
{
if (!event.touches())
return;
if (event.touches()->length() != 1) {
if (event.touches()->length() || event.type() != EventTypeNames::touchend || !event.changedTouches() || event.changedTouches()->length() != 1)
return;
}
const Touch* touch = event.touches()->length() == 1 ? event.touches()->item(0) : event.changedTouches()->item(0);
if (touch->identifier())
return;
if (event.type() == EventTypeNames::touchstart)
type = MouseDown;
else if (event.type() == EventTypeNames::touchmove)
type = MouseMove;
else if (event.type() == EventTypeNames::touchend)
type = MouseUp;
else
return;
timeStampSeconds = event.timeStamp() / millisPerSecond;
modifiers = getWebInputModifiers(event);
// The mouse event co-ordinates should be generated from the co-ordinates of the touch point.
ScrollView* view = toScrollView(widget->parent());
IntPoint windowPoint = IntPoint(touch->absoluteLocation().x(), touch->absoluteLocation().y());
if (view)
windowPoint = view->contentsToWindow(windowPoint);
globalX = touch->screenX();
globalY = touch->screenY();
windowX = windowPoint.x();
windowY = windowPoint.y();
button = WebMouseEvent::ButtonLeft;
modifiers |= WebInputEvent::LeftButtonDown;
clickCount = (type == MouseDown || type == MouseUp);
IntPoint localPoint = convertAbsoluteLocationForRenderObject(touch->absoluteLocation(), *renderObject);
x = localPoint.x();
y = localPoint.y();
}
void StoreScreen::CreateViews() {
using namespace UI;
root_ = new LinearLayout(ORIENT_VERTICAL);
I18NCategory *di = GetI18NCategory("Dialog");
I18NCategory *st = GetI18NCategory("Store");
// Top bar
LinearLayout *topBar = root_->Add(new LinearLayout(ORIENT_HORIZONTAL));
topBar->Add(new Button(di->T("Back")))->OnClick.Handle<UIScreen>(this, &UIScreen::OnBack);
titleText_ = new TextView("PPSSPP Homebrew Store");
topBar->Add(titleText_);
UI::Drawable solid(0xFFbd9939);
topBar->SetBG(solid);
LinearLayout *content;
if (connectionError_ || loading_) {
content = new LinearLayout(ORIENT_VERTICAL, new LinearLayoutParams(FILL_PARENT, FILL_PARENT, 1.0f));
content->Add(new TextView(loading_ ? st->T("Loading...") : st->T("Connection Error")));
content->Add(new Button(di->T("Retry")))->OnClick.Handle(this, &StoreScreen::OnRetry);
content->Add(new Button(di->T("Back")))->OnClick.Handle<UIScreen>(this, &UIScreen::OnBack);
} else {
content = new LinearLayout(ORIENT_HORIZONTAL, new LinearLayoutParams(FILL_PARENT, FILL_PARENT, 1.0f));
ScrollView *leftScroll = new ScrollView(ORIENT_VERTICAL, new LinearLayoutParams(WRAP_CONTENT, FILL_PARENT, 0.4f));
leftScroll->SetTag("StoreMainList");
content->Add(leftScroll);
LinearLayout *scrollItemView = new LinearLayout(ORIENT_VERTICAL, new LayoutParams(FILL_PARENT, WRAP_CONTENT));
leftScroll->Add(scrollItemView);
std::vector<StoreEntry> entries = FilterEntries();
for (size_t i = 0; i < entries.size(); i++) {
scrollItemView->Add(new ProductItemView(entries_[i]))->OnClick.Handle(this, &StoreScreen::OnGameSelected);
}
// TODO: Similar apps, etc etc
productPanel_ = new ScrollView(ORIENT_VERTICAL, new LinearLayoutParams(0.5f));
leftScroll->SetTag("StoreMainProduct");
content->Add(productPanel_);
}
root_->Add(content);
}
void PluginView::updatePluginWidget()
{
FrameView* frameView = static_cast<FrameView*>(parent());
PLUGIN_LOG("--%p UpdatePluginWidget frame=[%p] \n", instance(), frameView);
if (frameView) {
m_windowRect = frameView->contentsToWindow(frameRect());
IntRect oldPageRect = m_pageRect;
// only the top ScrollView can have the offset
m_pageRect = m_windowRect;
ScrollView* top = parent();
while (top->parent())
top = top->parent();
m_pageRect.move(top->scrollOffset());
if (m_pageRect != oldPageRect)
setNPWindowIfNeeded();
}
}
void ShaderListScreen::CreateViews() {
using namespace UI;
I18NCategory *di = GetI18NCategory("Dialog");
LinearLayout *layout = new LinearLayout(ORIENT_VERTICAL);
root_ = layout;
tabs_ = new TabHolder(ORIENT_HORIZONTAL, 40, new LinearLayoutParams(1.0));
layout->Add(tabs_);
layout->Add(new Button(di->T("Back")))->OnClick.Handle<UIScreen>(this, &UIScreen::OnBack);
for (size_t i = 0; i < ARRAY_SIZE(shaderTypes); i++) {
ScrollView *scroll = new ScrollView(ORIENT_VERTICAL, new LinearLayoutParams(1.0));
LinearLayout *shaderList = new LinearLayout(ORIENT_VERTICAL, new LayoutParams(FILL_PARENT, WRAP_CONTENT));
ListShaders(shaderTypes[i].type, shaderList);
scroll->Add(shaderList);
tabs_->AddTab(shaderTypes[i].name, scroll);
}
}
// Takes care of the SVET_SELECTION events.
// Depending on the drag_mode_ we are in, either draw a line, a rectangle or
// an ellipse.
void SVPaint::SelectionHandler(const SVEvent* sv_event) {
switch (drag_mode_) {
//FIXME inversed x_size, y_size
case 4: //Line
window_->Line(sv_event->x, sv_event->y,
sv_event->x - sv_event->x_size,
sv_event->y - sv_event->y_size);
break;
case 5: //Rectangle
window_->Rectangle(sv_event->x, sv_event->y,
sv_event->x - sv_event->x_size,
sv_event->y - sv_event->y_size);
break;
case 6: //Ellipse
window_->Ellipse(sv_event->x - sv_event->x_size,
sv_event->y - sv_event->y_size,
sv_event->x_size, sv_event->y_size);
break;
}
}
void AddImage( ScrollView& scrollView, Size& stageSize, int index )
{
ImageView imageView = ImageView::New( IMAGE_PATHS[index] );
imageView.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
imageView.SetSizeScalePolicy( SizeScalePolicy::FIT_WITH_ASPECT_RATIO );
imageView.SetParentOrigin( ParentOrigin::CENTER );
imageView.SetAnchorPoint( AnchorPoint::CENTER );
imageView.SetPosition( index * stageSize.x, 0 );
scrollView.Add( imageView );
}
void ScrollView::scrollRectIntoViewRecursively(const IntRect& r)
{
IntPoint p(max(0, r.x()), max(0, r.y()));
ScrollView* view = this;
while (view) {
view->setContentsPos(p.x(), p.y());
p.move(view->x() - view->scrollOffset().width(), view->y() - view->scrollOffset().height());
view = static_cast<ScrollView*>(view->parent());
}
}
RenderWidget::UpdateSuspendScope::~UpdateSuspendScope()
{
ASSERT(s_updateSuspendCount > 0);
if (s_updateSuspendCount == 1) {
WidgetToParentMap map;
widgetNewParentMap().swap(map);
WidgetToParentMap::iterator end = map.end();
for (WidgetToParentMap::iterator it = map.begin(); it != end; ++it) {
Widget* child = it->key.get();
ScrollView* currentParent = toScrollView(child->parent());
FrameView* newParent = it->value;
if (newParent != currentParent) {
if (currentParent)
currentParent->removeChild(child);
if (newParent)
newParent->addChild(child);
}
}
}
--s_updateSuspendCount;
}
// Takes care of the SVET_CLICK events.
// Depending on the click_mode_ we are in, either do Point-to-Point drawing,
// point drawing, or draw text.
void SVPaint::ClickHandler(const SVEvent* sv_event) {
switch (click_mode_) {
case 1: //Point to Point
if (has_start_point_) { window_->DrawTo(sv_event->x, sv_event->y);
} else {
has_start_point_ = true;
window_->SetCursor(sv_event->x, sv_event->y);
}
break;
case 2: //Point Drawing..simulated by drawing a 1 pixel line.
window_->Line(sv_event->x, sv_event->y, sv_event->x, sv_event->y);
break;
case 3: //Text
// We show a modal input dialog on our window, then draw the input and
// finally delete the input pointer.
char* p = window_->ShowInputDialog("Text:");
window_->Text(sv_event->x, sv_event->y, p);
delete p;
break;
}
}
void RenderWidget::resumeWidgetHierarchyUpdates()
{
ASSERT(widgetHierarchyUpdateSuspendCount);
if (widgetHierarchyUpdateSuspendCount == 1) {
WidgetToParentMap map = widgetNewParentMap();
widgetNewParentMap().clear();
WidgetToParentMap::iterator end = map.end();
for (WidgetToParentMap::iterator it = map.begin(); it != end; ++it) {
Widget* child = it->first.get();
ScrollView* currentParent = child->parent();
FrameView* newParent = it->second;
if (newParent != currentParent) {
if (currentParent)
currentParent->removeChild(child);
if (newParent)
newParent->addChild(child);
}
}
}
widgetHierarchyUpdateSuspendCount--;
}
void Widget::invalidateRect(const IntRect& rect)
{
//printf("invalidateRect x=%d y=%d w=%d h=%d\n", rect.x(), rect.y(), rect.width(), rect.height());
if (data->suppressInvalidation)
return;
if (!parent()) {
if (isFrameView())
static_cast<FrameView*>(this)->addToDirtyRegion(rect);
return;
}
// Get the root widget.
ScrollView* outermostView = parent();
while (outermostView && outermostView->parent())
outermostView = outermostView->parent();
if (!outermostView)
return;
IntRect windowRect = convertToContainingWindow(rect);
outermostView->addToDirtyRegion(windowRect);
}
static void accumulateRendererTouchEventTargetRects(Vector<IntRect>& rects, const RenderObject* renderer, const IntRect& parentRect = IntRect())
{
IntRect adjustedParentRect = parentRect;
if (parentRect.isEmpty() || renderer->isFloating() || renderer->isPositioned() || renderer->hasTransform()) {
// FIXME: This method is O(N^2) as it walks the tree to the root for every renderer. RenderGeometryMap would fix this.
IntRect r = enclosingIntRect(renderer->clippedOverflowRectForRepaint(0));
if (!r.isEmpty()) {
// Convert to the top-level view's coordinates.
ASSERT(renderer->document()->view());
for (ScrollView* view = renderer->document()->view(); view && view->parent(); view = view->parent())
r = view->convertToContainingView(r);
if (!parentRect.contains(r)) {
rects.append(r);
adjustedParentRect = r;
}
}
}
for (RenderObject* child = renderer->firstChild(); child; child = child->nextSibling())
accumulateRendererTouchEventTargetRects(rects, child, adjustedParentRect);
}
WebMouseWheelEventBuilder::WebMouseWheelEventBuilder(const Widget* widget, const WheelEvent& event)
{
if (event.type() != eventNames().mousewheelEvent)
return;
type = WebInputEvent::MouseWheel;
timeStampSeconds = event.timeStamp() / millisPerSecond;
modifiers = getWebInputModifiers(event);
ScrollView* view = widget->parent();
IntPoint p = view->contentsToWindow(
IntPoint(event.absoluteLocation().x(), event.absoluteLocation().y()));
globalX = event.screenX();
globalY = event.screenY();
windowX = p.x();
windowY = p.y();
x = event.absoluteLocation().x() - widget->location().x();
y = event.absoluteLocation().y() - widget->location().y();
deltaX = static_cast<float>(event.rawDeltaX());
deltaY = static_cast<float>(event.rawDeltaY());
// The 120 is from WheelEvent::initWheelEvent().
wheelTicksX = static_cast<float>(event.wheelDeltaX()) / 120;
wheelTicksY = static_cast<float>(event.wheelDeltaY()) / 120;
scrollByPage = event.granularity() == WheelEvent::Page;
}
// on "init" you need to initialize your instance
bool HelloWorld::init()
{
//////////////////////////////
// 1. super init first
if ( !Layer::init() )
{
return false;
}
rootNode = CSLoader::createNode("MainScene.csb");
addChild(rootNode);
Button * bt1 = dynamic_cast<Button *>(rootNode->getChildByName("Button_1"));
bt1->addTouchEventListener([&](Ref * pSender,Widget::TouchEventType type){
auto layoutParameter = LinearLayoutParameter::create();
layoutParameter->setGravity(LinearLayoutParameter::LinearGravity::LEFT);
ScrollView * scrollView = (ScrollView *)rootNode->getChildByName("ScrollView_1");
Widget * widget = makeWords();
widget->setLayoutParameter(layoutParameter);
scrollView->addChild(widget);
// scrollView->cocos2d::ui::LayoutProtocol::doLayout();
log("...%zd",scrollView->getChildren().size());
});
Button * bt2 = dynamic_cast<Button *>(rootNode->getChildByName("Button_2"));
bt2->addTouchEventListener(CC_CALLBACK_2(HelloWorld::addRight, this));
return true;
}
// Draws the data in a new window.
void ImageData::Display() const {
const int kTextSize = 64;
int x_max, y_max;
WordFeature::ComputeSize(features_, &x_max, &y_max);
ScrollView* win = new ScrollView("Imagedata", 100, 100,
2 * (x_max + 2 * kTextSize),
2 * (y_max + 4 * kTextSize),
x_max + 10, y_max + 3 * kTextSize, true);
// Draw the image.
Pix* pix = GetPix();
int height = 256;
if (pix != NULL) {
height = pixGetHeight(pix);
win->Image(pix, 0, height - 1);
pixDestroy(&pix);
}
// Draw the boxes.
win->Pen(ScrollView::RED);
win->Brush(ScrollView::NONE);
win->TextAttributes("Arial", kTextSize, false, false, false);
for (int b = 0; b < boxes_.size(); ++b) {
boxes_[b].plot(win);
win->Text(boxes_[b].left(), y_max + kTextSize, box_texts_[b].string());
TBOX scaled(boxes_[b]);
scaled.scale(256.0 / height);
scaled.plot(win);
}
// The full transcription.
win->Pen(ScrollView::CYAN);
win->Text(0, y_max + kTextSize * 2, transcription_.string());
// Add the features.
win->Pen(ScrollView::GREEN);
WordFeature::Draw(features_, win);
win->Update();
window_wait(win);
}
virtual void frameRectsChanged()
{
if (!platformWidget())
return;
IntRect windowRect = convertToContainingWindow(IntRect(0, 0, frameRect().width(), frameRect().height()));
platformWidget()->setGeometry(windowRect);
ScrollView* parentScrollView = parent();
if (!parentScrollView)
return;
ASSERT(parentScrollView->isFrameView());
IntRect clipRect(static_cast<FrameView*>(parentScrollView)->windowClipRect());
clipRect.move(-windowRect.x(), -windowRect.y());
clipRect.intersect(platformWidget()->rect());
QRegion clipRegion = QRegion(clipRect);
platformWidget()->setMask(clipRegion);
// if setMask is set with an empty QRegion, no clipping will
// be performed, so in that case we hide the platformWidget
platformWidget()->setVisible(!clipRegion.isEmpty());
}
bool MapScene::init()
{
if (!Scene::init()){
return false;
}
Director *director = Director::getInstance();
Size winSize = director->getWinSize();
Layer *mapLayer = Layer::create();
Sprite *map = Sprite::create("Map/Main_Main.png");
map->setAnchorPoint(Vec2::ZERO);
mapLayer->addChild(map);
Sprite *regionNormal = Sprite::create("Map/Main_flag.png");
Sprite *regionSelected = Sprite::create("Map/Main_flag.png");
regionSelected->setScale(1.2f);
std::function<void(Ref *ref)>
onRegionTouched = [this](Ref *ref)->void
{
if (_readyMenu) {
delete _readyMenu;
_readyMenu = nullptr;
}
RegionInfo regionInfo;
HeroInfo heroInfo;
regionInfo.stageName = "Stage1.json";
heroInfo.heroName = "normal";
_readyMenu = new ReadyMenu(regionInfo, heroInfo);
Layer *readyLayer = _readyMenu->getLayer();
addChild(readyLayer);
};
MenuItemSprite *regionMenuItem = MenuItemSprite::create(regionNormal, regionSelected, onRegionTouched);
Menu *regionMenu = Menu::create(regionMenuItem, nullptr);
regionMenu->setPosition(Vec2(700.0f, 220.0f));
mapLayer->addChild(regionMenu);
ScrollView *scrollView = ScrollView::create(winSize, mapLayer);
scrollView->setTouchEnabled(true);
scrollView->setContentSize(map->getContentSize());
scrollView->setPosition(Vec2::ZERO);
scrollView->setDirection(ScrollView::Direction::BOTH);
scrollView->setBounceable(false);
addChild(scrollView);
return true;
}
bool SpriteIntro::initWithDoc(rapidjson::Document *doc)
{
auto size = cocos2d::Director::sharedDirector()->getWinSize();
rapidjson::Value* v = new rapidjson::Value;
std::string name;
std::string picurl;
ScrollView *scrollView = ScrollView::create();
Layer *layer = Layer::create();
Sprite *sprite;
for (unsigned int i = 1; i < doc->Size(); i++)
{
(*v)=(*doc)[i];
name = (*v)[2].GetString();
picurl = "ownimage/"+name+".png";
sprite = Sprite::create(picurl.c_str());
sprite->setScaleX(2.0);
sprite->setScaleY(1.0);
layer->addChild(sprite,1,i);
sprite->setPosition(32+(i-1)%4*120,1536-((i-1)/4+1)*152);
}
layer->setAnchorPoint(CCPointZero);
layer->setPosition(CCPointZero);
scrollView->setPosition(CCPointZero);
scrollView->setContentOffset(CCPointZero);
layer->setContentSize(CCSizeMake(384,512*3));
scrollView->setContentSize(CCSizeMake(384,512));
scrollView->setContainer(layer);
scrollView->setTouchEnabled(true);
scrollView->setDelegate(this);
scrollView->setDirection(ScrollView::Direction::VERTICAL);
this->addChild(scrollView);
delete v;
return true;
}
// Three panes: Block chooser, MIPS view, ARM/x86 view
void JitCompareScreen::CreateViews() {
I18NCategory *di = GetI18NCategory("Dialog");
I18NCategory *dev = GetI18NCategory("Developer");
using namespace UI;
root_ = new LinearLayout(ORIENT_HORIZONTAL);
ScrollView *leftColumnScroll = root_->Add(new ScrollView(ORIENT_VERTICAL, new LinearLayoutParams(1.0f)));
LinearLayout *leftColumn = leftColumnScroll->Add(new LinearLayout(ORIENT_VERTICAL));
ScrollView *midColumnScroll = root_->Add(new ScrollView(ORIENT_VERTICAL, new LinearLayoutParams(2.0f)));
LinearLayout *midColumn = midColumnScroll->Add(new LinearLayout(ORIENT_VERTICAL));
midColumn->SetTag("JitCompareLeftDisasm");
leftDisasm_ = midColumn->Add(new LinearLayout(ORIENT_VERTICAL));
leftDisasm_->SetSpacing(0.0f);
ScrollView *rightColumnScroll = root_->Add(new ScrollView(ORIENT_VERTICAL, new LinearLayoutParams(2.0f)));
rightColumnScroll->SetTag("JitCompareRightDisasm");
LinearLayout *rightColumn = rightColumnScroll->Add(new LinearLayout(ORIENT_VERTICAL));
rightDisasm_ = rightColumn->Add(new LinearLayout(ORIENT_VERTICAL));
rightDisasm_->SetSpacing(0.0f);
leftColumn->Add(new Choice(dev->T("Current")))->OnClick.Handle(this, &JitCompareScreen::OnCurrentBlock);
leftColumn->Add(new Choice(dev->T("By Address")))->OnClick.Handle(this, &JitCompareScreen::OnSelectBlock);
leftColumn->Add(new Choice(dev->T("Prev")))->OnClick.Handle(this, &JitCompareScreen::OnPrevBlock);
leftColumn->Add(new Choice(dev->T("Next")))->OnClick.Handle(this, &JitCompareScreen::OnNextBlock);
leftColumn->Add(new Choice(dev->T("Random")))->OnClick.Handle(this, &JitCompareScreen::OnRandomBlock);
leftColumn->Add(new Choice(dev->T("FPU")))->OnClick.Handle(this, &JitCompareScreen::OnRandomFPUBlock);
leftColumn->Add(new Choice(dev->T("VFPU")))->OnClick.Handle(this, &JitCompareScreen::OnRandomVFPUBlock);
leftColumn->Add(new Choice(dev->T("Stats")))->OnClick.Handle(this, &JitCompareScreen::OnShowStats);
leftColumn->Add(new Choice(di->T("Back")))->OnClick.Handle<UIScreen>(this, &UIScreen::OnBack);
blockName_ = leftColumn->Add(new TextView(dev->T("No block")));
blockAddr_ = leftColumn->Add(new TextEdit("", "", new LayoutParams(FILL_PARENT, WRAP_CONTENT)));
blockAddr_->OnTextChange.Handle(this, &JitCompareScreen::OnAddressChange);
blockStats_ = leftColumn->Add(new TextView(""));
EventParams ignore{};
OnCurrentBlock(ignore);
}
