void MidiAnalyzerResults::GenerateFrameTabularText( U64 frame_index, DisplayBase display_base )
{
	Frame frame = GetFrame( frame_index );
    ClearTabularText();

	char number_str[128];
	AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 8, number_str, 128 );
    AddTabularText( number_str );
}
void ManchesterAnalyzerResults::GenerateFrameTabularText(U64 frame_index, DisplayBase display_base )
{
    ClearTabularText();

	Frame frame = GetFrame( frame_index );
	
	char number_str[128];
	AnalyzerHelpers::GetNumberString( frame.mData1, display_base, mSettings->mBitsPerTransfer, number_str, 128 );
	AddTabularText( number_str );
}
void AtmelSWIAnalyzerResults::GenerateFrameTabularText(U64 frame_index, DisplayBase display_base)
{
	/*Frame frame = GetFrame(frame_index);
	ClearResultStrings();

	char number_str[128];
	AnalyzerHelpers::GetNumberString(frame.mData1, display_base, 8, number_str, sizeof(number_str));
	AddResultString(number_str);*/

    ClearTabularText();

	const int BUFF_SIZE = 128;
	char number_str[BUFF_SIZE];

	Frame f = GetFrame(frame_index);

	if (f.mType == FrameToken)
	{
		if (f.mData1 == SWI_Wake)
		{
			AddTabularText("Token Wake");
		} else if (f.mData1 == SWI_One) {
			AddTabularText("Token One");
		} else if (f.mData1 == SWI_Zero) {
			AddTabularText("Token Zero");
		}

	} else if (f.mType == FrameByte) {
		AnalyzerHelpers::GetNumberString(f.mData1, display_base, 8, number_str, BUFF_SIZE);
		AddTabularText(number_str);

	} else if (f.mType == FrameChecksum) {

		std::vector<std::string> texts;
		GetTextsForChecksumFrame(f, display_base, texts);

        AddTabularText( texts[0].c_str() );

	} else if (f.mType == FrameFlag) {
		AnalyzerHelpers::GetNumberString(f.mData1, display_base, 8, number_str, BUFF_SIZE);
        AddTabularText("Bad Flag (", number_str, ")");

	} else if (f.mType == FrameCount) {
		AnalyzerHelpers::GetNumberString(f.mData1, display_base, 8, number_str, BUFF_SIZE);
		AddTabularText("Count (", number_str, ")");

	} else if (f.mType == FramePacketSegment) {

		std::vector<std::string> texts;
		GetTextsForPacketSegmentFrame(f, display_base, texts);
        AddTabularText( texts[0].c_str() );
	}
}
void Pn5180AnalyzerResults::GenerateFrameTabularText( U64 frame_index, DisplayBase display_base )
{
    ClearTabularText();
	Frame frame = GetFrame( frame_index );

	std::stringstream ss;

	if(  frame.mFlags & Pn5180_INSTRUCTION_FLAG  )
	{
		char instr_str[128];
		AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 8, instr_str, 128 );

		if (frame.mData1 >= NUM_INSTRUCTIONS)
		{
			ss << "Unknown Instruction (";
			ss << instr_str;
			ss << ")";
		}
		else
		{
			ss << Pn5180InstructionCodes[frame.mData1];
		}

	}
	else
	{
		char mosi_str[128];
		
		AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 8, mosi_str, 128 );

		if(  frame.mFlags & Pn5180_NEW_FRAME_FLAG  )
		{
			mCnt = 0;
			ss << "Instruction: ";
			ss << mosi_str;
		}
		else
		{
			ss << "Payload[";
			ss << mCnt-1;
			ss << "]: ";
			ss << mosi_str;
			if (mOldFrameId < frame_index)
			{
				mCnt++;
				mOldFrameId = frame_index;
			}
		}
	}

	AddTabularText( ss.str().c_str() );
}
void PJONAnalyzerResults::GenerateFrameTabularText( U64 frame_index, DisplayBase display_base )
{
	Frame frame = GetFrame( frame_index );
    ClearTabularText();
   
    char buf[50];
   	char number_str[128];

    switch (frame.mType) {
        case Sync: {
            char* str = PJONPacketState::asDisplayString(frame.mFlags);
            AddTabularText("Sync ", str);
            break;
        }
            
        case Data: {
            UILabel label = GetAckNackLabels(frame_index);

            AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 8, number_str, 128 );
            AddTabularText("Data ", label.full.c_str(), " ", number_str);
            break;
        }
            
        case Error: {
            AddTabularText("Error");
            break;
        }
            
        default: {
           	AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 8, number_str, 128 );
            AddTabularText(number_str );
            break;
        }
    }

}
void UnioAnalyzerResults::GenerateFrameTabularText( U64 frame_index, DisplayBase display_base )
{
    ClearTabularText();
	Frame frame = GetFrame( frame_index );

	//enum UnioFrameType { HeaderFrame, AddressFrame8, AddressFrame12, DataFrame, InvalidBit, ErrorMakRequired, ErrorNoSakRequired };
	switch( UnioFrameType( frame.mType ) )
	{
	case HeaderFrame:
		{
			double bit_rate = double( mAnalyzer->GetSampleRate() ) / ( double( frame.mData1 ) * .125 );
			char frequency[256];
			sprintf( frequency, "%.1f kHz", bit_rate * .001 );
			AddTabularText( "Header; Bit-rate: ",  frequency );
		}
		break;

	case AddressFrame8:
	case AddressFrame12:
		{
			char number_str[128];
			if( UnioFrameType( frame.mType ) == AddressFrame8 )
				AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 8, number_str, 128 );
			else
				AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 12, number_str, 128 );

			char master_ack[16];
			if( ( frame.mFlags & MASTER_ACK ) != 0 )
				sprintf( master_ack, "MAK" );
			else
				sprintf( master_ack, "NoMAK" );

			char slave_ack[16];
			if( ( frame.mFlags & SLAVE_ACK ) != 0 )
				sprintf( slave_ack, "SAK" );
			else
				sprintf( slave_ack, "NoSAK" );

			AddTabularText( "Address: ", number_str, "; ", master_ack, "; ", slave_ack );
		}
		break;

	case DataFrame:
		{
			char number_str[128];
			AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 8, number_str, 128 );

			char master_ack[16];
			if( ( frame.mFlags & MASTER_ACK ) != 0 )
				sprintf( master_ack, "MAK" );
			else
				sprintf( master_ack, "NoMAK" );

			char slave_ack[16];
			if( ( frame.mFlags & SLAVE_ACK ) != 0 )
				sprintf( slave_ack, "SAK" );
			else
				sprintf( slave_ack, "NoSAK" );

			AddTabularText( "Data: ", number_str, "; ", master_ack, "; ", slave_ack );
		}
		break;

	case ErrorMakRequired:
		AddTabularText( "Error: MAK is required" );
		break;

	case ErrorNoSakRequired:
		AddTabularText( "Error: NoSAK is required" );
		break;

	case InvalidBit:
		AddTabularText( "Error: Invalid UNIO bit" );
		break;

	default:
		AnalyzerHelpers::Assert( "unexpected" );
		break;
	}
}
void CanAnalyzerResults::GenerateFrameTabularText( U64 frame_index, DisplayBase display_base )
{
    ClearTabularText();

	Frame frame = GetFrame( frame_index );

	switch( frame.mType )
	{
	case IdentifierField:
	case IdentifierFieldEx:
		{
			char number_str[128];

			if( frame.mType == IdentifierField )
				AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 12, number_str, 128 );
			else
				AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 32, number_str, 128 );

			std::stringstream ss;

			
			if( frame.HasFlag( REMOTE_FRAME ) == false )
			{
				if( frame.mType == IdentifierField )
					ss << "Standard CAN Identifier: " << number_str;
				else
					ss << "Extended CAN Identifier: " << number_str;
			}else
			{
				if( frame.mType == IdentifierField )
					ss << "Standard CAN Identifier: " << number_str << " (RTR)";
				else
					ss << "Extended CAN Identifier: " << number_str << " (RTR)";
			}

			AddTabularText( ss.str().c_str() );
		}
		break;
	case ControlField:
		{
			char number_str[128];
			AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 4, number_str, 128 );

			std::stringstream ss;
			
			ss << "Control Field: " << number_str;
			ss << " bytes";
			AddTabularText( ss.str().c_str() );

		}
		break;
	case DataField:
		{
			char number_str[128];
			AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 8, number_str, 128 );

			std::stringstream ss;
			
			ss << "Data Field Byte: " << number_str;
			AddTabularText( ss.str().c_str() );
		}
		break;
	case CrcField:
		{
			char number_str[128];
			AnalyzerHelpers::GetNumberString( frame.mData1, display_base, 15, number_str, 128 );
						
			std::stringstream ss;
			
			ss << "CRC value: " << number_str;
			AddTabularText( ss.str().c_str() );
		}
		break;	
	case AckField:
		{
			if( bool( frame.mData1 ) == true )
				AddTabularText( "ACK" );
			else
				AddTabularText( "NAK" );
		}
		break;	
	case CanError:
		{
			AddTabularText( "Error" );
		}
		break;
	}
}