Context Navigation

fsCore.cpp @ 4

Revision 4, 35.0 KB checked in by ajaworski, 13 years ago (diff)
Added modified SAGE sources

Rev	Line
[4]	1	/******************************************************************************
	2	* SAGE - Scalable Adaptive Graphics Environment
	3	*
	4	* Module: fsCore.cpp - the core part of the Free Space Manager processing
	5	* user commands to run applications or send appropriate orders
	6	* to each part of SAGE.
	7	* Author : Byungil Jeong
	8	*
	9	* Copyright (C) 2004 Electronic Visualization Laboratory,
	10	* University of Illinois at Chicago
	11	*
	12	* All rights reserved.
	13	*
	14	* Redistribution and use in source and binary forms, with or without
	15	* modification, are permitted provided that the following conditions are met:
	16	*
	17	* * Redistributions of source code must retain the above copyright
	18	* notice, this list of conditions and the following disclaimer.
	19	* * Redistributions in binary form must reproduce the above
	20	* copyright notice, this list of conditions and the following disclaimer
	21	* in the documentation and/or other materials provided with the distribution.
	22	* * Neither the name of the University of Illinois at Chicago nor
	23	* the names of its contributors may be used to endorse or promote
	24	* products derived from this software without specific prior written permission.
	25	*
	26	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	27	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	28	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	29	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
	30	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	31	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	32	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
	33	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
	34	* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
	35	* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
	36	* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	37	*
	38	* Direct questions, comments etc about SAGE to sage_users@listserv.uic.edu or
	39	* http://www.evl.uic.edu/cavern/forum/
	40	*
	41	*****************************************************************************/
	42
	43	#include "fsCore.h"
	44	#include "fsManager.h"
	45	#include "streamInfo.h"
	46	#include "misc.h"
	47	#include "displayInstance.h"
	48	#include "sageVirtualDesktop.h"
	49	#include "streamProtocol.h"
	50	#include "sageDrawObject.h"
	51
	52	FILE *logFile;
	53
	54	fsCore::fsCore()
	55	{
	56	fsm = NULL;
	57	}
	58
	59	fsCore::~fsCore()
	60	{
	61	}
	62
	63	int fsCore::init(fsManager *m)
	64	{
	65	fsm = m;
	66	winSteps = (int)ceil(m->winTime/20.0);
	67	logFile = fopen("window.log","w+");
	68	return 0;
	69	}
	70
	71	int fsCore::initDisp(appInExec* app)
	72	{
	73	displayInstance *disp = new displayInstance(fsm, fsm->m_execIndex, app);
	74	fsm->dispList.push_back(disp);
	75
	76	return 0;
	77	}
	78
	79	int fsCore::initAudio()
	80	{
	81	appInExec *appExec;
	82	int execNum = fsm->execList.size();
	83
	84	//int msgLen = 8 + SAGE_IP_LEN * execNum;
	85	int msgLen = 8 + SAGE_IP_LEN * fsm->vdtList[0]->getNodeNum();
	86	char *msgStr = new char[msgLen];
	87	memset(msgStr, 0, msgLen);
	88
	89	int i = execNum -1;
	90	i = fsm->m_execIndex;
	91	appExec = fsm->execList[i];
	92	if (!appExec) {
	93	//continue;
	94	}
	95	else
	96	{
	97	fsm->vdtList[0]->generateAudioRcvInfo(fsm->rInfo.audioPort, msgStr);
	98	//printf("initaudio --> %s\n", msgStr);
	99	char conMessage[TOKEN_LEN];
	100	sprintf(conMessage, "%s %d", msgStr, i);
	101	if (fsm->sendMessage(appExec->sailClient, SAIL_CONNECT_TO_ARCV, conMessage) < 0) {
	102	sage::printLog("fsCore : %s(%d) is stuck or shutdown", appExec->appName, i);
	103	clearAppInstance(i);
	104	}
	105	}
	106
	107	return 0;
	108	}
	109
	110	void fsCore::clearAppInstance(int id)
	111	{
	112	int index = 0;
	113	appInExec* app = findApp(id, index);
	114	if (!app)
	115	{
	116	std::cout << "fsCore::clearAppInstance() : ERROR : " << id << " app instance is not found" << std::endl;
	117	return;
	118	}
	119
	120	// clear app instance on display nodes
	121	fsm->sendToAllRcvs(RCV_SHUTDOWN_APP, id);
	122
	123	// clear app instance on audio nodes
	124	if (app->audioOn) {
	125	std::vector<int> arcvList = fsm->vdtList[0]->getAudioRcvClientList();
	126	int arcvNum = arcvList.size();
	127	for(int i=0; i<arcvNum; i++)
	128	fsm->sendMessage(arcvList[i], ARCV_SHUTDOWN_APP, id);
	129	}
	130
	131	// clear app instace on ui clients
	132	int uiNum = fsm->uiList.size();
	133	for (int j=0; j<uiNum; j++) {
	134	if (fsm->uiList[j] < 0)
	135	continue;
	136
	137	if (fsm->sendMessage(fsm->uiList[j], UI_APP_SHUTDOWN, id) < 0) {
	138	sage::printLog("fsCore::clearAppInstance() : uiClient(%d) is stuck or shutdown", j);
	139	fsm->uiList[j] = -1;
	140	}
	141	}
	142
	143	// RE-GENERATING ID (1/2)
	144	//fsm->m_execIDList[id] = 0;
	145	// release data structure
	146	delete app;
	147	app = NULL;
	148	fsm->execList.erase(fsm->execList.begin() + index);
	149
	150	displayInstance* temp_disp = (displayInstance*) fsm->dispList[index];
	151	if (temp_disp) {
	152	delete temp_disp;
	153	fsm->dispList.erase(fsm->dispList.begin() + index);
	154	}
	155	//std::cout << "FsCore : " << id << " app instance is cleared (index: " << index << ")" << std::endl;
	156
	157	}
	158
	159	int fsCore::getAvailableInstID(void)
	160	{
	161	for(int i=0; i<MAX_INST_NUM; i++)
	162	{
	163	if (fsm->m_execIDList[i] == 0)
	164	return i;
	165	}
	166	return -1;
	167	}
	168
	169	appInExec* fsCore::findApp(int id, int& index)
	170	{
	171	std::vector<appInExec*>::iterator iter_exec;
	172	appInExec* temp_exec = NULL;
	173	index = 0;
	174	for(iter_exec = fsm->execList.begin(); iter_exec != fsm->execList.end(); iter_exec++, index++)
	175	{
	176	if ((*iter_exec)->fsInstID == id)
	177	{
	178	temp_exec = (appInExec) iter_exec;
	179	break;
	180	}
	181	}
	182	return temp_exec;
	183	}
	184
	185
	186	//#define MAX_SAGE_WINDOW_SIZE 4096
	187	#define MAX_SAGE_WINDOW_SIZE 8192
	188
	189	int fsCore::parseMessage(sageMessage &msg, int clientID)
	190	{
	191	appInExec *app;
	192	displayInstance *disp;
	193
	194	char token[TOKEN_LEN], dataStr[TOKEN_LEN];
	195	int tokenNum;
	196
	197	if (msg.getData())
	198	strcpy(dataStr, (char *)msg.getData());
	199
	200	switch(msg.getCode()) {
	201	case REG_APP : {
	202	app = new appInExec;
	203	memset(app->launcherID, 0, SAGE_NAME_LEN);
	204	sscanf((char *)msg.getData(), "%s %d %d %d %d %d %s %d %d %d %d %d %d %s %d", app->appName, &app->x, &app->y,
	205	&app->width, &app->height, &app->bandWidth, app->renderNodeIP, &app->imageWidth,
	206	&app->imageHeight, (int )&app->audioOn, (int )&app->protocol, &app->frameRate,
	207	&app->instID, app->launcherID, &app->portForwarding );
	208
	209	// adjust app window size considering image resolution
	210	float ar = (float)(app->imageWidth) / (float)(app->imageHeight);
	211	if ((app->imageWidth > MAX_SAGE_WINDOW_SIZE && app->width < MAX_SAGE_WINDOW_SIZE) \|\|
	212	(app->imageHeight > MAX_SAGE_WINDOW_SIZE && app->height < MAX_SAGE_WINDOW_SIZE)) {
	213	if (ar > 1) {
	214	app->width = MAX_SAGE_WINDOW_SIZE;
	215	app->height = (int)(MAX_SAGE_WINDOW_SIZE/ar);
	216	}
	217	else {
	218	app->height = MAX_SAGE_WINDOW_SIZE;
	219	app->width = (int)(MAX_SAGE_WINDOW_SIZE*ar);
	220	}
	221	}
	222
	223	app->sailClient = clientID;
	224
	225	char sailInitMsg[TOKEN_LEN];
	226	memset(sailInitMsg, 0, TOKEN_LEN);
	227
	228	// RE-GENERATING ID (2/2)
	229	//fsm->m_execIndex = getAvailableInstID();
	230	//fsm->m_execIDList[fsm->m_execIndex] = 1;
	231	app->fsInstID = fsm->m_execIndex;
	232	std::cout << "[fsCore::parseMessage] REG_APP inst id : " << app->fsInstID << std::endl;
	233
	234	sprintf(sailInitMsg, "%d %d %d %d", fsm->m_execIndex, fsm->nwInfo->rcvBufSize,
	235	fsm->nwInfo->sendBufSize, fsm->nwInfo->mtuSize);
	236
	237	if (fsm->sendMessage(clientID, SAIL_INIT_MSG, sailInitMsg) < 0) {
	238	sage::printLog("fsCore::parseMessage() : REG_APP : %s is stuck or shutdown", app->appName);
	239	}
	240	else
	241	fsm->execList.push_back(app);
	242
	243	if (fsm->NRM) {
	244	char rcvIP[SAGE_IP_LEN];
	245	fsm->vdtList[0]->getNodeIPs(0, rcvIP);
	246	char msgStr[TOKEN_LEN];
	247	memset(msgStr, 0, TOKEN_LEN);
	248	sprintf(msgStr, "%s %s %d %d", app->renderNodeIP, rcvIP, app->bandWidth,
	249	fsm->m_execIndex);
	250
	251	int uiNum = fsm->uiList.size();
	252	for (int j=0; j<uiNum; j++) {
	253	if (fsm->uiList[j] < 0)
	254	continue;
	255
	256	if (fsm->sendMessage(fsm->uiList[j], REQUEST_BANDWIDTH, msgStr) < 0) {
	257	sage::printLog("fsCore : uiClient(%d) is stuck or shutdown", j);
	258	fsm->uiList[j] = -1;
	259	}
	260	}
	261	}
	262	else {
	263	initDisp(app);
	264	if (app->audioOn) {
	265	std::cout << "initAudio is called" << std::endl;
	266	initAudio();
	267	}
	268
	269	//windowChanged(fsm->execList.size()-1);
	270	//bringToFront(fsm->execList.size()-1);
	271	fsm->m_execIndex++;
	272	}
	273
	274	break;
	275	}
	276
	277	case NOTIFY_APP_SHUTDOWN : {
	278	/*
	279	getToken((char *)msg.getData(), token);
	280	int appID = atoi(token);
	281	*/
	282	int appID;
	283	sscanf((char *)msg.getData(), "%d", &appID);
	284
	285	#ifdef DEBUG_KILL
	286	fprintf(stderr, "fsCore::parseMsg() : NOTIFY_APP_SHUTDOWN. app %d\n", appID);
	287	#endif
	288	int index =0;
	289	app = findApp(appID, index);
	290	if (!app) {
	291	std::cout << "FsCore : app "<< appID << " doesn't exist" << std::endl;
	292	break;
	293	}
	294
	295	clearAppInstance(appID);
	296	break;
	297	}
	298
	299	case NETWORK_RESERVED : {
	300	//std::cout << "network_reserved is called ------------------- " << std::endl;
	301	if (fsm->NRM) {
	302	int appID = fsm->execList.size()-1;
	303	app = fsm->execList[appID];
	304
	305	int success = atoi(dataStr);
	306	if (success) {
	307	initDisp(app);
	308	if (app->audioOn)
	309	initAudio();
	310	windowChanged(fsm->execList.size()-1);
	311	bringToFront(fsm->execList.size()-1);
	312	}
	313	else {
	314	if (fsm->sendMessage(app->sailClient, APP_QUIT) < 0) {
	315	//sage::printLog("fsCore : %s(%d) is stuck or shutdown", app->appName, app->fsInstID);
	316	//clearAppInstance(appID);
	317	clearAppInstance(app->fsInstID);
	318	}
	319
	320	fsm->execList.pop_back();
	321	}
	322	}
	323	break;
	324	}
	325
	326	case REG_GRCV : {
	327	int nodeID, dispID;
	328	sscanf((char *)msg.getData(), "%d %d", &nodeID, &dispID);
	329	/*
	330	getToken((char *)msg.getData(), token);
	331	int nodeID = atoi(token);
	332	getToken((char *)msg.getData(), token);
	333	int dispID = atoi(token);
	334	*/
	335	// store client ID of receivers
	336	fsm->vdtList[dispID]->regRcv(clientID, nodeID);
	337
	338	char info[TOKEN_LEN];
	339	// get the tile config info of display node
	340	fsm->vdtList[dispID]->getRcvInfo(nodeID, info);
	341	int streamPort = fsm->vdtList[dispID]->getLocalPort(nodeID);
	342	if (streamPort < 1024)
	343	streamPort = fsm->rInfo.streamPort;
	344	else
	345	fsm->useLocalPort = true;
	346
	347	char msgStr[TOKEN_LEN];
	348	memset(msgStr, 0, TOKEN_LEN);
	349	sprintf(msgStr, "%d %d %d %d %d %d %d %s", fsm->nwInfo->rcvBufSize,
	350	fsm->nwInfo->sendBufSize, fsm->nwInfo->mtuSize,
	351	streamPort, fsm->rInfo.bufSize, (int)fsm->rInfo.fullScreen,
	352	fsm->vdtList[dispID]->getNodeNum(), info);
	353
	354	if (fsm->sendMessage(clientID, RCV_INIT, msgStr) < 0) {
	355	sage::printLog("fsCore : displaynode(%d) doesn't respond", nodeID);
	356	}
	357	break;
	358	}
	359
	360	case REG_ARCV : {
	361	int nodeID;
	362	sscanf((char *)msg.getData(), "%d", &nodeID);
	363	/*
	364	getToken((char *)msg.getData(), token);
	365	int nodeID = atoi(token);
	366	*/
	367	// store client ID of receivers
	368	fsm->vdtList[0]->regAudioRcv(clientID, nodeID);
	369
	370	char info[TOKEN_LEN];
	371	// get the tile config info of display node
	372	fsm->vdtList[0]->getAudioRcvInfo(nodeID, info);
	373	char msgStr[TOKEN_LEN];
	374	sprintf(msgStr, "%d %d %d %d %d %d %d %d %s", fsm->nwInfo->rcvBufSize,
	375	fsm->nwInfo->sendBufSize, fsm->nwInfo->mtuSize, fsm->rInfo.audioSyncPort,
	376	fsm->rInfo.audioPort, fsm->rInfo.agSyncPort, fsm->rInfo.bufSize, fsm->vdtList[0]->getNodeNum(), info);
	377
	378	//cout << " ----> fsCore : " << msgStr << endl;
	379	fsm->sendMessage(clientID, ARCV_AUDIO_INIT, msgStr);
	380	break;
	381	}
	382
	383	/*case SYNC_INIT_ARCV : {
	384	// find gStreamRcvs connected to this aStreamRcv
	385	getToken((char *)msg.getData(), token);
	386	int nodeID = atoi(token);
	387	//fsm->vdt->getgRcvs(nodeID);
	388	char info[TOKEN_LEN];
	389	fsm->vdt->getAudioNodeIPs(nodeID, info);
	390
	391	// send message to gStreamRcvs
	392
	393	// for testing
	394	std::vector<int> rcvList = fsm->vdt->getRcvClientList();
	395	int rcvNum = rcvList.size();
	396	for(int i=0; i<rcvNum; i++) {
	397	fsm->sendMessage(rcvList[i], RCV_SYNC_INIT, info);
	398	}
	399
	400	break;
	401	}*/
	402
	403	case SHUTDOWN_APP : {
	404	int appID = -1;
	405	//tokenNum = getToken((char *)msg.getData(), token);
	406	//appID = atoi(token);
	407	sscanf((char *)msg.getData(), "%d", &appID);
	408	fprintf(stderr, "fsCore::parseMessage() : SHUTDOWN_APP : %d\n", appID);
	409
	410	int index = 0;
	411	app = findApp(appID, index);
	412	if (!app) {
	413	fprintf(stderr, "fsCore::parseMessage() : SHUTDOWN_APP : appID %d doesn't exist in the app vector\n", appID);
	414	break;
	415	}
	416
	417	#ifdef DEBUG_KILL
	418	fprintf(stderr, "fsCore::parseMsg() : SHUTDOWN_APP : sendMessage(%d, APP_QUIT)\n", app->sailClient);
	419	#endif
	420	if (fsm->sendMessage(app->sailClient, APP_QUIT) < 0) {
	421	sage::printLog("fsCore::parseMessage() : SHUTDOWN_APP : %s(%d) exist in the app vector but fsClient doesn't exist\n", app->appName, appID);
	422	}
	423
	424	clearAppInstance(appID);
	425
	426	break;
	427	}
	428
	429	case SAGE_APP_SHARE : {
	430	/*
	431	tokenNum = getToken((char *)msg.getData(), token);
	432	int appID = atoi(token);
	433	*/
	434
	435	int appID, fsPort, index=0;
	436	char fsIP[SAGE_IP_LEN];
	437	sscanf((char *)msg.getData(), "%d %s %d", &appID, &fsIP[0], &fsPort);
	438
	439	app = findApp(appID, index);
	440	if (!app) {
	441	std::cout << "FsCore : app "<< appID << " doesn't exist" << std::endl;
	442	break;
	443	}
	444
	445	/*
	446	getToken((char *)msg.getData(), fsIP);
	447	getToken((char *)msg.getData(), token);
	448	*/
	449	//int fsPort = atoi(token);
	450	char msgData[TOKEN_LEN];
	451	memset(msgData, 0, TOKEN_LEN);
	452	sprintf(msgData, "%s %d", fsIP, fsPort);
	453
	454	//std::cout << fsIP << ":" << fsPort << std::endl;
	455
	456	if (fsm->sendMessage(app->sailClient, SAGE_APP_SHARE, msgData) < 0) {
	457	sage::printLog("fsCore : %s(%d) is stuck or shutdown", app->appName, appID);
	458	clearAppInstance(appID);
	459	}
	460
	461	break;
	462	}
	463
	464	case MOVE_WINDOW : {
	465	sageRect devRect;
	466	int winID, index;
	467	float x,y;
	468	sscanf((char *)msg.getData(), "%d %f %f", &winID, &x, &y);
	469	devRect.x = int(x);
	470	devRect.y = int(y);
	471	/*
	472	tokenNum = getToken((char *)msg.getData(), token);
	473	int winID = atoi(token);
	474	int index =0;
	475	*/
	476	app = findApp(winID, index);
	477	if (!app) {
	478	std::cout << "FsCore : app "<< winID << " doesn't exist" << std::endl;
	479	break;
	480	}
	481	/*
	482	// change x position(left) of app window
	483	if (tokenNum < 1) {
	484	std::cout << "More arguments are needed for this command " << std::endl;
	485	break;
	486	}
	487
	488	tokenNum = getToken((char *)msg.getData(), token);
	489	devRect.x = atoi(token);
	490
	491	// change y position(bottom) of app windows
	492	if (tokenNum < 1) {
	493	std::cout << "More arguments are needed for this command " << std::endl;
	494	break;
	495	}
	496
	497	tokenNum = getToken((char *)msg.getData(), token);
	498	devRect.y = atoi(token);
	499	*/
	500	//fsm->dispList[index]->modifyStream();
	501
	502	startTime = sage::getTime();
	503	if (fsm->winStep > 0)
	504	winSteps = fsm->winStep;
	505
	506	if (fsm->dispList[index]->changeWindow(devRect, winSteps) < 0)
	507	clearAppInstance(winID);
	508	else
	509	windowChanged(winID);
	510
	511	break;
	512	}
	513
	514	case ADD_OBJECT : {
	515	if (!msg.getData())
	516	break;
	517
	518	sageRect *obj = new sageRect;
	519	char objectName[SAGE_NAME_LEN];
	520	sscanf(dataStr, "%s %d %d %d %d", objectName, &obj->x, &obj->y,
	521	&obj->width, &obj->height);
	522	int objectID = fsm->drawObjectList.size();
	523	fsm->drawObjectList.push_back(obj);
	524
	525	char msgStr[TOKEN_LEN];
	526	sprintf(msgStr, "%d %s", objectID, dataStr);
	527	fsm->sendToAllRcvs(ADD_OBJECT, msgStr);
	528	fsm->sendMessage(clientID, UI_OBJECT_INFO, msgStr);
	529
	530	break;
	531	}
	532
	533	case MOVE_OBJECT : {
	534	if (!msg.getData())
	535	break;
	536
	537	int id, dx, dy;
	538	sscanf(dataStr, "%d %d %d", &id, &dx, &dy);
	539
	540	if (id >= fsm->drawObjectList.size())
	541	break;
	542
	543	sageRect *obj = fsm->drawObjectList[id];
	544	obj->x += dx;
	545	obj->y += dy;
	546
	547	char msgStr[TOKEN_LEN];
	548	sprintf(msgStr, "%d %d %d", id, obj->x, obj->y);
	549	fsm->sendToAllRcvs(UPDATE_OBJECT_POSITION, msgStr);
	550
	551	break;
	552	}
	553
	554	case REMOVE_OBJECT : {
	555	if (!msg.getData())
	556	break;
	557
	558	int id;
	559	sscanf(dataStr, "%d", &id);
	560
	561	if (id >= fsm->drawObjectList.size()) {
	562	std::cout << "fsCore: invalid object ID " << id << std::endl;
	563	break;
	564	}
	565
	566	fsm->sendToAllRcvs(REMOVE_OBJECT, dataStr);
	567
	568	break;
	569	}
	570
	571	case OBJECT_MESSAGE : {
	572	if (!msg.getData())
	573	break;
	574
	575	int id;
	576	sscanf(dataStr, "%d", &id);
	577
	578	if (id >= fsm->drawObjectList.size()) {
	579	std::cout << "fsCore: invalid object ID " << id << std::endl;
	580	break;
	581	}
	582
	583	fsm->sendToAllRcvs(OBJECT_MESSAGE, dataStr);
	584
	585	break;
	586	}
	587
	588	case SHOW_OBJECT : {
	589	if (!msg.getData())
	590	break;
	591
	592	int id;
	593	sscanf(dataStr, "%d", &id);
	594
	595	if (id >= fsm->drawObjectList.size()) {
	596	std::cout << "fsCore: invalid object ID " << id << std::endl;
	597	break;
	598	}
	599
	600	fsm->sendToAllRcvs(SHOW_OBJECT, dataStr);
	601
	602	break;
	603	}
	604
	605	case FS_TIME_MSG : {
	606	double endTime = sage::getTime();
	607	double bigTime = floor(endTime/1000000.0)*1000000.0;
	608	endTime = (endTime - bigTime)/1000.0;
	609	double sageLatency = (endTime - startTime)/1000.0;
	610	//std::cout << "total latency = " << sageLatency << "ms" << std::endl;
	611	std::cout << "Time Block received at " << endTime << "ms" << std::endl;
	612
	613	/*
	614	double endTime = sageGetTime();
	615	double winTime = (endTime - startTime)/1000.0;
	616	double singleLatency = winTime / winSteps;
	617
	618	//std::cout << winTime << std::endl;
	619
	620	//std::cout << "total time = " << winTime << "ms for " << winSteps << " move/resizing" << std::endl;
	621	//std::cout << "single move/resizing time = " << singleLatency << "ms" << std::endl;
	622	winSteps = (int)(ceil)(fsm->winTime /singleLatency);
	623	//std::cout << "# of window change steps changed to " << winSteps << std::endl;
	624	*/
	625
	626	break;
	627	}
	628
	629	case RESIZE_WINDOW : {
	630	/*
	631	tokenNum = getToken((char *)msg.getData(), token);
	632	int winID = atoi(token);
	633	sageRect devRect;
	634	int index =0;
	635	*/
	636	int winID, index, left, right, bottom, top;
	637	sscanf((char *)msg.getData(), "%d %d %d %d %d", &winID, &left, &right, &bottom, &top);
	638
	639	app = findApp(winID, index);
	640
	641	if (!app) {
	642	std::cout << "FsCore : app "<< winID << " doesn't exist" << std::endl;
	643	break;
	644	}
	645
	646	sageRect devRect;
	647	/*
	648	// change x position(left) of app window
	649	if (tokenNum < 1) {
	650	std::cout << "More arguments are needed for this command " << std::endl;
	651	break;
	652	}
	653
	654	int left, right, bottom, top;
	655
	656	tokenNum = getToken((char *)msg.getData(), token);
	657	left = atoi(token);
	658
	659	// change width of app window
	660	if (tokenNum < 1) {
	661	std::cout << "More arguments are needed for this command " << std::endl;
	662	break;
	663	}
	664
	665	tokenNum = getToken((char *)msg.getData(), token);
	666	right = atoi(token);
	667
	668	// change y position(bottom) of app window
	669	if (tokenNum < 1) {
	670	std::cout << "More arguments are needed for this command " << std::endl;
	671	break;
	672	}
	673
	674	tokenNum = getToken((char *)msg.getData(), token);
	675	bottom = atoi(token);
	676
	677	// change height of app windows
	678	if (tokenNum < 1) {
	679	std::cout << "More arguments are needed for this command " << std::endl;
	680	break;
	681	}
	682
	683	tokenNum = getToken((char *)msg.getData(), token);
	684	top = atoi(token);
	685	**/
	686
	687	// adjust app window size considering image resolution
	688	float ar = (float)(right - left) / (float)(top - bottom);
	689	if (ar > 1 && app->imageWidth > MAX_SAGE_WINDOW_SIZE && right - left < MAX_SAGE_WINDOW_SIZE) {
	690	right = left + MAX_SAGE_WINDOW_SIZE;
	691	top = bottom + (int)(MAX_SAGE_WINDOW_SIZE/ar);
	692	}
	693
	694	if (ar <= 1 && app->imageHeight > MAX_SAGE_WINDOW_SIZE && top - bottom < MAX_SAGE_WINDOW_SIZE) {
	695	top = bottom + MAX_SAGE_WINDOW_SIZE;
	696	right = left + (int)(MAX_SAGE_WINDOW_SIZE*ar);
	697	}
	698
	699	devRect.x = left - app->x;
	700	devRect.width = right - (app->width+app->x) - devRect.x;
	701	devRect.y = bottom - app->y;
	702	devRect.height = top - (app->y+app->height) - devRect.y;
	703
	704	startTime = sage::getTime();
	705
	706	if (fsm->winStep > 0)
	707	winSteps = fsm->winStep;
	708
	709	if (fsm->dispList[index]->changeWindow(devRect, winSteps) < 0)
	710	clearAppInstance(winID);
	711	else
	712	windowChanged(winID);
	713
	714	break;
	715	}
	716
	717	case ROTATE_WINDOW : {
	718	rotateWindow((char *)msg.getData());
	719	break;
	720	}
	721
	722	case SAGE_UI_REG : {
	723	fsm->uiList.push_back(clientID);
	724	sendDisplayInfo(clientID);
	725	sendSageStatus(clientID);
	726	sendAppInfo(clientID);
	727	break;
	728	}
	729
	730	case APP_UI_REG : {
	731	fsm->appUiList.push_back(clientID);
	732	fprintf(stderr,"fsCore::%s() : APP_UI_REG : %s\n", __FUNCTION__, (char *)msg.getData());
	733	tokenNum = getToken((char *)msg.getData(), token);
	734
	735	if (strlen(token) > 0) {
	736	sendAppStatus(clientID, token);
	737	}
	738	else {
	739	std::cout << "More arguments are needed for this command " << std::endl;
	740	}
	741	break;
	742	}
	743
	744	case APP_FRAME_RATE : {
	745	/*
	746	tokenNum = getToken((char *)msg.getData(), token);
	747	int appID = atoi(token);
	748	int index =0;
	749	*/
	750	int appID, index;
	751	char msgData[TOKEN_LEN];
	752	sscanf((char *)msg.getData(), "%d %s", &appID, msgData);
	753
	754	app = findApp(appID, index);
	755
	756	if (!app) {
	757	std::cout << "FsCore : app "<< appID << " doesn't exist" << std::endl;
	758	break;
	759	}
	760
	761	//getToken((char *)msg.getData(), token);
	762	if (fsm->sendMessage(app->sailClient, SAIL_FRAME_RATE, token) < 0) {
	763	sage::printLog("fsCore : %s(%d) is stuck or shutdown", app->appName, appID);
	764	clearAppInstance(appID);
	765	}
	766
	767	break;
	768	}
	769
	770	case PERF_INFO_REQ : {
	771	//int dispNum = fsm->dispList.size();
	772	/*
	773	tokenNum = getToken((char *)msg.getData(), token);
	774	int appID = atoi(token);
	775	int index =0;
	776	*/
	777	int appID, sendingRate, index;
	778	sscanf((char *)msg.getData(), "%d %d", &appID, &sendingRate);
	779
	780	app = findApp(appID, index);
	781	if (!app) {
	782	std::cout << "FsCore : app "<< appID << " doesn't exist" << std::endl;
	783	break;
	784	}
	785	disp = fsm->dispList[index];
	786	/*
	787	int sendingRate;
	788
	789	if (tokenNum < 1) {
	790	std::cout << "More arguments are needed for this command " << std::endl;
	791	break;
	792	}
	793
	794	tokenNum = getToken((char *)msg.getData(), token);
	795	sendingRate = atoi(token);
	796	*/
	797
	798	if (disp->requestPerformanceInfo(sendingRate) < 0)
	799	clearAppInstance(appID);
	800
	801	break;
	802	}
	803
	804	case STOP_PERF_INFO : {
	805	//int dispNum = fsm->dispList.size();
	806	/*
	807	tokenNum = getToken((char *)msg.getData(), token);
	808	int appID = atoi(token);
	809	int index =0;
	810	*/
	811	int appID, index;
	812	sscanf((char *)msg.getData(), "%d", &appID);
	813
	814	app = findApp(appID, index);
	815	if (!app) {
	816	std::cout << "FsCore : app "<< appID << " doesn't exist" << std::endl;
	817	break;
	818	}
	819	disp = fsm->dispList[index];
	820
	821	if (disp->stopPerformanceInfo() < 0)
	822	clearAppInstance(appID);
	823	break;
	824	}
	825
	826	case SAGE_BG_COLOR : {
	827	int red, green, blue;
	828	sscanf((char *)msg.getData(), "%d %d %d", &red, &green, &blue);
	829	/*
	830	tokenNum = getToken((char *)msg.getData(), token);
	831	red = atoi(token);
	832
	833	if (tokenNum < 1) {
	834	std::cout << "More arguments are needed for this command " << std::endl;
	835	_exit(0);
	836	}
	837
	838	tokenNum = getToken((char *)msg.getData(), token);
	839	green = atoi(token);
	840
	841	if (tokenNum < 1) {
	842	std::cout << "More arguments are needed for this command " << std::endl;
	843	_exit(0);
	844	}
	845
	846	tokenNum = getToken((char *)msg.getData(), token);
	847	blue = atoi(token);
	848	*/
	849
	850	for (int i=0; i<fsm->vdtList.size(); i++)
	851	fsm->vdtList[i]->changeBGColor(red, green, blue);
	852
	853	break;
	854	}
	855
	856	case UPDATE_WIN_PROP : {
	857	//int dispNum = fsm->dispList.size();
	858	/*
	859	tokenNum = getToken((char *)msg.getData(), token);
	860	int appID = atoi(token);
	861	int index =0;
	862	*/
	863	int appID, index;
	864	sscanf((char *)msg.getData(), "%d", &appID);
	865
	866	app = findApp(appID, index);
	867	if (!app) {
	868	std::cout << "FsCore : app "<< appID << " doesn't exist" << std::endl;
	869	break;
	870	}
	871	//disp = fsm->dispList[index];
	872
	873	//disp->updateWinProp((char *)msg.getData());
	874	windowChanged(appID);
	875	break;
	876	}
	877
	878	case BRING_TO_FRONT : {
	879	/*
	880	tokenNum = getToken((char *)msg.getData(), token);
	881	int winID = atoi(token);
	882	*/
	883	int winID;
	884	sscanf((char *)msg.getData(), "%d", &winID);
	885	bringToFront(winID);
	886	break;
	887	}
	888
	889	case SAGE_FLIP_WINDOW : {
	890	//int execNum = fsm->execList.size();
	891	/*
	892	tokenNum = getToken((char *)msg.getData(), token);
	893	int appID = atoi(token);
	894	*/
	895	int appID;
	896	sscanf((char *)msg.getData(), "%d", &appID);
	897
	898	int index =0;
	899	app = findApp(appID, index);
	900
	901	if (!app) {
	902	std::cout << "FsCore : app "<< appID << " doesn't exist" << std::endl;
	903	break;
	904	}
	905
	906	if (fsm->sendMessage(app->sailClient, SAIL_FLIP_WINDOW) < 0) {
	907	sage::printLog("fsCore : %s(%d) is stuck or shutdown", app->appName, appID);
	908	clearAppInstance(appID);
	909	}
	910
	911	break;
	912	}
	913
	914	case SAGE_CHECK_LATENCY : {
	915	//int execNum = fsm->execList.size();
	916	/*
	917	tokenNum = getToken((char *)msg.getData(), token);
	918	int appID = atoi(token);
	919	*/
	920	int appID;
	921	sscanf((char *)msg.getData(), "%d", &appID);
	922
	923	int index =0;
	924	app = findApp(appID, index);
	925
	926	if (!app) {
	927	std::cout << "FsCore : app "<< appID << " doesn't exist" << std::endl;
	928	break;
	929	}
	930
	931	if (fsm->sendMessage(app->sailClient, SAIL_SEND_TIME_BLOCK) < 0) {
	932	sage::printLog("fsCore : %s(%d) is stuck or shutdown", app->appName, appID);
	933	clearAppInstance(appID);
	934	}
	935	startTime = sage::getTime();
	936
	937	break;
	938	}
	939
	940	case SAGE_Z_VALUE : {
	941	fsm->sendToAllRcvs(RCV_CHANGE_DEPTH, dataStr);
	942
	943	int uiNum = fsm->uiList.size();
	944
	945	for (int j=0; j<uiNum; j++) {
	946	if (fsm->uiList[j] < 0)
	947	continue;
	948
	949	if (fsm->sendMessage(fsm->uiList[j], Z_VALUE_RETURN, dataStr) < 0) {
	950	sage::printLog("fsCore : uiClient(%d) is stuck or shutdown", j);
	951	fsm->uiList[j] = -1;
	952	}
	953	}
	954
	955	char *tokenbuf;
	956	getToken((char *)msg.getData(), token, &tokenbuf);
	957	int numOfChange = atoi(token);
	958
	959	int index =0;
	960	int appID, zValue;
	961	for (int i=0; i<numOfChange; i++) {
	962	/*
	963	if (tokenNum > 0) {
	964	tokenNum = getToken((char *)msg.getData(), token);
	965	appID = atoi(token);
	966	}
	967	else {
	968	std::cout << "More arguments are needed for this command " << std::endl;
	969	_exit(0);
	970	}
	971
	972	if (tokenNum > 0) {
	973	tokenNum = getToken((char *)msg.getData(), token);
	974	zValue = atoi(token);
	975	}
	976	else {
	977	std::cout << "More arguments are needed for this command " << std::endl;
	978	_exit(0);
	979	}
	980	*/
	981	getToken(NULL, token, &tokenbuf);
	982	appID = atoi(token);
	983	getToken(NULL, token, &tokenbuf);
	984	zValue = atoi(token);
	985
	986	app = findApp(appID, index);
	987	if(!app) continue;
	988
	989	fsm->dispList[index]->setZValue(zValue);
	990	}
	991
	992	break;
	993	}
	994
	995	case SAGE_ADMIN_CHECK : {
	996	int execNum = fsm->execList.size();
	997
	998	for (int i=0; i<execNum; i++) {
	999	app = fsm->execList[i];
	1000	if (!app)
	1001	continue;
	1002
	1003	displayInstance *disp = fsm->dispList[i];
	1004
	1005	int left = app->x;
	1006	int bottom = app->y;
	1007	int right = app->x + app->width;
	1008	int top = app->y + app->height;
	1009
	1010	int dispNodes = 0; //disp->getReceiverNum();
	1011	int renderNodes = 0;//app->nodeNum;
	1012	int numStream = 0; //disp->getStreamNum();
	1013
	1014	char msgStr[512];
	1015	memset(msgStr, 0, 512);
	1016	sprintf(msgStr, "App Name : %s\n App Instance ID : %d\n",
	1017	app->appName, app->fsInstID);
	1018	sprintf(token, " position (left, right, bottom, top) : ( %d , %d , %d , %d )\n",
	1019	left, right, bottom, top);
	1020	strcat(msgStr, token);
	1021	sprintf(token, " Z-Value : %d\n", disp->getZValue());
	1022	strcat(msgStr, token);
	1023	sprintf(token, " %d Rendering Nodes %d Display Nodes %d Streams\n",
	1024	renderNodes, dispNodes, numStream );
	1025	strcat(msgStr, token);
	1026
	1027	fsm->sendMessage(clientID, UI_ADMIN_INFO, msgStr);
	1028	}
	1029
	1030	break;
	1031	}
	1032
	1033	case SAGE_SHUTDOWN : {
	1034	std::cout << "shutdown SAGE" << std::endl;
	1035	int execNum = fsm->execList.size();
	1036
	1037	for (int i=0; i<execNum; i++) {
	1038	app = fsm->execList[i];
	1039	if (!app)
	1040	continue;
	1041
	1042	fsm->sendMessage(app->sailClient, APP_QUIT);
	1043	}
	1044
	1045	fsm->sendToAllRcvs(SHUTDOWN_RECEIVERS);
	1046
	1047	std::vector<int> arcvList = fsm->vdtList[0]->getAudioRcvClientList();
	1048	int arcvNum = arcvList.size();
	1049	for(int i=0; i<arcvNum; i++)
	1050	fsm->sendMessage(arcvList[i], SHUTDOWN_RECEIVERS);
	1051
	1052	fsm->fsmClose = true;
	1053	break;
	1054	}
	1055	}
	1056
	1057	return 0;
	1058	}
	1059
	1060	int fsCore::rotateWindow(char *msgStr)
	1061	{
	1062	//char token[TOKEN_LEN];
	1063	//int tokenNum = getToken(msgStr, token);
	1064	//int winID = atoi(token);
	1065
	1066	int winID, rotation;
	1067	sscanf( msgStr, "%d %d", &winID, &rotation);
	1068
	1069	appInExec *app = NULL;
	1070	int index =0;
	1071	app = findApp(winID, index);
	1072	if (!app) {
	1073	sage::printLog("fsCore::rotateWindow : app %d doesn't exist", winID);
	1074	return -1;
	1075	}
	1076	/*
	1077	if (tokenNum < 1) {
	1078	sage::printLog("fsCore::rotateWindow : more arguments are needed for this command");
	1079	return -1;
	1080	}
	1081
	1082	getToken(msgStr, token);
	1083	int rotation = atoi(token);
	1084	*/
	1085	switch(rotation) {
	1086	case 90:
	1087	app->rotate(CCW_90);
	1088	break;
	1089	case 180:
	1090	app->rotate(CCW_180);
	1091	break;
	1092	case 270:
	1093	app->rotate(CCW_270);
	1094	break;
	1095	case -90:
	1096	app->rotate(CCW_270);
	1097	break;
	1098	case -180:
	1099	app->rotate(CCW_180);
	1100	break;
	1101	case -270:
	1102	app->rotate(CCW_90);
	1103	break;
	1104	default:
	1105	sage::printLog("rotation commnad error : invalid rotation degree");
	1106	break;
	1107	}
	1108
	1109	if (fsm->dispList[index]->modifyStream() < 0)
	1110	clearAppInstance(winID);
	1111	else
	1112	windowChanged(winID);
	1113
	1114	return 0;
	1115	}
	1116
	1117	int fsCore::windowChanged(int appId)
	1118	{
	1119	int uiNum = fsm->uiList.size();
	1120	for (int j=0; j<uiNum; j++) {
	1121	if (fsm->uiList[j] < 0)
	1122	continue;
	1123
	1124	if (sendAppInfo(appId, fsm->uiList[j]) < 0) {
	1125	sage::printLog("fsCore : uiClient(%d) is stuck or shutdown", j);
	1126	fsm->uiList[j] = -1;
	1127	}
	1128	}
	1129
	1130	return 0;
	1131	}
	1132
	1133	int fsCore::sendSageStatus(int clientID)
	1134	{
	1135	/*
	1136	int numApps = fsm->appDataList.size();
	1137
	1138	char statusStr[SAGE_MESSAGE_SIZE], token[TOKEN_LEN];
	1139
	1140	memset(statusStr, 0, SAGE_MESSAGE_SIZE);
	1141	sprintf(statusStr, "%d\n", numApps);
	1142
	1143	for (int i=0; i<numApps; i++) {
	1144	appDataNode *dataNode = fsm->appDataList[i];
	1145	int instNum = dataNode->instList.size();
	1146	int execNum = dataNode->execs.size();
	1147
	1148	sprintf(token, "%s %d %d ", dataNode->app, execNum, instNum);
	1149	strcat(statusStr, token);
	1150
	1151	for (int j=0; j<instNum; j++) {
	1152	sprintf(token, "%d ", dataNode->instList[j]);
	1153	strcat(statusStr, token);
	1154	}
	1155	strcat(statusStr, "\n");
	1156	}
	1157
	1158	fsm->sendMessage(clientID, SAGE_STATUS, statusStr);
	1159
	1160	memset(statusStr, 0, SAGE_MESSAGE_SIZE);
	1161
	1162	for (int i=0; i<numApps; i++) {
	1163	appDataNode *dataNode = fsm->appDataList[i];
	1164	int execNum = dataNode->execs.size();
	1165
	1166	sprintf(statusStr, "%s\n", dataNode->app);
	1167
	1168	for(int j=0; j<execNum; j++) {
	1169	sprintf(token, "config %s : nodeNum=%d initX=%d initY=%d dimX=%d dimY=%d\n",
	1170	dataNode->execs[j].name, dataNode->execs[j].nodeNum, dataNode->execs[j].posX,
	1171	dataNode->execs[j].posY, dataNode->execs[j].dimX,
	1172	dataNode->execs[j].dimY);
	1173	strcat(statusStr, token);
	1174
	1175	int cmdNum = dataNode->execs[j].cmdList.size();
	1176	for (int k=0; k<cmdNum; k++) {
	1177	sprintf(token, "exec %s %s\n", dataNode->execs[j].cmdList[k].ip,
	1178	dataNode->execs[j].cmdList[k].cmd);
	1179	strcat(statusStr, token);
	1180	}
	1181	sprintf(token, "nwProtocol=%s\n", dataNode->execs[j].nwProtocol);
	1182	strcat(statusStr, token);
	1183	sprintf(token, "bufNum=%d\n", dataNode->execs[j].bufNum);
	1184	strcat(statusStr, token);
	1185	sprintf(token, "syncMode=%d\n", dataNode->execs[j].syncMode);
	1186	strcat(statusStr, token);
	1187	}
	1188
	1189	fsm->sendMessage(clientID, APP_EXEC_CONFIG, statusStr);
	1190	}
	1191	*/
	1192	return 0;
	1193	}
	1194
	1195	int fsCore::sendDisplayInfo(int clientID)
	1196	{
	1197	char displayStr[STRBUF_SIZE];
	1198	memset(displayStr, 0, STRBUF_SIZE);
	1199	displayStr[0] = '\0';
	1200
	1201	for (int i=0; i<fsm->vdtList.size(); i++) {
	1202	int tileNum = fsm->vdtList[i]->getTileNum();
	1203	int dimX = fsm->vdtList[i]->dimX;
	1204	int dimY = fsm->vdtList[i]->dimY;
	1205	int vdtWidth = fsm->vdtList[i]->width;
	1206	int vdtHeight = fsm->vdtList[i]->height;
	1207	int tileWidth = fsm->vdtList[i]->tileList[0]->width;
	1208	int tileHeight = fsm->vdtList[i]->tileList[0]->height;
	1209	int id = fsm->vdtList[i]->displayID;
	1210
	1211	char info[STRBUF_SIZE];
	1212	memset(info, 0, STRBUF_SIZE);
	1213	sprintf(info, "%d %d %d\n%d %d\n%d %d %d\n", tileNum, dimX, dimY, vdtWidth, vdtHeight,
	1214	tileWidth, tileHeight, id);
	1215	strcat(displayStr, info);
	1216	}
	1217
	1218	fsm->sendMessage(clientID, SAGE_DISPLAY_INFO, displayStr);
	1219
	1220	memset(displayStr, 0, STRBUF_SIZE);
	1221	displayStr[0] = '\0';
	1222
	1223	for (int i=0; i<fsm->dispConnectionList.size(); i++) {
	1224	int disp0 = fsm->dispConnectionList[i]->displays[0]->displayID;
	1225	int disp1 = fsm->dispConnectionList[i]->displays[1]->displayID;
	1226	int edge0 = fsm->dispConnectionList[i]->edges[0];
	1227	int edge1 = fsm->dispConnectionList[i]->edges[1];
	1228	int offset = fsm->dispConnectionList[i]->offset;
	1229
	1230	char info[STRBUF_SIZE];
	1231	memset(info, 0, STRBUF_SIZE);
	1232	sprintf(info, "%d %d %d %d %d\n", disp0, edge0, disp1, edge1, offset);
	1233	strcat(displayStr, info);
	1234	}
	1235
	1236	if (fsm->dispConnectionList.size() > 0)
	1237	fsm->sendMessage(clientID, DISP_CONNECTION_INFO, displayStr);
	1238
	1239	return 0;
	1240	}
	1241
	1242	int fsCore::sendAppInfo(int appID, int clientID)
	1243	{
	1244	appInExec *app;
	1245	int index =0;
	1246	app = findApp(appID, index);
	1247	if(!app)
	1248	{
	1249	std::cout << "FsCore::Invalid App ID " << appID << std::endl;
	1250	return 1;
	1251	}
	1252
	1253
	1254	int zValue = 0;
	1255	char appInfoStr[TOKEN_LEN];
	1256	zValue = fsm->dispList[index]->getZValue();
	1257
	1258	int left = app->x;
	1259	int bottom = app->y;
	1260	int right = app->x + app->width;
	1261	int top = app->y + app->height;
	1262	int sailID = app->sailClient;
	1263	int degree = 90 * (int)app->getOrientation();
	1264
	1265	memset(appInfoStr, 0, TOKEN_LEN);
	1266	sprintf(appInfoStr, "%s %d %d %d %d %d %d %d %d %d %d %s %s", app->appName, appID,
	1267	left, right, bottom, top, sailID, zValue, degree, app->displayID,
	1268	app->fsInstID, app->launcherID, fsm->dispList[index]->winTitle);
	1269
	1270	return fsm->sendMessage(clientID, APP_INFO_RETURN, appInfoStr);
	1271	}
	1272
	1273	int fsCore::sendAppInfo(int clientID)
	1274	{
	1275	int appInstNum = fsm->execList.size();
	1276	appInExec *app = NULL;
	1277
	1278	int retVal = 0;
	1279	for (int i=0; i<appInstNum; i++)
	1280	{
	1281	app = (appInExec*) fsm->execList[i];
	1282	if (!app) continue;
	1283	if (sendAppInfo(app->fsInstID, clientID) < 0)
	1284	retVal = 1;
	1285	}
	1286
	1287	return retVal;
	1288	}
	1289
	1290	int fsCore::sendAppStatus(int clientID, char *appName)
	1291	{
	1292	int appInstNum = fsm->execList.size();
	1293	appInExec *app;
	1294	int instNum = 0;
	1295	char statusMsg[TOKEN_LEN];
	1296	statusMsg[0] = '\0';
	1297
	1298	for (int i=0; i<appInstNum; i++) {
	1299	app = fsm->execList[i];
	1300	if (!app)
	1301	return -1;
	1302	if (strcmp(app->appName, appName) == 0) {
	1303	instNum++;
	1304	char instStr[TOKEN_LEN];
	1305	sprintf(instStr, " %d %d", app->fsInstID, app->sailClient);
	1306	strcat(statusMsg, instStr);
	1307	}
	1308	}
	1309
	1310	char msgStr[TOKEN_LEN];
	1311	memset(msgStr, 0, TOKEN_LEN);
	1312	sprintf(msgStr, "%d%s", instNum, statusMsg);
	1313	fsm->sendMessage(clientID, APP_STATUS, msgStr);
	1314
	1315	return 0;
	1316	}
	1317
	1318	int fsCore::bringToFront(int winID)
	1319	{
	1320	appInExec *app;
	1321
	1322	int execNum = fsm->execList.size();
	1323	int numOfWin = 0;
	1324	char depthStr[TOKEN_LEN];
	1325	depthStr[0] = '\0';
	1326
	1327	for (int i=0; i<execNum; i++) {
	1328	app = fsm->execList[i];
	1329	if (!app)
	1330	continue;
	1331
	1332	displayInstance *disp = fsm->dispList[i];
	1333	if (app->fsInstID != winID)
	1334	disp->increaseZ();
	1335	else
	1336	disp->setZValue(0);
	1337
	1338	numOfWin++;
	1339	char zVal[TOKEN_LEN];
	1340	sprintf(zVal, "%d %d ", app->fsInstID, disp->getZValue());
	1341	strcat(depthStr, zVal);
	1342	}
	1343
	1344	char msgStr[TOKEN_LEN];
	1345	memset(msgStr, 0, TOKEN_LEN);
	1346	sprintf(msgStr, "%d %s", numOfWin, depthStr);
	1347
	1348	fsm->sendToAllRcvs(RCV_CHANGE_DEPTH, msgStr);
	1349
	1350	int uiNum = fsm->uiList.size();
	1351
	1352	for (int j=0; j<uiNum; j++) {
	1353	if (fsm->uiList[j] < 0)
	1354	continue;
	1355
	1356	if (fsm->sendMessage(fsm->uiList[j], Z_VALUE_RETURN, msgStr) < 0) {
	1357	sage::printLog("fsCore : uiClient(%d) is stuck or shutdown", j);
	1358	fsm->uiList[j] = -1;
	1359	}
	1360	}
	1361
	1362	return 0;
	1363	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/src/testing/src/fsCore.cpp @ 4

Download in other formats: