コード例 #1
0
////
// which_s = 0 means that it returns first 4th level spell
cItemRec store_mage_spells(short which_s) 
{
	cItemRec spell('spel');// = {21,0, 0,0,0,0,0,0, 53,0,0,0,0, 0, 0,0, {0,0},"", "",0,0,0,0};
	static const short cost[32] = {
		150,200,150,1000,1200,400,300,200,
		200,250,500,1500,300,  250,125,150, 
		400,450, 800,600,700,600,7500, 500,
		5000,3000,3500,4000,4000,4500,7000,5000
	};

	char str[255];
	
	if (which_s != minmax(0,31,which_s))
		which_s = 0;
	spell.item_level = which_s + 30;
	spell.value = cost[which_s];
	get_str((unsigned char*)str,38,which_s + 1);
	spell.full_name = str;
	return spell;
}
コード例 #2
0
MenuConfig::MenuConfig(QWidget *parent, struct ActionUserData *data)
        : MenuConfigBase(parent)
{
    m_data   = data;

    lstMenu->addColumn(i18n("Item"));
    lstMenu->addColumn(i18n("Program"));
    lstMenu->setExpandingColumn(1);
    lstMenu->adjustColumn();
    connect(lstMenu, SIGNAL(selectionChanged(QListViewItem*)), this, SLOT(selectionChanged(QListViewItem*)));
    connect(btnAdd, SIGNAL(clicked()), this, SLOT(add()));
    connect(btnEdit, SIGNAL(clicked()), this, SLOT(edit()));
    connect(btnRemove, SIGNAL(clicked()), this, SLOT(remove()));
    for (unsigned i = 0; i < m_data->NMenu; i++){
        QString str = QString::fromUtf8(get_str(data->Menu, i + 1));
        QString item = getToken(str, ';');
        new QListViewItem(lstMenu, item, str);
    }
    selectionChanged(NULL);
}
コード例 #3
0
ファイル: parser.c プロジェクト: Jamil/miniOS
void cd_function(char* arg){

  char* pwd_current;
 
  char* flags=split_line(arg);
 
  char *temp_response[100];

  *temp_response='\0';
  
  concatinate(temp_response,get_str(10));
  concatinate(temp_response,arg);
  
  pwd_current=temp_response;
  
  
  newLine_load(pwd_current);
  return;
  
}
コード例 #4
0
ファイル: elf_hide.c プロジェクト: jyin0813/OpenBSD-src
void
dump_symtab(Elf_Shdr * symsect, Elf_Sym * symtab, int symtabsize)
{
	int             i;
	Elf_Sym        *psymtab;

	for (i = 0; i < (symtabsize / sizeof(Elf_Sym)); i++) {
		psymtab = &(symtab[i]);
		if ((psymtab->st_info & 0xf0) == 0x10 &&
		    (psymtab->st_shndx != SHN_UNDEF)) {
			printf("symbol %d:\n", i);
			printf("st_name %x \"%s\"\n", psymtab->st_name,
			    get_str(psymtab->st_name));
			printf("st_value %x\n", psymtab->st_value);
			printf("st_size %x\n", psymtab->st_size);
			printf("st_info %x\n", psymtab->st_info);
			printf("st_other %x\n", psymtab->st_other);
			printf("st_shndx %x\n", psymtab->st_shndx);
		}
	}
}
コード例 #5
0
void SearchInfoRequest::element_end(const char *el)
{
    if (!strcmp(el, "field")){
        if (data.Field && *data.Field){
            set_str(&data.VHost, m_client->data.owner.VHost);
            Event e(static_cast<JabberPlugin*>(m_client->protocol()->plugin())->EventSearchInfo, &data);
            e.process();
        }
    }else if (!strcmp(el, "option")){
        m_bOption = false;
        const char *str = get_str(data.Options, data.nOptions);
        if (str && *str)
            data.nOptions++;
    }else if (!strcmp(el, "value")){
        if (m_bOption){
            set_str(&data.Options, data.nOptions, m_data.c_str());
        }else{
            set_str(&data.Value, m_data.c_str());
        }
    }
}
コード例 #6
0
ファイル: drv_ranged_ops.c プロジェクト: sdimitro/libslablist
void
do_ops(slablist_t *sl, uint64_t maxops, int str, int ord)
{
	uint64_t ops = 0;
	static uint64_t rd = 0;
	slablist_elem_t elem;
	slablist_elem_t randrem;
	slablist_elem_t remd;
	remd.sle_u = 0;
	while (ops < maxops) {
		if (str) {
			elem.sle_p = get_str(fd);
		} else {
			rd++;
			elem.sle_u = rd;
		}

		slablist_elem_t found;

		slablist_add(sl, elem, 0);
		/*
		if (!ord) {
			slablist_find(sl, elem, &found);
		}
		*/

		/*
		if (!(ops % 3) && !ord) {
			*
			 * Remove after every 3rd addition.
			randrem = slablist_get_rand(sl);
			slablist_rem(sl, randrem, 0, &remd);
			if (str && remd != NULL) {
				rm_str((char *)remd);
			}
		}
		*/
		ops++;
	}
}
コード例 #7
0
ファイル: read.c プロジェクト: Zabrane/SPOCP
static ptree_t *
parse_sexp(octet_t * sexp)
{
	ptree_t        *ptp, *ntp = 0, *ptr;

	if (*sexp->val == '(') {
		ptp = (ptree_t *) Calloc(1, sizeof(ptree_t));
		ptp->list = 1;
		sexp->val++;
		sexp->len--;
		while (sexp->len && *sexp->val != ')') {
			if ((ptr = parse_sexp(sexp)) == 0) {
				ptree_free(ptp);
				return 0;
			}

			if (ptp->part == 0)
				ntp = ptp->part = ptr;
			else {
				ntp->next = ptr;
				ntp = ntp->next;
			}
		}
		if (*sexp->val == ')') {
			sexp->val++;
			sexp->len--;
		} else {	/* error */
			ptree_free(ptp);
			return 0;
		}
	} else {
		ptp = (ptree_t *) Calloc(1, sizeof(ptree_t));
		if (get_str(sexp, &ptp->val) != SPOCP_SUCCESS) {
			ptree_free(ptp);
			return 0;
		}
	}

	return ptp;
}
コード例 #8
0
bool PContainer::replace(prop_id_t prop_id, std::unique_ptr<PropertyBase>&& prop_ptr) {
  auto it = strids_.find(prop_id);
  auto strid = it->second;
  if (strids_.end() == it) return false;  // prop not found
  auto old_value = get_str(prop_id);
  // keep a reference to the old property documentation tree
  auto old_tree = props_[prop_id].get()->get_spec();
  // copy notification cbs
  auto notification_cbs = props_[prop_id].get()->get_notify_cbs();
  // replace with new prop
  props_[prop_id] = std::forward<std::unique_ptr<PropertyBase>>(prop_ptr);
  auto* prop = props_[prop_id].get();
  prop->set_notify_cbs(notification_cbs);
  prop->set_id(prop_id);
  prop->set_str(old_value);
  // place old tree into new property
  auto tree = prop->get_spec();
  tree->graft(".", old_tree);
  // updating tree_
  tree_->graft(std::string("property.") + strid, tree);
  return true;
}
コード例 #9
0
/*
* Routine: 
* Purpose: 
* Algorithm:
* Data Structures:
*
* Params:
* Returns:
* Called By: 
* Calls: 
* Assumptions:
* Side Effects:
* TODO: None
*/
void
parseQueries(void)
{
	char szFileName[1024],
		*cp;
	FILE *pInputFile;
	int nIndex = 1;
	
	if (!is_set("INPUT"))
	{
		ReportErrorNoLine(QERR_NO_QUERYLIST, NULL, 1);
	}

	strcpy(szFileName, get_str("INPUT"));
	
#ifndef WIN32
	if ((pInputFile = fopen(szFileName, "r")) == NULL)
#else
	if ((pInputFile = fopen(szFileName, "rt")) == NULL)
#endif
	{
		SetErrorGlobals(szFileName, NULL);
		ReportErrorNoLine(QERR_OPEN_FAILED, szFileName, 1);
	}
	
	while (fgets(szFileName, 1024, pInputFile))
	{
		if (strncmp(szFileName, "--", 2) == 0)
			continue;
		if ((cp = strchr(szFileName, '\n')))
			*cp = '\0';
		if (!strlen(szFileName))
			continue;
			
		parseTemplate(szFileName, nIndex++);
	}

	return;
}
コード例 #10
0
ファイル: server.c プロジェクト: jonsafari/mocp
/* Send requested option value to the client. Return 1 if OK. */
static int send_option (struct client *cli)
{
	char *name;

	if (!(name = get_str(cli->socket)))
		return 0;

	/* We can send only a few options, others make no sense here. */
	if (!valid_sync_option(name)) {
		logit ("Client wanted to get invalid option '%s'", name);
		free (name);
		return 0;
	}

	/* All supported options are boolean type. */
	if (!send_data_bool(cli, options_get_bool(name))) {
		free (name);
		return 0;
	}

	free (name);
	return 1;
}
コード例 #11
0
ファイル: sstring.c プロジェクト: nobody1986/libsrt
static ss_t *aux_toint(ss_t **s, const sbool_t cat, const sint_t num)
{
	ASSERT_RETURN_IF(!s, ss_void);
	char btmp[128], *p = btmp + sizeof(btmp) - 1;
	sint_t n = num < 0 ? -num : num;
	do {
		*p-- = '0' + n % 10;
		n /= 10;
	} while (n);
	if (num < 0)
		*p-- = '-';
	const size_t off = (size_t)((p - (char *)btmp) + 1),
		     digits = sizeof(btmp) - off,
		     at = (cat && *s) ? sd_get_size(*s) : 0;
	SS_OVERFLOW_CHECK(s, at, digits);
	const size_t out_size = at + digits;
        if (ss_reserve(s, out_size) >= out_size) {
		memcpy(get_str(*s) + at, btmp + off, digits);
		set_size(*s, out_size);
		inc_unicode_size(*s, digits);
	}
	return *s;
}
コード例 #12
0
ファイル: server.c プロジェクト: jonsafari/mocp
/* Get and set an option from the client. Return 1 on error. */
static int get_set_option (struct client *cli)
{
	char *name;
	int val;

	if (!(name = get_str (cli->socket)))
		return 0;
	if (!valid_sync_option (name)) {
		logit ("Client requested setting invalid option '%s'", name);
		return 0;
	}
	if (!get_int (cli->socket, &val)) {
		free (name);
		return 0;
	}

	options_set_bool (name, val ? true : false);
	free (name);

	add_event_all (EV_OPTIONS, NULL);

	return 1;
}
コード例 #13
0
string SoundPlugin::messageSound(unsigned type, SoundUserData *data)
{
    CommandDef *def = core->messageTypes.find(type);
    if (def){
        MessageDef *mdef = (MessageDef*)(def->param);
        if (mdef->base_type)
            type = mdef->base_type;
    }
    string sound;
    if (data)
        sound = get_str(data->Receive, type);
    if (sound == "-")
        return "";
    if (sound.empty()){
        def = core->messageTypes.find(type);
        if ((def == NULL) || (def->icon == NULL))
            return "";
        sound = def->icon;
        sound += ".wav";
        sound = fullName(sound.c_str());
    }
    return sound;
}
コード例 #14
0
ファイル: strcmd.c プロジェクト: daemqn/Atari_ST_Sources
/*----------------------------------------------------------------------------------------*/
int16	parse_items( uint8 *zeile, uint8 *data, uint8 *value )
{
	uint8		*p = zeile, *q = zeile;
	int16		dlen = (int16)strlen( data );

	while( p != NULL )
	{
		p = strstri(q, data);
	/*	printf( "%s >%s< p=0x%p\n", zeile, data, p ); */
	
		if( p && ((p==zeile) || p[-1] != '\"') && (p[dlen] == '=') )
		{
			get_str( p+dlen+1, value );
			return 1;
		}
		else if( p != NULL )
			q = p+1;
		else
			value[0] = EOS;
	}

	return 0;
}
コード例 #15
0
ファイル: layer_set_rtsp.c プロジェクト: ZakaryWu/iteIndoor
/*************************************************
Function:		ShowRtspEnable
Description: 	获取rtsp存储以及显示是否启用
Input:		无
Output:		无
Return:		TRUE 是 FALSE 否
Others:
*************************************************/
static void ShowRtspEnable()
{
	uint8 i;

	storage_free_monitordev_memory(&g_list);
	storage_get_monitordev(&g_list);
	if (NULL == g_list)
	{
		return false;
	}
	else
	{
		for (i = 0; i < MAX_HOME_NUM; i++)
		{
			int used = 0;
			if (i < g_list->Homenum)
			{
				used = g_list->Homedev[i].EnableOpen;
			}
			ituTextSetString(SetCamera2Text[i], get_str(SID_Set_UnUsed + used));
		}
	}
}
コード例 #16
0
ファイル: creature.cpp プロジェクト: grimoire/Cataclysm-DDA
int Creature::weight_capacity() const
{
    int base_carry = 13000 + get_str() * 4000;
    switch( get_size() ) {
    case MS_TINY:
        base_carry /= 4;
        break;
    case MS_SMALL:
        base_carry /= 2;
        break;
    case MS_MEDIUM:
    default:
        break;
    case MS_LARGE:
        base_carry *= 2;
        break;
    case MS_HUGE:
        base_carry *= 4;
        break;
    }

    return base_carry;
}
コード例 #17
0
ファイル: stream.c プロジェクト: xupingmao-old/venus
tm_obj stream_read( tm_vm* tm, tm_obj params){
	int len = list_len( params );
	tm_obj fp_ = get_arg( params, 0, TM_STREAM);
	int rest_len = 0;
	FILE* fp = get_file(fp_);
	if( len == 1){
		rest_len = _get_file_rest_len( fp );
		fseek(fp, 0, SEEK_END);
	}else if( len == 2){
		tm_obj size = get_arg( params, 1, TM_NUM);
		int v = (int) get_num( size );
		rest_len = _get_file_rest_len( fp );
		if( rest_len > v ){
			rest_len = v;
		}
	}else {
		tm_raise("stream_read: too many arguments");
	}
	tm_obj des = str_new(NULL, rest_len);
	char* s = get_str(des);
	fread(s, rest_len, 1, fp );
	return des;
}
コード例 #18
0
ファイル: graphics.cpp プロジェクト: PBrookfield/cboe-msvc
void get_str(char *str,short i, short j)
{
	if (i == -1) {
		strcpy((char *) str,scen_item_list.monst_names[j]);
		return;
		}
	if (i == -2) {
		strcpy((char *) str,scen_item_list.scen_items[j].full_name);
		return;
		}
	if (i == -3) {
		strcpy((char *) str,button_strs[available_dlog_buttons[j]]);
		return;
		}
	if (i == -4) {
		strcpy((char *) str,scen_item_list.ter_names[j]);
		return;
		}
	if (i == -5) {
		get_str(str,40,j * 7 + 1);
		return;
		}
	GetIndString(str, i, j);
}
コード例 #19
0
/*************************************************
Function:		ShowMsgSysEventHitLayer
Description: 	调用消息框处理函数
Input:		无
Output:		无
Return:		TRUE 是 FALSE 否
Others:
param:
*************************************************/
void ShowMsgSysEventHitLayer(uint32 id)
{
	debug_log("Show Msg Sys Event hit Layer!");

	if (!MsgSysEventHitLayer)
	{
		MsgSysEventHitLayer = ituSceneFindWidget(&theScene, "MsgSysEventHitLayer");
		assert(MsgSysEventHitLayer);

		MsgSysEventHitText = ituSceneFindWidget(&theScene, "MsgSysEventHitText");
		assert(MsgSysEventHitText);
	}

	if (ituWidgetIsVisible(MsgSysEventHitLayer))
	{
		ituWidgetHide(MsgSysEventHitLayer, ITU_EFFECT_NONE, 0); //如果该界面已经有显示出来,那先关闭重新显示
	}

	g_TimerClock = SDL_GetTicks();

	ituTextSetString(MsgSysEventHitText, get_str(id));
	
	ituWidgetShow(MsgSysEventHitLayer, ITU_EFFECT_NONE, 0);	// 提示框界面使用show出,不是goto
}
コード例 #20
0
ファイル: QNameCoin.cpp プロジェクト: Emercoin/emercoin
QNameCoin::SignMessageRet QNameCoin::signMessageByName(const QString& name, const QString& message) {
	SignMessageRet ret;
	try {
		auto val = nameShow(name);
		UniValue address_uni = find_value(val, "address");
		if(!address_uni.isStr()) {
			ret.error = tr("Can't get address for name %1").arg(name);
			return ret;
		}
		ret.address = QString::fromStdString(address_uni.get_str());

		val = signMessageByAddress(ret.address, message);
		if(!val.isStr()) {
			ret.error = tr("Can't sign message");
			return ret;
		}
		ret.signature = QString::fromStdString(val.get_str());
	} catch (UniValue& objError) {
		ret.error = errorToString(objError);
	} catch (const std::exception& e) {
		ret.error = toString(e);
	}
	return ret;
}
コード例 #21
0
ファイル: processor.c プロジェクト: EkimiaSAS/hardinfo
GSList *
processor_scan(void)
{
    Processor *processor;
    FILE *cpuinfo;
    gchar buffer[128];

    cpuinfo = fopen("/proc/cpuinfo", "r");
    if (!cpuinfo)
	return NULL;

    processor = g_new0(Processor, 1);
    while (fgets(buffer, 128, cpuinfo)) {
	gchar **tmp = g_strsplit(buffer, ":", 2);

	if (tmp[0] && tmp[1]) {
	    tmp[0] = g_strstrip(tmp[0]);
	    tmp[1] = g_strstrip(tmp[1]);

	    get_str("vendor_id", processor->vendor_id);
	    get_float("# processors", processor->cache_size);
	    get_int("bogomips per cpu", processor->bogomips);

	}
	g_strfreev(tmp);
    }

    processor->cpu_mhz = 0.0f;
    
    processor->model_name = g_strconcat("S390 ", processor->vendor_id, NULL);
    g_free(processor->vendor_id);

    fclose(cpuinfo);

    return g_slist_append(NULL, processor);
}
コード例 #22
0
bool ftrace_decode_ascii::callback_call(void)
{
	int j;
	for (j = 0; j < events_max; j++)
	{
		if (events[j].event_name == NULL)
			continue;
		if (strcmp(events[j].event_name, event_current.event_name) == 0)
			break;;
	}
	if (j == events_max)
		return false;
	struct callback_struct *callback = events[j].callback;
	while (callback != NULL)
	{
		int i = 0;
		bool success = true;
		if (callback->number != NULL)
			while (callback->number[i] != NULL)
			{
				if (callback->number_index[i] == -1)
				{
					callback->number_index[i] = get_index(callback->number[i]);
					if (callback->number_index[i] == -1)
					{
						success = false;
						break;
					}
				}
				callback->number_value[i] = get_value(callback->number_index[i]);
				i++;
			}
		i = 0;
		if (callback->str != NULL)
			while (callback->str[i] != NULL)
			{
				if (callback->str_index[i] == -1)
				{
					callback->str_index[i] = get_index(callback->str[i]);
					if (callback->str_index[i] == -1)
					{
						success = false;
						break;
					}
				}
				callback->str_value[i] = get_str(callback->str_index[i]);
				if (callback->str_value[i] == NULL)
				{
					success = false;
					break;
				}
				i++;
			}
		/* if some fields are unknown, don't call the method */
		if (success)
			callback->fn(callback->data,
					event_current.cpu,
					event_current.time,
					callback->number_value,
					callback->str_value);
		callback = callback->next;
	}
	return true;
}
コード例 #23
0
ファイル: s_extrnl.c プロジェクト: LambdaCalculus379/SLS-1.02
int
ext_setup()
{
	extern char *null_ptr;
	WINDOW *ext_win, *newwin();
	int i, ret_code;
	char *str, *get_str();
	void disp_ext();

	ext_win = newwin(23, 80, 0, 0);

	horizontal(ext_win, 0, 0, 27);
	mvwattrstr(ext_win, 0, 28, A_BOLD, "External Protocol Setup");
	horizontal(ext_win, 0, 52, 27);
	mvwaddstr(ext_win, 3, 36, "UPLOAD");
	mvwaddstr(ext_win, 5, 8, "Name");
	mvwaddstr(ext_win, 5, 21, "Command line");
	mvwaddstr(ext_win, 5, 54, "Requires file list?");
	mvwaddstr(ext_win, 10, 35, "DOWNLOAD");
	mvwaddstr(ext_win, 12, 8, "Name");
	mvwaddstr(ext_win, 12, 21, "Command line");
	mvwaddstr(ext_win, 12, 54, "Requires file list?");
					/* display the current list */
	disp_ext(ext_win);

	horizontal(ext_win, 19, 0, 80);
	mvwattrstr(ext_win, 20, 0, A_BOLD, "OPTION ==> ");
	mvwaddstr(ext_win, 20, 58, "Press <ESC> to return");
	wmove(ext_win, 20, 12);
	touchwin(ext_win);
	wrefresh(ext_win);
					/* get the option */
	ret_code = 0;
	while ((str = get_str(ext_win, 1, "1234356", "")) != NULL) {
		switch(*str) {
			case '1':
				if (ext_prompt(ext_win, 1, 0, 6))
					ret_code++;
				break;
			case '2':
				if (ext_prompt(ext_win, 1, 1, 7))
					ret_code++;
				break;
			case '3':
				if (ext_prompt(ext_win, 1, 2, 8))
					ret_code++;
				break;
			case '4':
				if (ext_prompt(ext_win, 0, 0, 13))
					ret_code++;
				break;
			case '5':
				if (ext_prompt(ext_win, 0, 1, 14))
					ret_code++;
				break;
			case '6':
				if (ext_prompt(ext_win, 0, 2, 15))
					ret_code++;
				break;
		}
		mvwaddstr(ext_win, 20, 12, "  ");
		clear_line(ext_win, 21, 0, FALSE);
		clear_line(ext_win, 22, 0, FALSE);
		wmove(ext_win, 20, 12);
		wrefresh(ext_win);
	}
	/*
	 * Recalculate the number of entries.  Please notice that if you
	 * create an empty entry (a hole), all entries after that are ignored.  
	 * The software doesn't compact the holes out.. you're on your own.
	 */
	if (ret_code) {
		for (i=0; i<3; i++) {
			if (extrnl->name[1][i] == null_ptr)
				break;
		}
		extrnl->up_entries = i;

		for (i=0; i<3; i++) {
			if (extrnl->name[0][i] == null_ptr)
				break;
		}
		extrnl->dn_entries = i;
	}
	delwin(ext_win);
	return(ret_code);
}
コード例 #24
0
ファイル: layer_set_rtsp.c プロジェクト: ZakaryWu/iteIndoor
/*************************************************
Function:		ShowSetCameraParamList
Description: 	室内摄像头设置列表显示函数
Input:		无
Output:		无
Return:		TRUE 是 FALSE 否
Others:
*************************************************/
static void ShowSetCameraParamList(int index)
{
	char text_tmp[50];
	memset(text_tmp, 0, sizeof(text_tmp));

	switch (index)
	{
	case 0:
		if (g_homedev.EnableOpen)
		{
			ituSpriteGoto(SetCameraEnableSprite, 1);
			sprintf(text_tmp, "%s", get_str(SID_Set_Rtsp_Camera_Used));
		}
		else
		{
			ituSpriteGoto(SetCameraEnableSprite, 0);
			sprintf(text_tmp, "%s", get_str(SID_Set_Rtsp_Camera_Unused));
		}
		break;

	case 1:
		if (strcmp(g_homedev.FactoryName, "HIKVISION") == 0)
		{
			ituSetColor(&((ITUWidget*)SetPTZEnable1Text)->color, 255, 255, 255, 255);
			ituSetColor(&((ITUWidget*)SetRtspParamList[1])->color, 255, 255, 255, 255);
			ituWidgetEnable(SetPTZEnableContainer);
		}
		else
		{
			ituSetColor(&((ITUWidget*)SetPTZEnable1Text)->color, 255, 128, 138, 135);//冷灰
			ituSetColor(&((ITUWidget*)SetRtspParamList[1])->color, 255, 192, 192, 192);//灰色
			ituWidgetDisable(SetPTZEnableContainer);
		}

		if (g_homedev.CanControlPTZ)
		{
			ituSpriteGoto(SetPTZEnableSprite, 1);
			sprintf(text_tmp, "%s", get_str(SID_Set_Rtsp_PTZ_Used));
		}
		else
		{
			ituSpriteGoto(SetPTZEnableSprite, 0);
			sprintf(text_tmp, "%s", get_str(SID_Set_Rtsp_PTZ_Unused));
		}
		break;

	case 2:
		strcat(text_tmp, g_homedev.DeviceName);
		break;

	case 3:
		sprintf(text_tmp, "%s", UlongtoIP(g_homedev.DeviceIP));
		break;

	case 4:
		sprintf(text_tmp, "%d", g_homedev.DevPort);
		break;

	case 5:
		sprintf(text_tmp, "%d", g_homedev.ChannelNumber);
		break;

	case 6:
		sprintf(text_tmp, "%s", g_homedev.FactoryName);
		break;

	case 7:
		sprintf(text_tmp, "%s", g_homedev.UserName);
		if (0 == strlen(g_homedev.UserName))
		{
			ituWidgetSetVisible(SetRtspParamList[7], false);
			ituWidgetSetY(CameraUserName1Text, LIST_SHOW_ONE_TEXT_Y);
		}
		else
		{
			ituWidgetSetVisible(SetRtspParamList[7], true);
			ituWidgetSetY(CameraUserName1Text, LIST_SHOW_TWO_TEXT_Y);
		}
		break;

	case 8:
		sprintf(text_tmp, "%s", g_homedev.Password);
		if (0 == strlen(g_homedev.Password))
		{
			ituWidgetSetVisible(SetRtspParamList[8], false);
			ituWidgetSetY(CameraPwd1Text, LIST_SHOW_ONE_TEXT_Y);
		}
		else
		{
			ituWidgetSetVisible(SetRtspParamList[8], true);
			ituWidgetSetY(CameraPwd1Text, LIST_SHOW_TWO_TEXT_Y);
		}
		break;

	default:
		break;
	}

	ituTextSetString(SetRtspParamList[index], text_tmp);
}
コード例 #25
0
ファイル: Avt.c プロジェクト: kotohvost/arvid
int print_elem(int fdin, AVT_ELEM elem) {
int	i, rc;
u_short	dd, dt;
char	*p, *name, *ext, *desc;
my_info		*info;
//my_file	*f;
//my_dir	*d;

	rc = 0;
	name = new char[1024];
	bzero(name, 1024);
	ext = new char[1024];
	bzero(ext, 1024);
	desc = new char[1024];
	bzero(desc, 1024);
//	fprintf(stdout, "\t*** element ***\n");
//	fprintf(stdout, "Left:\t\t0x%08X\n", elem.left);
//	fprintf(stdout, "Right:\t\t0x%08X\n", elem.right);
	if (elem.bits.fdir)
		fprintf(stdout, "\t0x%08X", elem.tree);
	else
		fprintf(stdout, "\t%10u", elem.size);
	dd = elem.datime >> 16;
	dt = elem.datime;
	fprintf(stdout, "  %02d/%02d/%d",
		dd & 0x1f,
		(dd >> 5) & 0x0f,
		(dd >> 9) + 1980);
	fprintf(stdout, " %02d:%02d:%02d",
		dt >> 11,
		(dt >> 5) & 0x3f,
		(dt & 0x1f) << 1);
	fprintf(stdout, "  %10u", elem.startsect);
//	fprintf(stdout, "nlogsect:\t%u\n", elem.bits.nlogsect);
//	fprintf(stdout, "bal:\t\t%u\n", elem.bits.bal);
//	fprintf(stdout, "format:\t\t%u\n", elem.bits.format);
//	fprintf(stdout, "fdir:\t\t%u\n", elem.bits.fdir);
	fprintf(stdout, " ");
	switch(elem.bits.format) {
	case	0:
		p = elem.data1c;
		for (i = 0; i < 16 && *p; i++, p++)
			name[i] = *p;
		break;
	case	1:
		p = elem.data1c;
		for (i = 0; i < 12 && *p; i++, p++)
			name[i] = *p;
		if (elem.data4)
			rc = get_str(fdin, ext, elem.data4, 0);
		break;
	case	2:
		p = elem.data1c;
		for (i = 0; i < 12 && *p; i++, p++)
			name[i] = *p;
		if (elem.data4)
			rc = get_str(fdin, desc, elem.data4, 0);
		break;
	case	3:
		if (elem.data1)
			rc = get_str(fdin, name, elem.data1, 0);
		if (elem.data3 && rc == 0)
			rc = get_str(fdin, ext, elem.data3, 0);
		if (elem.data4 && rc == 0)
			rc = get_str(fdin, desc, elem.data4, 0);
		break;
	}
#if 0
	if (*name)
		fprintf(stdout, "%s", name);
	if (elem.bits.fdir)
		fprintf(stdout, "/");
	if (*ext)
		fprintf(stdout, " ext:\t\t%s", ext);
	if (*desc)
		fprintf(stdout, " description:\t%s", desc);
	fprintf(stdout, "\n");
#else
	info = new my_info(name, 0, desc);
	fprintf(stdout, "%s", info->Name());
	if (elem.bits.fdir)
		fprintf(stdout, "/");
//	fprintf(stdout, " ext:\t\t%s", ext);
	if (*info->Desc())
		fprintf(stdout, " description:\t%s", info->Desc());
	fprintf(stdout, "\n");
	delete info;
#endif
	if (name)
		delete name;
	if (ext)
		delete ext;
	if (desc)
		delete desc;
	return(rc);
};
コード例 #26
0
ファイル: layer_becall.c プロジェクト: ZakaryWu/iteIndoor
/*************************************************
Function:		DrawStringHint
Description: 	画状态提示
Input:			无
Output:			无
Return:			无
Others:			无
*************************************************/
static void DrawStringHint(void)
{
	char time[10] = { 0 };
	char temp[50] = { 0 };
	char DevDesc[50] = { 0 };
	char NoText[100] = { 0 };
	uint32 StrId = 0;

	switch (g_InterState)
	{
		case CALL_STATE_REQUEST:
			StrId = SID_Inter_Connecting;
			break;

		case CALL_STATE_CALLING:
			if (g_OperType == INTER_CALLOUT_E)
			{
				StrId = SID_Inter_Calling;
			}
			else if (g_OperType == INTER_CALLIN_E)
			{
				StrId = SID_Inter_BeCalling;
			}
			break;

		case CALL_STATE_RECORDHINT:
			StrId = SID_Inter_RecordHinting;
			break;

		case CALL_STATE_RECORDING:
			StrId = SID_Inter_Recording;
			break;

		case CALL_STATE_TALK:
			StrId = SID_Inter_Talking;
			break;

		case CALL_STATE_END:
			StrId = 0;
			break;

		default:
			StrId = 0;
			break;
	}
	// 画设备描述
	if (strlen(g_DevNo) > 0)
	{
		if (atoi(g_DevNo) == 0xFF)
		{
			strcpy(DevDesc, get_str(SID_DevManager));
		}
		else
		{
			get_dev_description(g_DevType, g_DevNo, DevDesc, 50); // 获得设备描述
		}
	}
	sprintf(temp, "[%s]", DevDesc);

	if (g_ErrHintTxtID)
	{
		sprintf(NoText, "%s %s", temp, get_str(g_ErrHintTxtID));
		ituTextSetString(BecallCallNoText, NoText);
	}
	else if (StrId)
	{
		sprintf(NoText, "%s %s", temp, get_str(StrId));
		ituTextSetString(BecallCallNoText, NoText);
	}
	else
	{
		ituTextSetString(BecallCallNoText, temp);
	}

	if (ENGLISH == storage_get_language())
	{
		text_ctrl_too_long_show_ellipsis(BecallCallNoText);
	}

	// 画时间提示: time
	if (g_RemainTime)
	{
		sprintf(time, "%d", g_RemainTime);
		ituTextSetString(BeCallTimeText, time);
	}

	// 画新来电提示
	if (strlen(g_NewCallNo) > 0)
	{
		uint16 DevType = g_NewCallNo[1];
		char NewCallNo[30] = { 0 };

		sprintf(NewCallNo, "%s", g_NewCallNo+2);
		memset(DevDesc, 0, sizeof(DevDesc));
		memset(temp, 0, sizeof(temp));
		memset(NoText, 0, sizeof(NoText));
		get_dev_description(DevType, NewCallNo, DevDesc, 50);
		StrId = SID_Inter_BeCalling;
		
		sprintf(temp, "[%s]", DevDesc);
		sprintf(NoText, "%s %s", temp, get_str(StrId));
		ituTextSetString(BecallNewCallNoText, NoText);
		if (ENGLISH == storage_get_language())
		{
			text_ctrl_too_long_show_ellipsis(BecallNewCallNoText);
		}
	}
}
コード例 #27
0
ファイル: bcresources.C プロジェクト: knutj/cinelerra
int BC_Resources::init_fontconfig(const char *search_path)
{
	if( fontlist ) return 0;
	fontlist = new ArrayList<BC_FontEntry*>;

#define get_str(str,sep,ptr,cond) do { char *out = str; \
  while( *ptr && !strchr(sep,*ptr) && (cond) ) *out++ = *ptr++; \
  *out = 0; \
} while(0)

