capplication.cpp

Gambas is a graphical development environment based on a Basic interpreter, like Visual Basic. It us

  #endif

  /* Conversion & Marshalling */

  QDataStream d(data, IO_WriteOnly);

  for (i = 0; i < n; i++)
  {
    arg = &args[i];
    type = func->args[i];

    if (type < 0)
    {
      GB.Error("Cannot handle datatype");
      return true;
    }
    
    gtype = type_conv[type].type;

    if (gtype < GB_T_OBJECT)
      ret = GB.Conv(arg, gtype);
    else
    {
      ret = GB.Conv(arg, (GB_TYPE)GB.FindClass((const char *)gtype));
      if (!ret)
      {
        ob = GET_OBJECT(arg, void);
        ret = GB.CheckObject(ob);
      }
    }

    if (ret)
      return true;

    if (type == QT_T_INT)
      d << (int)((GB_INTEGER *)arg)->value;
    else if (type == QT_T_UNSIGNED || type == QT_T_UINT)
      d << (unsigned int)((GB_INTEGER *)arg)->value;
    else if (type == QT_T_LONG)
      d << (long)((GB_INTEGER *)arg)->value;
    else if (type == QT_T_ULONG)
      d << (unsigned long)((GB_INTEGER *)arg)->value;
    else if (type == QT_T_FLOAT)
      d << (float)((GB_FLOAT *)arg)->value;
    else if (type == QT_T_DOUBLE)
      d << (double)((GB_FLOAT *)arg)->value;
    else if (type == QT_T_BOOL)
      d << (bool)((GB_BOOLEAN *)arg)->value;
    else if (type == QT_T_QCSTRING)
      d << QCString(GET_STRING(arg));
    else if (type == QT_T_QSTRING)
      d << GET_STRING(arg);
    else if (type == QT_T_QCSTRINGLIST)
    {
      GB_ARRAY a = (GB_ARRAY)ob;
      QCStringList list;
      char *val;
      
      for (j = 0; j < GB.Array.Count(a); j++)
      {
        val = *((char **)GB.Array.Get(a, j));
        list.append(QCString(TO_QSTRING(val)));
      }
      
      d << list;
    }      
    else if (type == QT_T_QSTRINGLIST)
    {
      GB_ARRAY a = (GB_ARRAY)ob;
      QStringList list;
      char *val;
      
      for (j = 0; j < GB.Array.Count(a); j++)
      {
        val = *((char **)GB.Array.Get(a, j));
        list.append(TO_QSTRING(val));
      }
      
      d << list;
    }      
    else if (type == QT_T_KURL)
      d << KURL(GET_STRING(arg));
    else if (type == QT_T_KURL_LIST)
    {
      GB_ARRAY a = (GB_ARRAY)ob;
      KURL::List list;
      char *url;
      
      for (j = 0; j < GB.Array.Count(a); j++)
      {
        url = *((char **)GB.Array.Get(a, j));
        list.append(KURL(TO_QSTRING(url)));
      }
      
      d << list;
    }      
    else if (type == QT_T_QPIXMAP)
      d << *(GET_OBJECT(arg, CPICTURE)->pixmap);
    else if (type == QT_T_QIMAGE)
      d << *(GET_OBJECT(arg, CIMAGE)->image);
    else if (type == QT_T_QCURSOR)
      d << *(GET_OBJECT(arg, CCURSOR)->cursor);
    else if (type == QT_T_QPOINT)
    {
      GB_ARRAY a = (GB_ARRAY)ob;
      
      if (GB.Array.Count(a) != 2)
      {
        GB.Error("Cannot convert datatype");
        return true;
      }
      
      QPoint p(*((int *)GB.Array.Get(a, 0)), *((int *)GB.Array.Get(a, 1)));
      d << p;
    }
    else if (type == QT_T_QSIZE)
    {
      GB_ARRAY a = (GB_ARRAY)ob;
      
      if (GB.Array.Count(a) != 2)
      {
        GB.Error("Cannot convert datatype");
        return true;
      }
      
      QSize s(*((int *)GB.Array.Get(a, 0)), *((int *)GB.Array.Get(a, 1)));
      d << s;
    }
    else if (type == QT_T_QRECT)
    {
      GB_ARRAY a = (GB_ARRAY)ob;
      
      if (GB.Array.Count(a) != 4)
      {
        GB.Error("Cannot convert datatype");
        return true;
      }
      
      QRect r(*((int *)GB.Array.Get(a, 0)), *((int *)GB.Array.Get(a, 1)), *((int *)GB.Array.Get(a, 2)), *((int *)GB.Array.Get(a, 3)));
      d << r;
    }
    else if (type == QT_T_QFONT)
    {
      d << *(GET_OBJECT(arg, CFONT)->font);
    }
  }

  QCString cname(THIS->name);
  QCString cobject(object);
  QCString ctype;

  ok = kapp->dcopClient()->call
    (
     cname,
     cobject,
     func->dcopName,
     data,
     ctype,
     replyData
    );

  if (!ok)
  {
    if (kapp->dcopClient()->isApplicationRegistered(THIS->name))
      GB.Error("DCOP call failed");
    else
      GB.Error("Application is not registered anymore");

    return true;
  }

  /* Demarshalling */

  type = get_type(ctype);

  if (type == QT_T_VOID || type == QT_T_ASYNC)
    return false;

  QDataStream reply(replyData, IO_ReadOnly);

  if (type == QT_T_QVARIANT)
  {
    Q_INT32 vt;
    QString vtn;
    reply >> vt;
    vtn = QVariant::typeToName((QVariant::Type)vt);
    type = get_type(vtn.latin1());
  }

  if (type == QT_T_INT)
  {
    int i;
    reply >> i;
    GB.ReturnInteger(i);
  }
  else if (type == QT_T_UINT)
  {
    uint i;
    reply >> i;
    GB.ReturnInteger(i);
  }
  else if (type == QT_T_LONG)
  {
    long l;
    reply >> l;
    GB.ReturnInteger(l);
  }
  else if (type == QT_T_ULONG)
  {
    ulong l;
    reply >> l;
    GB.ReturnInteger((long)l);
  }
  else if (type == QT_T_FLOAT)
  {
    float f;
    reply >> f;
    GB.ReturnFloat(f);
  }
  else if (type == QT_T_DOUBLE)
  {
    double d;
    reply >> d;
    GB.ReturnFloat(d);
  }
  else if (type == QT_T_BOOL)
  {
    bool b;
    reply >> b;
    GB.ReturnBoolean(b ? 1 : 0);
  }
  else if (type == QT_T_QSTRING)
  {
    QString s;
    reply >> s;
    GB.ReturnNewZeroString(s);
  }
  else if (type == QT_T_QCSTRING)
  {
    QCString r;
    reply >> r;
    GB.ReturnNewZeroString(r);
  }
  else if (type == QT_T_KURL)
  {
    KURL r;
    reply >> r;
    GB.ReturnNewZeroString(r.prettyURL());
  }
  else if (type == QT_T_QCOLOR)
  {
    QColor r;
    reply >> r;
    GB.ReturnInteger(r.rgb() & 0xFFFFFF);
  }
  else if (type == QT_T_QSTRINGLIST)
  {
    GB_ARRAY array;
    QStringList r;
    reply >> r;

    n = r.count();

    GB.Array.New(&array, GB_T_STRING, n);
    for (i = 0; i < n; i++)
      GB.NewString((char **)GB.Array.Get(array, i), r[i].latin1(), 0);

    GB.ReturnObject(array);
  }
  else if (type == QT_T_QCSTRINGLIST)
  {
    GB_ARRAY array;
    QCStringList r;
    reply >> r;

    n = r.count();

    GB.Array.New(&array, GB_T_STRING, n);

    for (i = 0; i < n; i++)
      GB.NewString((char **)GB.Array.Get(array, i), (const char *)r[i], 0);

    GB.ReturnObject(array);
  }
  else if (type == QT_T_DCOPREF)
  {
    DCOPRef r;
    reply >> r;
    GB.ReturnObject(make_dcopref(r));
  }
  else if (type == QT_T_QVALUELIST_DCOPREF)
  {
    GB_ARRAY array;
    QValueList<DCOPRef> r;
    reply >> r;
    CDCOPREF *ref;

    n = r.count();

    GB.Array.New(&array, GB_T_OBJECT, n);

    for (i = 0; i < n; i++)
    {
      ref = make_dcopref(r[i]);
      GB.Ref(ref);
      *((CDCOPREF **)GB.Array.Get(array, i)) = ref;
    }

    GB.ReturnObject(array);
  }
  else if (type == QT_T_QPOINT)
  {
    GB_ARRAY array;
    QPoint r;
    reply >> r;
  
    GB.Array.New(&array, GB_T_INTEGER, 2);

    *((int *)GB.Array.Get(array, 0)) = r.x();
    *((int *)GB.Array.Get(array, 1)) = r.y();
    
    GB.ReturnObject(array);
  }
  else if (type == QT_T_QSIZE)
  {
    GB_ARRAY array;
    QSize r;
    reply >> r;
  
    GB.Array.New(&array, GB_T_INTEGER, 2);

    *((int *)GB.Array.Get(array, 0)) = r.width();
    *((int *)GB.Array.Get(array, 1)) = r.height();
    
    GB.ReturnObject(array);
  }
  else if (type == QT_T_QRECT)
  {
    GB_ARRAY array;
    QRect r;
    reply >> r;
  
    GB.Array.New(&array, GB_T_INTEGER, 4);

    *((int *)GB.Array.Get(array, 0)) = r.x();
    *((int *)GB.Array.Get(array, 1)) = r.y();
    *((int *)GB.Array.Get(array, 2)) = r.width();
    *((int *)GB.Array.Get(array, 3)) = r.height();
    
    GB.ReturnObject(array);
  }
  else
    GB.ReturnNull();

  return false;
}


