int64
ClipboardSizeDataSource::NextValue(SystemInfo& info)
{
	if (fText)
		return info.ClipboardTextSize()/* / 1024*/;
	return info.ClipboardSize()/* / 1024*/;
}
SwapSpaceDataSource::SwapSpaceDataSource()
{
	SystemInfo info;

	fColor = (rgb_color){0, 120, 0};
	fMaximum = info.MaxSwapSpace();
}
MemoryDataSource::MemoryDataSource()
{
	SystemInfo info;

	fMinimum = 0;
	fMaximum = info.MaxMemory();
}
ThreadsDataSource::ThreadsDataSource()
{
	SystemInfo info;

	fMinimum = 0;
	fMaximum = info.MaxThreads();

	fColor = (rgb_color){0, 0, 200};
}
TeamsDataSource::TeamsDataSource()
{
	SystemInfo info;

	fMinimum = 0;
	fMaximum = info.MaxTeams();

	fColor = (rgb_color){0, 150, 255};
}
SemaphoresDataSource::SemaphoresDataSource()
{
	SystemInfo info;

	fMinimum = 0;
	fMaximum = info.MaxSemaphores();

	fColor = (rgb_color){100, 200, 100};
}
RunningAppsDataSource::RunningAppsDataSource()
{
	SystemInfo info;

	fMinimum = 0;
	fMaximum = info.MaxRunningApps();

	fColor = (rgb_color){100, 150, 255};
}
PortsDataSource::PortsDataSource()
{
	SystemInfo info;

	fMinimum = 0;
	fMaximum = info.MaxPorts();

	fColor = (rgb_color){180, 200, 180};
}
int64
NetworkUsageDataSource::NextValue(SystemInfo& info)
{
	uint64 transferred = fIn ? info.NetworkReceived() : info.NetworkSent();

	int64 bytesPerSecond = uint64(double(transferred - fPreviousBytes)
		/ (info.Time() - fPreviousTime) * 1000000.0);

	fPreviousBytes = transferred;
	fPreviousTime = info.Time();

	return bytesPerSecond;
}
int64
PageFaultsDataSource::NextValue(SystemInfo& info)
{
	uint64 faults = info.PageFaults();

	int64 faultsPerSecond = uint64(1024 * double(faults - fPreviousFaults)
		/ (info.Time() - fPreviousTime) * 1000000.0);

	fPreviousFaults = faults;
	fPreviousTime = info.Time();

	return faultsPerSecond;
}
Json::Value GenerateJsonData::GetPerformanceData()
{ 
	CpuInfoInPdh *cpu = new CpuInfoInPdh();

	MemoryInfo	*mem = new MemoryInfo();

	SystemInfo *sys = new SystemInfo();

	DiskInfo	*disk = new DiskInfo();
	disk->GetDefaultDriveFixedSize();

	NetInterfaceInfo *net = new NetInterfaceInfo();
	
	Json::Value root;
	
	Json::Value json_mem;
	Json::Value json_disk;
	Json::Value json_net;

	root["time"] = Json::Value((Json::Value::UInt64)sys->GetTimeGMT());
	
	root["vmid"] = "windows-vmid";
	
	root["cpu"] = Json::Value((Json::Value::UInt)cpu->GetCpuUsedRate());

	json_mem["total"] = Json::Value((Json::Value::UInt64)mem->GetTotalPhysMemSize());
	json_mem["used"] = Json::Value((Json::Value::UInt64)mem->GetUsedPhysMemSize());

	root["mem"] = json_mem;
		
	json_disk["total"] = Json::Value((Json::Value::UInt64)disk->GetDisk_C_TotalFixdSize());
	json_disk["used"] = Json::Value((Json::Value::UInt64)disk->GetDisk_C_UsedFixedSize());
	json_disk["read"] = Json::Value((Json::Value::UInt64)disk->GetDiskReadSpeed());
	json_disk["write"] = Json::Value((Json::Value::UInt64)disk->GetDiskWriteSpeed());

	root["disk"] = json_disk;

	json_net["in"] = Json::Value((Json::Value::UInt64)net->GetNetReceivedSpeed());
	json_net["out"] = Json::Value((Json::Value::UInt64)net->GetNetSendSpeed());

	root["net"] = json_net;

	
	Json::StyledWriter styled_writer;
	cout << styled_writer.write(root) << endl;
		
	return root;
}
int64
CPUUsageDataSource::NextValue(SystemInfo& info)
{
	bigtime_t active = info.Info().cpu_infos[fCPU].active_time;

	int64 percent = int64(1000.0 * (active - fPreviousActive)
		/ (info.Time() - fPreviousTime));
	if (percent < 0)
		percent = 0;
	if (percent > 1000)
		percent = 1000;

	fPreviousActive = active;
	fPreviousTime = info.Time();

	return percent;
}
Beispiel #13
0
/**
   Return the Description for the OS, usually the same as caption.

   \returns     Description for OS, intended for display/human reader
   \throws      SCXCoreLib::SCXNotSupportedException - if not implemented for the platform
(passed through from GetCaption().

*/
std::wstring SCXOSTypeInfo::GetDescription() const
{
    std::wstring str = GetCaption();

#if defined(sun)
    bool isInGlobalZone = false;
    SystemInfo si;

    // True means platform has zone support, false means does not
    if(si.GetSUN_IsInGlobalZone(isInGlobalZone))
    {
        if(isInGlobalZone)
            str += L" Global Zone";
        else
            str += L" Non-Global Zone";
    }
#endif
    return str;
}
int64
CPUCombinedUsageDataSource::NextValue(SystemInfo& info)
{
	int32 running = 0;
	bigtime_t active = 0;

	for (int32 cpu = 0; cpu < info.Info().cpu_count; cpu++) {
		active += info.Info().cpu_infos[cpu].active_time;
		running++;
			// TODO: take disabled CPUs into account
	}

	int64 percent = int64(1000.0 * (active - fPreviousActive)
		/ (running * (info.Time() - fPreviousTime)));
	if (percent < 0)
		percent = 0;
	if (percent > 1000)
		percent = 1000;

	fPreviousActive = active;
	fPreviousTime = info.Time();

	return percent;
}
status_t
LocalDebuggerInterface::GetSystemInfo(SystemInfo& info)
{
	system_info sysInfo;
	status_t result = get_system_info(&sysInfo);
	if (result != B_OK)
		return result;

	utsname name;
	result = uname(&name);
	if (result != B_OK)
		return result;

	info.SetTo(fTeamID, sysInfo, name);
	return B_OK;
}
Beispiel #16
0
  Status GetSystems(ServerContext* /*context*/, const Empty* /*request*/, ServerWriter<SystemType>* writer) override {
    auto _api = this->options.GetAPI();

    for (auto systems : _api) {
      SystemType system;

      system.set_name(systems.first);

      for (auto&& subsystem : systems.second) {
        SystemInfo* subInfo = system.add_subsystems();

        std::ifstream ifabout(subsystem, std::ios_base::in);
        if (!ifabout.is_open()) continue;

        ey_data about = parse_eyaml(ifabout, subsystem);

        std::string name = about.get("name");
        std::string id = about.get("identifier");
        std::string desc = about.get("description");
        std::string author = about.get("author");
        std::string target = about.get("target-platform");

        if (id.empty())
          id = about.get("id"); // allow alias
        if (id.empty()) {
          // compilers use filename minus ext as id
          boost::filesystem::path ey(subsystem);
          id = ey.stem().string();
        }

        // allow author alias used by compiler descriptors
        if (author.empty())
          author = about.get("maintainer");

        subInfo->set_name(name);
        subInfo->set_id(id);
        subInfo->set_description(desc);
        subInfo->set_author(author);
        subInfo->set_target(target);
      }

      writer->Write(system);
    }

    return Status::OK;
  }
    /**
       Returns the architecture of the platform, e.g. PA-Risc, x86 or SPARC
    
       \returns   String with the architecture of the platform
    
    */
    std::wstring SCXOSTypeInfo::GetArchitectureString() const
    {
#if defined(hpux)
#if defined(hppa)
        return L"PA-Risc";
#else
        return L"IA64";
#endif // defined(hpux)

#elif defined(linux)

        unsigned short bitSize = 0;
        try
        {
            SystemInfo sysInfo;
            sysInfo.GetNativeBitSize(bitSize);
        }
        catch (SCXCoreLib::SCXException &e)
        {
            SCX_LOGERROR(m_log, StrAppend( StrAppend(L"Failure in SystemInstance::GetNativeBitSize: ", e.What()), e.Where()));
        }

        if (32 == bitSize)
        {
            return L"x86";
        }
        else if (64 == bitSize) 
        {
            return L"x64";
        }
        else 
        {
            assert(!"Unknown architecture");
            return L"Unknown";
        }

#elif defined(sun)
            
#if defined(sparc)
        return L"SPARC";
#else
        return L"x86";
#endif
        
#elif defined(aix)
        return L"powerpc";     // This is what uname -p says
        
#elif defined(macos)

        // On MacOS Intel platforms, the architecture appears to always be i386,
        // regardless of 32-bit vs. 64-bit capabilities.  However, since we may
        // (some day) run on something else, we'll implement this properly.
        //
        // Intel (i386) on Mac is a special case: we return 'x86' or 'x64' based
        // on 64-bit capabilities of the CPU.

        // First get the machine architecture dynamically

        int mib[2];
        char hwMachine[64];
        size_t len_hwMachine = sizeof(hwMachine);

        mib[0] = CTL_HW;
        mib[1] = HW_MACHINE;

        if (0 != sysctl(mib, 2, hwMachine, &len_hwMachine, NULL, 0))
        {
            wostringstream sout;
            sout << L"Failure calling sysctl(): Errno=" << errno;
            SCX_LOGERROR(m_log, sout.str());

            return L"";
        }

        // Now figure out our bit size (if Intel, handle the special case)

        if (0 == strncmp("i386", hwMachine, sizeof(hwMachine)))
        {
            unsigned short bitSize = 0;
            try
            {
                SystemInfo sysInfo;
                sysInfo.GetNativeBitSize(bitSize);
            }
            catch (SCXCoreLib::SCXException &e)
            {
                SCX_LOGERROR(m_log, StrAppend( StrAppend(L"Failure in SystemInstance::GetNativeBitSize: ", e.What()), e.Where()));
            }

            if (32 == bitSize)
            {
                return L"x86";
            }
            else if (64 == bitSize) 
            {
                return L"x64";
            }
        }

        // Return the actual architecture, whatever it is

        return StrFromMultibyte(hwMachine);

#else
#error "Platform not supported"
#endif
    }
