Example #1
0
void PhysObject::DrawBounds()
{
    JObjectIterator it( this );
    ++it;
    while (it)
    {
        JObject* pObj = *it;
        if (!pObj->IsDrawBounds())
        {
            pObj->DrawBounds();
        }
        ++it;
    }
} // PhysObject::DrawBounds
Example #2
0
int JLuaServer::FnCall( lua_State* pLua )
{
    if (lua_gettop( pLua ) < 2 || lua_gettop( pLua ) > 3)
    {
        rlog.err( "LUA: Incorrect command usage: <call>. "
            "Function takes 2 to 3 arguments (object|objectName, funcName, [tag]), but %d is provided", lua_gettop( pLua ) );
        lua_settop( pLua, 0 );
        return 0;
    }

    JObject* pObj = NULL;
    const char* pPath = lua_tostring( pLua, 1 );
    if (pPath)
    {
        JLuaThread* pThread = reinterpret_cast<JLuaThread*>( pLua->userdata );
        assert( pThread->m_pLua == pLua );
        JObject* pRootObj = pThread->m_pRootObj;
        pObj = g_pObjectServer->FindObject( pPath, NULL, pRootObj );
        if (!pObj)
        {
            rlog.warn( "LUA: Method <call> refers to non-existing object: %s", pPath );
            return NULL;
        }
    }
    else
    {
        pObj = reinterpret_cast<JObject*>( lua_touserdata( pLua, 1 ) );
        if (!pObj)
        {
            rlog.warn( "LUA: Trying to call <call> for the nil object" );
            return NULL;
        }
    }
    
    const char* pMethodName = lua_tostring( pLua, 2 );

    int tag = -1;
    if (lua_isnumber( pLua, 3 ))
    {
        tag = (int)lua_tonumber( pLua, 3 );
    }

    bool bRes = pObj->CallMethod( pMethodName, tag );
    if (!bRes)
    {
        rlog.err( "LUA: Could not call method '%s' for object '%s' of type '%s'.", 
            pMethodName, pObj->GetName(), pObj->ClassName() );
    }
    return 0;
} // JLuaServer::FnCall
Example #3
0
// Socket close result handler.
static void AfterClose(uv_handle_t* handle) {
  HandleWrap* tcp_wrap = HandleWrap::FromHandle(handle);
  IOTJS_ASSERT(tcp_wrap != NULL);

  // tcp object.
  JObject jtcp = tcp_wrap->jobject();
  IOTJS_ASSERT(jtcp.IsObject());

  // callback function.
  JObject jcallback = jtcp.GetProperty("onclose");
  if (jcallback.IsFunction()) {
    MakeCallback(jcallback, JObject::Null(), JArgList::Empty());
  }
}
Example #4
0
int JLuaServer::FnGet( lua_State* pLua )
{
    if (lua_gettop( pLua ) < 2 || lua_gettop( pLua ) > 3)
    {
        rlog.err( "LUA: Incorrect command usage: <get>. "
            "Function takes 2 or 3 arguments (<objectRef>|<objectName>, <propName>, [tag]), but %d is provided", 
            lua_gettop( pLua ) );
        lua_settop( pLua, 0 );
        lua_pushnil( pLua );
        return 1;
    }
    JObject* pObj = NULL;
    const char* pPath = lua_tostring( pLua, 1 );
    if (pPath)
    {
        JLuaThread* pThread = reinterpret_cast<JLuaThread*>( pLua->userdata );
        assert( pThread->m_pLua == pLua );
        JObject* pRootObj = pThread->m_pRootObj;
        pObj = g_pObjectServer->FindObject( pPath, NULL, pRootObj );
    }
    else
    {
        pObj = reinterpret_cast<JObject*>( lua_touserdata( pLua, 1 ) );
    }
    const char* pPropName = lua_tostring( pLua, 2 );
    int tag = -1;
    if (lua_isnumber( pLua, 3 ))
    {
        tag = (int)lua_tonumber( pLua, 3 );
    }

    if (!pObj)
    {
        rlog.warn( "LUA: Trying to call <get> for the nil object. Nil is returned." );
        lua_pushnil( pLua );
        return 1;
    }

    static JString val;
    bool bRes = pObj->GetProperty( pPropName, val, tag );
    if (!bRes)
    {
        rlog.err( "LUA: Could not get property '%s' for object '%s' of type '%s'.", 
            pPropName, pObj->GetName(), pObj->ClassName() );
    }

    lua_pushstring( pLua, val.c_str() );
    return 1;
} // JLuaServer::FnGet
JHANDLER_FUNCTION(Buffer, handler) {
  IOTJS_ASSERT(handler.GetThis()->IsObject());
  IOTJS_ASSERT(handler.GetArgLength() == 2);
  IOTJS_ASSERT(handler.GetArg(0)->IsObject());
  IOTJS_ASSERT(handler.GetArg(1)->IsNumber());

  int length = handler.GetArg(1)->GetInt32();
  JObject* jbuffer = handler.GetArg(0);
  JObject* jbuiltin = handler.GetThis();

  BufferWrap* buffer_wrap = new BufferWrap(*jbuffer, *jbuiltin, length);
  IOTJS_ASSERT(buffer_wrap == (BufferWrap*)(jbuiltin->GetNative()));
  IOTJS_ASSERT(buffer_wrap->buffer() != NULL);

  return true;
}
Example #6
0
int JPoint::compareTo(const JObject& s) const {
  if (className() != s.className())
    return JObject::compareTo(s);
  int result = y-((JPoint*)&s)->y;
  if (!result) result = x-((JPoint*)&s)->x;
  return result;
}
Example #7
0
JObject MakeStatObject(uv_stat_t* statbuf) {


#define X(name)                              \
  JObject name((int)statbuf->st_##name);        \

  X(dev)
  X(mode)
  X(nlink)
  X(uid)
  X(gid)
  X(rdev)

#undef X

#define X(name)                              \
  JObject name((double)statbuf->st_##name);        \

  X(blksize)
  X(ino)
  X(size)
  X(blocks)

#undef X


  Module* module = GetBuiltinModule(MODULE_FS);
  JObject* fs = module->module;
  JObject createStat = fs->GetProperty("createStat");

  JArgList args(10);
  args.Add(dev);
  args.Add(mode);
  args.Add(nlink);
  args.Add(uid);
  args.Add(gid);
  args.Add(rdev);
  args.Add(blksize);
  args.Add(ino);
  args.Add(size);
  args.Add(blocks);

  JResult jstat_res(createStat.Call(JObject::Null(), args));
  IOTJS_ASSERT(jstat_res.IsOk());

  return jstat_res.value();
}
Example #8
0
JObject* InitFs() {
  Module* module = GetBuiltinModule(MODULE_FS);
  JObject* fs = module->module;

  if (fs == NULL) {
    fs = new JObject();
    fs->SetMethod("close", Close);
    fs->SetMethod("open", Open);
    fs->SetMethod("read", Read);
    fs->SetMethod("write", Write);
    fs->SetMethod("stat", Stat);

    module->module = fs;
  }

  return fs;
}
Example #9
0
int JLuaServer::FnSetParent( lua_State* pLua )
{
    if (lua_gettop( pLua ) != 2)
    {
        rlog.err( "LUA: Incorrect command usage: <setparent>. "
            "Function takes 2 arguments, but %d is provided", lua_gettop( pLua ) );
        lua_settop( pLua, 0 );
        lua_pushnil( pLua );
        return 1;
    }
    JObject* pParent = reinterpret_cast<JObject*>( lua_touserdata( pLua, 2 ) );
    JObject* pObj    = reinterpret_cast<JObject*>( lua_touserdata( pLua, 1 ) );
    if (!pObj)
    {
        lua_pushnil( pLua );
        return 0;
    }
    //  set new parent for the object
    JObject* pOldParent = pObj->GetParent();
    if (pParent)
    {
        pParent->AddChild( pObj );
    }
    if (pOldParent)
    {
        pOldParent->RemoveChild( pObj );
    }
    pObj->SetParent( pParent );
    
    return 0;
} // JLuaServer::FnSetParent
Example #10
0
int JLuaServer::FnChildren( lua_State* pLua )
{
    if (lua_gettop( pLua ) != 1)
    {
        rlog.err( "LUA: Incorrect command usage: <children>. "
            "Function takes 1 argument (<objectRef>|<objectName>), but %d is provided", lua_gettop( pLua ) );
        lua_settop( pLua, 0 );
        lua_pushnil( pLua );
        return 1;
    }

    JObject* pObj = NULL;
    const char* pPath = lua_tostring( pLua, -1 );
    if (pPath)
    {
        JLuaThread* pThread = reinterpret_cast<JLuaThread*>( pLua->userdata );
        assert( pThread->m_pLua == pLua );
        JObject* pRootObj = pThread->m_pRootObj;
        pObj = g_pObjectServer->FindObject( pPath, NULL, pRootObj );
    }
    else
    {
        pObj = reinterpret_cast<JObject*>( lua_touserdata( pLua, -1 ) );
    }

    if (!pObj)
    {
        lua_pushnil( pLua );
        return 1;
    }
    
    //  return table with children
    int nCh = pObj->GetNChildren();
    lua_createtable( pLua, nCh, 0 );
    lua_newtable( pLua );
    for (int i = 0; i < nCh; i++)
    {   
        //  key
        lua_pushnumber( pLua, i + 1 ); 
        //  value (child pointer)
        lua_pushlightuserdata( pLua, pObj->GetChild( i ) );
        lua_settable( pLua, -3 );
    }
    return 1;
} // JLuaServer::FnChildren
Example #11
0
void JObject::SetProperty(const char* name, const JObject& val) {
  IOTJS_ASSERT(IsObject());
  JRawValueType v = val.raw_value();
  bool is_ok  = jerry_api_set_object_field_value(
      _obj_val.v_object,
      reinterpret_cast<const jerry_api_char_t*>(name),
      &v);
  IOTJS_ASSERT(is_ok);
}
Example #12
0
int JThread::compareTo(const JObject& s) const {

  if (className() != s.className()) 

    return JObject::compareTo(s);

  return id-((JThread*)&s)->id;

}
Example #13
0
JObject MakeStatObject(uv_stat_t* statbuf) {
  Module* module = GetBuiltinModule(MODULE_FS);
  IOTJS_ASSERT(module != NULL);

  JObject* fs = module->module;
  IOTJS_ASSERT(fs != NULL);

  JObject createStat = fs->GetProperty("_createStat");
  IOTJS_ASSERT(createStat.IsFunction());

  JObject jstat;

#define X(statobj, name) \
  JObject name((int32_t)statbuf->st_##name); \
  statobj.SetProperty(#name, name); \

  X(jstat, dev)
  X(jstat, mode)
  X(jstat, nlink)
  X(jstat, uid)
  X(jstat, gid)
  X(jstat, rdev)

#undef X

#define X(statobj, name) \
  JObject name((double)statbuf->st_##name); \
  statobj.SetProperty(#name, name); \

  X(jstat, blksize)
  X(jstat, ino)
  X(jstat, size)
  X(jstat, blocks)

#undef X

  JArgList jargs(1);
  jargs.Add(jstat);

  JResult jstat_res(createStat.Call(JObject::Null(), jargs));
  IOTJS_ASSERT(jstat_res.IsOk());

  return jstat_res.value();
}
Example #14
0
static void After(uv_fs_t* req) {
  FsReqWrap* req_wrap = static_cast<FsReqWrap*>(req->data);
  IOTJS_ASSERT(req_wrap != NULL);
  IOTJS_ASSERT(req_wrap->data() == req);

  JObject cb = req_wrap->jcallback();
  IOTJS_ASSERT(cb.IsFunction());

  JArgList jarg(2);
  if (req->result < 0) {
    JObject jerror(CreateUVException(req->result, "open"));
    jarg.Add(jerror);
  } else {
    jarg.Add(JObject::Null());
    switch (req->fs_type) {
      case UV_FS_CLOSE:
      {
        break;
      }
      case UV_FS_OPEN:
      case UV_FS_READ:
      case UV_FS_WRITE:
      {
        JObject arg1(static_cast<int>(req->result));
        jarg.Add(arg1);
        break;
      }
      case UV_FS_STAT: {
        uv_stat_t s = (req->statbuf);
        JObject ret(MakeStatObject(&s));
        jarg.Add(ret);
        break;
      }
      default:
        jarg.Add(JObject::Null());
    }
  }

  JObject res = MakeCallback(cb, JObject::Null(), jarg);

  uv_fs_req_cleanup(req);

  delete req_wrap;
}
Example #15
0
int JFont::compareTo(const JObject& s) const {
  if (className() != s.className())
    return JObject::compareTo(s);
  JFont &obj = *(JFont*)&s;
  int result = name.compareTo(obj.name);
  if (!result) {
    result = style-obj.style;
    if (!result) result = size-obj.size;
  }
  return result;
}
Example #16
0
// Connection request result handler.
static void AfterConnect(uv_connect_t* req, int status) {
  ConnectReqWrap* req_wrap = reinterpret_cast<ConnectReqWrap*>(req->data);
  TcpWrap* tcp_wrap = reinterpret_cast<TcpWrap*>(req->handle->data);
  IOTJS_ASSERT(req_wrap != NULL);
  IOTJS_ASSERT(tcp_wrap != NULL);

  // Take callback function object.
  //  function afterConnect(status)
  JObject jcallback = req_wrap->jcallback();
  IOTJS_ASSERT(jcallback.IsFunction());

  // Only parameter is status code.
  JArgList args(1);
  args.Add(JVal::Number(status));

  // Make callback.
  MakeCallback(jcallback, JObject::Null(), args);

  // Release request wrapper.
  delete req_wrap;
}
Example #17
0
static bool StartIoTjs(Environment* env) {
  // Get jerry global object.
  JObject global = JObject::Global();

  // Bind environment to global object.
  global.SetNative((uintptr_t)(env), NULL);

  // Initialize builtin modules.
  JObject* process = InitModules();

  // Call the entry.
  // load and call iotjs.js
  env->GoStateRunningMain();

  RunIoTjs(process);

  // Run event loop.
  env->GoStateRunningLoop();

  bool more;
  do {
    more = uv_run(env->loop(), UV_RUN_ONCE);
    more |= ProcessNextTick();
    if (more == false) {
      more = uv_loop_alive(env->loop());
    }
  } while (more);

  env->GoStateExiting();

  // Emit 'exit' event.
  ProcessEmitExit(0);

  // Release bulitin modules.
  CleanupModules();

  return true;
}
Example #18
0
int JInsets::compareTo(const JObject& s) const {
  if (className() != s.className())
    return JObject::compareTo(s);
  JInsets &obj = *(JInsets*)&s;
  int result = top-obj.top;
  if (!result) {
    result = bottom-obj.bottom;
    if (!result) {
      result = left-obj.left;
      if (!result) result = right-obj.right;
    }
  }
  return result;
}
Example #19
0
void JObjectTree::Traverse( TraverseCallback callback, void* pContext ) const
{
    if (!m_pRoot) return;
    float nodeW    = m_NodeWidth;
    float nodeVisH = m_NodeHeight;
    Frame ext( m_RootPos.x, m_RootPos.y, nodeW, nodeVisH );

    //  find node path for tree expansion
    static std::vector<int> nodePath;
    nodePath.clear();
    JObject* pCurObj = m_pExpanded;
    if (pCurObj) nodePath.push_back( 0 );
    while (pCurObj && pCurObj != m_pRoot)
    {
        JObject* pParent = pCurObj->GetParent();
        if (!pParent) break;
        nodePath.push_back( pParent->GetChildIndex( pCurObj ) );
        pCurObj = pParent;
    }

    //  traverse root node (which is never collapsed)
    if ((this->*callback)( ext, m_pRoot, (m_pExpanded != NULL), pContext ) == false) return;

    //  traverse along expansion path
    pCurObj = m_pRoot;
    for (int i = nodePath.size() - 1; i >= 0; i--)
    {
        int childIdx = nodePath[i];
        if (!pCurObj) break;
        int nCh = pCurObj->GetNChildren();
        if (childIdx >= nCh) break;
        float blockH = float( nCh )*nodeVisH;
        ext.y = ext.y - blockH*0.5f + nodeVisH*0.5f;
        ext.x += nodeW;
        float cY = ext.y;
        for (int j = 0; j < nCh; j++)
        {
            JObject* pChild = pCurObj->GetChild( j );
            Frame chExt( ext );
            chExt.y = cY;
            bool bExpanded = (j == childIdx)&&(pCurObj != m_pExpanded);
            if ((this->*callback)( chExt, pChild, bExpanded, pContext ) == false)
            {
                return;
            }
            cY += nodeVisH;
        }
        pCurObj = pCurObj->GetChild( childIdx );
        ext.y += float( childIdx )*nodeVisH;
    }

} // JObjectTree::Traverse
Example #20
0
int JLuaServer::FnDelete( lua_State* pLua )
{
    if (lua_gettop( pLua ) != 1)
    {
        rlog.err( "LUA: Incorrect command usage: <delete>. "
            "Function takes 1 object ref argument, but %d is provided", lua_gettop( pLua ) );
        lua_settop( pLua, 0 );
        lua_pushnil( pLua );
        return 1;
    }
    
    //  TODO: make this casting safe
    JObject* pObj = reinterpret_cast<JObject*>( lua_touserdata( pLua, -1 ) );
    if (!pObj)
    {
        return 0;
    }
    
    //  delete object
    pObj->Release();

    lua_settop( pLua, 0 );
    return 0;
} // JLuaServer::FnDelete
Example #21
0
int JDList::compareTo(const JObject& s) const {
  if (className() != s.className()) 
    return JObject::compareTo(s);
  JDList &a = *(JDList*)&s;
  if (hnd == a.hnd) return 0;
  if (size() != a.size()) return size()-a.size();
  JDCell* c = CELL(hnd);
  JDCell* d = CELL(a.hnd);
  do {
    if (*c->obj != *d->obj) 
      return (c->obj)->compareTo(*d->obj);
    c = c->next;
    d = d->next;
  } while ((int)c != hnd);
  return 0;
}
Example #22
0
void OnRead(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf) {
  TcpWrap* tcp_wrap = reinterpret_cast<TcpWrap*>(handle->data);
  IOTJS_ASSERT(tcp_wrap != NULL);

  // tcp handle
  JObject jtcp = tcp_wrap->jobject();
  IOTJS_ASSERT(jtcp.IsObject());

  // socket object
  JObject jsocket = jtcp.GetProperty("owner");
  IOTJS_ASSERT(jsocket.IsObject());

  // onread callback
  JObject jonread = jtcp.GetProperty("onread");
  IOTJS_ASSERT(jonread.IsFunction());

  JArgList jargs(4);
  jargs.Add(jsocket);
  jargs.Add(JVal::Number((int)nread));
  jargs.Add(JVal::Bool(false));

  if (nread <= 0) {
    if (buf->base != NULL) {
      ReleaseBuffer(buf->base);
    }
    if (nread < 0) {
      if (nread == UV__EOF) {
        jargs.Set(2, JVal::Bool(true));
      }
      MakeCallback(jonread, JObject::Null(), jargs);
    }
    return;
  }

  JObject jbuffer(CreateBuffer(static_cast<size_t>(nread)));
  BufferWrap* buffer_wrap = BufferWrap::FromJBuffer(jbuffer);

  buffer_wrap->Copy(buf->base, nread);

  jargs.Add(jbuffer);
  MakeCallback(jonread, JObject::Null(), jargs);

  ReleaseBuffer(buf->base);
}
Example #23
0
bool JObjectTree::DeleteNode()
{
    if (!m_pSelected) return false;
    JObject* pParent = m_pSelected->GetParent();
    if (!pParent) return false;

    int idx = pParent->GetChildIndex( m_pSelected );
    pParent->RemoveChild( m_pSelected );
    if (idx >= pParent->GetNChildren()) idx = pParent->GetNChildren() - 1;
    if (idx < 0) idx = 0;
    m_pSelected = pParent->GetChild( idx );
    if (!m_pSelected) m_pSelected = pParent;
    m_pExpanded = m_pSelected;
    return true;
} // JObjectTree::DeleteNode
Example #24
0
std::string Proto::build_request(
                     int clientno, int serverno,
                     int messageid, long timestamp,
                     size_t method_hash, OutSerializer& sout) {
  JObject* obj = new JObject();
  obj->put(ClientNo, clientno);
  obj->put(ServerNo, serverno);
  obj->put(Version, 1);
  obj->put(Timestamp, timestamp);
  obj->put(MessageId, messageid);
  obj->put(Method, method_hash);
  obj->put(Param, sout.getContent());

  std::string msg = dumps(obj);
  delete obj;
  return msg;
}
Example #25
0
JObject* InitBuffer() {
  Module* module = GetBuiltinModule(MODULE_BUFFER);
  JObject* buffer = module->module;

  if (buffer == NULL) {
    buffer = new JObject(Buffer);

    JObject prototype;
    buffer->SetProperty("prototype", prototype);

    prototype.SetMethod("compare", Compare);
    prototype.SetMethod("copy", Copy);
    prototype.SetMethod("write", Write);
    prototype.SetMethod("slice", Slice);
    prototype.SetMethod("toString", ToString);

    module->module = buffer;
  }

  return buffer;
}
Example #26
0
// A client socket wants to connect to this server.
// Parameters:
//   * uv_stream_t* handle - server handle
//   * int status - status code
static void OnConnection(uv_stream_t* handle, int status) {
  // Server tcp wrapper.
  TcpWrap* tcp_wrap = reinterpret_cast<TcpWrap*>(handle->data);
  IOTJS_ASSERT(tcp_wrap->tcp_handle() == reinterpret_cast<uv_tcp_t*>(handle));

  // Tcp object
  JObject jtcp = tcp_wrap->jobject();
  IOTJS_ASSERT(jtcp.IsObject());

  // `onconnection` callback.
  JObject jonconnection = jtcp.GetProperty("onconnection");
  IOTJS_ASSERT(jonconnection.IsFunction());

  // The callback takes two parameter
  // [0] status
  // [1] client tcp object
  JArgList args(2);
  args.Add(JVal::Number(status));

  if (status == 0) {
    // Create client socket handle wrapper.
    JObject jcreate_tcp = jtcp.GetProperty("createTCP");
    IOTJS_ASSERT(jcreate_tcp.IsFunction());

    JObject jclient_tcp = jcreate_tcp.CallOk(JObject::Null(),
                                             JArgList::Empty());
    IOTJS_ASSERT(jclient_tcp.IsObject());

    TcpWrap* tcp_wrap = reinterpret_cast<TcpWrap*>(jclient_tcp.GetNative());

    uv_stream_t* client_handle =
        reinterpret_cast<uv_stream_t*>(tcp_wrap->tcp_handle());

    int err = uv_accept(handle, client_handle);
    if (err) {
      return;
    }

    args.Add(jclient_tcp);
  }

  MakeCallback(jonconnection, jtcp, args);
}
Example #27
0
void JBoundsEditor::ClearEditors()
{
    JObject* pEditors = GetEditorsGroup();
    pEditors->RemoveChildren();
    m_Edited.clear();
}
Example #28
0
void JBoundsEditor::CreateEditor( JObject* pEdited )
{
    JObject* pTemplates = g_pObjectServer->FindObject( "templates", this );
    JObject* pEditors = GetEditorsGroup();
    if (pTemplates == NULL || pEditors == NULL)
    {
        return;
    }
    int nTemplates = pTemplates->GetNChildren();
    JString editorName;
    for (int i = 0; i < nTemplates; i++)
    {
        JWidget* pTemplate = obj_cast<JWidget>( pTemplates->GetChild( i ) );
        if (pTemplate && is_a( pEdited, pTemplate->GetName() ))
        {
            //  this object can be edited with this editor template
            editorName = pEdited->GetName();
            editorName += "_";
            editorName += pTemplate->GetName();
            editorName += "_editor";
            JObject* pEditor = pTemplate->Clone( pEditors, editorName.c_str(), true );

            pEditors->AddChild( pEditor );

            JBoundsEditContext ctx;
            ctx.m_pEdited = pEdited;
            ctx.m_pEditor = pEditor;
            pEdited->GetPath( ctx.m_Path );
            m_Edited.push_back( ctx );

            //  parse property connections from text field
            JString propcfg( pTemplate->GetText() );
            char* propConfig = (char*)propcfg.c_str();
            while (propConfig && *propConfig != 0)
            {
                char* editedVal = propConfig;
                char* editorVal = propConfig + strcspn( propConfig, "<|" );
                char& ch = *editorVal;

                if (ch == '|')
                {
                    ch = 0;
                    editorVal = "value";
                }
                else if (ch == '<')
                {
                    *editorVal = 0;
                    editorVal++;
                    propConfig = editorVal + strcspn( editorVal, "|" );
                    if (*propConfig == '|')
                    {
                        *propConfig = 0;
                        propConfig++;
                    }
                }
                else if (ch == 0)
                {
                    propConfig = 0;
                    editorVal = "value";
                }

                g_pSignalServer->Connect( pEditor, editorVal, pEdited, editedVal );
                g_pSignalServer->Connect( pEdited, editedVal, pEditor, editorVal );
                pEdited->SendSignal( editedVal );

                g_pSignalServer->Connect( pEdited, "visible", pEditor, "visible" );
                pEdited->SendSignal( "visible" );
            }
        }
    }
}
Example #29
0
void JHandlerInfo::Return(JObject& ret) {
  ret.Ref();
  *_ret_val_p = ret.raw_value();
}
Example #30
0
void JavaUpload::globalInit()
{
	if (!JVM::JVMAvailable())
		return;
	
	// locate Java plugins
	try
	{
		JUploadPlugin::registerNatives();

		JClass helper("info.dolezel.fatrat.plugins.helpers.NativeHelpers");
		JClass annotation("info.dolezel.fatrat.plugins.annotations.UploadPluginInfo");
		JClass annConfigDialog("info.dolezel.fatrat.plugins.annotations.ConfigDialog");
		QList<QVariant> args;

		args << "info.dolezel.fatrat.plugins" << annotation.toVariant();

		JArray arr = helper.callStatic("findAnnotatedClasses",
						  JSignature().addString().add("java.lang.Class").retA("java.lang.Class"),
						  args).value<JArray>();
		qDebug() << "Found" << arr.size() << "annotated classes (UploadPluginInfo)";

		int classes = arr.size();
		for (int i = 0; i < classes; i++)
		{
			try
			{
				JClass obj = (jobject) arr.getObject(i);
				JObject ann = obj.getAnnotation(annotation);
				QString name = ann.call("name", JSignature().retString()).toString();
				QString clsName = obj.getClassName();
				JObject instance(obj, JSignature());

				qDebug() << "Class name:" << clsName;
				qDebug() << "Name:" << name;

				JObject cfgDlg = obj.getAnnotation(annConfigDialog);

				JavaEngine e = { "EXT - " + name.toStdString(), clsName.toStdString() };

				if (!cfgDlg.isNull())
					e.configDialog = cfgDlg.call("value", JSignature().retString()).toString();

				if (instance.instanceOf("info.dolezel.fatrat.plugins.extra.URLAcceptableFilter"))
					e.ownAcceptable = instance;
				if (instance.instanceOf("info.dolezel.fatrat.plugins.listeners.ConfigListener"))
					g_configListeners << instance;
				m_engines[clsName] = e;

				qDebug() << "createInstance of " << clsName;

				EngineEntry entry;
				entry.longName = m_engines[clsName].name.c_str();
				entry.shortName = m_engines[clsName].shortName.c_str();
				entry.lpfnAcceptable2 = JavaUpload::acceptable;
				entry.lpfnCreate2 = JavaUpload::createInstance;
				entry.lpfnInit = 0;
				entry.lpfnExit = 0;
				entry.lpfnMultiOptions = 0;

				addTransferClass(entry, Transfer::Upload);
			}
			catch (const RuntimeException& e)
			{
				qDebug() << e.what();
			}
		}
	}
	catch (const RuntimeException& e)
	{
		qDebug() << e.what();
	}
}