BEGIN_METHOD(CAPPLICATION_unknown, GB_VALUE param[0])

  if (GB.IsProperty())
  {
    if (call_method(THIS, NULL, GB.GetUnknown(), NULL, 0, false))
      get_object(THIS, GB.GetUnknown());
  }
  else
  {
    call_method(THIS, THIS->object, GB.GetUnknown(), ARG(param[0]), GB.NParam(), true);
    GB.FreeString(&THIS->object);
  }

END_METHOD


#undef THIS
#define THIS ((CDCOPREF *)_object)

BEGIN_METHOD_VOID(CDCOPREF_free)

  delete THIS->ref;
  THIS->ref = 0;

  //qDebug("Delete DCOPREF %p", _object);

END_METHOD


BEGIN_METHOD(CDCOPREF_unknown, GB_VALUE param[0])

  CAPPLICATION *app;
  DCOPRef *ref = THIS->ref;

  //qDebug("Calling DCOPREF %p", _object);

  app = get_application(ref->app());

  call_method(app, ref->object(), GB.GetUnknown(), ARG(param[0]), GB.NParam(), true);

END_METHOD


BEGIN_PROPERTY(CDCOPREF_name)

  GB.ReturnNewZeroString(THIS->ref->object());

END_PROPERTY


BEGIN_PROPERTY(CDCOPREF_application)

  GB.ReturnObject(get_application(THIS->ref->app()));

