Esempio n. 1
0
		void getConfig( map<string,string> &config ) const {
			
			GET_CONFIG(DescriptorType);
			GET_CONFIG(DescriptorSize);
			GET_CONFIG(Quality);
			GET_CONFIG(Ratio);
		};
Esempio n. 2
0
/* @req SWS_Gpt_00288 */
void Gpt_SetMode( Gpt_ModeType Mode ) {

    /* @req SWS_Gpt_00228 */
    VALIDATE((STD_ON == Gpt_Global.initRun), GPT_SETMODE_SERVICE_ID, GPT_E_UNINIT);

    /* @req SWS_Gpt_00231 */
    VALIDATE(((GPT_MODE_SLEEP == Mode) || (GPT_MODE_NORMAL == Mode)), GPT_SETMODE_SERVICE_ID, GPT_E_PARAM_MODE);

    /* @req SWS_Gpt_00164 */
    if (GPT_MODE_SLEEP == Mode) {
        for (uint8 chnlCnt = 0; chnlCnt < GPT_CHANNEL_CNT; chnlCnt++) {
            if ((!Gpt_Global.Gpt_WakUpEnable[chnlCnt]) && (GPT_STATE_RUNNING == Gpt_Global.Gpt_ChannelState[chnlCnt])) {
                Gpt_StopTimer( GET_CONFIG(chnlCnt).GptChannelId); //Stop channels not configured/Enabled for wakeup
            }
            /* @req SWS_Gpt_00341 */
            //No Wakeup timer started
        }
    }
    else {
        /* @req SWS_Gpt_00165 */
        //Other timers are not started in Normal mode
    }

    /* @req SWS_Gpt_00151 */
    Gpt_Global.mode = Mode;
}
	NavGraphRosRetriever(ros::NodeHandle &n)
		: n(n)
	{
		ros::NodeHandle privn("~");
		GET_CONFIG(privn, n, "navgraph_file", cfg_navgraph_file_);

		if (cfg_navgraph_file_.empty()) {
			throw std::runtime_error("No navgraph file given");
		}

		boost::filesystem::path p(cfg_navgraph_file_);
		p = boost::filesystem::absolute(p);
		cfg_navgraph_file_ = p.string();
		ROS_INFO("Using navgraph path: %s", p.string().c_str());
		if (boost::filesystem::exists(p)) {
			boost::filesystem::remove(p);
		}
		boost::filesystem::create_directories(p.parent_path());

		sub_has_received_ = false;
		sub_navgraph_ = n.subscribe<fawkes_msgs::NavGraph>("navgraph", 10, &NavGraphRosRetriever::cb_navgraph, this);

		sub_init_timer_ =
			n.createWallTimer(ros::WallDuration(5.0), &NavGraphRosRetriever::cb_sub_init_timer, this);
	}
Esempio n. 4
0
void OutputWindow::setCounterAlignment(Qt::Alignment align)
{
	GET_CONFIG();
	config.setValue("counter-alignment", (int)align);
	
	/// TODO
}
Esempio n. 5
0
void OutputWindow::setOverlayAlignment(Qt::Alignment align)
{
	GET_CONFIG();
	config.setValue("overlay-alignment", (int)align);
	
	/// TODO
}
Esempio n. 6
0
void OutputWindow::setCounterVisible(bool flag)
{
	m_counterVisible = flag;
	m_counterText->setVisible(flag);
	m_counterBgRect->setVisible(flag);
	
	GET_CONFIG();
	config.setValue("counter-visible", flag ? "true" : "false");
}
Esempio n. 7
0
void OutputWindow::setOverlayText(QString text)
{
	m_overlayText->setText(text);
	
	GET_CONFIG();
	config.setValue("overlay-text", text);
	
	m_overlayBgRect->setPos(m_overlayText->pos());
	m_overlayBgRect->setRect(m_overlayText->boundingRect().adjusted(0,13/2,0,0));
}
Esempio n. 8
0
/* @req SWS_Gpt_00287 */
void Gpt_DisableNotification( Gpt_ChannelType Channel ) {

    /* @req SWS_Gpt_00227 */
    VALIDATE((STD_ON == Gpt_Global.initRun), GPT_DISABLENOTIFICATION_SERVICE_ID, GPT_E_UNINIT);

    /* @req SWS_Gpt_00217 */
    VALIDATE(IS_CHANNEL_VALID(Channel), GPT_DISABLENOTIFICATION_SERVICE_ID, GPT_E_PARAM_CHANNEL);

    /* @req SWS_Gpt_00379 */
    VALIDATE((NULL != GET_CONFIG(Channel).GptNotification), GPT_DISABLENOTIFICATION_SERVICE_ID, GPT_E_PARAM_CHANNEL);

    /* @req SWS_Gpt_00015 */
    Gpt_Global.Gpt_NotifEnable[Channel] = FALSE;

}
Esempio n. 9
0
/* @req SWS_Gpt_00279 */
void Gpt_GetVersionInfo( Std_VersionInfoType* VersionInfoPtr ) {

    const Std_VersionInfoType _Gpt_VersionInfo =
    {   .vendorID = (uint16)GPT_VENDOR_ID,
        .moduleID = (uint16) GPT_MODULE_ID,
        .sw_major_version = (uint8)GPT_SW_MAJOR_VERSION,
        .sw_minor_version = (uint8)GPT_SW_MINOR_VERSION,
        .sw_patch_version = (uint8)GPT_SW_PATCH_VERSION,
    };

    /* @req SWS_Gpt_00338 **/
    VALIDATE( (VersionInfoPtr != NULL), GPT_GETVERSIONINFO_SERVICE_ID, GPT_E_PARAM_POINTER );

    memcpy(VersionInfoPtr, &_Gpt_VersionInfo, sizeof(Std_VersionInfoType));
    return;

}
#endif