#define skip_str(sep, ptr) do { \
  while( *ptr && strchr(sep,*ptr) ) ++ptr; \
} while(0)

	char find_command[BCTEXTLEN];
	sprintf(find_command,
		"find %s -name 'fonts.dir' -print -exec cat {} \\;",
		search_path);
	FILE *in = popen(find_command, "r");

	FT_Library freetype_library = 0;
//	FT_Face freetype_face = 0;
//	FT_Init_FreeType(&freetype_library);

	char line[BCTEXTLEN], current_dir[BCTEXTLEN];
	current_dir[0] = 0;

	while( !feof(in) && fgets(line, BCTEXTLEN, in) ) {
		if(!strlen(line)) break;

		char *in_ptr = line;

// Get current directory
		if(line[0] == '/') {
			get_str(current_dir, "\n", in_ptr,1);
			for( int i=strlen(current_dir); --i>=0 && current_dir[i]!='/'; )
				current_dir[i] = 0;
			continue;
		}

//printf("TitleMain::build_fonts %s\n", line);
		BC_FontEntry *entry = new BC_FontEntry;
		char string[BCTEXTLEN];
// Path
		get_str(string, "\n", in_ptr, in_ptr[0]!=' ' || in_ptr[1]!='-');
		entry->path = cstrcat(2, current_dir, string);
// Foundary
		skip_str(" -", in_ptr);
		get_str(string, " -\n", in_ptr, 1);
		if( !string[0] ) { delete entry;  continue; }
		entry->foundry = cstrdup(string);
		if(*in_ptr == '-') in_ptr++;
// Family
		get_str(string, "-\n", in_ptr, 1);
		if( !string[0] ) { delete entry;  continue; }
		entry->family = cstrdup(string);
		if(*in_ptr == '-') in_ptr++;
// Weight
		get_str(string, "-\n", in_ptr, 1);
		entry->weight = cstrdup(string);
		if(*in_ptr == '-') in_ptr++;
// Slant
		get_str(string, "-\n", in_ptr, 1);
		entry->slant = cstrdup(string);
		if(*in_ptr == '-') in_ptr++;
// SWidth
		get_str(string, "-\n", in_ptr, 1);
		entry->swidth = cstrdup(string);
		if(*in_ptr == '-') in_ptr++;
// Adstyle
		get_str(string, "-\n", in_ptr, 1);
		entry->adstyle = cstrdup(string);
		if(*in_ptr == '-') in_ptr++;
// pixelsize
		get_str(string, "-\n", in_ptr, 1);
		entry->pixelsize = atol(string);
		if(*in_ptr == '-') in_ptr++;
// pointsize
		get_str(string, "-\n", in_ptr, 1);
		entry->pointsize = atol(string);
		if(*in_ptr == '-') in_ptr++;
// xres
		get_str(string, "-\n", in_ptr, 1);
		entry->xres = atol(string);
		if(*in_ptr == '-') in_ptr++;
// yres
		get_str(string, "-\n", in_ptr, 1);
		entry->yres = atol(string);
		if(*in_ptr == '-') in_ptr++;
// spacing
		get_str(string, "-\n", in_ptr, 1);
		entry->spacing = cstrdup(string);
		if(*in_ptr == '-') in_ptr++;
// avg_width
		get_str(string, "-\n", in_ptr, 1);
		entry->avg_width = atol(string);
		if(*in_ptr == '-') in_ptr++;
// registry
		get_str(string, "-\n", in_ptr, 1);
		entry->registry = cstrdup(string);
		if(*in_ptr == '-') in_ptr++;
// encoding
		get_str(string, "-\n", in_ptr, 1);
		entry->encoding = cstrdup(string);
		if(*in_ptr == '-') in_ptr++;

// Add to list
//printf("TitleMain::build_fonts 1 %s\n", entry->path);
// This takes a real long time to do.  Instead just take all fonts
// 		if(!load_freetype_face(freetype_library,
// 			freetype_face, entry->path) )
// Fix parameters
		sprintf(line, "%s (%s)", entry->family, entry->foundry);
		entry->displayname = cstrdup(line);

		if(!strcasecmp(entry->weight, "demibold")) {
			entry->fixed_style |= BC_FONT_BOLD;
			entry->style |= FL_WEIGHT_DEMIBOLD;
		}
		else if(!strcasecmp(entry->weight, "bold")) {
			entry->fixed_style |= BC_FONT_BOLD;
			entry->style |= FL_WEIGHT_BOLD;
		}
		else {
			entry->style |= FL_WEIGHT_NORMAL;
		}

		if(!strcasecmp(entry->slant, "r")) {
			entry->style |= FL_SLANT_ROMAN;
		}
		else if(!strcasecmp(entry->slant, "i")) {
			entry->style |= FL_SLANT_ITALIC;
			entry->fixed_style |= BC_FONT_ITALIC;
		}
		else if(!strcasecmp(entry->slant, "o")) {
			entry->style |= FL_SLANT_OBLIQUE;
			entry->fixed_style |= BC_FONT_ITALIC;
		}

		if(!strcasecmp(entry->swidth, "normal"))
			entry->style = FL_WIDTH_NORMAL;
		else if(!strcasecmp(entry->swidth, "ultracondensed"))
			entry->style = FL_WIDTH_ULTRACONDENSED;
		else if(!strcasecmp(entry->swidth, "extracondensed"))
			entry->style = FL_WIDTH_EXTRACONDENSED;
		else if(!strcasecmp(entry->swidth, "condensed"))
			entry->style = FL_WIDTH_CONDENSED;
		else if(!strcasecmp(entry->swidth, "semicondensed"))
			entry->style = FL_WIDTH_SEMICONDENSED;
		else if(!strcasecmp(entry->swidth, "semiexpanded"))
			entry->style = FL_WIDTH_SEMIEXPANDED;
		else if(!strcasecmp(entry->swidth, "expanded"))
			entry->style = FL_WIDTH_EXPANDED;
		else if(!strcasecmp(entry->swidth, "extraexpanded"))
			entry->style = FL_WIDTH_EXTRAEXPANDED;
		else if(!strcasecmp(entry->swidth, "ultraexpanded"))
			entry->style = FL_WIDTH_ULTRAEXPANDED;
		else
			entry->style = FL_WIDTH_NORMAL;

		fontlist->append(entry);
//		printf("TitleMain::build_fonts %s: success\n",	entry->path);
//printf("TitleMain::build_fonts 2\n");
	}
	pclose(in);


