Ejemplo n.º 1
0
void StocksDialog::createFundamentalsPage ()
{
    QWidget *w = new QWidget(this);

    Q3VBoxLayout *vbox = new Q3VBoxLayout(w);
    vbox->setMargin(5);
    vbox->setSpacing(5);

    Setting fund;
    QString s, s2;
    index->getFundamentals(symbol, s2);
    fund.parse(s2);

    s = tr("Fundamentals: last updated ");
    s2 = "updateDate";
    QString s3;
    fund.getData(s2, s3);
    s.append(s3);
    fund.remove(s2);
    QStringList key;
    fund.getKeyList(key);
    key.sort();

    vbox->addSpacing(10);
    QLabel *label = new QLabel(s, w);
    vbox->addWidget(label);

    fundView = new Q3ListView(w);
    fundView->addColumn(tr("Description"));
    fundView->addColumn(tr("Value"));
    vbox->addWidget(fundView);

    int loop;
    for (loop = 0; loop < (int) key.count(); loop++)
    {
        fund.getData(key[loop], s);
        new Q3ListViewItem(fundView, key[loop], s);
    }

    if (! key.count())
        new Q3ListViewItem(fundView, tr("No data available."));

    addTab(w, tr("Fundamentals"));
}
Ejemplo n.º 2
0
bool AVConfig::Init()
{
	int video_device = NULL;
	const char *device_name;
	struct stat st;

	//check if there're essential settings
	if(!getRoot()->exists("audio"))
		getRoot()->add("audio", Setting::TypeGroup);
	if(!getRoot()->exists("video"))
		getRoot()->add("video", Setting::TypeGroup);

	//open video device
	if(!getVideoSettings()->exists("device"))
		getVideoSettings()->add("device", Setting::TypeString) = "/dev/video0";
	device_name = (*getVideoSettings())["device"];
	if(-1 == stat(device_name, &st))
	{
		log_message(1, "AVConfig: Cannot identify '%s': %d, %s.", device_name, errno, strerror (errno));
		return false;
	}
	if(!S_ISCHR(st.st_mode))
	{
		log_message(1, "AVConfig: %s is no device.", device_name);
		return false;
	}

	video_device = open(device_name, O_RDWR | O_NONBLOCK, 0);
	if(-1 == video_device)
	{
		log_message(1, "AVConfig: Cannot open '%s': %d, %s.", device_name, errno, strerror (errno));
		exit (EXIT_FAILURE);
	}


	//determine video device capabilities
	v4l2_capability cap;
	if(-1 == xioctl(video_device, VIDIOC_QUERYCAP, &cap))
	{
		if (EINVAL == errno)
		{
			log_message(1, "AVConfig: %s is no V4L2 device.", device_name);
			exit(1);
		}
		else log_message(1, "AVConfig: VIDIOC_QUERYCAP: %d, %s.", errno, strerror(errno));
	}
	if(!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE))
	{
		log_message(1, "AVConfig: %s is no video capture device.", device_name);
		exit(1);
	}
	if(cap.capabilities & V4L2_CAP_READWRITE)
		log_message(0, "AVConfig: %s supports read i/o.", device_name);
	if(cap.capabilities & V4L2_CAP_STREAMING)
		log_message(0, "AVConfig: %s supports streaming i/o.", device_name);


	//enumerate inputs
	vector<v4l2_input> input_list;
	v4l2_input input;
	int current_input;
	CLEAR(input);
	input.index = 0;
	while(-1 != xioctl(video_device, VIDIOC_ENUMINPUT, &input))
	{
		input_list.push_back(input);
		log_message(0, "AVConfig: Input [%d -- %s] is found.", input.index, input.name);
		input.index++;
	}
	if(-1 == xioctl(video_device, VIDIOC_G_INPUT, &current_input))
	{
		log_errno("AVConfig: VIDIOC_G_INPUT");
		exit(1);
	}
	log_message(0, "AVConfig: Currently selected input is: %d -- %s.", current_input, input_list[current_input].name);


	//enumerate standards if applied
	vector<v4l2_standard> standard_list;
	v4l2_standard standard;
	v4l2_std_id current_standard;
	CLEAR(standard);
	standard.index = 0;
	if(-1 != xioctl(video_device, VIDIOC_G_STD, &current_standard))
	{
        while(0 == xioctl(video_device, VIDIOC_ENUMSTD, &standard))
        {
            if(standard.id & input_list[current_input].std)
            {
                standard_list.push_back(standard);
                log_message(0, "AVConfig: Standard %s is supported by current input.", standard.name);
                log_message(0, "AVConfig: The framerate defined by this standard is: %d", standard.frameperiod.denominator/standard.frameperiod.numerator);
                if(standard.id == current_standard)
                    log_message(0, "AVConfig: Standard %s is currently selected on input.", standard.name);
            }
            standard.index++;
        }
        if(errno != EINVAL || standard.index == 0)
        {
            log_errno("AVConfig: VIDIOC_ENUMSTD");
            return false;
        }
	}

	//enumerate controls
	vector<v4l2_queryctrl> queryctrl_list;
	vector<v4l2_control> control_list;
	map<unsigned long, vector<v4l2_querymenu> > querymenu_list;
	v4l2_queryctrl queryctrl;
	v4l2_control control;
	CLEAR(queryctrl);
	CLEAR(control);
	log_message(0, "AVConfig: Quering standard controls");
	queryctrl.id = V4L2_CID_BASE;
	while(queryctrl.id < V4L2_CID_LASTP1)
	{
	    queryctrl.id |= V4L2_CTRL_FLAG_NEXT_CTRL;
	    control.id    = queryctrl.id;
	    int res = query_control(video_device, &queryctrl, &control,
	                            queryctrl_list, control_list, querymenu_list);
        if(-1 == res)
        {
            log_errno("AVConfig: unable to query device control");
            return false;
        }
        else if(0 == res) break;
	}
	log_message(0, "AVConfig: Quering driver specific controls");
	queryctrl.id = V4L2_CID_PRIVATE_BASE;
    while(true)
    {
        queryctrl.id |= V4L2_CTRL_FLAG_NEXT_CTRL;
        control.id    = queryctrl.id;
        int res = query_control(video_device, &queryctrl, &control,
                                queryctrl_list, control_list, querymenu_list);
        if(-1 == res)
        {
            log_errno("AVConfig: unable to query device control");
            return false;
        }
        else if(0 == res) break;
    }

	//close the device
	close(video_device);

	//construct inputs setting
	Setting *video = getVideoSettings();

	try{ video->remove("input"); } catch(...){}
	video->add("input", Setting::TypeInt) = current_input;

	try{ video->remove("inputs"); } catch(...){}
	Setting &inputs = video->add("inputs", Setting::TypeGroup);
	for(int i = 0; i < input_list.size(); i++)
		inputs.add(fix_str(input_list[i].name), Setting::TypeInt) = i;

    //construct standarts setting
	try{ video->remove("standard"); } catch(...){}
	try{ video->remove("standards"); } catch(...){}
	if(!standard_list.empty())
	{
	    video->add("standard", Setting::TypeInt64) = (long long)current_standard;
        Setting &standards = video->add("standards", Setting::TypeGroup);
        for(int i = 0; i < standard_list.size(); i++)
            standards.add(fix_str(standard_list[i].name), Setting::TypeInt64) = (long long)standard_list[i].id;
	}

	//construct controls setting
	try{ video->remove("controls"); } catch(...){}
	Setting &controls = video->add("controls", Setting::TypeGroup);

	for(int i = 0; i < queryctrl_list.size(); i++)
	{
		Setting &control = controls.add(fix_str(queryctrl_list[i].name), Setting::TypeGroup);
		control.add("id", Setting::TypeInt) = (int)queryctrl_list[i].id;
		control.add("value", Setting::TypeInt) = (int)control_list[i].value;
		control.add("default_value", Setting::TypeInt) = (int)queryctrl_list[i].default_value;
		if(queryctrl_list[i].type == V4L2_CTRL_TYPE_MENU)
		{
			vector<v4l2_querymenu> items = querymenu_list[(int)queryctrl_list[i].id];
			for(int j = 0; j < items.size(); j++)
				control.add(fix_str(items[j].name), Setting::TypeInt64) = (long long)items[j].index;
		}
		else
		{
			control.add("minimum", Setting::TypeInt) = (int)queryctrl_list[i].minimum;
			control.add("maximum", Setting::TypeInt) = (int)queryctrl_list[i].maximum;
			control.add("step", Setting::TypeInt) = (int)queryctrl_list[i].step;
		}
	}

	return true;
}
Ejemplo n.º 3
0
void UpgradeMessage::saveHeaderData (DbPlugin &db, QString &k, QString &d, QString &sym, DBIndexItem &item)
{
  // is this a co key?
  bool ok = FALSE;
  double t = k.toDouble(&ok);
  if (ok)
  {
    if (t < 10000)
    {
      // its a chart object
      Setting t;
      t.parse(d);
      QString s = "Plugin";
      QString s2;
      t.getData(s,s2);
      if (s2.length())
      {
        t.remove(s);
        s = "Type";
        t.setData(s, s2);
      }

      s = "Plot";
      t.getData(s, s2);
      if (! s2.compare("Main Plot"))
      {
        s2 = "Bars";
        t.setData(s, s2);
      }
      else
        return;

      index.setChartObject(sym, k, t);
      return;
    }
  }

  if (! k.compare("Type"))
  {
    item.setType(d);
    return;
  }

  if (! k.compare("FuturesType"))
  {
    item.setFuturesType(d);
    return;
  }

  if (! k.compare("FuturesMonth"))
  {
    item.setFuturesMonth(d);
    return;
  }

  if (! k.compare("BarType"))
  {
    item.setBarType(d);
    return;
  }

  if (! k.compare("Fundamentals"))
  {
    index.setFundamentals(sym, d);
    return;
  }

  if (! k.compare("LocalIndicators"))
  {
    index.addIndicator(sym, d);
    return;
  }

  if (! k.compare("QuotePlugin"))
  {
    item.setQuotePlugin(d);
    return;
  }

  if (! k.compare("Symbol"))
  {
    item.setSymbol(d);
    return;
  }

  if (! k.compare("Title"))
  {
    item.setTitle(d);
    return;
  }

  if (! k.compare("Path"))
  {
    item.setPath(d);
    return;
  }

  if (! k.compare("SpreadFirstSymbol"))
  {
    int t = d.find("/data0/", 0, TRUE);
    d.replace(t + 5, 1, "1");
    QString ts = "FirstSymbol";
    db.setData(ts, d);
    return;
  }

  if (! k.compare("SpreadSecondSymbol"))
  {
    int t = d.find("/data0/", 0, TRUE);
    d.replace(t + 5, 1, "1");
    QString ts = "SecondSymbol";
    db.setData(ts, d);
    return;
  }

  if (! k.compare("IndexList"))
  {
    while (1)
    {
      int t = d.find("/data0/", 0, TRUE);
      if (t == -1)
        break;
      else
        d.replace(t + 5, 1, "1");
    }
    QString ts = "List";
    db.setData(ts, d);
    return;
  }

  if (! k.compare("CCAdjustment"))
  {
    QString ts = "Adjustment";
    db.setData(ts, d);
    return;
  }
}
Ejemplo n.º 4
0
    void _apply(Setting& root, Setting& source, LockList* lockList)
    {
        Setting* s = nullptr;

        if (!source.isRoot()) {
            const char* name = source.getName();
            if (name != nullptr) {
                if (root.exists(name)) {
                    s = &root[name];

                    if (_isLocked(*s, true, lockList)) {
                        LogWarn("Ignored updating configuration '%s' to value "
                                "'%s'. Setting locked to value '%s'.",
                                s->getPath().c_str(),
                                settingToString(source).c_str(),
                                settingToString(*s).c_str());

                        return;
                    }

                    if (!s->isGroup()) {
                        root.remove(s->getIndex());
                        s = &root.add(name, source.getType());
                    }
                } else {
                    s = &root.add(name, source.getType());

                    if (_isLocked(*s, false, lockList)) {
                        LogWarn("Ignored creating configuration '%s' with "
                                "value '%s'. Setting locked.",
                                s->getPath().c_str(),
                                settingToString(*s).c_str());

                        root.remove(s->getIndex());
                        return;
                    }
                }
            } else {
                // List or array elements
                s = &root.add(source.getType());
            }
        } else {
            s = &root;
        }

        switch (source.getType())
        {
            case Setting::Type::TypeInt: {
                *s = (int)source;
                break;
            }

            case Setting::Type::TypeInt64: {
                *s = (long long)source;
                break;
            }

            case Setting::Type::TypeString: {
                *s = (const char*)source;
                break;
            }

            case Setting::Type::TypeBoolean: {
                *s = (bool)source;
                break;
            }

            case Setting::Type::TypeArray:
            case Setting::Type::TypeList:
            case Setting::Type::TypeGroup: {
                for (int i = 0; i < source.getLength(); ++i) {
                    _apply(*s, source[i], lockList);
                }
                break;
            }

            default: {
                assert(false);
                break;
            }
        }
    }