/* @req SWS_Gpt_00280 */
void Gpt_Init(const Gpt_ConfigType* ConfigPtr) {
    uint8 hwCh;

    /* @req SWS_Gpt_00307 */
    VALIDATE ((STD_OFF == Gpt_Global.initRun), GPT_INIT_SERVICE_ID, GPT_E_ALREADY_INITIALIZED);
    /* @req SWS_Gpt_00294 */
    VALIDATE((ConfigPtr != NULL), GPT_INIT_SERVICE_ID, GPT_E_PARAM_POINTER);

    /* @req SWS_Gpt_00107 */
    memset(&Gpt_Global, 0, sizeof(Gpt_Global));

    /* @req SWS_Gpt_00006 */
    Gpt_Global.config = (const Gpt_ConfigType (*)[GPT_CHANNEL_CNT]) ConfigPtr; /*lint !e929 !e740 !e826 */

    for (uint8 ch = 0; ch < GPT_CHANNEL_CNT; ch++) {
        hwCh = GET_CONFIG(ch).GptChannelId;

        Gpt_Global.channelMap[hwCh] = ch;
        Gpt_Global.Gpt_ChannelState[ch] = GPT_STATE_INITIALIZED;
    }

    Gpt_Hw_Init(ConfigPtr);

    /* @req SWS_Gpt_00339 */
    Gpt_Global.mode = GPT_MODE_NORMAL;
    Gpt_Global.initRun = STD_ON;
}
Esempio n. 10
0
/* @req SWS_Gpt_00328 */
void Gpt_CheckWakeup( EcuM_WakeupSourceType WakeupSource ) {

    /* @req SWS_Gpt_00325 */
    VALIDATE((STD_ON == Gpt_Global.initRun), GPT_CHECKWAKEUP_SERVICE_ID, GPT_E_UNINIT);

    for (uint8 chnlCnt = 0; chnlCnt < GPT_CHANNEL_CNT; chnlCnt++) {
        // Loop over all channels to check if Wakeup source is found
        if (Gpt_Global.Gpt_WakUpEnable[chnlCnt] && (GET_CONFIG(chnlCnt).GptWakeupSource == WakeupSource)
                && ( GPT_STATE_EXPIRED == Gpt_Global.Gpt_ChannelState[chnlCnt])) {
            /* @req SWS_Gpt_00321 */
            EcuM_SetWakeupEvent(WakeupSource);
            break;
        }
    }

    return;
}
Esempio n. 11
0
void OutputWindow::setBlinkOverlay(bool flag, int speed)
{
	m_blinkOverlayTimer.setInterval(speed);
	m_blinkOverlay = flag;
	if(flag)
	{
		m_blinkOverlayTimer.start();
	}
	else
	{
		m_blinkOverlayTimer.stop();
		if(m_overlayVisible);
			m_overlayText->show();
	}
	
	GET_CONFIG();
	config.setValue("blink-overlay", flag ? "true" : "false");
	config.setValue("blink-speed", speed);
}
Esempio n. 12
0
/* @req SWS_Gpt_00290 */
void Gpt_EnableWakeup( Gpt_ChannelType Channel ) {

    uint8 chnlidx;

    /* @req SWS_Gpt_00230 */
    VALIDATE((STD_ON == Gpt_Global.initRun), GPT_ENABLEWAKEUP_SERVICE_ID, GPT_E_UNINIT);

    /* @req SWS_Gpt_00216 */
    VALIDATE(IS_CHANNEL_VALID(Channel), GPT_ENABLEWAKEUP_SERVICE_ID, GPT_E_PARAM_CHANNEL);

    chnlidx = Gpt_Global.channelMap[Channel];

    /* @req SWS_Gpt_00216 */
    VALIDATE(GET_CONFIG(chnlidx).GptEnableWakeup, GPT_ENABLEWAKEUP_SERVICE_ID, GPT_E_PARAM_CHANNEL);

    /* @req SWS_Gpt_00160 */
    Gpt_Global.Gpt_WakUpEnable[chnlidx] = TRUE;

}
Esempio n. 13
0
/* @req SWS_Gpt_00283 */
Gpt_ValueType Gpt_GetTimeRemaining( Gpt_ChannelType Channel ) {

    /* @req SWS_Gpt_00223 */
    VALIDATE_W_RV((STD_ON == Gpt_Global.initRun), GPT_GETTIMEREMAINING_SERVICE_ID, GPT_E_UNINIT, DEFAULT_RETURN_VALUE);

    /* @req SWS_Gpt_00211 */
    VALIDATE_W_RV(IS_CHANNEL_VALID(Channel), GPT_GETTIMEREMAINING_SERVICE_ID, GPT_E_PARAM_CHANNEL, DEFAULT_RETURN_VALUE);

    if (GPT_STATE_INITIALIZED == Gpt_Global.Gpt_ChannelState[Channel])
    {
        /* @req SWS_Gpt_00301 */
        return DEFAULT_RETURN_VALUE;
    }

    /* @req SWS_Gpt_00305 */ // Expired - Counter Freeze at target
    if ((GPT_CH_MODE_ONESHOT == GET_CONFIG(Channel).GptChannelMode) &&
            (GPT_STATE_EXPIRED == Gpt_Global.Gpt_ChannelState[Channel])) {
        return DEFAULT_RETURN_VALUE;
    }

    return Gpt_Hw_GetTimeRemaining(ChannelToHwChannel(Channel));
}
Esempio n. 14
0
void OutputWindow::setWindowGeom(QRect geom)
{
	scene()->setSceneRect(0,0,geom.size().width(),geom.size().height());
	
	QPixmap bluePixmap(32,23);
	bluePixmap.fill(Qt::blue);
	
	m_pixmap->setPixmap(bluePixmap.scaled(geom.size()));
	
	if(m_drw)
		m_drw->setRect(scene()->sceneRect());
	
// 	if(verbose)
// 		qDebug() << "SlideShowWindow: pos:"<<windowPos<<", size:"<<windowSize;
	
	resize(geom.width(),geom.height());
	move(geom.x(),geom.y());
	
	m_geom = geom;
	
	GET_CONFIG();
	config.setValue("geom",tr("%1,%2,%3,%4").arg(geom.x()).arg(geom.y()).arg(geom.width()).arg(geom.height()));
	
}
Esempio n. 15
0
		void getConfig( map<string,string> &config ) const {

			GET_CONFIG( Threshold );
		}