// Load all the fonts from fontconfig
	FcPattern *pat;
	FcFontSet *fs;
	FcObjectSet *os;
	FcChar8 *family, *file, *foundry, *style, *format;
	int slant, spacing, width, weight;
	int force_style = 0;
// if you want limit search to TrueType put 1
	int limit_to_trutype = 1;
	FcConfig *config;
	int i;
	char tmpstring[BCTEXTLEN];
	if(!FcInit())
		return 1;
	config = FcConfigGetCurrent();
	FcConfigSetRescanInterval(config, 0);

	pat = FcPatternCreate();
	os = FcObjectSetBuild ( FC_FAMILY, FC_FILE, FC_FOUNDRY, FC_WEIGHT,
		FC_WIDTH, FC_SLANT, FC_FONTFORMAT, FC_SPACING, FC_STYLE, (char *) 0);
	FcPatternAddBool(pat, FC_SCALABLE, true);

	if(language[0]) {
		char langstr[LEN_LANG * 3];
		strcpy(langstr, language);

		if(region[0]) {
			strcat(langstr, "-");
			strcat(langstr, region);
		}

		FcLangSet *ls =  FcLangSetCreate();
		if(FcLangSetAdd(ls, (const FcChar8*)langstr))
		if(FcPatternAddLangSet(pat, FC_LANG, ls))
		FcLangSetDestroy(ls);
	}

	fs = FcFontList(config, pat, os);
	FcPatternDestroy(pat);
	FcObjectSetDestroy(os);

	for (i = 0; fs && i < fs->nfont; i++) {
		FcPattern *font = fs->fonts[i];
		force_style = 0;
		FcPatternGetString(font, FC_FONTFORMAT, 0, &format);
		//on this point you can limit font search
		if(limit_to_trutype && strcmp((char *)format, "TrueType"))
			continue;

		sprintf(tmpstring, "%s", format);
		BC_FontEntry *entry = new BC_FontEntry;
		if(FcPatternGetString(font, FC_FILE, 0, &file) == FcResultMatch) {
			entry->path = cstrdup((char*)file);
		}

		if(FcPatternGetString(font, FC_FOUNDRY, 0, &foundry) == FcResultMatch) {
			entry->foundry = cstrdup((char*)foundry);
		}

		if(FcPatternGetInteger(font, FC_WEIGHT, 0, &weight) == FcResultMatch) {
			switch(weight) {
			case FC_WEIGHT_THIN:
			case FC_WEIGHT_EXTRALIGHT:
			case FC_WEIGHT_LIGHT:
			case FC_WEIGHT_BOOK:
				force_style = 1;
				entry->weight = cstrdup("medium");
				break;

			case FC_WEIGHT_NORMAL:
			case FC_WEIGHT_MEDIUM:
			default:
				entry->weight = cstrdup("medium");
				break;

			case FC_WEIGHT_BLACK:
			case FC_WEIGHT_SEMIBOLD:
			case FC_WEIGHT_BOLD:
				entry->weight = cstrdup("bold");
				entry->fixed_style |= BC_FONT_BOLD;
				break;

			case FC_WEIGHT_EXTRABOLD:
			case FC_WEIGHT_EXTRABLACK:
				force_style = 1;
				entry->weight = cstrdup("bold");
				entry->fixed_style |= BC_FONT_BOLD;
				break;
			}
		}

		if(FcPatternGetString(font, FC_FAMILY, 0, &family) == FcResultMatch)
			entry->family = cstrdup((char*)family);

		if(FcPatternGetInteger(font, FC_SLANT, 0, &slant) == FcResultMatch) {
			switch(slant) {
			case FC_SLANT_ROMAN:
			default:
				entry->slant = cstrdup("r");
				entry->style |= FL_SLANT_ROMAN;
				break;
			case FC_SLANT_ITALIC:
				entry->slant = cstrdup("i");
				entry->style |= FL_SLANT_ITALIC;
				entry->fixed_style |= BC_FONT_ITALIC;
				break;
			case FC_SLANT_OBLIQUE:
				entry->slant = cstrdup("o");
				entry->style |= FL_SLANT_OBLIQUE;
				entry->fixed_style |= BC_FONT_ITALIC;
				break;
			}
		}

		if(FcPatternGetInteger(font, FC_WIDTH, 0, &width) == FcResultMatch) {
			switch(width) {
			case FC_WIDTH_ULTRACONDENSED:
				entry->swidth = cstrdup("ultracondensed");
				break;

			case FC_WIDTH_EXTRACONDENSED:
				entry->swidth = cstrdup("extracondensed");
				break;

			case FC_WIDTH_CONDENSED:
				entry->swidth = cstrdup("condensed");
				break;
			case FC_WIDTH_SEMICONDENSED:
				entry->swidth = cstrdup("semicondensed");
				break;

			case FC_WIDTH_NORMAL:
			default:
				entry->swidth = cstrdup("normal");
				break;

			case FC_WIDTH_SEMIEXPANDED:
				entry->swidth = cstrdup("semiexpanded");
				break;

			case FC_WIDTH_EXPANDED:
				entry->swidth = cstrdup("expanded");
				break;

			case FC_WIDTH_EXTRAEXPANDED:
				entry->swidth = cstrdup("extraexpanded");
				break;

			case FC_WIDTH_ULTRAEXPANDED:
				entry->swidth = cstrdup("ultraexpanded");
				break;
			}
		}

		if(FcPatternGetInteger(font, FC_SPACING, 0, &spacing) == FcResultMatch) {
			switch(spacing) {
			case 0:
			default:
				entry->spacing = cstrdup("p");
				break;

			case 90:
				entry->spacing = cstrdup("d");
				break;

			case 100:
				entry->spacing = cstrdup("m");
				break;

			case 110:
				entry->spacing = cstrdup("c");
				break;
			}
		}

		// Add fake stuff for compatibility
		entry->adstyle = cstrdup(" ");
		entry->pixelsize = 0;
		entry->pointsize = 0;
		entry->xres = 0;
		entry->yres = 0;
		entry->avg_width = 0;
		entry->registry = cstrdup("utf");
		entry->encoding = cstrdup("8");

		if(!FcPatternGetString(font, FC_STYLE, 0, &style) == FcResultMatch)
			force_style = 0;

		// If font has a style unmanaged by titler plugin, force style to be displayed on name
		// in this way we can shown all available fonts styles.
		if(force_style) {
			sprintf(tmpstring, "%s (%s)", entry->family, style);
			entry->displayname = cstrdup(tmpstring);
		}
		else {
			if(strcmp(entry->foundry, "unknown")) {
				sprintf(tmpstring, "%s (%s)", entry->family, entry->foundry);
				entry->displayname = cstrdup(tmpstring);
			}
			else {
				sprintf(tmpstring, "%s", entry->family);
				entry->displayname = cstrdup(tmpstring);
			}

		}
		fontlist->append(entry);
	}

	FcFontSetDestroy(fs);
	if(freetype_library)
		FT_Done_FreeType(freetype_library);