int main(int argc, char* argv[])
{
    SystemInfo sysInfo;
    TCHAR szServicePack[128] = { 0 };

    switch (sysInfo.getWindowsVersion())
    {
    case Windows:
        cout << "Windows" << endl;
        break;

    case Windows32s:
        cout << "Windows 32s" << endl;
        break;

    case Windows95:
        cout << "Windows 95" << endl;
        break;

    case Windows95OSR2:
        cout << "Windows 95 SR2" << endl;
        break;

    case Windows98:
        cout << "Windows 98" << endl;
        break;

    case Windows98SE:
        cout << "Windows 98 SE" << endl;
        break;

    case WindowsMillennium:
        cout << "Windows Me" << endl;
        break;

    case WindowsNT351:
        cout << "Windows NT 3.51" << endl;
        break;

    case WindowsNT40:
        cout << "Windows NT 4.0" << endl;
        break;

    case WindowsNT40Server:
        cout << "Windows NT 4.0 Server" << endl;
        break;

    case Windows2000:
        cout << "Windows 2000" << endl;
        break;

    case WindowsXP:
        cout << "Windows XP" << endl;
        break;

    case WindowsXPProfessionalx64:
        cout << "Windows XP Professional x64" << endl;
        break;

    case WindowsHomeServer:
        cout << "Windows Home Server" << endl;
        break;

    case WindowsServer2003:
        cout << "Windows Server 2003" << endl;
        break;

    case WindowsServer2003R2:
        cout << "Windows Server 2003 R2" << endl;
        break;

    case WindowsVista:
        cout << "Windows Vista" << endl;
        break;

    case WindowsServer2008:
        cout << "Windows Server 2008" << endl;
        break;

    case WindowsServer2008R2:
        cout << "Windows Server 2008 R2" << endl;
        break;

    case Windows7:
        cout << "Windows 7" << endl;
        break;
    case Windows8Point1:
        cout << "Windows 8.1" << endl;

    case Windows10:
        cout << "Windows 10 ";
        break;

    case WindowsServer2016TechnicalPreview:
        cout << "Windows 10 Server" << endl;
        break;
    }

    switch (sysInfo.getWindowsEdition())
    {
    case EditionUnknown:
        cout << "Edition unknown Edition" << endl;
        break;

    case Workstation:
        cout << "Workstation Edition" << endl;
        break;

    case Server:
        cout << "Server Edition" << endl;
        break;

    case AdvancedServer:
        cout << "Advanced Server Edition" << endl;
        break;

    case Home:
        cout << "Home Edition" << endl;
        break;

    case Ultimate:
        cout << "Ultimate Edition" << endl;
        break;

    case HomeBasic:
        cout << "Home Basic Edition" << endl;
        break;

    case HomePremium:
        cout << "Home Premium Edition" << endl;
        break;

    case Enterprise:
        cout << "Enterprise Edition" << endl;
        break;

    case Professional:
        cout << "Professional Edition" << endl;
        break;

    case HomeBasic_N:
        cout << "Home Basic N Edition" << endl;
        break;

    case Business:
        cout << "Business Edition" << endl;
        break;

    case StandardServer:
        cout << "Standard Server Edition" << endl;
        break;

    case EnterpriseServerCore:
        cout << "Enterprise Server Core Edition" << endl;
        break;

    case EnterpriseServerIA64:
        cout << "Enterprise Server IA64 Edition" << endl;
        break;

    case Business_N:
        cout << "Business N Edition" << endl;
        break;

    case WebServer:
        cout << "Web Server Edition" << endl;
        break;

    case ClusterServer:
        cout << "Cluster Server Edition" << endl;
        break;

    case HomeServer:
        cout << "Home Server Edition" << endl;
        break;
    }

    cout << "Platform type: ";
    if (sysInfo.isNTPlatform())
    {
        cout << "NT" << endl;
    }
    else if (sysInfo.isWindowsPlatform())
    {
        cout << "Windows" << endl;
    }
    else if (sysInfo.isWin32sPlatform())
    {
        cout << "Win32s" << endl;
    }
    else
    {
        cout << "Unknown" << endl;
    }

    cout << "Major version: " << sysInfo.getMajorVersion() << endl;
    cout << "Minor version: " << sysInfo.getMinorVersion() << endl;
    cout << "Build number: " << sysInfo.getBuildNumber() << endl;

    sysInfo.getServicePackInfo(szServicePack);
    cout << "Service Pack info: " << szServicePack << endl;

    cout << "32-bit platform: " << std::boolalpha << sysInfo.is32bitPlatform() << endl;
    cout << "64-bit platform: " << std::boolalpha << sysInfo.is64bitPlatform() << endl;

    std::string softWareName1 = "360云盘";
    std::string softWareName2 = "Microsoft Visual Studio Professional 2015 - 简体中文"; 
    std::string softWareName = "支付宝安全控件 5.3.0.3807";
    cout << checkIsInstalled(softWareName);

    return 0;
}
static void EnumerateOneInstance(
    Context& context,
    SCX_OperatingSystem_Class& inst,
    bool keysOnly,
    SCXHandle<OSInstance> osinst,
    SCXHandle<MemoryInstance> meminst)
{
    // Get some handles
    SCXHandle<SCXOSTypeInfo> osTypeInfo = SCXCore::g_OSProvider.GetOSTypeInfo();
    SCXLogHandle& log = SCXCore::g_OSProvider.GetLogHandle();

    SCX_LOGTRACE(log, L"OSProvider EnumerateOneInstance()");

    // Fill in the keys
    inst.Name_value( StrToMultibyte(osTypeInfo->GetOSName(true)).c_str() );
    inst.CSCreationClassName_value( "SCX_ComputerSystem" );

    try {
        NameResolver mi;
        inst.CSName_value( StrToMultibyte(mi.GetHostDomainname()).c_str() );
    } catch (SCXException& e) {
        SCX_LOGWARNING(log, StrAppend(
                              StrAppend(L"Can't read host/domainname because ", e.What()),
                              e.Where()));
    }

    inst.CreationClassName_value( "SCX_OperatingSystem" );

    if ( !keysOnly )
    {
        SCXCalendarTime ASCXCalendarTime;
        scxulong Ascxulong, Ascxulong1;
        unsigned short Aunsignedshort;
        vector<string> Avector;
        vector<unsigned short> Aushortvector;
        wstring Awstring;
        signed short Ashort;
        unsigned int Auint;

        /*===================================================================================*/
        /* Defaulted Values (from MOF)                                                       */
        /*===================================================================================*/

        inst.EnabledDefault_value( 2 );
        inst.EnabledState_value( 5 );
        inst.RequestedState_value( 12 );

        /*===================================================================================*/
        /* Properties of CIM_ManagedElement                                                  */
        /*===================================================================================*/

        inst.Caption_value( StrToMultibyte(osTypeInfo->GetCaption()).c_str() );
        inst.Description_value( StrToMultibyte(osTypeInfo->GetDescription()).c_str() );

        /*===================================================================================*/
        /* Properties of CIM_ManagedSystemElement                                            */
        /*===================================================================================*/

        // We don't support the following because there's no way to retrieve on any platforms:
        //      InstallDate
        //      Status
        //      OperationalStatus
        //      StatusDescriptions
        //      HealthState

        /*===================================================================================*/
        /* Properties of CIM_OperatingSystem                                                 */
        /*===================================================================================*/

        // We don't support the following because there's no way to retrieve on any platforms:
        //      EnabledState
        //      OtherEnabledState
        //      RequestedState
        //      EnabledDefault
        //      TimeOfLastStateChange
        //      OverwritePolicy
        //      Distributed

        /* CSCreationClassName is a key property and thus set in AddKeys */
        /* CSName is a key property and thus set in AddKeys */
        /* CreationClassName is a key property and thus set in AddKeys */

        if (osinst->GetOSType(Aunsignedshort))
            inst.OSType_value( Aunsignedshort );

        if (osinst->GetOtherTypeDescription(Awstring))
            inst.OtherTypeDescription_value( StrToMultibyte(Awstring).c_str() );

        if (osinst->GetVersion(Awstring))
            inst.Version_value( StrToMultibyte(Awstring).c_str() );

        if (osinst->GetLastBootUpTime(ASCXCalendarTime))
        {
            MI_Datetime bootTime;
            CIMUtils::ConvertToCIMDatetime( bootTime, ASCXCalendarTime );
            inst.LastBootUpTime_value( bootTime );
        }

        if (osinst->GetLocalDateTime(ASCXCalendarTime))
        {
            MI_Datetime localTime;
            CIMUtils::ConvertToCIMDatetime( localTime, ASCXCalendarTime );
            inst.LocalDateTime_value( localTime );
        }

        if (osinst->GetCurrentTimeZone(Ashort))
            inst.CurrentTimeZone_value( Ashort );

        if (osinst->GetNumberOfLicensedUsers(Auint))
            inst.NumberOfLicensedUsers_value( Auint );

        if (osinst->GetNumberOfUsers(Auint))
            inst.NumberOfUsers_value( Auint );

        if (ProcessEnumeration::GetNumberOfProcesses(Auint))
            inst.NumberOfProcesses_value( Auint );

        if (osinst->GetMaxNumberOfProcesses(Auint))
            inst.MaxNumberOfProcesses_value( Auint );

        if (meminst->GetTotalSwap(Ascxulong))
        {
            inst.TotalSwapSpaceSize_value( BytesToKiloBytes(Ascxulong) );
        }

        if (meminst->GetTotalPhysicalMemory(Ascxulong) && meminst->GetTotalSwap(Ascxulong1))
        {
            inst.TotalVirtualMemorySize_value( BytesToKiloBytes(Ascxulong) + BytesToKiloBytes(Ascxulong1) );
        }

        if (meminst->GetAvailableMemory(Ascxulong))
        {
            Ascxulong = BytesToKiloBytes(Ascxulong);

            if (meminst->GetAvailableSwap(Ascxulong1)) {
                inst.FreeVirtualMemory_value( Ascxulong + BytesToKiloBytes(Ascxulong1) );
            }

            inst.FreePhysicalMemory_value( Ascxulong );
        }

        if (meminst->GetTotalPhysicalMemory(Ascxulong))
            inst.TotalVisibleMemorySize_value( BytesToKiloBytes(Ascxulong) );

        if (meminst->GetTotalSwap(Ascxulong))
            inst.SizeStoredInPagingFiles_value( BytesToKiloBytes(Ascxulong) );

        if (meminst->GetAvailableSwap(Ascxulong))
            inst.FreeSpaceInPagingFiles_value( BytesToKiloBytes(Ascxulong) );

        if (osinst->GetMaxProcessMemorySize(Ascxulong))
            inst.MaxProcessMemorySize_value( Ascxulong );

        if (osinst->GetMaxProcessesPerUser(Auint))
            inst.MaxProcessesPerUser_value( Auint );

        /*===================================================================================*/
        /* Properties of SCX_OperatingSystem (Taken from PG_OperatingSystem)                 */
        /*===================================================================================*/

        SystemInfo sysInfo;
        if (sysInfo.GetNativeBitSize(Aunsignedshort))
        {
            std::ostringstream bitText;
            bitText << Aunsignedshort << " bit";

            inst.OperatingSystemCapability_value( bitText.str().c_str() );
        }

        if (osinst->GetSystemUpTime(Ascxulong))
            inst.SystemUpTime_value( Ascxulong );
    }

    context.Post(inst);
}
status_t
DebugReportGenerator::_GenerateReportHeader(BFile& _output)
{
	AutoLocker< ::Team> locker(fTeam);

	BString data;
	data.SetToFormat("Debug information for team %s (%" B_PRId32 "):\n",
		fTeam->Name(), fTeam->ID());
	WRITE_AND_CHECK(_output, data);

	cpu_platform platform = B_CPU_UNKNOWN;
	cpu_vendor cpuVendor = B_CPU_VENDOR_UNKNOWN;
	uint32 cpuModel = 0;
	uint32 topologyNodeCount = 0;
	cpu_topology_node_info* topology = NULL;
	get_cpu_topology_info(NULL, &topologyNodeCount);
	if (topologyNodeCount != 0) {
		topology = new(std::nothrow) cpu_topology_node_info[topologyNodeCount];
		if (topology == NULL)
			return B_NO_MEMORY;

		BPrivate::ArrayDeleter<cpu_topology_node_info> deleter(topology);
		get_cpu_topology_info(topology, &topologyNodeCount);

		for (uint32 i = 0; i < topologyNodeCount; i++) {
			switch (topology[i].type) {
				case B_TOPOLOGY_ROOT:
					platform = topology[i].data.root.platform;
					break;

				case B_TOPOLOGY_PACKAGE:
					cpuVendor = topology[i].data.package.vendor;
					break;

				case B_TOPOLOGY_CORE:
					cpuModel = topology[i].data.core.model;
					break;

				default:
					break;
			}
		}
	}

	SystemInfo sysInfo;
	if (fDebuggerInterface->GetSystemInfo(sysInfo) == B_OK) {
		const system_info &info = sysInfo.GetSystemInfo();
		data.SetToFormat("CPU(s): %" B_PRId32 "x %s %s\n",
			info.cpu_count, get_cpu_vendor_string(cpuVendor),
			get_cpu_model_string(platform, cpuVendor, cpuModel));
		WRITE_AND_CHECK(_output, data);

		char maxSize[32];
		char usedSize[32];

		data.SetToFormat("Memory: %s total, %s used\n",
			BPrivate::string_for_size((int64)info.max_pages * B_PAGE_SIZE,
				maxSize, sizeof(maxSize)),
			BPrivate::string_for_size((int64)info.used_pages * B_PAGE_SIZE,
				usedSize, sizeof(usedSize)));
		WRITE_AND_CHECK(_output, data);

		const utsname& name = sysInfo.GetSystemName();
		data.SetToFormat("Haiku revision: %s (%s)\n", name.version,
			name.machine);
		WRITE_AND_CHECK(_output, data);
	}

	return B_OK;
}
int64
MediaNodesDataSource::NextValue(SystemInfo& info)
{
	return info.MediaNodes();
}
int64
RunningAppsDataSource::NextValue(SystemInfo& info)
{
	return info.UsedRunningApps();
}
int64
CachedMemoryDataSource::NextValue(SystemInfo& info)
{
	return info.CachedMemory();
}
int64
SwapSpaceDataSource::NextValue(SystemInfo& info)
{
	return info.UsedSwapSpace();
}
int64
TeamsDataSource::NextValue(SystemInfo& info)
{
	return info.UsedTeams();
}
int64
SemaphoresDataSource::NextValue(SystemInfo& info)
{
	return info.UsedSemaphores();
}
int64
ThreadsDataSource::NextValue(SystemInfo& info)
{
	return info.UsedThreads();
}
Beispiel #28
0
status_t
ActivityView::AddDataSource(const DataSource* source, const BMessage* state)
{
	if (source == NULL)
		return B_BAD_VALUE;

	BAutolock _(fSourcesLock);

	// Search for the correct insert spot to maintain the order of the sources
	int32 insert = DataSource::IndexOf(source);
	for (int32 i = 0; i < fSources.CountItems() && i < insert; i++) {
		DataSource* before = fSources.ItemAt(i);
		if (DataSource::IndexOf(before) > insert) {
			insert = i;
			break;
		}
	}
	if (insert > fSources.CountItems())
		insert = fSources.CountItems();

	// Generate DataHistory and ViewHistory objects for the source
	// (one might need one history per CPU)

	uint32 count = 1;
	if (source->PerCPU()) {
		SystemInfo info;
		count = info.CPUCount();
	}

	for (uint32 i = 0; i < count; i++) {
		DataHistory* values = new(std::nothrow) DataHistory(10 * 60000000LL,
			RefreshInterval());
		ListAddDeleter<DataHistory> valuesDeleter(fValues, values, insert);

		ViewHistory* viewValues = new(std::nothrow) ViewHistory;
		ListAddDeleter<ViewHistory> viewValuesDeleter(fViewValues, viewValues,
			insert);

		if (valuesDeleter.Failed() || viewValuesDeleter.Failed())
			return B_NO_MEMORY;

		values->SetScale(_ScaleFor(source->ScaleType()));

		DataSource* copy;
		if (source->PerCPU())
			copy = source->CopyForCPU(i);
		else
			copy = source->Copy();

		ListAddDeleter<DataSource> sourceDeleter(fSources, copy, insert);
		if (sourceDeleter.Failed())
			return B_NO_MEMORY;

		BString colorName = source->Name();
		colorName << " color";
		if (state != NULL) {
			const rgb_color* color = NULL;
			ssize_t colorLength;
			if (state->FindData(colorName.String(), B_RGB_COLOR_TYPE, i,
					(const void**)&color, &colorLength) == B_OK
				&& colorLength == sizeof(rgb_color))
				copy->SetColor(*color);
		}

		valuesDeleter.Detach();
		viewValuesDeleter.Detach();
		sourceDeleter.Detach();
		insert++;
	}

#ifdef __HAIKU__
	InvalidateLayout();
#endif
	return B_OK;
}
Beispiel #29
0
void
ActivityView::MouseDown(BPoint where)
{
	int32 buttons = B_SECONDARY_MOUSE_BUTTON;
	if (Looper() != NULL && Looper()->CurrentMessage() != NULL)
		Looper()->CurrentMessage()->FindInt32("buttons", &buttons);

	if (buttons == B_PRIMARY_MOUSE_BUTTON) {
		fZoomPoint = where;
		fOriginalResolution = fDrawResolution;
		fZooming = true;
		SetMouseEventMask(B_POINTER_EVENTS);
		return;
	}

	BPopUpMenu *menu = new BPopUpMenu(B_EMPTY_STRING, false, false);
	menu->SetFont(be_plain_font);

	BMenu* additionalMenu = new BMenu(B_TRANSLATE("Additional items"));
	additionalMenu->SetFont(be_plain_font);

	SystemInfo info;
	BMenuItem* item;

	for (int32 i = 0; i < DataSource::CountSources(); i++) {
		const DataSource* source = DataSource::SourceAt(i);

		if (source->MultiCPUOnly() && info.CPUCount() == 1)
			continue;

		BMessage* message = new BMessage(kMsgToggleDataSource);
		message->AddInt32("index", i);

		item = new BMenuItem(source->Name(), message);
		if (FindDataSource(source))
			item->SetMarked(true);

		if (source->Primary())
			menu->AddItem(item);
		else
			additionalMenu->AddItem(item);
	}

	menu->AddItem(new BMenuItem(additionalMenu));
	menu->AddSeparatorItem();
	menu->AddItem(item = new BMenuItem(B_TRANSLATE("Show legend"),
		new BMessage(kMsgToggleLegend)));
	item->SetMarked(fShowLegend);

	menu->SetTargetForItems(this);
	additionalMenu->SetTargetForItems(this);

	ActivityWindow* window = dynamic_cast<ActivityWindow*>(Window());
	if (window != NULL && window->ActivityViewCount() > 1) {
		menu->AddSeparatorItem();
		BMessage* message = new BMessage(kMsgRemoveView);
		message->AddPointer("view", this);
		menu->AddItem(item = new BMenuItem(B_TRANSLATE("Remove graph"),
			message));
		item->SetTarget(window);
	}

	ConvertToScreen(&where);
	menu->Go(where, true, false, true);
}
int64
PortsDataSource::NextValue(SystemInfo& info)
{
	return info.UsedPorts();
}