Esempio n. 16
0
int enic_get_vnic_config(struct enic *enic)
{
	struct vnic_enet_config *c = &enic->config;
	int err;

	err = vnic_dev_get_mac_addr(enic->vdev, enic->mac_addr);
	if (err) {
		dev_err(enic_get_dev(enic),
			"Error getting MAC addr, %d\n", err);
		return err;
	}

#define GET_CONFIG(m) \
	do { \
		err = vnic_dev_spec(enic->vdev, \
			offsetof(struct vnic_enet_config, m), \
			sizeof(c->m), &c->m); \
		if (err) { \
			dev_err(enic_get_dev(enic), \
				"Error getting %s, %d\n", #m, err); \
			return err; \
		} \
	} while (0)

	GET_CONFIG(flags);
	GET_CONFIG(wq_desc_count);
	GET_CONFIG(rq_desc_count);
	GET_CONFIG(mtu);
	GET_CONFIG(intr_timer_type);
	GET_CONFIG(intr_mode);
	GET_CONFIG(intr_timer_usec);
	GET_CONFIG(loop_tag);

	c->wq_desc_count =
		min_t(u32, ENIC_MAX_WQ_DESCS,
		max_t(u32, ENIC_MIN_WQ_DESCS,
		c->wq_desc_count));
	c->wq_desc_count &= 0xffffffe0; /* must be aligned to groups of 32 */

	c->rq_desc_count =
		min_t(u32, ENIC_MAX_RQ_DESCS,
		max_t(u32, ENIC_MIN_RQ_DESCS,
		c->rq_desc_count));
	c->rq_desc_count &= 0xffffffe0; /* must be aligned to groups of 32 */

	if (c->mtu == 0)
		c->mtu = 1500;
	c->mtu = min_t(u16, ENIC_MAX_MTU,
		max_t(u16, ENIC_MIN_MTU,
		c->mtu));

	c->intr_timer_usec = min_t(u32, c->intr_timer_usec,
		vnic_dev_get_intr_coal_timer_max(enic->vdev));

	dev_info(enic_get_dev(enic),
		"vNIC MAC addr %pM wq/rq %d/%d mtu %d\n",
		enic->mac_addr, c->wq_desc_count, c->rq_desc_count, c->mtu);

	dev_info(enic_get_dev(enic), "vNIC csum tx/rx %s/%s "
		"tso/lro %s/%s rss %s intr mode %s type %s timer %d usec "
		"loopback tag 0x%04x\n",
		ENIC_SETTING(enic, TXCSUM) ? "yes" : "no",
		ENIC_SETTING(enic, RXCSUM) ? "yes" : "no",
		ENIC_SETTING(enic, TSO) ? "yes" : "no",
		ENIC_SETTING(enic, LRO) ? "yes" : "no",
		ENIC_SETTING(enic, RSS) ? "yes" : "no",
		c->intr_mode == VENET_INTR_MODE_INTX ? "INTx" :
		c->intr_mode == VENET_INTR_MODE_MSI ? "MSI" :
		c->intr_mode == VENET_INTR_MODE_ANY ? "any" :
		"unknown",
		c->intr_timer_type == VENET_INTR_TYPE_MIN ? "min" :
		c->intr_timer_type == VENET_INTR_TYPE_IDLE ? "idle" :
		"unknown",
		c->intr_timer_usec,
		c->loop_tag);

	return 0;
}
Esempio n. 17
0
BOOL q5_config_block_show(BYTE *config)
{
    uint32_t    value= hextoulong(config);

    UserMessage("  Config Block: %.8s\r\n", config);
    UserMessageNum("   Page Select: %d  = ", GET_CONFIG(value, Q5_MASK_PAGE_SELECT, Q5_SHIFT_PAGE_SELECT));
    UserMessage("%s\r\n", GET_CONFIG(value, Q5_MASK_PAGE_SELECT, Q5_SHIFT_PAGE_SELECT) ? "True" : "False");
    UserMessageNum("    Fast Write: %d  = ", GET_CONFIG(value, Q5_MASK_FAST_WRITE, Q5_SHIFT_FAST_WRITE));
    UserMessage("%s\r\n", GET_CONFIG(value, Q5_MASK_FAST_WRITE, Q5_SHIFT_FAST_WRITE) ? "True" : "False");
    UserMessageNum("     Data Rate: %02d = ", GET_CONFIG(value, Q5_MASK_DATA_BIT_RATE, Q5_SHIFT_DATA_BIT_RATE));
    UserMessageNum("%d * FC\r\n", GET_CONFIG(value, Q5_MASK_DATA_BIT_RATE, Q5_SHIFT_DATA_BIT_RATE) * 2 + 2);
    UserMessageNum("       Use AOR: %d  = ", GET_CONFIG(value, Q5_MASK_USE_AOR, Q5_SHIFT_USE_AOR));
    UserMessage("%s\r\n", GET_CONFIG(value, Q5_MASK_USE_AOR, Q5_SHIFT_USE_AOR) ? "True" : "False");
    UserMessageNum("       Use PWD: %d  = ", GET_CONFIG(value, Q5_MASK_USE_PWD, Q5_SHIFT_USE_PWD));
    UserMessage("%s\r\n", GET_CONFIG(value, Q5_MASK_USE_PWD, Q5_SHIFT_USE_PWD) ? "True" : "False");
    UserMessageNum("   PSK Carrier: %d  = ", GET_CONFIG(value, Q5_MASK_PSK_CARRIER_FREQ, Q5_SHIFT_PSK_CARRIER_FREQ));
    UserMessageNum("%d * FC\r\n", PSK_Rates[GET_CONFIG(value, Q5_MASK_PSK_CARRIER_FREQ, Q5_SHIFT_PSK_CARRIER_FREQ)]);
    UserMessageNum("    Modulation: %d  = ", GET_CONFIG(value, Q5_MASK_MODULATION, Q5_SHIFT_MODULATION));
    UserMessage("%s\r\n", (BYTE *) Q5_Modulation[GET_CONFIG(value, Q5_MASK_MODULATION, Q5_SHIFT_MODULATION)]);
    UserMessageNum("     Max Block: %d\r\n", GET_CONFIG(value, Q5_MASK_MAX_BLOCK, Q5_SHIFT_MAX_BLOCK));
    UserMessageNum("            ST: %d  = ", GET_CONFIG(value, Q5_MASK_ST, Q5_SHIFT_ST));
    UserMessage("%s\r\n", GET_CONFIG(value, Q5_MASK_ST, Q5_SHIFT_ST) ? "True" : "False");
    return TRUE;
}
Esempio n. 18
0
BOOL hitag2_config_block_show(BYTE *config, BYTE *password, BYTE *key)
{
    BYTE    value= hextobyte(config); // first byte only used as config

    UserMessage("     PWD Block (1): %.8s    ", password);
    printhexreadable(password, 4);

    UserMessage("\r\n\r\n     Key Block (2): %.8s    ", key);
    printhexreadable(key, 4);

    UserMessage("\r\n\r\n  Config Block (3): %.8s\r\n\r\n", config);
    UserMessageNum("        Page 1 & 2: %d = ", GET_CONFIG(value, HITAG2_MASK_PAGE_1_2_OTP_PROTECT, HITAG2_SHIFT_PAGE_1_2_OTP_PROTECT));
    if(GET_CONFIG(value, HITAG2_MASK_SECURITY, HITAG2_SHIFT_SECURITY))
        UserMessage("%s\r\n", GET_CONFIG(value, HITAG2_MASK_PAGE_1_2_OTP_PROTECT, HITAG2_SHIFT_PAGE_1_2_OTP_PROTECT) ? "No Read / No Write" : "Read / Write");
    else
        UserMessage("%s\r\n", GET_CONFIG(value, HITAG2_MASK_PAGE_1_2_OTP_PROTECT, HITAG2_SHIFT_PAGE_1_2_OTP_PROTECT) ? "Page 1: No Read / No Write, Page 2: Read Only" : "Read / Write");
    UserMessageNum("            Page 3: %d = ", GET_CONFIG(value, HITAG2_MASK_PAGE_3_OTP_PROTECT, HITAG2_SHIFT_PAGE_3_OTP_PROTECT));
    UserMessage("%s\r\n", GET_CONFIG(value, HITAG2_MASK_PAGE_3_OTP_PROTECT, HITAG2_SHIFT_PAGE_3_OTP_PROTECT) ? "Read Only" : "Read / Write");
    UserMessageNum("        Page 4 & 5: %d = ", GET_CONFIG(value, HITAG2_MASK_PAGE_4_5_PROTECT, HITAG2_SHIFT_PAGE_4_5_PROTECT));
    UserMessage("%s\r\n", GET_CONFIG(value, HITAG2_MASK_PAGE_4_5_PROTECT, HITAG2_SHIFT_PAGE_4_5_PROTECT) ? "Read Only" : "Read / Write");
    UserMessageNum("        Page 6 & 7: %d = ", GET_CONFIG(value, HITAG2_MASK_PAGE_6_7_PROTECT, HITAG2_SHIFT_PAGE_6_7_PROTECT));
    UserMessage("%s\r\n", GET_CONFIG(value, HITAG2_MASK_PAGE_6_7_PROTECT, HITAG2_SHIFT_PAGE_6_7_PROTECT) ? "Read Only" : "Read / Write");
    UserMessageNum("          Security: %d = ", GET_CONFIG(value, HITAG2_MASK_SECURITY, HITAG2_SHIFT_SECURITY));
    UserMessage("%s\r\n", GET_CONFIG(value, HITAG2_MASK_SECURITY, HITAG2_SHIFT_SECURITY) ? "Crypto" : "Password");
    UserMessageNum("              Mode: %d = ", GET_CONFIG(value, HITAG2_MASK_MODE, HITAG2_SHIFT_MODE));
    UserMessage("%s\r\n", (BYTE *) Hitag2_Modes[GET_CONFIG(value, HITAG2_MASK_MODE, HITAG2_SHIFT_MODE)]);
    UserMessageNum("        Modulation: %d = ", GET_CONFIG(value, HITAG2_MASK_MODULATION, HITAG2_SHIFT_MODULATION));
    UserMessage("%s\r\n", GET_CONFIG(value, HITAG2_MASK_MODULATION, HITAG2_SHIFT_MODULATION) ? "BiPhase" : "Manchester");

    UserMessage("\r\n     PWD Block (3): %.6s      ", config + 2);
    printhexreadable(config + 2, 3);
    UserMessage("%s", "\r\n");
    return TRUE;
}
Esempio n. 19
0
		void getConfig( map<string, string> &config ) const {
			GET_CONFIG( param1 );
			GET_CONFIG( param2 );
		}
Esempio n. 20
0
OutputWindow::OutputWindow()
	: QGraphicsView(new QGraphicsScene())
	, m_url("")
	, m_pollDviz(false)
	, m_updateTime(1000)
	, m_isDataPoll(false)
	, m_slideId(-1)
	, m_slideName("")
	//, m_startStopButton(0)
        , m_countValue(0)
        , m_drw(0)
        , m_blinkCount(0)
{
	// Setup graphics view
	setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::SmoothPixmapTransform );
	setCacheMode(QGraphicsView::CacheBackground);
	setViewportUpdateMode(QGraphicsView::BoundingRectViewportUpdate);
	setOptimizationFlags(QGraphicsView::DontSavePainterState);
	setViewportUpdateMode(QGraphicsView::SmartViewportUpdate);
	setTransformationAnchor(AnchorUnderMouse);
	setResizeAnchor(AnchorViewCenter);
	setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
	setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
		
	// Add pixmap item for background
	QPixmap bluePixmap(32,23);
	bluePixmap.fill(Qt::blue);
	m_pixmap = scene()->addPixmap(bluePixmap);
	
	// Background behind text
	m_counterBgRect = scene()->addRect(0,0,100,60,QPen(), Qt::black);
	m_counterBgRect->setZValue(99);
	// Add text (for use with clock)
	QFont font("Monospace", 50, 600);
	m_counterText = new QGraphicsSimpleTextItem("0");
	m_counterText->setFont(font);
	m_counterText->setPen(QPen(Qt::black));
	m_counterText->setBrush(Qt::white);
	m_counterText->setPos(0, -13);
	m_counterText->setZValue(100);
	scene()->addItem(m_counterText);
	
	
	// Background behind text
	m_overlayBgRect = scene()->addRect(0,300,100,60,QPen(), Qt::black);
	m_overlayBgRect->setZValue(99);
	// Add text (for use with clock)
	//QFont font("Monospace", 50, 600);
	m_overlayText = new QGraphicsSimpleTextItem("Hello, World!");
	m_overlayText->setFont(font);
	m_overlayText->setPen(QPen(Qt::black));
	m_overlayText->setBrush(Qt::white);
	m_overlayText->setPos(0, 300-13);
	m_overlayText->setZValue(100);
	scene()->addItem(m_overlayText);
	
	m_blinkOverlay = false;
	connect(&m_blinkOverlayTimer, SIGNAL(timeout()), this, SLOT(blinkOverlaySlot()));
	
	GET_CONFIG();
	
	QPoint windowPos(1024,0);
	QPoint windowSize(1024,768);

	//QPoint windowPos(10,10);
	//QPoint windowSize = QPoint(640,480);
	QString windowGeomString = config.value("geom","1024,0,1024,768").toString();
	if(!windowGeomString.isEmpty())
	{
		QStringList list = windowGeomString.split(",");
		windowPos  = QPoint(list[0].toInt(), list[1].toInt());
		windowSize = QPoint(list[2].toInt(), list[3].toInt());
	}
	
	setWindowGeom(QRect(windowPos.x(),windowPos.y(),windowSize.x(),windowSize.y()));
	
	
	bool frameless = config.value("frameless","true").toString() == "true";
	if(frameless)
		setWindowFlags(Qt::FramelessWindowHint);// | Qt::ToolTip);

	connect(&m_pollDvizTimer, SIGNAL(timeout()), this, SLOT(initDvizPoll()));
	//connect(&m_pollImageTimer, SIGNAL(timeout()), this, SLOT(initImagePoll()));
	
	setUpdateTime(m_updateTime);
	
        //setUrl("http://10.10.9.90:8081/image");
        //setUrl("");
	//setPollDviz(true);
	
	setInputSource(config.value("source","dviz://192.168.0.10:8081/image").toString());
	
// 	m_startStopButton = new QPushButton("Start Counter");
// 	connect(m_startStopButton, SIGNAL(clicked()), this, SLOT(toggleCounter()));
 	connect(&m_counterTimer, SIGNAL(timeout()), this, SLOT(counterTick()));
 	m_counterTimer.setInterval(1000);
// 	
// 	m_startStopButton->show();

	//toggleCounter();
	setCounterActive(false);
		
	
	setBlinkOverlay(config.value("blink-overlay","false").toString() == "true", config.value("blink-speed", 333).toInt());
	//setOverlayVisible(config.value("overlay-visible", "true").toString() == "true");
	setCounterVisible(config.value("counter-visible", "true").toString() == "true");
	
	setCounterAlignment((Qt::Alignment)config.value("counter-alignment", (int)(Qt::AlignLeft | Qt::AlignTop)).toInt());
	setOverlayAlignment((Qt::Alignment)config.value("overlay-alignment", (int)(Qt::AlignCenter | Qt::AlignBottom)).toInt());
	
	setOverlayText(config.value("overlay-text").toString());
}
Esempio n. 21
0
/*
 * Dump the devspec
 */