END_PROPERTY


GB_DESC CKDEObjectDesc[] =
{
  GB_DECLARE(".KDEObject", 0), GB_VIRTUAL_CLASS(),

  GB_METHOD("_unknown", "v", CAPPLICATION_unknown, "."),

  GB_END_DECLARE
};


GB_DESC CKDEDCOPRefDesc[] =
{
  GB_DECLARE("DCOPRef", sizeof(CDCOPREF)), GB_NOT_CREATABLE(),

  GB_METHOD("_free", NULL, CDCOPREF_free, NULL),
  GB_METHOD("_unknown", "v", CDCOPREF_unknown, "."),

  GB_PROPERTY_READ("Name", "s", CDCOPREF_name),
  GB_PROPERTY_READ("Application", "KDEApplication", CDCOPREF_application),

  GB_END_DECLARE
};


GB_DESC CKDEApplicationDesc[] =
{
  GB_DECLARE("KDEApplication", sizeof(CAPPLICATION)),
  GB_NOT_CREATABLE(),

  GB_STATIC_METHOD("_exit", NULL, CAPPLICATION_exit, NULL),

  GB_METHOD("_free", NULL, CAPPLICATION_free, NULL),

  GB_PROPERTY_READ("Name", "s", CAPPLICATION_name),

  GB_METHOD("_get", ".KDEObject", CAPPLICATION_get_object, "(Object)s"),
  GB_METHOD("_unknown", "v", CAPPLICATION_unknown, "."),

  GB_END_DECLARE
};


GB_DESC CApplicationDesc[] =
{
  GB_DECLARE("Application", 0), GB_VIRTUAL_CLASS(),

  GB_STATIC_METHOD("_get", "KDEApplication", CAPPLICATION_get, "(Name)s"),
  //GB_STATIC_METHOD("_next", "KDEApplication", CAPPLICATION_next, NULL),

  //GB_STATIC_PROPERTY("Title", "s", CDIALOG_title),

  GB_END_DECLARE
};