From 2c830a0bafaa573f005246195071076dac468ccd Mon Sep 17 00:00:00 2001 From: Radek Novacek Date: Tue, 31 Jul 2012 10:56:04 +0200 Subject: Replace all Linux_ prefixes with Cura_ prefixes. --- src/power/power.c | 96 +++++++++++++++++++++++++++---------------------------- 1 file changed, 48 insertions(+), 48 deletions(-) (limited to 'src/power/power.c') diff --git a/src/power/power.c b/src/power/power.c index 3210a37..4042f4a 100644 --- a/src/power/power.c +++ b/src/power/power.c @@ -5,8 +5,8 @@ #include -#include "Linux_AssociatedPowerManagementService.h" -#include "Linux_ConcreteJob.h" +#include "Cura_AssociatedPowerManagementService.h" +#include "Cura_ConcreteJob.h" #ifdef HAS_UPOWER #include @@ -70,8 +70,8 @@ Power *power_new(const CMPIBroker *_cb) Power *power = malloc(sizeof(Power)); power->broker = _cb; power->instances = 0; - power->requestedPowerState = Linux_AssociatedPowerManagementService_RequestedPowerState_Unknown; - power->transitioningToPowerState = Linux_AssociatedPowerManagementService_TransitioningToPowerState_No_Change; + power->requestedPowerState = Cura_AssociatedPowerManagementService_RequestedPowerState_Unknown; + power->transitioningToPowerState = Cura_AssociatedPowerManagementService_TransitioningToPowerState_No_Change; power->mutex = _cb->xft->newMutex(0); power->jobs = NULL; #ifdef HAS_UPOWER @@ -125,7 +125,7 @@ void *state_change_thread(void *data) { PowerStateChangeJob *powerStateChangeJob = data; MUTEX_LOCK(powerStateChangeJob); - powerStateChangeJob->jobState = Linux_ConcreteJob_JobState_Running; + powerStateChangeJob->jobState = Cura_ConcreteJob_JobState_Running; powerStateChangeJob->timeOfLastChange = time(NULL); MUTEX_UNLOCK(powerStateChangeJob); @@ -133,14 +133,14 @@ void *state_change_thread(void *data) // Check if the job was cancelled if (powerStateChangeJob->cancelled) { MUTEX_LOCK(powerStateChangeJob); - powerStateChangeJob->jobState = Linux_ConcreteJob_JobState_Terminated; + powerStateChangeJob->jobState = Cura_ConcreteJob_JobState_Terminated; powerStateChangeJob->timeOfLastChange = time(NULL); MUTEX_UNLOCK(powerStateChangeJob); if (!powerStateChangeJob->superseded) { // There is no job that replaced this job MUTEX_LOCK(powerStateChangeJob->power); - powerStateChangeJob->power->transitioningToPowerState = Linux_AssociatedPowerManagementService_TransitioningToPowerState_No_Change; + powerStateChangeJob->power->transitioningToPowerState = Cura_AssociatedPowerManagementService_TransitioningToPowerState_No_Change; MUTEX_UNLOCK(powerStateChangeJob->power); } @@ -155,7 +155,7 @@ void *state_change_thread(void *data) int succeeded = 0; switch (powerStateChangeJob->requestedPowerState) { - case Linux_AssociatedPowerManagementService_PowerState_Sleep__Deep: + case Cura_AssociatedPowerManagementService_PowerState_Sleep__Deep: // Sleep #ifdef HAS_UPOWER succeeded = up_client_suspend_sync(powerStateChangeJob->power->up, NULL, &error); @@ -163,7 +163,7 @@ void *state_change_thread(void *data) succeeded = system("pm-suspend") == 0; #endif break; - case Linux_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Soft: + case Cura_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Soft: // Reboot (without shutting down programs) #ifdef HAS_SYSTEMCTL succeeded = system("systemctl --force reboot &") == 0; @@ -171,7 +171,7 @@ void *state_change_thread(void *data) succeeded = system("reboot --force &") == 0; #endif break; - case Linux_AssociatedPowerManagementService_PowerState_Hibernate_Off___Soft: + case Cura_AssociatedPowerManagementService_PowerState_Hibernate_Off___Soft: // Hibernate #ifdef HAS_UPOWER succeeded = up_client_hibernate_sync(powerStateChangeJob->power->up, NULL, &error); @@ -179,7 +179,7 @@ void *state_change_thread(void *data) succeeded = system("pm-hibernate") == 0; #endif break; - case Linux_AssociatedPowerManagementService_PowerState_Off___Soft: + case Cura_AssociatedPowerManagementService_PowerState_Off___Soft: // Poweroff (without shutting down programs) #ifdef HAS_SYSTEMCTL succeeded = system("systemctl --force poweroff &") == 0; @@ -187,7 +187,7 @@ void *state_change_thread(void *data) succeeded = system("shutdown --halt now &") == 0; #endif break; - case Linux_AssociatedPowerManagementService_PowerState_Off___Soft_Graceful: + case Cura_AssociatedPowerManagementService_PowerState_Off___Soft_Graceful: // Poweroff (shut down programs first) #ifdef HAS_SYSTEMCTL succeeded = system("systemctl poweroff &") == 0; @@ -195,7 +195,7 @@ void *state_change_thread(void *data) succeeded = system("shutdown --poweroff now &") == 0; #endif break; - case Linux_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Soft_Graceful: + case Cura_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Soft_Graceful: // Reboot (shut down programs first) #ifdef HAS_SYSTEMCTL succeeded = system("systemctl reboot &") == 0; @@ -206,14 +206,14 @@ void *state_change_thread(void *data) } MUTEX_LOCK(powerStateChangeJob->power); - powerStateChangeJob->power->transitioningToPowerState = Linux_AssociatedPowerManagementService_TransitioningToPowerState_No_Change; + powerStateChangeJob->power->transitioningToPowerState = Cura_AssociatedPowerManagementService_TransitioningToPowerState_No_Change; MUTEX_UNLOCK(powerStateChangeJob->power); MUTEX_LOCK(powerStateChangeJob); if (succeeded) { - powerStateChangeJob->jobState = Linux_ConcreteJob_JobState_Completed; + powerStateChangeJob->jobState = Cura_ConcreteJob_JobState_Completed; } else { - powerStateChangeJob->jobState = Linux_ConcreteJob_JobState_Exception; + powerStateChangeJob->jobState = Cura_ConcreteJob_JobState_Exception; #ifdef HAS_UPOWER if (error != NULL) { powerStateChangeJob->error = error->message; @@ -250,7 +250,7 @@ int power_request_power_state(Power *power, unsigned short state) powerStateChangeJob->power = power; powerStateChangeJob->mutex = power->broker->xft->newMutex(0); powerStateChangeJob->requestedPowerState = state; - powerStateChangeJob->jobState = Linux_ConcreteJob_JobState_New; + powerStateChangeJob->jobState = Cura_ConcreteJob_JobState_New; powerStateChangeJob->cancelled = 0; powerStateChangeJob->superseded = 0; powerStateChangeJob->timeOfLastChange = time(NULL); @@ -266,13 +266,13 @@ int power_request_power_state(Power *power, unsigned short state) while (plist) { job = plist->data; MUTEX_LOCK(job); - if (job->jobState != Linux_ConcreteJob_JobState_Suspended && - job->jobState != Linux_ConcreteJob_JobState_Killed && - job->jobState != Linux_ConcreteJob_JobState_Terminated) { + if (job->jobState != Cura_ConcreteJob_JobState_Suspended && + job->jobState != Cura_ConcreteJob_JobState_Killed && + job->jobState != Cura_ConcreteJob_JobState_Terminated) { job->cancelled = 1; job->superseded = 1; - job->jobState = Linux_ConcreteJob_JobState_Shutting_Down; + job->jobState = Cura_ConcreteJob_JobState_Shutting_Down; job->timeOfLastChange = time(NULL); } MUTEX_UNLOCK(job); @@ -292,7 +292,7 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) int i = 0; /* 1 Other - * Linux_AssociatedPowerManagementService_PowerState_Other + * Cura_AssociatedPowerManagementService_PowerState_Other */ /* 2 On @@ -300,7 +300,7 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * * Bring system to full On from any state (Sleep, Hibernate, Off) * - * Linux_AssociatedPowerManagementService_PowerState_On + * Cura_AssociatedPowerManagementService_PowerState_On */ // not supported @@ -309,7 +309,7 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * * Standby * - * Linux_AssociatedPowerManagementService_PowerState_Sleep___Light + * Cura_AssociatedPowerManagementService_PowerState_Sleep___Light */ // not supported @@ -318,16 +318,16 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * * Suspend * - * Linux_AssociatedPowerManagementService_PowerState_Sleep__Deep + * Cura_AssociatedPowerManagementService_PowerState_Sleep__Deep */ // Sleep #ifdef HAS_UPOWER if (up_client_get_can_suspend(power->up)) { - list[i++] = Linux_AssociatedPowerManagementService_PowerState_Sleep__Deep; + list[i++] = Cura_AssociatedPowerManagementService_PowerState_Sleep__Deep; } #else if (system("pm-is-supported --suspend") == 0) { - list[i++] = Linux_AssociatedPowerManagementService_PowerState_Sleep__Deep; + list[i++] = Cura_AssociatedPowerManagementService_PowerState_Sleep__Deep; } #endif @@ -337,10 +337,10 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * * Reset system without removing power * - * Linux_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Soft + * Cura_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Soft */ // Reboot (without shutting down programs) - list[i++] = Linux_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Soft; + list[i++] = Cura_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Soft; /* 6 Off - Hard * corresponding to ACPI state G3, S5, or D3. @@ -348,7 +348,7 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * Power Off performed through mechanical means like unplugging * power cable or UPS On * - * Linux_AssociatedPowerManagementService_PowerState_Off___Hard + * Cura_AssociatedPowerManagementService_PowerState_Off___Hard */ /* 7 Hibernate (Off - Soft) @@ -358,16 +358,16 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * System context and OS image written to non-volatile storage; * system and devices powered off * - * Linux_AssociatedPowerManagementService_PowerState_Hibernate_Off___Soft + * Cura_AssociatedPowerManagementService_PowerState_Hibernate_Off___Soft */ // Hibernate #ifdef HAS_UPOWER if (up_client_get_can_hibernate(power->up)) { - list[i++] = Linux_AssociatedPowerManagementService_PowerState_Hibernate_Off___Soft; + list[i++] = Cura_AssociatedPowerManagementService_PowerState_Hibernate_Off___Soft; } #else if (system("pm-is-supported --hibernate") == 0) { - list[i++] = Linux_AssociatedPowerManagementService_PowerState_Hibernate_Off___Soft; + list[i++] = Cura_AssociatedPowerManagementService_PowerState_Hibernate_Off___Soft; } #endif @@ -376,10 +376,10 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * * System power off but auxiliary or flea power may be available * - * Linux_AssociatedPowerManagementService_PowerState_Off___Soft + * Cura_AssociatedPowerManagementService_PowerState_Off___Soft */ // Poweroff (without shutting down programs) - list[i++] = Linux_AssociatedPowerManagementService_PowerState_Off___Soft; + list[i++] = Cura_AssociatedPowerManagementService_PowerState_Off___Soft; /* 9 Power Cycle (Off-Hard) * corresponds to the managed element reaching the ACPI state G3 @@ -387,7 +387,7 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * * Equivalent to Off–Hard followed by On * - * Linux_AssociatedPowerManagementService_PowerState_Power_Cycle_Off_Hard + * Cura_AssociatedPowerManagementService_PowerState_Power_Cycle_Off_Hard */ // not implemented @@ -397,7 +397,7 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * * Hardware reset * - * Linux_AssociatedPowerManagementService_PowerState_Master_Bus_Reset + * Cura_AssociatedPowerManagementService_PowerState_Master_Bus_Reset */ // not implemented @@ -407,7 +407,7 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * * Hardware reset * - * Linux_AssociatedPowerManagementService_PowerState_Diagnostic_Interrupt_NMI + * Cura_AssociatedPowerManagementService_PowerState_Diagnostic_Interrupt_NMI */ // not implemented @@ -418,10 +418,10 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * System power off but auxiliary or flea power may be available but preceded * by a request to the managed element to perform an orderly shutdown. * - * Linux_AssociatedPowerManagementService_PowerState_Off___Soft_Graceful + * Cura_AssociatedPowerManagementService_PowerState_Off___Soft_Graceful */ // Poweroff (shut down programs first) - list[i++] = Linux_AssociatedPowerManagementService_PowerState_Off___Soft_Graceful; + list[i++] = Cura_AssociatedPowerManagementService_PowerState_Off___Soft_Graceful; /* 13 Off - Hard Graceful * equivalent to Off Hard but preceded by a request to the managed element @@ -431,7 +431,7 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * or UPS On but preceded by a request to the managed element to perform * an orderly shutdown. * - * Linux_AssociatedPowerManagementService_PowerState_Off___Hard_Graceful + * Cura_AssociatedPowerManagementService_PowerState_Off___Hard_Graceful */ // not implemented @@ -442,7 +442,7 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * Hardware reset but preceded by a request to the managed element * to perform an orderly shutdown. * - * Linux_AssociatedPowerManagementService_PowerState_Master_Bus_Reset_Graceful + * Cura_AssociatedPowerManagementService_PowerState_Master_Bus_Reset_Graceful */ // not implemented @@ -453,10 +453,10 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * Reset system without removing power but preceded by a request * to the managed element to perform an orderly shutdown. * - * Linux_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Soft_Graceful + * Cura_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Soft_Graceful */ // Reboot (shut down programs first) - list[i++] = Linux_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Soft_Graceful; + list[i++] = Cura_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Soft_Graceful; /* 16 Power Cycle (Off - Hard Graceful) * equivalent to Power Cycle (Off - Hard) but preceded by a request @@ -465,7 +465,7 @@ unsigned short *power_available_requested_power_states(Power *power, int *count) * Equivalent to Off–Hard followed by On but preceded by a request * to the managed element to perform an orderly shutdown. * - * Linux_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Hard_Graceful + * Cura_AssociatedPowerManagementService_PowerState_Power_Cycle_Off___Hard_Graceful */ // not implemented @@ -485,9 +485,9 @@ GList *power_get_jobs(Power *power) while (plist) { powerStateChangeJob = plist->data; MUTEX_LOCK(powerStateChangeJob); - if ((powerStateChangeJob->jobState == Linux_ConcreteJob_JobState_Completed || - powerStateChangeJob->jobState == Linux_ConcreteJob_JobState_Killed || - powerStateChangeJob->jobState == Linux_ConcreteJob_JobState_Terminated) && + if ((powerStateChangeJob->jobState == Cura_ConcreteJob_JobState_Completed || + powerStateChangeJob->jobState == Cura_ConcreteJob_JobState_Killed || + powerStateChangeJob->jobState == Cura_ConcreteJob_JobState_Terminated) && time(NULL) - powerStateChangeJob->timeOfLastChange > powerStateChangeJob->timeBeforeRemoval) { MUTEX_LOCK(power); -- cgit