int
usd_dump_devspec(
    struct usd_qp_impl *qp)
{
    struct vnic_enet_config config;
    struct vnic_enet_config *c;
    int ret;

    c = &config;
    memset(&config, 0, sizeof(config));

    GET_CONFIG(flags);
    GET_CONFIG(wq_desc_count);
    GET_CONFIG(rq_desc_count);
    GET_CONFIG(mtu);
    GET_CONFIG(intr_timer_deprecated);
    GET_CONFIG(intr_timer_type);
    GET_CONFIG(intr_mode);
    GET_CONFIG(intr_timer_usec);
    GET_CONFIG(loop_tag);
    GET_CONFIG(vf_rq_count);
    GET_CONFIG(num_arfs);
    GET_CONFIG(mem_paddr);

    ret = vnic_dev_spec(qp->uq_vf->vf_vdev,
            usd_offset_of(struct vnic_enet_config, devname),
            8, &c->devname[0]);
    ret |= vnic_dev_spec(qp->uq_vf->vf_vdev,
            usd_offset_of(struct vnic_enet_config, devname) + 8,
            8, &c->devname[8]);
    printf("devname = \"%s\", ret = %d\n", c->devname, ret);

    return 0;
}
Esempio n. 22
0
void OutputWindow::setInputSource(QString source)
{
	if(m_drw)
	{
		scene()->removeItem(m_drw);
		delete m_drw;
		m_drw = 0;
	}
	
	GET_CONFIG();
	config.setValue("source",source);

	qDebug() << "OutputWindow::setInputSource: source:"<<source;

	if(source.startsWith("dviz:") ||
	   source.startsWith("http:"))
	{
		setUrl(source.replace("dviz:","http:"));
		setPollDviz(true);
		m_pixmap->show();
		qDebug() << "OutputWindow: dviz source:"<<source;
	}
	else
	if(source.startsWith("tx:") ||
	   source.startsWith("raw:"))
	{
		setPollDviz(false);
		// ex: tx://192.168.0.18:7758
		source = source.replace("tx://","");
		source = source.replace("raw://","");
		QStringList hostPort = source.split(":");
		QString host = hostPort[0];
		int port     = hostPort[1].toInt();
		
		m_rx = VideoReceiver::getReceiver(host, port);
		
		if(!m_rx)
		{
			qDebug() << "OutputWindow: Error connecting to source "<<source;
		}
		else
		{
			qDebug() << "OutputWindow: raw source, host:"<<host<<", port:"<<port<<", rx:"<<m_rx;
		}
		
		m_drw = new GLVideoDrawable();
		m_drw->setVideoSource(m_rx);
		m_drw->setPos(0,0);
		m_drw->setRect(scene()->sceneRect());
		
		scene()->addItem(m_drw);
		m_drw->show();
		m_drw->setZIndex(-99);
		
		m_pixmap->hide();
	}
	else
	{
		// assume it's a capture device
// 		CameraThread *cam = CameraThread::threadForCamera(source);
// 		if(!cam)
// 		{
// 			qDebug() << "OutputWindow: Unable to locate input source: "<<source;
// 		}
// 		
// 		m_drw = new GLDrawable();
// 		m_drw->setVideoSource(cam);
// 		m_drw->setPos(0,0);
// 		m_drw->setRect(scene()->sceneRect());
// 		
// 		m_pixmap->hide();
	}
}
Esempio n. 23
0
int enic_get_vnic_config(struct enic *enic)
{
	struct vnic_enet_config *c = &enic->config;
	int err;

	err = vnic_dev_mac_addr(enic->vdev, enic->mac_addr);
	if (err) {
		dev_err(enic_get_dev(enic),
			"Error getting MAC addr, %d\n", err);
		return err;
	}

#define GET_CONFIG(m) \
	do { \
		err = vnic_dev_spec(enic->vdev, \
			offsetof(struct vnic_enet_config, m), \
			sizeof(c->m), &c->m); \
		if (err) { \
			dev_err(enic_get_dev(enic), \
				"Error getting %s, %d\n", #m, err); \
			return err; \
		} \
	} while (0)

	GET_CONFIG(flags);
	GET_CONFIG(wq_desc_count);
	GET_CONFIG(rq_desc_count);
	GET_CONFIG(mtu);
	GET_CONFIG(intr_timer_type);
	GET_CONFIG(intr_mode);
	GET_CONFIG(intr_timer_usec);
	GET_CONFIG(loop_tag);

	c->wq_desc_count =
		min_t(u32, ENIC_MAX_WQ_DESCS,
		max_t(u32, ENIC_MIN_WQ_DESCS,
		c->wq_desc_count));
	c->wq_desc_count &= 0xffffffe0; /* must be aligned to groups of 32 */

	c->rq_desc_count =
		min_t(u32, ENIC_MAX_RQ_DESCS,
		max_t(u32, ENIC_MIN_RQ_DESCS,
		c->rq_desc_count));
	c->rq_desc_count &= 0xffffffe0; /* must be aligned to groups of 32 */

	if (c->mtu == 0)
		c->mtu = 1500;
	c->mtu = min_t(u16, ENIC_MAX_MTU,
		max_t(u16, ENIC_MIN_MTU,
		c->mtu));

	c->intr_timer_usec = min_t(u32,
		INTR_COALESCE_HW_TO_USEC(VNIC_INTR_TIMER_MAX),
		c->intr_timer_usec);

	dev_info(enic_get_dev(enic), "vNIC MAC addr %02x:%02x:%02x:%02x:%02x:%02x "
		"wq/rq %d/%d\n",
		enic->mac_addr[0], enic->mac_addr[1], enic->mac_addr[2],
		enic->mac_addr[3], enic->mac_addr[4], enic->mac_addr[5],
		c->wq_desc_count, c->rq_desc_count);
	dev_info(enic_get_dev(enic), "vNIC mtu %d csum tx/rx %d/%d "
		"tso/lro %d/%d intr timer %d usec\n",
		c->mtu, ENIC_SETTING(enic, TXCSUM),
		ENIC_SETTING(enic, RXCSUM), ENIC_SETTING(enic, TSO),
		ENIC_SETTING(enic, LRO), c->intr_timer_usec);

	return 0;
}
		void getConfig( map<string,string> &config ) const {
            GET_CONFIG( PatchSize );
            GET_CONFIG( Density );
            GET_CONFIG( ToFilter );
		}
Esempio n. 25
0
int enic_get_vnic_config(struct enic *enic)
{
	struct vnic_enet_config *c = &enic->config;
	int err;

	err = vnic_dev_mac_addr(enic->vdev, enic->mac_addr);
	if (err) {
		printk(KERN_ERR PFX "Error getting MAC addr, %d\n", err);
		return err;
	}

#define GET_CONFIG(m) \
	do { \
		err = vnic_dev_spec(enic->vdev, \
			offsetof(struct vnic_enet_config, m), \
			sizeof(c->m), &c->m); \
		if (err) { \
			printk(KERN_ERR PFX \
				"Error getting %s, %d\n", #m, err); \
			return err; \
		} \
	} while (0)

	GET_CONFIG(flags);
	GET_CONFIG(wq_desc_count);
	GET_CONFIG(rq_desc_count);
	GET_CONFIG(mtu);
	GET_CONFIG(intr_timer);
	GET_CONFIG(intr_timer_type);
	GET_CONFIG(intr_mode);

	c->wq_desc_count =
		min_t(u32, ENIC_MAX_WQ_DESCS,
		max_t(u32, ENIC_MIN_WQ_DESCS,
		c->wq_desc_count));
	c->wq_desc_count &= 0xfffffff0; /* must be aligned to groups of 16 */

	c->rq_desc_count =
		min_t(u32, ENIC_MAX_RQ_DESCS,
		max_t(u32, ENIC_MIN_RQ_DESCS,
		c->rq_desc_count));
	c->rq_desc_count &= 0xfffffff0; /* must be aligned to groups of 16 */

	if (c->mtu == 0)
		c->mtu = 1500;
	c->mtu = min_t(u16, ENIC_MAX_MTU,
		max_t(u16, ENIC_MIN_MTU,
		c->mtu));

	c->intr_timer = min_t(u16, VNIC_INTR_TIMER_MAX, c->intr_timer);

	printk(KERN_INFO PFX "vNIC MAC addr %pM wq/rq %d/%d\n",
		enic->mac_addr, c->wq_desc_count, c->rq_desc_count);
	printk(KERN_INFO PFX "vNIC mtu %d csum tx/rx %d/%d tso/lro %d/%d "
		"intr timer %d\n",
		c->mtu, ENIC_SETTING(enic, TXCSUM),
		ENIC_SETTING(enic, RXCSUM), ENIC_SETTING(enic, TSO),
		ENIC_SETTING(enic, LRO), c->intr_timer);

	return 0;
}
Esempio n. 26
0
		void getConfig( map<string,string> &config ) const {

			GET_CONFIG( MinPoints );
			GET_CONFIG( FeatureDistance );
		}
Esempio n. 27
0
int enic_get_vnic_config(struct enic *enic)
{
	struct vnic_enet_config *c = &enic->config;
	int err;

	err = vnic_dev_get_mac_addr(enic->vdev, enic->mac_addr);
	if (err) {
		dev_err(enic_get_dev(enic),
			"Error getting MAC addr, %d\n", err);
		return err;
	}


#define GET_CONFIG(m) \
	do { \
		err = vnic_dev_spec(enic->vdev, \
			offsetof(struct vnic_enet_config, m), \
			sizeof(c->m), &c->m); \
		if (err) { \
			dev_err(enic_get_dev(enic), \
				"Error getting %s, %d\n", #m, err); \
			return err; \
		} \
	} while (0)

	GET_CONFIG(flags);
	GET_CONFIG(wq_desc_count);
	GET_CONFIG(rq_desc_count);
	GET_CONFIG(mtu);
	GET_CONFIG(intr_timer_type);
	GET_CONFIG(intr_mode);
	GET_CONFIG(intr_timer_usec);
	GET_CONFIG(loop_tag);
	GET_CONFIG(num_arfs);
	GET_CONFIG(max_pkt_size);

	/* max packet size is only defined in newer VIC firmware
	 * and will be 0 for legacy firmware and VICs
	 */
	if (c->max_pkt_size > ENIC_DEFAULT_MAX_PKT_SIZE)
		enic->max_mtu = c->max_pkt_size - (ETHER_HDR_LEN + 4);
	else
		enic->max_mtu = ENIC_DEFAULT_MAX_PKT_SIZE - (ETHER_HDR_LEN + 4);
	if (c->mtu == 0)
		c->mtu = 1500;

	enic->rte_dev->data->mtu = min_t(u16, enic->max_mtu,
					 max_t(u16, ENIC_MIN_MTU, c->mtu));

	enic->adv_filters = vnic_dev_capable_adv_filters(enic->vdev);
	dev_info(enic, "Advanced Filters %savailable\n", ((enic->adv_filters)
		 ? "" : "not "));

	c->wq_desc_count =
		min_t(u32, ENIC_MAX_WQ_DESCS,
		max_t(u32, ENIC_MIN_WQ_DESCS,
		c->wq_desc_count));
	c->wq_desc_count &= 0xffffffe0; /* must be aligned to groups of 32 */

	c->rq_desc_count =
		min_t(u32, ENIC_MAX_RQ_DESCS,
		max_t(u32, ENIC_MIN_RQ_DESCS,
		c->rq_desc_count));
	c->rq_desc_count &= 0xffffffe0; /* must be aligned to groups of 32 */

	c->intr_timer_usec = min_t(u32, c->intr_timer_usec,
		vnic_dev_get_intr_coal_timer_max(enic->vdev));

	dev_info(enic_get_dev(enic),
		"vNIC MAC addr %02x:%02x:%02x:%02x:%02x:%02x "
		"wq/rq %d/%d mtu %d, max mtu:%d\n",
		enic->mac_addr[0], enic->mac_addr[1], enic->mac_addr[2],
		enic->mac_addr[3], enic->mac_addr[4], enic->mac_addr[5],
		c->wq_desc_count, c->rq_desc_count,
		enic->rte_dev->data->mtu, enic->max_mtu);
	dev_info(enic_get_dev(enic), "vNIC csum tx/rx %s/%s "
		"rss %s intr mode %s type %s timer %d usec "
		"loopback tag 0x%04x\n",
		ENIC_SETTING(enic, TXCSUM) ? "yes" : "no",
		ENIC_SETTING(enic, RXCSUM) ? "yes" : "no",
		ENIC_SETTING(enic, RSS) ? "yes" : "no",
		c->intr_mode == VENET_INTR_MODE_INTX ? "INTx" :
		c->intr_mode == VENET_INTR_MODE_MSI ? "MSI" :
		c->intr_mode == VENET_INTR_MODE_ANY ? "any" :
		"unknown",
		c->intr_timer_type == VENET_INTR_TYPE_MIN ? "min" :
		c->intr_timer_type == VENET_INTR_TYPE_IDLE ? "idle" :
		"unknown",
		c->intr_timer_usec,
		c->loop_tag);

	return 0;
}
Esempio n. 28
0
int fnic_get_vnic_config(struct fnic *fnic)
{
	struct vnic_fc_config *c = &fnic->config;
	int err;

#define GET_CONFIG(m) \
	do { \
		err = vnic_dev_spec(fnic->vdev, \
				    offsetof(struct vnic_fc_config, m), \
				    sizeof(c->m), &c->m); \
		if (err) { \
			shost_printk(KERN_ERR, fnic->lport->host, \
				     "Error getting %s, %d\n", #m, \
				     err); \
			return err; \
		} \
	} while (0);

	GET_CONFIG(node_wwn);
	GET_CONFIG(port_wwn);
	GET_CONFIG(wq_enet_desc_count);
	GET_CONFIG(wq_copy_desc_count);
	GET_CONFIG(rq_desc_count);
	GET_CONFIG(maxdatafieldsize);
	GET_CONFIG(ed_tov);
	GET_CONFIG(ra_tov);
	GET_CONFIG(intr_timer);
	GET_CONFIG(intr_timer_type);
	GET_CONFIG(flags);
	GET_CONFIG(flogi_retries);
	GET_CONFIG(flogi_timeout);
	GET_CONFIG(plogi_retries);
	GET_CONFIG(plogi_timeout);
	GET_CONFIG(io_throttle_count);
	GET_CONFIG(link_down_timeout);
	GET_CONFIG(port_down_timeout);
	GET_CONFIG(port_down_io_retries);
	GET_CONFIG(luns_per_tgt);

	c->wq_enet_desc_count =
		min_t(u32, VNIC_FNIC_WQ_DESCS_MAX,
		      max_t(u32, VNIC_FNIC_WQ_DESCS_MIN,
			    c->wq_enet_desc_count));
	c->wq_enet_desc_count = ALIGN(c->wq_enet_desc_count, 16);

	c->wq_copy_desc_count =
		min_t(u32, VNIC_FNIC_WQ_COPY_DESCS_MAX,
		      max_t(u32, VNIC_FNIC_WQ_COPY_DESCS_MIN,
			    c->wq_copy_desc_count));
	c->wq_copy_desc_count = ALIGN(c->wq_copy_desc_count, 16);

	c->rq_desc_count =
		min_t(u32, VNIC_FNIC_RQ_DESCS_MAX,
		      max_t(u32, VNIC_FNIC_RQ_DESCS_MIN,
			    c->rq_desc_count));
	c->rq_desc_count = ALIGN(c->rq_desc_count, 16);

	c->maxdatafieldsize =
		min_t(u16, VNIC_FNIC_MAXDATAFIELDSIZE_MAX,
		      max_t(u16, VNIC_FNIC_MAXDATAFIELDSIZE_MIN,
			    c->maxdatafieldsize));
	c->ed_tov =
		min_t(u32, VNIC_FNIC_EDTOV_MAX,
		      max_t(u32, VNIC_FNIC_EDTOV_MIN,
			    c->ed_tov));

	c->ra_tov =
		min_t(u32, VNIC_FNIC_RATOV_MAX,
		      max_t(u32, VNIC_FNIC_RATOV_MIN,
			    c->ra_tov));

	c->flogi_retries =
		min_t(u32, VNIC_FNIC_FLOGI_RETRIES_MAX, c->flogi_retries);

	c->flogi_timeout =
		min_t(u32, VNIC_FNIC_FLOGI_TIMEOUT_MAX,
		      max_t(u32, VNIC_FNIC_FLOGI_TIMEOUT_MIN,
			    c->flogi_timeout));

	c->plogi_retries =
		min_t(u32, VNIC_FNIC_PLOGI_RETRIES_MAX, c->plogi_retries);

	c->plogi_timeout =
		min_t(u32, VNIC_FNIC_PLOGI_TIMEOUT_MAX,
		      max_t(u32, VNIC_FNIC_PLOGI_TIMEOUT_MIN,
			    c->plogi_timeout));

	c->io_throttle_count =
		min_t(u32, VNIC_FNIC_IO_THROTTLE_COUNT_MAX,
		      max_t(u32, VNIC_FNIC_IO_THROTTLE_COUNT_MIN,
			    c->io_throttle_count));

	c->link_down_timeout =
		min_t(u32, VNIC_FNIC_LINK_DOWN_TIMEOUT_MAX,
		      c->link_down_timeout);

	c->port_down_timeout =
		min_t(u32, VNIC_FNIC_PORT_DOWN_TIMEOUT_MAX,
		      c->port_down_timeout);

	c->port_down_io_retries =
		min_t(u32, VNIC_FNIC_PORT_DOWN_IO_RETRIES_MAX,
		      c->port_down_io_retries);

	c->luns_per_tgt =
		min_t(u32, VNIC_FNIC_LUNS_PER_TARGET_MAX,
		      max_t(u32, VNIC_FNIC_LUNS_PER_TARGET_MIN,
			    c->luns_per_tgt));

	c->intr_timer = min_t(u16, VNIC_INTR_TIMER_MAX, c->intr_timer);
	c->intr_timer_type = c->intr_timer_type;

	shost_printk(KERN_INFO, fnic->lport->host,
		     "vNIC MAC addr %pM "
		     "wq/wq_copy/rq %d/%d/%d\n",
		     fnic->ctlr.ctl_src_addr,
		     c->wq_enet_desc_count, c->wq_copy_desc_count,
		     c->rq_desc_count);
	shost_printk(KERN_INFO, fnic->lport->host,
		     "vNIC node wwn %llx port wwn %llx\n",
		     c->node_wwn, c->port_wwn);
	shost_printk(KERN_INFO, fnic->lport->host,
		     "vNIC ed_tov %d ra_tov %d\n",
		     c->ed_tov, c->ra_tov);
	shost_printk(KERN_INFO, fnic->lport->host,
		     "vNIC mtu %d intr timer %d\n",
		     c->maxdatafieldsize, c->intr_timer);
	shost_printk(KERN_INFO, fnic->lport->host,
		     "vNIC flags 0x%x luns per tgt %d\n",
		     c->flags, c->luns_per_tgt);
	shost_printk(KERN_INFO, fnic->lport->host,
		     "vNIC flogi_retries %d flogi timeout %d\n",
		     c->flogi_retries, c->flogi_timeout);
	shost_printk(KERN_INFO, fnic->lport->host,
		     "vNIC plogi retries %d plogi timeout %d\n",
		     c->plogi_retries, c->plogi_timeout);
	shost_printk(KERN_INFO, fnic->lport->host,
		     "vNIC io throttle count %d link dn timeout %d\n",
		     c->io_throttle_count, c->link_down_timeout);
	shost_printk(KERN_INFO, fnic->lport->host,
		     "vNIC port dn io retries %d port dn timeout %d\n",
		     c->port_down_io_retries, c->port_down_timeout);

	return 0;
}
Esempio n. 29
0
/* CENTRY */
int GLUTAPIENTRY
glutGet(GLenum param)
{
    Window win, root;
    int x, y, value;
    unsigned int width, height, border, depth;

    switch (param) {
    case GLUT_INIT_WINDOW_X:
        return __glutInitX;
    case GLUT_INIT_WINDOW_Y:
        return __glutInitY;
    case GLUT_INIT_WINDOW_WIDTH:
        return __glutInitWidth;
    case GLUT_INIT_WINDOW_HEIGHT:
        return __glutInitHeight;
    case GLUT_INIT_DISPLAY_MODE:
        return __glutDisplayMode;
    case GLUT_WINDOW_X:
        XTranslateCoordinates(__glutDisplay, __glutCurrentWindow->win,
                              __glutRoot, 0, 0, &x, &y, &win);
        return x;
    case GLUT_WINDOW_Y:
        XTranslateCoordinates(__glutDisplay, __glutCurrentWindow->win,
                              __glutRoot, 0, 0, &x, &y, &win);
        return y;
    case GLUT_WINDOW_WIDTH:
        if (!__glutCurrentWindow->reshape) {
            XGetGeometry(__glutDisplay, __glutCurrentWindow->win,
                         &root, &x, &y,
                         &width, &height, &border, &depth);
            return width;
        }
        return __glutCurrentWindow->width;
    case GLUT_WINDOW_HEIGHT:
        if (!__glutCurrentWindow->reshape) {
            XGetGeometry(__glutDisplay, __glutCurrentWindow->win,
                         &root, &x, &y,
                         &width, &height, &border, &depth);
            return height;
        }
        return __glutCurrentWindow->height;
#ifdef __OS2__
#define GET_CONFIG(attrib) \
  { if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win)  \
       glXGetConfig( __glutCurrentWindow->vis, attrib, &value); \
    else  \
    glXGetConfig(__glutCurrentWindow->overlay->vis, attrib, &value); \
  } \

#else

#define GET_CONFIG(attrib) { \
  if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) { \
    glXGetConfig(__glutDisplay, __glutCurrentWindow->vis, \
      attrib, &value); \
  } else { \
    glXGetConfig(__glutDisplay, __glutCurrentWindow->overlay->vis, \
      attrib, &value); \
  } \
}
#endif

    case GLUT_WINDOW_BUFFER_SIZE:
        GET_CONFIG(GLX_BUFFER_SIZE);
        return value;
    case GLUT_WINDOW_STENCIL_SIZE:
        GET_CONFIG(GLX_STENCIL_SIZE);
        return value;
    case GLUT_WINDOW_DEPTH_SIZE:
        GET_CONFIG(GLX_DEPTH_SIZE);
        return value;
    case GLUT_WINDOW_RED_SIZE:
        GET_CONFIG(GLX_RED_SIZE);
        return value;
    case GLUT_WINDOW_GREEN_SIZE:
        GET_CONFIG(GLX_GREEN_SIZE);
        return value;
    case GLUT_WINDOW_BLUE_SIZE:
        GET_CONFIG(GLX_BLUE_SIZE);
        return value;
    case GLUT_WINDOW_ALPHA_SIZE:
        GET_CONFIG(GLX_ALPHA_SIZE);
        return value;
    case GLUT_WINDOW_ACCUM_RED_SIZE:
        GET_CONFIG(GLX_ACCUM_RED_SIZE);
        return value;
    case GLUT_WINDOW_ACCUM_GREEN_SIZE:
        GET_CONFIG(GLX_ACCUM_GREEN_SIZE);
        return value;
    case GLUT_WINDOW_ACCUM_BLUE_SIZE:
        GET_CONFIG(GLX_ACCUM_BLUE_SIZE);
        return value;
    case GLUT_WINDOW_ACCUM_ALPHA_SIZE:
        GET_CONFIG(GLX_ACCUM_ALPHA_SIZE);
        return value;
    case GLUT_WINDOW_DOUBLEBUFFER:
        GET_CONFIG(GLX_DOUBLEBUFFER);
        return value;
    case GLUT_WINDOW_RGBA:
        GET_CONFIG(GLX_RGBA);
        return value;
    case GLUT_WINDOW_COLORMAP_SIZE:
        GET_CONFIG(GLX_RGBA);
        if (value) {
            return 0;
        } else {
#if defined(_WIN32) || defined(__OS2__)
            /* KLUDGE: we always assume 256 colors in CI mode on
               Win32 */
            return 256;
#else
            if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) {
                return __glutCurrentWindow->vis->visual->map_entries;
            } else {
                return __glutCurrentWindow->overlay->vis->visual->map_entries;
            }
#endif /* _WIN32 */
        }
    case GLUT_WINDOW_PARENT:
        return __glutCurrentWindow->parent ?
               __glutCurrentWindow->parent->num + 1 : 0;
    case GLUT_WINDOW_NUM_CHILDREN:
    {
        int num = 0;
        GLUTwindow *children = __glutCurrentWindow->children;

        while (children) {
            num++;
            children = children->siblings;
        }
        return num;
    }
    case GLUT_WINDOW_NUM_SAMPLES:
#if defined(GLX_VERSION_1_1) && defined(GLX_SGIS_multisample)
        if (__glutIsSupportedByGLX("GLX_SGIS_multisample")) {
            GET_CONFIG(GLX_SAMPLES_SGIS);
            return value;
        } else {
            return 0;
        }
#else
        /* Independent of GLX server support, multisampling not
           supported by GLX client-side. */
        return 0;
#endif
    case GLUT_WINDOW_STEREO:
        GET_CONFIG(GLX_STEREO);
        return value;
    case GLUT_WINDOW_CURSOR:
        return __glutCurrentWindow->cursor;
    case GLUT_SCREEN_WIDTH:
        return DisplayWidth(__glutDisplay, __glutScreen);
    case GLUT_SCREEN_HEIGHT:
        return DisplayHeight(__glutDisplay, __glutScreen);
    case GLUT_SCREEN_WIDTH_MM:
        return DisplayWidthMM(__glutDisplay, __glutScreen);
    case GLUT_SCREEN_HEIGHT_MM:
        return DisplayHeightMM(__glutDisplay, __glutScreen);
    case GLUT_MENU_NUM_ITEMS:
        return __glutCurrentMenu->num;
    case GLUT_DISPLAY_MODE_POSSIBLE:
    {
        XVisualInfo *vi;
        Bool dummy, visAlloced;
        void *fbc;

#if defined(_WIN32)
        /* Our fake glXChooseVisual (which is called by
           __glutDetermineVisual) needs an HDC to work with, so grab one
           from the "root" window. */
        XHDC = GetDC(GetDesktopWindow());
#endif
        vi = __glutDetermineWindowVisual(&dummy, &visAlloced, &fbc);
#if defined(_WIN32)
        ReleaseDC(GetDesktopWindow(), XHDC);
#endif
        if (vi) {
            if (visAlloced)
                XFree(vi);
            return 1;
        }
        return 0;
    }
    case GLUT_ELAPSED_TIME:
    {
#ifdef OLD_VMS
        struct timeval6 elapsed, beginning, now;
#else
        struct timeval elapsed, beginning, now;
#endif

        __glutInitTime(&beginning);
        GETTIMEOFDAY(&now);
        TIMEDELTA(elapsed, now, beginning);
        /* Return elapsed milliseconds. */
#if defined(__vms) && ( __VMS_VER < 70000000 )
        return (int) (elapsed.val / TICKS_PER_MILLISECOND);
#else
        return (int) ((elapsed.tv_sec * 1000) + (elapsed.tv_usec / 1000));
#endif
    }
    case GLUT_WINDOW_FORMAT_ID:
#if defined(__OS2__)
        return wglGetPixelFormat(__glutCurrentWindow->hdc);
#elif defined(_WIN32)
        return GetPixelFormat(__glutCurrentWindow->hdc);
#else
        if (__glutCurrentWindow->renderWin == __glutCurrentWindow->win) {
            return (int) __glutCurrentWindow->vis->visualid;
        } else {
            return (int) __glutCurrentWindow->overlay->vis->visualid;
        }
#endif
    default:
        __glutWarning("invalid glutGet parameter: %d", param);
        return -1;
    }
}
Esempio n. 30
0
BOOL t55x7_config_block_show(BYTE *config, BYTE *password)
{
    uint32_t    value= hextoulong(config);
    BOOL        xmode;

    UserMessage("  Config Block (0): %.8s\r\n\r\n", config);
    UserMessageNum("        Master Key: %d  = ", GET_CONFIG(value, T55X7_MASK_MASTER_KEY, T55X7_SHIFT_MASTER_KEY));
    if(GET_CONFIG(value, T55X7_MASK_MASTER_KEY, T55X7_SHIFT_MASTER_KEY) == T55X7_COMPAT_MODE)
        UserMessage("%s\r\n", "Compatibility Mode");
    else
        if(GET_CONFIG(value, T55X7_MASK_MASTER_KEY, T55X7_SHIFT_MASTER_KEY) == T55X7_XMODE_MODE)
            UserMessage("%s\r\n", "Extended Mode");
        else
            UserMessage("%s\r\n", "Undefined Mode");
    xmode= GET_CONFIG(value, T55X7_MASK_XMODE, T55X7_SHIFT_XMODE);
    UserMessage("            X-Mode: %s\r\n", xmode ? "True" : "False");

    // display additional/alternate fields if in xmode
    if(xmode)
    {
        UserMessageNum("         Data Rate: %02d = ", GET_CONFIG(value, T55X7_XMODE_MASK_DATA_BIT_RATE, T55X7_SHIFT_DATA_BIT_RATE));
        UserMessageNum("%d * FC\r\n", GET_CONFIG(value, T55X7_XMODE_MASK_DATA_BIT_RATE, T55X7_SHIFT_DATA_BIT_RATE) * 2 + 2);
        UserMessageNum("        Modulation: %02d = ", GET_CONFIG(value, T55X7_MASK_MODULATION, T55X7_SHIFT_MODULATION));
        if(GET_CONFIG(value, T55X7_MASK_MODULATION, T55X7_SHIFT_MODULATION) > 8)
        {
            if(GET_CONFIG(value, T55X7_MASK_MODULATION, T55X7_SHIFT_MODULATION)== T55X7_MOD_BIPHASE_50)
                UserMessage("%s\r\n", "BiPhase ('50)");
            else
                if (GET_CONFIG(value, T55X7_MASK_MODULATION, T55X7_SHIFT_MODULATION)== T55X7_MOD_BIPHASE_57)
                    UserMessage("%s\r\n", "BiPhase ('57)");
                else
                    UserMessage("%s\r\n", "Invalid");
        }
        else
            UserMessage("%s\r\n", (BYTE *) T55x7_Compat_Modulation[GET_CONFIG(value, T55X7_MASK_MODULATION, T55X7_SHIFT_MODULATION)]);
       UserMessage("              SST: %s\r\n", GET_CONFIG(value, T55X7_XMODE_MASK_SST, T55X7_SHIFT_ST_SST) ? "True" : "False");
    }
    else
    {
        UserMessageNum("         Data Rate: %02d = ", GET_CONFIG(value, T55X7_COMPAT_MASK_DATA_BIT_RATE, T55X7_SHIFT_DATA_BIT_RATE));
        UserMessageNum("%d * FC\r\n", T55x7_Compat_Data_Rates[GET_CONFIG(value, T55X7_COMPAT_MASK_DATA_BIT_RATE, T55X7_SHIFT_DATA_BIT_RATE)]);
        UserMessageNum("        Modulation: %02d = ", GET_CONFIG(value, T55X7_MASK_MODULATION, T55X7_SHIFT_MODULATION));
        if(GET_CONFIG(value, T55X7_MASK_MODULATION, T55X7_SHIFT_MODULATION) > 8)
        {
            if(GET_CONFIG(value, T55X7_MASK_MODULATION, T55X7_SHIFT_MODULATION)== 16)
                UserMessage("%s\r\n", "BiPhase ('50)");
            else
                UserMessage("%s\r\n", "Reserved/Invalid");
        }
        else
            UserMessage("%s\r\n", (BYTE *) T55x7_Compat_Modulation[GET_CONFIG(value, T55X7_MASK_MODULATION, T55X7_SHIFT_MODULATION)]);
        UserMessage("                ST: %s\r\n", GET_CONFIG(value, T55X7_COMPAT_MASK_ST, T55X7_SHIFT_ST_SST) ? "True" : "False");
    }
    // display common fields
    UserMessageNum("       PSK Carrier: %d = ", GET_CONFIG(value, T55X7_MASK_PSK_CARRIER_FREQ, T55X7_SHIFT_PSK_CARRIER_FREQ));
    if(GET_CONFIG(value, T55X7_MASK_PSK_CARRIER_FREQ, T55X7_SHIFT_PSK_CARRIER_FREQ) > 2)
        UserMessage("%s\r\n", "Reserved");
    else
        UserMessageNum("%d * FC\r\n", GET_CONFIG(value, T55X7_MASK_PSK_CARRIER_FREQ, T55X7_SHIFT_PSK_CARRIER_FREQ) * 2 + 2);
    UserMessageNum("          Maxblock: %d\r\n", GET_CONFIG(value, T55X7_MASK_MAX_BLOCK, T55X7_SHIFT_MAX_BLOCK));
    UserMessage("               AOR: %s\r\n", GET_CONFIG(value, T55X7_MASK_AOR, T55X7_SHIFT_AOR) ? "True" : "False");
    UserMessage("               OTP: %s\r\n", GET_CONFIG(value, T55X7_MASK_OTP, T55X7_SHIFT_OTP) ? "True" : "False");
    UserMessage("               PWD: %s\r\n", GET_CONFIG(value, T55X7_MASK_PWD, T55X7_SHIFT_PWD) ? "True" : "False");
    UserMessage("        Fast Write: %s\r\n", GET_CONFIG(value, T55X7_MASK_FAST_WRITE, T55X7_SHIFT_FAST_WRITE) ? "True" : "False");
    UserMessage("      Inverse Data: %s\r\n", GET_CONFIG(value, T55X7_MASK_INVERSE_DATA, T55X7_SHIFT_INVERSE_DATA) ? "True" : "False");
    UserMessage("         POR Delay: %s\r\n", GET_CONFIG(value, T55X7_MASK_POR_DELAY, T55X7_SHIFT_POR_DELAY) ? "True" : "False");

    UserMessage("\r\n     PWD Block (7): %.8s    ", password);
    printhexreadable(password, 4);
    UserMessage("%s", "\r\n");
    return TRUE;
}