Beispiel #1
0
//==============================================================================
/// Configures the given filter.
//==============================================================================
void JRangeFilter::Config(std::string filter){
  Reset();
  std::string tx,tx2;
  while(!filter.empty()){
    int pos=int(filter.find(","));
    tx=(pos>0? filter.substr(0,pos): filter);
    filter=(pos>0? filter.substr(pos+1): "");
    pos=int(tx.find("-"));
    tx2=(pos>0? tx.substr(0,pos): "");
    if(pos>0)tx=tx.substr(pos+1);
    if(tx2.empty())AddValue(atoi(tx.c_str()));
    else AddRange(atoi(tx2.c_str()),atoi(tx.c_str()));
  }
  SortRanges();
  JoinRanges();
  if(Count){
    ValueMin=Ranges[0]; ValueMax=Ranges[((int(Count)-1)<<1)+1];
    if(ValueMax-ValueMin<1000&&ValueMax-ValueMin>1&&Count>1){
      FastValue=new byte[ValueMax-ValueMin+1];
      memset(FastValue,0,sizeof(byte)*(ValueMax-ValueMin+1));
      for(unsigned c=0;c<Count;c++){
        unsigned r=Ranges[c<<1],r2=Ranges[(c<<1)+1];
        for(;r<=r2;r++)FastValue[r-ValueMin]=1;
      }
    }
  }
}
Beispiel #2
0
template<class T> Vector<T>& Vector<T>::operator+=(Vector const & source)
{
	if(!source.IsEmpty())
		AddRange(source.Begin(), source.End());

	return *this;
}
bool trpgRangeTable::Read(trpgReadBuffer &buf)
{
	int32 numRange;
	trpgToken tok;
	int32 len;
	valid = false;

	try {
		buf.Get(numRange);
		if (numRange < 0) throw 1;
		for (int i=0;i<numRange;i++) {
			// Read in the individual range
			buf.GetToken(tok,len);
			if (tok != TRPG_RANGE) throw 1;
			buf.PushLimit(len);
			trpgRange range;
			bool status = range.Read(buf);
			buf.PopLimit();
			if (!status) throw 1;
			AddRange(range);
		}

		valid = true;
	}

	catch (...) {
		return false;
	}

	return isValid();
}
Beispiel #4
0
template<class T> Vector<T>::Vector(ConstElement* begin, ConstElement* end, CtorModeEnum ctorMode) :
	_ctorMode(ctorMode),
	_origin(NULL),
	_last(NULL),
	_end(NULL)
{
	AddRange(begin, end);
}
Beispiel #5
0
static int Append(ElementType *SC1, ElementType *SC2)
{
    if (SC1 == NULL || SC2 == NULL) {
        return NullPtrError("Append");
    }
    if (SC1->Flags & CONTAINER_READONLY) {
        return ReadOnlyError(SC1,"Append");
    }
    return AddRange(SC1,SC2->count,(const CHAR_TYPE **)SC2->contents);
}
void InitFilterTable()
{
	filter_count=0;
	AddRange(L"uxtheme.dll");
	AddRange(L"usp10.dll");
	AddRange(L"msctf.dll");
	AddRange(L"gdiplus.dll");
	AddRange(L"lpk.dll");
	AddRange(L"psapi.dll");
	AddRange(L"user32.dll");
}
int trpgRangeTable::FindAddRange(trpgRange &range)
{
	RangeMapType::iterator itr = rangeMap.begin();
	for (  ; itr != rangeMap.end( ); itr++) {
		if(itr->second==range)
			return itr->first;
	}

#if 0
	for (int i=0;i<rangeList.size();i++) {
		if (range == rangeList[i])
			return i;
	}
#endif
	return AddRange(range);
}
Beispiel #8
0
RegExpressionT *D(char *e, int *place) {
  int input, peek, nextchar, result, invert = 0;
  RegExpressionT *ex;
  CharSetT *cs;
	
  input = NextCharacter(e, *place);
  if (input == '^') {
    invert = 1;
    AdvanceParser(e, place);
  }
  cs = CreateCharSet();
  while(1) {
    input = NextCharacter(e, *place);
    switch(input) {
    case ']': 
      if (invert) InvertCharSet(cs);
      ex = NewRegularExpression();
      ex->type = CHARSET;
      ex->charset = cs;
      return ex;
    default: 
      if (!ValidForD(input)) {
#if ERR_MESG
	fprintf(stderr, "Bad regexp: character %c.\n", input);
	fprintf(stderr, "%s == at %d\n", e, *place);
#endif
	free (cs); 
	return NULL;
      }
      if (input == '\\') peek = 2;
      else if (input == '#') peek = 4; 
      else peek = 1;
      nextchar = PeekCharacter(e, place, peek);
      if (nextchar == '-') result = AddRange(e, place, cs);
      else result = AddSymbol(e, place, cs);
      if (result == 0) {
#if ERR_MESG
	fprintf(stderr, "Failed to create character set.\n");
	fprintf(stderr, "%s == at %d\n", e, *place);
#endif
	free (cs);
	return NULL;
      }
    }
  }
  return NULL;
}
Beispiel #9
0
void OutputSet::Add(int output_port, int vc, int pri)
{
	AddRange(output_port, vc, vc, pri);
}
Beispiel #10
0
/*******************************************************
* Convert an IP list to numbers and add them
********************************************************/
int AddIPRanges(NumList* n, char* Ranges){
	int				i;
	char			ThisNum[64];
	int				ThisNumCount;
	unsigned int	LowNum;
	unsigned int	HighNum;
	unsigned int	Mask;
	int				SubListID;
	int				IsDashed=FALSE;
	
	DEBUGPATH;

	if (!n) return FALSE;

#ifdef DEBUG
	printf("Ranges is %s\n",Ranges);
#endif	

	if ( (SubListID=GetListByName(Ranges))!=LIST_NONE){
		if (!AddSubList(n,Globals.Lists[SubListID].List)){
			printf("Failed to add ip list \"%s\" \n",Ranges);
			return FALSE;
		}
		return TRUE;
	}
	
	ThisNumCount=0;
	LowNum=0;
	for (i=0;i<=strlen(Ranges);i++){
		switch(Ranges[i]){
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case '0':
		case '.':
			/*normal number, keep going*/
			ThisNum[ThisNumCount]=Ranges[i];
			ThisNumCount++;
			break;
		case '-':
			/*contiguous range notation*/
			/*this a delimiter, add the numbers*/
			ThisNum[ThisNumCount]=0x00;
			LowNum=ntohl(inet_addr(ThisNum));
#ifdef DEBUG
			printf("Setting Low Range to %u\n",LowNum);
#endif				
			ThisNumCount=0;
			IsDashed=TRUE;
			break;			
		case 0x00:
		case ',':
			/*this a delimiter, add the numbers*/
			ThisNum[ThisNumCount]=0x00;
			HighNum=ntohl(inet_addr(ThisNum));
			if (LowNum==0) LowNum=HighNum;
			if (IsDashed){
				AddRange(n, LowNum, HighNum);
#ifdef DEBUG
				printf("1Added Number %u-%u\n",LowNum, HighNum);
#endif										
			}else{
				/*there may be a bug here*/
				/*keep an eye on it*/
				AddRange(n, LowNum, LowNum);
#ifdef DEBUG
				printf("5Added Number %u-%u\n", LowNum, LowNum);
#endif				
			}
			ThisNumCount=0;
			IsDashed=FALSE;
			LowNum=0;
			break;
		case ' ':
			/*ignore white space*/
			break;
		case '/':
			/*this is a range*/
			ThisNum[ThisNumCount]=0x00;
			LowNum=ntohl(inet_addr(ThisNum));
			i++;
			Mask=atoi(&Ranges[i]);
			HighNum=LowNum;
			switch (Mask){
			case 0:
				LowNum&=0x00000000;
				HighNum|=0xFFFFFFFF;
				AddRange(n, LowNum, HighNum);
				break;			
			case 1:
				LowNum&=0x10000000;
				HighNum|=0x7FFFFFFF;
				AddRange(n, LowNum, HighNum);
				break;						
			case 2:
				LowNum&=0x30000000;
				HighNum|=0x3FFFFFFF;
				AddRange(n, LowNum, HighNum);
				break;						
			case 3:
				LowNum&=0x70000000;
				HighNum|=0x1FFFFFFF;
				AddRange(n, LowNum, HighNum);
				break;						
			case 4:
				LowNum&=0xF0000000;
				HighNum|=0x0FFFFFFF;
				AddRange(n, LowNum, HighNum);
				break;						
			case 5:
				LowNum&=0xF1000000;
				HighNum|=0x07FFFFFF;
				AddRange(n, LowNum, HighNum);
				break;						
			case 6:
				LowNum&=0xF3000000;
				HighNum|=0x03FFFFFF;
				AddRange(n, LowNum, HighNum);
				break;						
			case 7:
				LowNum&=0xF7000000;
				HighNum|=0x01FFFFFF;
				AddRange(n, LowNum, HighNum);
				break;						
			case 8:
				LowNum&=0xFF000000;
				HighNum|=0x00FFFFFF;
				AddRange(n, LowNum, HighNum);
				break;						
			case 9:
				LowNum&=0xFF100000;
				HighNum|=0x007FFFFF;
				AddRange(n, LowNum, HighNum);
				break;						
			case 10:
				LowNum&=0xFF300000;
				HighNum|=0x003FFFFF;
				AddRange(n, LowNum, HighNum);
				break;									
			case 11:
				LowNum&=0xFF700000;
				HighNum|=0x001FFFFF;
				AddRange(n, LowNum, HighNum);
				break;									
			case 12:
				LowNum&=0xFFF00000;
				HighNum|=0x000FFFFF;
				AddRange(n, LowNum, HighNum);
				break;									
			case 13:
				LowNum&=0xFFF10000;
				HighNum|=0x0007FFFF;
				AddRange(n, LowNum, HighNum);
				break;									
			case 14:
				LowNum&=0xFFF30000;
				HighNum|=0x0003FFFF;
				AddRange(n, LowNum, HighNum);
				break;									
			case 15:
				LowNum&=0xFFF70000;
				HighNum|=0x0001FFFF;
				AddRange(n, LowNum, HighNum);
				break;									
			case 16:
				LowNum&=0xFFFF0000;
				HighNum|=0x0000FFFF;
				AddRange(n, LowNum, HighNum);
				break;
			case 17:
				LowNum&=0xFFFF1000;
				HighNum|=0x00007FFF;
				AddRange(n, LowNum, HighNum);
				break;						
			case 18:
				LowNum&=0xFFFF3000;
				HighNum|=0x00003FFF;
				AddRange(n, LowNum, HighNum);
				break;						
			case 19:
				LowNum&=0xFFFF7000;
				HighNum|=0x00001FFF;
				AddRange(n, LowNum, HighNum);
				break;						
			case 20:
				LowNum&=0xFFFF000;
				HighNum|=0x00000FFF;
				AddRange(n, LowNum, HighNum);
				break;						
			case 21:
				LowNum&=0xFFFFF100;
				HighNum|=0x000007FF;
				AddRange(n, LowNum, HighNum);
				break;						
			case 22:
				LowNum&=0xFFFFF300;
				HighNum|=0x000003FF;
				AddRange(n, LowNum, HighNum);
				break;						
			case 23:
				LowNum&=0xFFFFF700;
				HighNum|=0x000001FF;
				AddRange(n, LowNum, HighNum);
				break;						
			case 24:
				LowNum&=0xFFFFFF00;
				HighNum|=0x000000FF;
				AddRange(n, LowNum, HighNum);
				break;			
			case 25:
				LowNum&=0xFFFFFF10;
				HighNum|=0x0000007F;
				AddRange(n, LowNum, HighNum);
				break;						
			case 26:
				LowNum&=0xFFFFFF30;
				HighNum|=0x0000003F;
				AddRange(n, LowNum, HighNum);
				break;						
			case 27:
				LowNum&=0xFFFFFF70;
				HighNum|=0x0000001F;
				AddRange(n, LowNum, HighNum);
				break;						
			case 28:
				LowNum&=0xFFFFFFF0;
				HighNum|=0x0000000F;
				AddRange(n, LowNum, HighNum);
				break;						
			case 29:
				LowNum&=0xFFFFFFF1;
				HighNum|=0x00000007;
				AddRange(n, LowNum, HighNum);
				break;						
			case 30:
				LowNum&=0xFFFFFFF3;
				HighNum|=0x00000003;
				AddRange(n, LowNum, HighNum);
				break;						
			case 31:
				LowNum&=0xFFFFFFF7;
				HighNum|=0x00000001;
				AddRange(n, LowNum, HighNum);
				break;			
			case 32:
				LowNum&=0xFFFFFFFF;
				HighNum|=0x00000000;
				AddRange(n, LowNum, HighNum);
				break;
			default:
				printf("Invalid CIDR Notation /%u\n",Mask);
				return FALSE;
			}
			
#ifdef DEBUG
			printf("1Added Range %u-%u\n",LowNum, HighNum);
#endif				

			
			while ((Ranges[i]>='0') && (Ranges[i]<='9')) i++;
			ThisNumCount=0;
			IsDashed=FALSE;
			
			break;
		default:
			printf("Invalid character \"%c\"\n", Ranges[i]);
			printf("I don't understand %s\n",Ranges);
			return FALSE;
		}
	}

	return TRUE;
}
Beispiel #11
0
/****************************************************
* Parse a string for the ranges
****************************************************/
int AddRangesString(NumList* n, char* RawRanges, NumAlias* Aliases, int NumAliases){
	int				i;
	char			ThisNum[64];
	int				ThisNumCount;
	unsigned int	LowNum;
	unsigned int	HighNum;
	int				IsRange;
	char*			Ranges;
	
	DEBUGPATH;

	if (!n) return FALSE;

	Ranges=calloc(strlen(RawRanges)*2,sizeof(char));
	if (!ReplaceAliases(RawRanges, strlen(RawRanges), Ranges, strlen(RawRanges)*2, Aliases, NumAliases)){
		printf("Couldn't apply alias list\n");
		free(Ranges);
		return FALSE;	
	}

	ThisNumCount=0;
	IsRange=FALSE;
	for (i=0;i<strlen(Ranges);i++){
		switch(Ranges[i]){
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case '0':
			/*normal number, keep going*/
			ThisNum[ThisNumCount]=Ranges[i];
			ThisNumCount++;
			break;
		case ',':
			/*this a delimiter, add the numbers*/
			ThisNum[ThisNumCount]=0x00;
			if (!IsRange){
				LowNum=strtoul(ThisNum,NULL,10);
				AddRange(n, LowNum, LowNum);
#ifdef DEBUG
				printf("2Added Number %u-%u\n",LowNum, LowNum);
#endif				
			}else{
				HighNum=strtoul(ThisNum, NULL, 10);
				AddRange(n, LowNum, HighNum);
#ifdef DEBUG
				printf("Added Range %u-%u\n",LowNum, HighNum);
#endif								
			}
			ThisNumCount=0;
			IsRange=FALSE;
			break;
		case ' ':
			/*ignore white space*/
			break;
		case '-':
			/*this is a range*/
			ThisNum[ThisNumCount]=0x00;
			LowNum=strtoul(ThisNum, NULL, 10);
#ifdef DEBUG
			printf("Low part of the range is %u\n",LowNum);
#endif			
			IsRange=TRUE;
			ThisNumCount=0;
			break;
		default:
			printf("Invalid character \"%c\"\n", Ranges[i]);
			printf("I don't understand %s\n",Ranges);
			free(Ranges);
			return FALSE;
		}
	}

	/*Finish out the last one*/
	ThisNum[ThisNumCount]=0x00;
	if (!IsRange){
		LowNum=strtoul(ThisNum,NULL,10);
		AddRange(n, LowNum, LowNum);
#ifdef DEBUG
		printf("3Added Number %u-%u\n",LowNum, LowNum);
#endif				
	}else{
		HighNum=strtoul(ThisNum, NULL, 10);
		AddRange(n, LowNum, HighNum);
#ifdef DEBUG
		printf("Added Range %u-%u\n",LowNum, HighNum);
#endif								
	}

	free(Ranges);
	return TRUE;
}
Beispiel #12
0
/*----------------------------------------------------------------------------------------------------------------------
|	Reads in a set from a NEXUS data file. Returns true if the set was terminated by a semicolon, false otherwise.
*/
bool NxsSetReader::Run()
	{
	bool ok;
	bool retval = false;

	unsigned rangeBegin = UINT_MAX;
	unsigned rangeEnd = rangeBegin;
	bool insideRange = false;
	unsigned modValue = 0;

	for (;;)
		{
		// Next token should be one of the following:
		//   ';'        --> set definition finished
		//   '-'        --> range being defined
		//   <integer>  --> member of set (or beginning or end of a range)
		//   '.'        --> signifies the number max
		//   '\'        --> signifies modulus value coming next
		//
		token.GetNextToken();

		if (token.Equals("-"))
			{
			// We should not be inside a range when we encounter a hyphenation symbol.
			// The hyphen is what _puts_ us inside a range!
			//
			if (insideRange)
				{
				block.errormsg = "The symbol '-' is out of place here";
				throw NxsException(block.errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
				}
			insideRange = true;
			}

		else if (token.Equals("."))
			{
			// We _should_ be inside a range if we encounter a period, as this
			// is a range termination character
			//
			if (!insideRange)
				{
				block.errormsg = "The symbol '.' can only be used to specify the end of a range";
				throw NxsException(block.errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
				}
			rangeEnd = max;
			}

		else if (token.Equals("\\"))
			{
			// The backslash character is used to specify a modulus to a range, and
			// thus should only be encountered if currently inside a range
			//
			if (!insideRange)
				{
				block.errormsg = "The symbol '\\' can only be used after the end of a range has been specified";
				throw NxsException(block.errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
				}

			// This should be the modulus value
			//
			modValue = NxsToken::DemandPositiveInt(token, block.errormsg, "The modulus value");
			}

		else if (insideRange && rangeEnd == UINT_MAX)
			{
			// The beginning of the range and the hyphen symbol have been read
			// already, just need to store the end of the range at this point
			//
			rangeEnd = GetTokenValue();
			}

		else if (insideRange)
			{
			// If insideRange is true, we must have already stored the beginning
			// of the range and read in the hyphen character. We would not have
			// made it this far if we had also not already stored the range end.
			// Thus, we can go ahead and add the range.
			//
			ok = AddRange(rangeBegin, rangeEnd, modValue);

			if (!ok)
				{
				block.errormsg = "Character number out of range (or range incorrectly specified) in set specification";
				throw NxsException(block.errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
				}

			// We have actually already read in the next token, so deal with it
			// now so that we don't end up skipping a token
			//
			if (token.Equals(";"))
				{
				retval = true;
				break;
				}
			else if (token.Equals(","))
				{
				break;
				}

			rangeBegin = GetTokenValue();
			rangeEnd = UINT_MAX;
			insideRange = false;
			}

		else if (rangeBegin != UINT_MAX)
			{
			// If we were inside a range, we would have not gotten this far.
			// If not in a range, we are either getting ready to begin a new
			// range or have previously read in a single value. Handle the
			// latter possibility here.
			//
			ok = AddRange(rangeBegin, rangeBegin, modValue);

			if (!ok)
				{
				block.errormsg = "Character number out of range (or range incorrectly specified) in set specification";
				throw NxsException(block.errormsg, token.GetFilePosition(), token.GetFileLine(), token.GetFileColumn());
				}

			if (token.Equals(";"))
				{
				retval = true;
				break;
				}
			else if (token.Equals(","))
				{
				break;
				}

			rangeBegin = GetTokenValue();
			rangeEnd = UINT_MAX;
			}

		else if (token.Equals(";"))
			{
			retval = true;
			break;
			}

		else if (token.Equals(","))
			{
			break;
			}

		else if (token.Equals("ALL"))
			{
			rangeBegin = 1;
			rangeEnd = max;
			ok = AddRange(rangeBegin, rangeEnd);
			}

		else
			{
			// Can only get here if rangeBegin still equals UINT_MAX and thus we
			// are reading in the very first token and that token is neither
			// the word "all" nor is it a semicolon
			//
			rangeBegin = GetTokenValue();
			rangeEnd = UINT_MAX;
			}
		}

	return retval;
	}
//****************************************************************************************
BOOL CBCGPGridSerializeManager::PrepareDataFromSelection ()
{
	ASSERT (m_pOwnerGrid != NULL);

	CleanUp ();

	if (m_pOwnerGrid != NULL)
	{
		m_nLastColumn = m_pOwnerGrid->GetColumnsInfo ().GetColumnCount (TRUE) - 1;
		m_nLastRow = m_pOwnerGrid->GetTotalRowCount () - 1;
	}

	if (m_ClipboardFormatType == CF_Rows)
	{
		if (!m_pOwnerGrid->NormalizeSelectionList ())
		{
			return FALSE;
		}
	}

	//---------------------
	// Calculate min offset
	//---------------------
	int i = 0;
	CBCGPGridItemID idOffset (-1, -1);
	for (i = 0; i < m_pOwnerGrid->GetSelectionCount (); i++)
	{
		CBCGPGridRange rangeIndex, rangeOrder;
		if (m_pOwnerGrid->GetSelection (i, rangeIndex) && 
			IndexToOrder (rangeIndex, rangeOrder))
		{
			const int nRow = (rangeOrder.m_nTop != -1) ? rangeOrder.m_nTop: 0;
			const int nCol = (rangeOrder.m_nLeft != -1) ? rangeOrder.m_nLeft: 0;
			
			if (idOffset.m_nRow == -1 || nRow <= idOffset.m_nRow)
			{
				idOffset.m_nRow = nRow;
			}
			
			if (idOffset.m_nColumn == -1 || nCol <= idOffset.m_nColumn)
			{
				idOffset.m_nColumn = nCol;
			}

			if (idOffset.m_nRow == -1 || 
				idOffset.m_nRow == 0 && idOffset.m_nRow == m_nLastRow)
			{
				m_bWholeColSelected = TRUE;
			}

			if (idOffset.m_nColumn == -1 || 
				idOffset.m_nColumn == 0 && idOffset.m_nColumn == m_nLastColumn)
			{
				m_bWholeRowSelected = TRUE;
			}
		}
	}
	
	if (idOffset.m_nRow == -1)
	{
		idOffset.m_nRow = 0;
	}
	if (idOffset.m_nColumn == -1)
	{
		idOffset.m_nColumn = 0;
	}

	ASSERT (idOffset.m_nRow >= 0);
	ASSERT (idOffset.m_nColumn >= 0);
	m_idRangesOffset = idOffset;

	//------------------------------
	// Prepare serialized selection:
	//------------------------------
	for (i = 0; i < m_pOwnerGrid->GetSelectionCount (); i++)
	{
		CBCGPGridRange rangeIndex, rangeOrder;
		if (m_pOwnerGrid->GetSelection (i, rangeIndex) &&
			IndexToOrder (rangeIndex, rangeOrder))
		{
			const int nRowOffset = (rangeOrder.m_nTop != -1) ? rangeOrder.m_nTop - m_idRangesOffset.m_nRow: 0;
			const int nColOffset = (rangeOrder.m_nLeft != -1) ? rangeOrder.m_nLeft - m_idRangesOffset.m_nColumn: 0;
		
			CBCGPGridRange rangeRelative (
				nColOffset, 
				nRowOffset, 
				nColOffset + (rangeOrder.m_nRight - rangeOrder.m_nLeft), 
				nRowOffset + (rangeOrder.m_nBottom - rangeOrder.m_nTop));

			try
			{
				CMemFile f;

				CArchive archive (&f, CArchive::store | CArchive::bNoFlushOnDelete);
				if (m_ClipboardFormatType == CF_Items)
				{
					WriteItemsToArchive (archive, rangeOrder);
				}
				else if (m_ClipboardFormatType == CF_Rows)
				{
					WriteRowsToArchive (archive, rangeOrder);
				}
				archive.Close ();

				if (f.GetLength () <= 0)
				{
					return FALSE;
				}
				
				UINT	cbSize = (UINT)f.GetLength ();
				BYTE*	pData = new BYTE[cbSize];
				
				if (NULL == pData)
				{
					delete [] pData;
					return FALSE;
				}
				
				f.SeekToBegin ();
				if (f.Read (pData, cbSize) != cbSize)
				{
					delete [] pData;
					return FALSE;
				}
				
				AddRange (rangeRelative, cbSize, pData);
			}
			catch (CFileException* pEx)
			{
				TRACE(_T("CBCGPGridSerializeManager::PrepareDataFromSelection. File exception\r\n"));
				pEx->Delete ();
				
				return FALSE;
			}
			catch (CException* e)
			{
				TRACE(_T("CBCGPGridSerializeManager::PrepareDataFromSelection. Exception\r\n"));
				e->Delete ();
				return FALSE;
			}
		}
	}

	return TRUE;
}
//****************************************************************************************
BOOL CBCGPGridSerializeManager::ReadFromArchive (CArchive& archive)
{
	CleanUp ();

	if (m_pOwnerGrid != NULL)
	{
		m_nLastColumn = m_pOwnerGrid->GetColumnsInfo ().GetColumnCount (TRUE) - 1;
		m_nLastRow = m_pOwnerGrid->GetTotalRowCount () - 1;
	}

	//----------------------
	// Read serialized data:
	//----------------------
	// int	- format type
	// int	- ranges common offset: row
	// int	- ranges common offset: column
	// int	- range count
	// ranges array:
	// int - range offset: row				\	
	// int - range offset: column			|	range
	// int - range size: row count			|
	// int - range size: columns count		|
	// UINT - size in bytes	| range data	|
	// BYTE - range data	|				/
	try
	{
		int nClipboardFormatType = 0;;
		archive >> nClipboardFormatType;
		if (nClipboardFormatType != (int) m_ClipboardFormatType)
		{
			return FALSE;
		}

		//-----------------------------------
		// Read common offset for all ranges:
		//-----------------------------------
		archive >> m_idRangesOffset.m_nRow;
		archive >> m_idRangesOffset.m_nColumn;

		//---------------------
		// Read list of ranges:
		//---------------------
		int nRangeCount = 0;
		archive >> nRangeCount;
		if (nRangeCount <= 0)
		{
			return FALSE;
		}
		
		for (int nRange = 0; nRange < nRangeCount; nRange++)
		{
			//------------
			// Read range:
			//------------
			CBCGPGridItemID idOffset;
			archive >> idOffset.m_nRow;
			archive >> idOffset.m_nColumn;
			
			int nRowCount = 0;
			archive >> nRowCount;
			if (nRowCount <= 0)
			{
				return FALSE;
			}
			
			int nColCount = 0;
			archive >> nColCount;
			if (nColCount <= 0)
			{
				return FALSE;
			}
			
			CBCGPGridRange range (
				idOffset.m_nColumn, 
				idOffset.m_nRow,
				idOffset.m_nColumn + nColCount - 1,
				idOffset.m_nRow + nRowCount - 1);

			if (idOffset.m_nRow == 0 && nRowCount - 1 == m_nLastRow)
			{
				m_bWholeColSelected = TRUE;
			}

			if (idOffset.m_nColumn == 0 && nColCount - 1 == m_nLastColumn)
			{
				m_bWholeRowSelected = TRUE;
			}

			//-----------------
			// Read range data:
			//-----------------
			UINT nDataSize = 0;
			archive >> nDataSize;

			if (nDataSize <= 0)
			{
				return FALSE;
			}

			BYTE* pData = new BYTE[nDataSize];
			
			if (NULL == pData)
			{
				delete [] pData;
				return FALSE;
			}
			
			if (archive.Read (pData, nDataSize) != nDataSize)
			{
				delete [] pData;
				return FALSE;
			}
			
			AddRange (range, nDataSize, pData);
		}
	}
	catch (CArchiveException* pEx)
	{
		TRACE(_T("CBCGPGridSerializeManager::ReadFromArchive. Archive exception\r\n"));
		pEx->Delete ();
		return FALSE;
	}

	return TRUE;
}
Beispiel #15
0
void CGUIDialogMediaFilter::InitializeSettings()
{
  CGUIDialogSettingsManualBase::InitializeSettings();

  if (m_filter == NULL)
    return;

  Reset(true);

  int handledRules = 0;

  CSettingCategory *category = AddCategory("filter", -1);
  if (category == NULL)
  {
    CLog::Log(LOGERROR, "CGUIDialogMediaFilter: unable to setup filters");
    return;
  }

  CSettingGroup *group = AddGroup(category);
  if (group == NULL)
  {
    CLog::Log(LOGERROR, "CGUIDialogMediaFilter: unable to setup filters");
    return;
  }

  for (unsigned int index = 0; index < NUM_FILTERS; index++)
  {
    if (filterList[index].mediaType != m_mediaType)
      continue;

    Filter filter = filterList[index];

    // check the smartplaylist if it contains a matching rule
    for (CDatabaseQueryRules::iterator rule = m_filter->m_ruleCombination.m_rules.begin(); rule != m_filter->m_ruleCombination.m_rules.end(); rule++)
    {
      if ((*rule)->m_field == filter.field)
      {
        filter.rule = (CSmartPlaylistRule *)rule->get();
        handledRules++;
        break;
      }
    }

    std::string settingId = StringUtils::Format("filter.%s.%d", filter.mediaType.c_str(), filter.field); 
    if (filter.controlType == "edit")
    {
      CVariant data;
      if (filter.rule != NULL && filter.rule->m_parameter.size() == 1)
        data = filter.rule->m_parameter.at(0);

      if (filter.settingType == SettingTypeString)
        filter.setting = AddEdit(group, settingId, filter.label, 0, data.asString(), true, false, filter.label, true);
      else if (filter.settingType == SettingTypeInteger)
        filter.setting = AddEdit(group, settingId, filter.label, 0, static_cast<int>(data.asInteger()), 0, 1, 0, false,  static_cast<int>(filter.label), true);
      else if (filter.settingType == SettingTypeNumber)
        filter.setting = AddEdit(group, settingId, filter.label, 0, data.asFloat(), 0.0f, 1.0f, 0.0f, false, filter.label, true);
    }
    else if (filter.controlType == "toggle")
    {
      int value = CHECK_ALL;
      if (filter.rule != NULL)
        value = filter.rule->m_operator == CDatabaseQueryRule::OPERATOR_TRUE ? CHECK_YES : CHECK_NO;

      StaticIntegerSettingOptions entries;
      entries.push_back(std::pair<int, int>(CHECK_LABEL_ALL, CHECK_ALL));
      entries.push_back(std::pair<int, int>(CHECK_LABEL_NO,  CHECK_NO));
      entries.push_back(std::pair<int, int>(CHECK_LABEL_YES, CHECK_YES));

      filter.setting = AddSpinner(group, settingId, filter.label, 0, value, entries, true);
    }
    else if (filter.controlType == "list")
    {
      std::vector<std::string> values;
      if (filter.rule != NULL && !filter.rule->m_parameter.empty())
      {
        values = StringUtils::Split(filter.rule->GetParameter(), DATABASEQUERY_RULE_VALUE_SEPARATOR);
        if (values.size() == 1 && values.at(0).empty())
          values.erase(values.begin());
      }

      filter.setting = AddList(group, settingId, filter.label, 0, values, GetStringListOptions, filter.label);
    }
    else if (filter.controlType == "range")
    {
      CVariant valueLower, valueUpper;
      if (filter.rule != NULL)
      {
        if (filter.rule->m_parameter.size() == 2)
        {
          valueLower = filter.rule->m_parameter.at(0);
          valueUpper = filter.rule->m_parameter.at(1);
        }
        else
        {
          DeleteRule(filter.field);
          filter.rule = NULL;
        }
      }

      if (filter.settingType == SettingTypeInteger)
      {
        int min, interval, max;
        GetRange(filter, min, interval, max);

        // don't create the filter if there's no real range
        if (min == max)
          continue;

        int iValueLower = valueLower.isNull() ? min : static_cast<int>(valueLower.asInteger());
        int iValueUpper = valueUpper.isNull() ? max : static_cast<int>(valueUpper.asInteger());

        if (filter.controlFormat == "integer")
          filter.setting = AddRange(group, settingId, filter.label, 0, iValueLower, iValueUpper, min, interval, max, -1, 21469, true);
        else if (filter.controlFormat == "percentage")
          filter.setting = AddPercentageRange(group, settingId, filter.label, 0, iValueLower, iValueUpper, -1, 1, 21469, true);
        else if (filter.controlFormat == "date")
          filter.setting = AddDateRange(group, settingId, filter.label, 0, iValueLower, iValueUpper, min, interval, max, -1, 21469, true);
        else if (filter.controlFormat == "time")
          filter.setting = AddTimeRange(group, settingId, filter.label, 0, iValueLower, iValueUpper, min, interval, max, -1, 21469, true);
      }
      else if (filter.settingType == SettingTypeNumber)
      {
        float min, interval, max;
        GetRange(filter, min, interval, max);

        // don't create the filter if there's no real range
        if (min == max)
          continue;

        float fValueLower = valueLower.isNull() ? min : valueLower.asFloat();
        float fValueUpper = valueUpper.isNull() ? max : valueUpper.asFloat();

        filter.setting = AddRange(group, settingId, filter.label, 0, fValueLower, fValueUpper, min, interval, max, -1, 21469, true);
      }
    }
    else
    {
      if (filter.rule != NULL)
        handledRules--;

      CLog::Log(LOGWARNING, "CGUIDialogMediaFilter: filter %d of media type %s with unknown control type '%s'",
                filter.field, filter.mediaType.c_str(), filter.controlType.c_str());
      continue;
    }

    if (filter.setting == NULL)
    {
      if (filter.rule != NULL)
        handledRules--;

      CLog::Log(LOGWARNING, "CGUIDialogMediaFilter: failed to create filter %d of media type %s with control type '%s'",
                filter.field, filter.mediaType.c_str(), filter.controlType.c_str());
      continue;
    }

    m_filters.insert(make_pair(settingId, filter));
  }

  // make sure that no change in capacity size is needed when adding new rules
  // which would copy around the rules and our pointers in the Filter struct
  // wouldn't work anymore
  m_filter->m_ruleCombination.m_rules.reserve(m_filters.size() + (m_filter->m_ruleCombination.m_rules.size() - handledRules));
}
struct ZippedUniqueObjectCollection
{
	// apply _func_ to _graphics_ and _physics_
#define DOBOTH(func) graphics.func; physics.func;
	UniqueObjectCollection graphics, physics;

	inline void Add(WorldObject& obj)
	{
		DOBOTH(Add(obj))
	}

	template<typename Iter>
	inline void AddRange(Iter begin, Iter end)
	{
		DOBOTH(AddRange(begin, end))
	}

	inline void Remove(WorldObject& obj)
	{
		DOBOTH(Remove(obj))
	}

	template<typename Iter>
	inline void RemoveRange(Iter begin, Iter end)
	{
		DOBOTH(RemoveRange(begin, end))
	}

#undef DOBOTH
};