// for(int i = 0; i < fonts->total; i++)
//	fonts->values[i]->dump();

	FcConfigAppFontAddDir(0, (const FcChar8*)search_path);
	FcConfigSetRescanInterval(0, 0);

	os = FcObjectSetBuild(FC_FAMILY, FC_FILE, FC_FOUNDRY, FC_WEIGHT,
		FC_WIDTH, FC_SLANT, FC_SPACING, FC_STYLE, (char *)0);
	pat = FcPatternCreate();
	FcPatternAddBool(pat, FC_SCALABLE, true);

	if(language[0])
	{
		char langstr[LEN_LANG * 3];
		strcpy(langstr, language);

		if(region[0])
		{
			strcat(langstr, "-");
			strcat(langstr, region);
		}

		FcLangSet *ls =  FcLangSetCreate();
		if(FcLangSetAdd(ls, (const FcChar8*)langstr))
			if(FcPatternAddLangSet(pat, FC_LANG, ls))
		FcLangSetDestroy(ls);
	}

	fs = FcFontList(0, pat, os);
	FcPatternDestroy(pat);
	FcObjectSetDestroy(os);

	for(int i = 0; i < fs->nfont; i++)
	{
		FcPattern *font = fs->fonts[i];
		BC_FontEntry *entry = new BC_FontEntry;

		FcChar8 *strvalue;
		if(FcPatternGetString(font, FC_FILE, 0, &strvalue) == FcResultMatch)
		{
			entry->path = new char[strlen((char*)strvalue) + 1];
			strcpy(entry->path, (char*)strvalue);
		}

		if(FcPatternGetString(font, FC_FOUNDRY, 0, &strvalue) == FcResultMatch)
		{
			entry->foundry = new char[strlen((char*)strvalue) + 1];
			strcpy(entry->foundry, (char *)strvalue);
		}

		if(FcPatternGetString(font, FC_FAMILY, 0, &strvalue) == FcResultMatch)
		{
			entry->family = new char[strlen((char*)strvalue) + 2];
			strcpy(entry->family, (char*)strvalue);
		}

		int intvalue;
		if(FcPatternGetInteger(font, FC_SLANT, 0, &intvalue) == FcResultMatch)
		{
			switch(intvalue)
			{
			case FC_SLANT_ROMAN:
			default:
				entry->style |= FL_SLANT_ROMAN;
				break;

			case FC_SLANT_ITALIC:
				entry->style |= FL_SLANT_ITALIC;
				break;

			case FC_SLANT_OBLIQUE:
				entry->style |= FL_SLANT_OBLIQUE;
				break;
			}
		}

		if(FcPatternGetInteger(font, FC_WEIGHT, 0, &intvalue) == FcResultMatch)
		{
			switch(intvalue)
			{
			case FC_WEIGHT_THIN:
				entry->style |= FL_WEIGHT_THIN;
				break;

			case FC_WEIGHT_EXTRALIGHT:
				entry->style |= FL_WEIGHT_EXTRALIGHT;
				break;

			case FC_WEIGHT_LIGHT:
				entry->style |= FL_WEIGHT_LIGHT;
				break;

			case FC_WEIGHT_BOOK:
				entry->style |= FL_WEIGHT_BOOK;
				break;

			case FC_WEIGHT_NORMAL:
			default:
				entry->style |= FL_WEIGHT_NORMAL;
				break;

			case FC_WEIGHT_MEDIUM:
				entry->style |= FL_WEIGHT_MEDIUM;
				break;

			case FC_WEIGHT_DEMIBOLD:
				entry->style |= FL_WEIGHT_DEMIBOLD;
				break;

			case FC_WEIGHT_BOLD:
				entry->style |= FL_WEIGHT_BOLD;
				break;

			case FC_WEIGHT_EXTRABOLD:
				entry->style |= FL_WEIGHT_EXTRABOLD;
				break;

			case FC_WEIGHT_BLACK:
				entry->style |= FL_WEIGHT_BLACK;
				break;

			case FC_WEIGHT_EXTRABLACK:
				entry->style |= FL_WEIGHT_EXTRABLACK;
				break;
			}
		}

		if(FcPatternGetInteger(font, FC_WIDTH, 0, &intvalue) == FcResultMatch)
		{
			switch(intvalue)
			{
			case FC_WIDTH_ULTRACONDENSED:
				entry->style |= FL_WIDTH_ULTRACONDENSED;
				break;

			case FC_WIDTH_EXTRACONDENSED:
				entry->style |= FL_WIDTH_EXTRACONDENSED;
				break;

			case FC_WIDTH_CONDENSED:
				entry->style |= FL_WIDTH_CONDENSED;
				break;

			case FC_WIDTH_SEMICONDENSED:
				entry->style = FL_WIDTH_SEMICONDENSED;
				break;

			case FC_WIDTH_NORMAL:
			default:
				entry->style |= FL_WIDTH_NORMAL;
				break;

			case FC_WIDTH_SEMIEXPANDED:
				entry->style |= FL_WIDTH_SEMIEXPANDED;
				break;

			case FC_WIDTH_EXPANDED:
				entry->style |= FL_WIDTH_EXPANDED;
				break;

			case FC_WIDTH_EXTRAEXPANDED:
				entry->style |= FL_WIDTH_EXTRAEXPANDED;
				break;

			case FC_WIDTH_ULTRAEXPANDED:
				entry->style |= FL_WIDTH_ULTRAEXPANDED;
				break;
			}
		}
		if(FcPatternGetInteger(font, FC_SPACING, 0, &intvalue) == FcResultMatch)
		{
			switch(intvalue)
			{
			case FC_PROPORTIONAL:
			default:
				entry->style |= FL_PROPORTIONAL;
				break;

			case FC_DUAL:
				entry->style |= FL_DUAL;
				break;

			case FC_MONO:
				entry->style |= FL_MONO;
				break;

			case FC_CHARCELL:
				entry->style |= FL_CHARCELL;
				break;
			}
		}
		if(entry->foundry && strcmp(entry->foundry, "unknown"))
		{
			char tempstr[BCTEXTLEN];
			sprintf(tempstr, "%s (%s)", entry->family, entry->foundry);
			entry->displayname = new char[strlen(tempstr) + 1];
			strcpy(entry->displayname, tempstr);
		}
		else
		{
			entry->displayname = new char[strlen(entry->family) + 1];
			strcpy(entry->displayname, entry->family);
		}
		fontlist->append(entry);
	}
	FcFontSetDestroy(fs);
	return 0;
}
コード例 #28
0
struct node* get_node_array() {

    int i, j;
    const char *a = ":";
    int numtokens;
    char **str = get_str();

    struct node* n_array = malloc(linenum * 10000);

    if (n_array == NULL) {
        fprintf(stderr, "failed to allocate memory.\n");
        exit(1);
    }

    static const struct node node_empty;
    struct node Node;
    char **argvp;

    for(i=0; i<linenum; i++) {
        Node = node_empty;
        numtokens = makeargv(str[i], a, &argvp);
        Node.id = i;
        Node.num_parent = 0;
        strcpy(Node.prog, argvp[0]);
        /*parse children from .txt file to node*/
        const char *none = "none";
        if(!strcmp(argvp[1],none)) {
            Node.children[0] = -1;
        }
        else {
             int k = 0;
             char *n = strtok(argvp[1], " ");
             do { 
                 Node.children[k++] = atoi(n);
              } while (n = strtok(NULL, " "));
             Node.num_children = k;
        }
        strcpy(Node.input, argvp[2]); /*parse the input filename*/
        strcpy(Node.output, argvp[3]); /*parse the output filename*/
        n_array[i] = Node;
    }

    for(j=0; j<linenum; j++) {
        free(str[j]);
    }

    free(str);
    /* assign num_parent*/
    for(i=0; i<linenum; i++) {

    	int j;

    	for(j=0; j<n_array[i].num_children; j++) {
    		int target = n_array[i].children[j];
            	if(target != -1) {
                n_array[target].num_parent ++;
            }
        }
    }
    return n_array;
}
コード例 #29
0
ファイル: handle_rpc.c プロジェクト: GreenfieldTech/kamailio
int erl_rpc_struct_scan(erl_rpc_ctx_t* ctx, char* fmt, ...)
{
	int* int_ptr;
	char** char_ptr;
	str* str_ptr;
	double* double_ptr;
	char* member_name;
	str s; /* helper str */

	int reads = 0;
	int modifiers = 0;
	int index;
	int autoconv = 0;

	int arity;

	va_list ap;

	/* save index */
	index = ctx->request_index;

	if(ei_decode_tuple_header(ctx->request->buff,&ctx->request_index, &arity))
	{
		erl_rpc_fault(ctx,400,"Bad tuple");
		return -1;
	}

	va_start(ap,fmt);

	while(*fmt)
	{
		member_name = va_arg(ap, char*);

		if (find_member(ctx,arity,member_name))
		{
			goto error;
		}

		switch(*fmt)
		{
		case 'b': /* Bool */
		case 't': /* Date and time */
		case 'd': /* Integer */
			int_ptr = va_arg(ap, int*);

			if (get_int(int_ptr,ctx,reads,autoconv))
			{
				goto error;
			}

			break;
		case 'f': /* double */
			double_ptr = va_arg(ap, double*);

			if (get_double(double_ptr,ctx,reads,autoconv))
			{
				goto error;
			}

			break;
		case 'S': /* str structure */

			str_ptr = va_arg(ap, str*);

			if (get_str(str_ptr,ctx,reads,autoconv))
			{
				goto error;
			}

			break;
		case 's':/* zero terminated string */

			char_ptr = va_arg(ap,char**);

			if (get_str(&s,ctx,reads,autoconv))
			{
				goto error;
			}

			*char_ptr = s.s;

			break;

		 default:
			 LM_ERR("Invalid parameter type in formatting string: %c\n", *fmt);
			 erl_rpc_fault(ctx, 500, "Server Internal Error (Invalid Formatting String)");
			 goto error;
		}

		reads++;
		fmt++;
	}

	/* restore index */
	ctx->request_index = index;

    va_end(ap);
    return reads-modifiers;

error:
    va_end(ap);
    return -(reads-modifiers);
}
コード例 #30
0
ファイル: handle_rpc.c プロジェクト: GreenfieldTech/kamailio
int erl_rpc_scan(erl_rpc_ctx_t* ctx, char* fmt, ...)
{
	int* int_ptr;
	char** char_ptr;
	str* str_ptr;
	double* double_ptr;
	void** void_ptr;
	str s; /* helper str */

	int reads = 0;
	int modifiers = 0;
	int autoconv = 0;

	int type,size;
	erl_rpc_ctx_t *handler;

	va_list ap;

	va_start(ap,fmt);

	while(*fmt && ctx->size)
	{
		/* optional and we at the end of decoding params */
		if (ctx->optional && !ctx->size)
		{
			break;
		}

		if (ei_get_type(ctx->request->buff,&ctx->request_index,&type,&size))
		{
			erl_rpc_fault(ctx,400,"Can't determine data type, for parameter #%d",reads);
			LM_ERR("Can't determine data type, for parameter #%d",reads);

			goto error;
		}

		switch(*fmt)
		{
		case '*': /* start of optional parameters */
			modifiers++;
			ctx->optional = 1;
			reads++;
			fmt++;
			continue;
		case '.':  /* autoconvert */
			modifiers++;
			autoconv = 1;
			reads++;
			fmt++;
			continue;
		case 'b': /* Bool */
		case 't': /* Date and time */
		case 'd': /* Integer */
			int_ptr = va_arg(ap, int*);

			if (get_int(int_ptr,ctx,reads,autoconv))
			{
				goto error;
			}

			break;
		case 'f': /* double */
			double_ptr = va_arg(ap, double*);

			if (get_double(double_ptr,ctx,reads,autoconv))
			{
				goto error;
			}

			break;
		case 'S': /* str structure */

			str_ptr = va_arg(ap, str*);

			if (get_str(str_ptr,ctx,reads,autoconv))
			{
				goto error;
			}

			break;
		case 's':/* zero terminated string */

			char_ptr = va_arg(ap, char **);
			if (get_str(&s,ctx,reads,autoconv))
			{
				goto error;
			}

			*char_ptr = s.s;

			break;
		case '{':
			void_ptr = va_arg(ap,void**);

			if (type!=ERL_SMALL_TUPLE_EXT && type!=ERL_LARGE_TUPLE_EXT)
			{
				erl_rpc_fault(ctx,400,"Bad type of parameter #%d (t=%c).",reads,type);
				goto error;
			}

			handler = (erl_rpc_ctx_t*)pkg_malloc(sizeof(erl_rpc_ctx_t));

			if (!handler)
			{
				erl_rpc_fault(ctx,500, "Internal Server Error (No memory left)");
				LM_ERR("Not enough memory\n");
				goto error;
			}

			*handler = *ctx; /* copy state */
			handler->optional = 0;
			handler->no_params = 0;
			handler->size = size; /* size of tuple */

			if (add_to_recycle_bin(JUNK_PKGCHAR,handler,ctx))
			{
				pkg_free(handler);
				goto error;
			}

			/* skip element */
			if (ei_skip_term(ctx->request->buff,&ctx->request_index))
			{
				goto error;
			}

			/* go where we stopped */
			*(erl_rpc_ctx_t**)void_ptr = handler;

			break;
		 default:
			 LM_ERR("Invalid parameter type in formatting string: %c\n", *fmt);
			 erl_rpc_fault(ctx, 500, "Server Internal Error (Invalid Formatting String)");
			 goto error;
		}

		autoconv = 0; /* reset autovoncersion for next parameter */
		reads++;
		fmt++;
		ctx->size--;
	}
    va_end(ap);
    return reads-modifiers;

error:
    va_end(ap);
    return -(reads-modifiers);

}