void DirectoryMangaVolume::readImages(const QString & path) {
QFileInfo fileInfo(path);
if (fileInfo.isDir()) {
QDir dir(path);
QStringList fileList = dir.entryList(
QDir::AllEntries | QDir::NoDotAndDotDot
| QDir::NoSymLinks | QDir::Hidden, QDir::Name
| QDir::IgnoreCase);
for (int i = 0; i < fileList.count(); ++i) {
readImages(path + tr("/")+fileList.at(i));
}
} else {
QString extension = path.split(".").last();
auto formats = Configuration().getSupportedImageFormats();
if (Configuration().isSupportedImageFormat(fileInfo.suffix())) {
m_page_names.push_back(fileInfo.canonicalFilePath());
/*
MangaPage img(path);
if (!img.isNull()) {
m_pages.push_back(img);
}*/
} else {
qDebug() << "Skipping file with unknown extension " << path;
}
}
}
StraightPathSegment::StraightPathSegment(Segment& segment, bool dir) {
double angle = segment.getOrientation();
if (dir) {
start = Configuration(segment.getA(), angle);
end = Configuration(segment.getB(), angle);
} else {
start = Configuration(segment.getA(), wrapAngle(angle + M_PI));
end = Configuration(segment.getB(), wrapAngle(angle + M_PI));
}
this->dir = dir;
length = Point::distance(start.position, end.position);
}
//__________________________________________________
Qt::Alignment Configuration::titleAlignment( QString value, bool translated )
{
if (value == titleAlignmentName( Qt::AlignLeft, translated ) ) return Qt::AlignLeft;
else if (value == titleAlignmentName( Qt::AlignHCenter, translated, false ) || value == titleAlignmentName( Qt::AlignHCenter, translated, true ) ) return Qt::AlignHCenter;
else if (value == titleAlignmentName( Qt::AlignRight, translated ) ) return Qt::AlignRight;
else return Configuration().titleAlignment();
}
ReducerNoDedup<Q>::ReducerNoDedup(const PolyRing& ring):
mRing(ring),
mLeadTermKnown(false),
mQueue(Configuration(ring))
{
mLeadTerm.mono = mRing.monoid().alloc().release();
}
status_ setCapacitance()
{
char query1[20];
snprintf(query1,sizeof(query1),"CONF:CAP\n");
return Configuration(query1);
}
User::User(QObject *parent)
{
timer = new QTimer(this);
actions = new QQueue<QStringList *>();
Configuration();
}
Configuration ConfigurationFile::Read(const Provider& provider)
{
std::ifstream file(m_filename.c_str());
if (!file.good())
return Configuration();
std::map<int, std::string> channelMap;
std::string line;
while (std::getline(file, line))
{
std::vector<std::string> split;
boost::split(split, line, boost::is_any_of("="));
if (is_number(split[0]))
channelMap[boost::lexical_cast<int>(split[0])] = split[1];
}
::Channels channels;
::Channels allChannels = provider.GetChannels();
for (::Channels::iterator it = allChannels.begin(); it != allChannels.end(); ++it)
{
if (channelMap.find(it->Id()) != channelMap.end())
{
it->Name(channelMap[it->Id()]);
channels.push_back(*it);
}
}
m_configuration.Channels(channels);
m_configuration.Valid(true);
return m_configuration;
}
status_ setFrequency()
{
char query1[20];
snprintf(query1,sizeof(query1),"CONF:FREQ\n");
return Configuration(query1);
}
status_ setPeriod()
{
char query1[20];
snprintf(query1,sizeof(query1),"CONF:PER\n");
return Configuration(query1);
}
//__________________________________________________
Configuration::BlendColorType Configuration::blendColor( QString value, bool translated )
{
if( value == blendColorName( NoBlending, translated ) ) return NoBlending;
else if( value == blendColorName( RadialBlending, translated ) ) return RadialBlending;
else if( value == blendColorName( BlendFromStyle, translated ) ) return BlendFromStyle;
else return Configuration().blendColor();
}
status_ setFresistance_range(float range_)
{
char query1[50];
snprintf(query1,sizeof(query1),"CONF:FRES %f\n",range_);
return Configuration(query1);
}
/**
* \brief This will save input settings according to how the user did map the buttons,
* axes or keys to the commands.
*/
void CInput::saveControlconfig()
{
CConfiguration Configuration(CONFIGFILENAME);
Configuration.Parse();
std::string section;
for(size_t i=0 ; i<NUM_INPUTS ; i++)
{
section = "input" + itoa(i);
Configuration.WriteString(section, "Left", getEventName(IC_LEFT, i));
Configuration.WriteString(section, "Up", getEventName(IC_UP, i));
Configuration.WriteString(section, "Right", getEventName(IC_RIGHT, i));
Configuration.WriteString(section, "Down", getEventName(IC_DOWN, i));
Configuration.WriteString(section, "Upper-Left", getEventName(IC_UPPERLEFT, i));
Configuration.WriteString(section, "Upper-Right", getEventName(IC_UPPERRIGHT, i));
Configuration.WriteString(section, "Lower-Left", getEventName(IC_LOWERLEFT, i));
Configuration.WriteString(section, "Lower-Right", getEventName(IC_LOWERRIGHT, i));
Configuration.WriteString(section, "Jump", getEventName(IC_JUMP, i));
Configuration.WriteString(section, "Pogo", getEventName(IC_POGO, i));
Configuration.WriteString(section, "Fire", getEventName(IC_FIRE, i));
Configuration.WriteString(section, "Status", getEventName(IC_STATUS, i));
Configuration.WriteString(section, "Help", getEventName(IC_HELP, i));
Configuration.WriteString(section, "Quit", getEventName(IC_QUIT, i));
Configuration.SetKeyword(section, "TwoButtonFiring", TwoButtonFiring[i]);
}
Configuration.saveCfgFile();
}
MathematicsManager::MathematicsManager(QObject *parent)
{
qDebug()<<"Create"<<metaObject()->className();
queAsk = new QQueue<EmptyModel *>();
queAnswer = new QQueue<EmptyModel *>();
timer = new QTimer(this);
Configuration();
}
//---------------------------------------------------------------------------
void File_Cmml::Data_Parse()
{
//Parsing
if (Status[IsAccepted])
Configuration();
else
Identification();
}
ReducerPack(const PolyRing& ring):
mRing(ring),
mLeadTermKnown(false),
mQueue(Configuration(ring)),
mPool(sizeof(MultipleWithPos))
{
mLeadTerm.mono = mRing.monoid().alloc().release();
}
//__________________________________________________
Configuration::ButtonSize Configuration::buttonSize( QString value, bool translated )
{
if( value == buttonSizeName( ButtonSmall, translated ) ) return ButtonSmall;
else if( value == buttonSizeName( ButtonDefault, translated ) ) return ButtonDefault;
else if( value == buttonSizeName( ButtonLarge, translated ) ) return ButtonLarge;
else if( value == buttonSizeName( ButtonVeryLarge, translated ) ) return ButtonVeryLarge;
else if( value == buttonSizeName( ButtonHuge, translated ) ) return ButtonHuge;
else return Configuration().buttonSize();
}
MATHICGB_NAMESPACE_BEGIN
TournamentReducer::TournamentReducer(const PolyRing& ring):
mRing(ring),
mLeadTerm(0, mRing.allocMonomial()),
mLeadTermKnown(false),
mQueue(Configuration(ring)),
mPool(sizeof(MultipleWithPos))
{
}
/**
* \brief This will load input settings that were saved previously by the user at past session.
*/
void CInput::loadControlconfig(void)
{
CConfiguration Configuration(CONFIGFILENAME);
if(Configuration.Parse())
{
std::string section;
for(size_t i=0 ; i<NUM_INPUTS ; i++)
{
// setup input from proper string
section = "input" + itoa(i);
std::string value;
Configuration.ReadString( section, "Left", value, "Left");
setupInputCommand( InputCommand[i], IC_LEFT, value );
Configuration.ReadString( section, "Up", value, "Up");
setupInputCommand( InputCommand[i], IC_UP, value );
Configuration.ReadString( section, "Right", value, "Right");
setupInputCommand( InputCommand[i], IC_RIGHT, value );
Configuration.ReadString( section, "Down", value, "Down");
setupInputCommand( InputCommand[i], IC_DOWN, value );
Configuration.ReadString( section, "Lower-Left", value, "End");
setupInputCommand( InputCommand[i], IC_LOWERLEFT, value );
Configuration.ReadString( section, "Lower-Right", value, "Page Down");
setupInputCommand( InputCommand[i], IC_LOWERRIGHT, value );
Configuration.ReadString( section, "Upper-Left", value, "Home");
setupInputCommand( InputCommand[i], IC_UPPERLEFT, value );
Configuration.ReadString( section, "Upper-Right", value, "Page Up");
setupInputCommand( InputCommand[i], IC_UPPERRIGHT, value );
Configuration.ReadString( section, "Jump", value, "Left ctrl");
setupInputCommand( InputCommand[i], IC_JUMP, value );
Configuration.ReadString( section, "Pogo", value, "Left alt");
setupInputCommand( InputCommand[i], IC_POGO, value );
Configuration.ReadString( section, "Fire", value, "Space");
setupInputCommand( InputCommand[i], IC_FIRE, value );
Configuration.ReadString( section, "Status", value, "Return");
setupInputCommand( InputCommand[i], IC_STATUS, value );
Configuration.ReadString( section, "Camlead", value, "c");
setupInputCommand( InputCommand[i], IC_CAMLEAD, value );
Configuration.ReadString( section, "Help", value, "F11");
setupInputCommand( InputCommand[i], IC_HELP, value );
Configuration.ReadString( section, "Back", value, "Escape");
setupInputCommand( InputCommand[i], IC_BACK, value );
Configuration.ReadKeyword( section, "TwoButtonFiring", &TwoButtonFiring[i], false);
Configuration.ReadKeyword( section, "Analog", &mAnalogAxesMovement[i], false);
}
}
else
{
for(size_t c=1 ; c<= NUM_INPUTS ; c++)
resetControls(c);
}
}
/**
* \brief Only saves the last used resolution or window size.
* \return If the configuration has been saved successfully, it return true, else it's false.
*/
bool CSettings::saveDispCfg()
{
CConfiguration Configuration(CONFIGFILENAME);
Configuration.Parse();
CVidConfig &VidConf = gVideoDriver.getVidConfig();
Configuration.WriteInt("Video", "width", VidConf.m_DisplayRect.w);
Configuration.WriteInt("Video", "height", VidConf.m_DisplayRect.h);
return Configuration.saveCfgFile();
}
//__________________________________________________
Configuration::FrameBorder Configuration::frameBorder( QString value, bool translated )
{
if( value == frameBorderName( BorderNone, translated ) ) return BorderNone;
else if( value == frameBorderName( BorderNoSide, translated ) ) return BorderNoSide;
else if( value == frameBorderName( BorderTiny, translated ) ) return BorderTiny;
else if( value == frameBorderName( BorderDefault, translated ) ) return BorderDefault;
else if( value == frameBorderName( BorderLarge, translated ) ) return BorderLarge;
else if( value == frameBorderName( BorderVeryLarge, translated ) ) return BorderVeryLarge;
else if( value == frameBorderName( BorderHuge, translated ) ) return BorderHuge;
else if( value == frameBorderName( BorderVeryHuge, translated ) ) return BorderVeryHuge;
else if( value == frameBorderName( BorderOversized, translated ) ) return BorderOversized;
else return Configuration().frameBorder();
}
/**
* \brief Saves the options in the settings
*/
bool CSettings::saveGameOptions()
{
CConfiguration Configuration(CONFIGFILENAME);
if(!Configuration.Parse()) return false;
stOption *p_option = g_pBehaviorEngine->m_option;
for (int i = 0; i < NUM_OPTIONS; i++)
Configuration.SetKeyword("Game", p_option[i].name, p_option[i].value);
Configuration.saveCfgFile();
return true;
}
//__________________________________________________
QString Configuration::sizeGripModeName( SizeGripMode value, bool translated )
{
QString out;
switch( value )
{
case SizeGripNever: out = translated ? i18n( "Always Hide Extra Size Grip" ):"Always Hide Extra Size Grip"; break;
case SizeGripWhenNeeded: out = translated ? i18n( "Show Extra Size Grip When Needed" ):"Show Extra Size Grip When Needed"; break;
default: return Configuration().sizeGripModeName( translated );
}
return out;
}
//__________________________________________________
int Configuration::iconScale( ButtonSize value )
{
switch( value )
{
case ButtonSmall: return 13;
case ButtonDefault: return 16;
case ButtonLarge: return 20;
case ButtonVeryLarge: return 24;
case ButtonHuge: return 35;
default: return Configuration().iconScale();
}
}
/**
* \brief This will load input settings that were saved previously by the user at past session.
*/
void CInput::loadControlconfig(void)
{
CConfiguration Configuration(CONFIGFILENAME);
if(Configuration.Parse())
{
std::string section;
for(size_t i=0 ; i<NUM_INPUTS ; i++)
{
// setup input from proper string
section = "input" + itoa(i);
std::string value;
Configuration.ReadString( section, "Left", value, "Key 276 (left)");
setupInputCommand( InputCommand[i], IC_LEFT, value );
Configuration.ReadString( section, "Up", value, "Key 273 (up)");
setupInputCommand( InputCommand[i], IC_UP, value );
Configuration.ReadString( section, "Right", value, "Key 275 (right)");
setupInputCommand( InputCommand[i], IC_RIGHT, value );
Configuration.ReadString( section, "Down", value, "Key 274 (down)");
setupInputCommand( InputCommand[i], IC_DOWN, value );
Configuration.ReadString( section, "Lower-Left", value, "Key 279 (end)");
setupInputCommand( InputCommand[i], IC_LOWERLEFT, value );
Configuration.ReadString( section, "Lower-Right", value, "Key 281 (page down)");
setupInputCommand( InputCommand[i], IC_LOWERRIGHT, value );
Configuration.ReadString( section, "Upper-Left", value, "Key 278 (home)");
setupInputCommand( InputCommand[i], IC_UPPERLEFT, value );
Configuration.ReadString( section, "Upper-Right", value, "Key 280 (page up)");
setupInputCommand( InputCommand[i], IC_UPPERRIGHT, value );
Configuration.ReadString( section, "Jump", value, "Key 306 (left ctrl)");
setupInputCommand( InputCommand[i], IC_JUMP, value );
Configuration.ReadString( section, "Pogo", value, "Key 308 (left alt)");
setupInputCommand( InputCommand[i], IC_POGO, value );
Configuration.ReadString( section, "Fire", value, "Key 32 (space)");
setupInputCommand( InputCommand[i], IC_FIRE, value );
Configuration.ReadString( section, "Status", value, "Key 13 (return)");
setupInputCommand( InputCommand[i], IC_STATUS, value );
Configuration.ReadString( section, "Help", value, "Key 282 (f1)");
setupInputCommand( InputCommand[i], IC_HELP, value );
Configuration.ReadString( section, "Quit", value, "Key 27 (escape)");
setupInputCommand( InputCommand[i], IC_QUIT, value );
Configuration.ReadKeyword( section, "TwoButtonFiring", &TwoButtonFiring[i], false);
}
}
else
{
for(size_t c=1 ; c<= NUM_INPUTS ; c++)
resetControls(c);
}
}
void ControllerTests:: persistProvideMetaDataTest()
{ // stick with user id 0, it is not persisted in the DB, and 0 is the default
Configuration configs[] = {
Configuration( true, true, User( "bla", 0 ), Configuration::TaskPrefilter_ShowAll, Configuration::TimeTrackerFont_Small,
Configuration::Minutes, true, Qt::ToolButtonIconOnly, true, true, true, false ),
Configuration( true, false, User( "blub", 0 ), Configuration::TaskPrefilter_CurrentOnly, Configuration::TimeTrackerFont_Regular,
Configuration::Minutes, false, Qt::ToolButtonTextOnly, false, false, false, false ),
Configuration( false, true, User(), Configuration::TaskPrefilter_SubscribedAndCurrentOnly, Configuration::TimeTrackerFont_Large,
Configuration::Minutes, true, Qt::ToolButtonTextBesideIcon, true, true, true, false ),
};
const int NumberOfConfigurations = sizeof configs / sizeof configs[0];
for ( int i = 0; i < NumberOfConfigurations; ++i )
{
m_controller->persistMetaData( configs[i] );
m_configuration = Configuration();
m_controller->provideMetaData( m_configuration );
m_configuration.dump();
configs[i].dump();
QVERIFY( m_configuration == configs[i] );
// and repeat, with some different values
}
}
//__________________________________________________
QString Configuration::blendColorName( BlendColorType value, bool translated )
{
QString out;
switch( value )
{
case NoBlending: out = translated ? i18n( "Solid Color" ):"Solid Color"; break;
case RadialBlending: out = translated ? i18n( "Radial Gradient" ):"Radial Gradient"; break;
case BlendFromStyle: out = translated ? i18n( "Follow Style Hint" ):"Follow Style Hint"; break;
default: return Configuration().blendColorName( translated );
}
return out;
}
configurationList StraightPathSegment::getPoints(double dr) {
configurationList points;
double conf = start.orientation;
Point startPoint = start.position;
dr *= dir ? 1 : -1;
double dx = dr * cos(conf);
double dy = dr * sin(conf);
for (int i = 0; fabs(i * dr) < length; i++) {
Point p(i*dx, i*dy);
points.push_back(Configuration(startPoint + p, conf));
}
points.push_back(end);
return points;
}
status_ setVoltageAC_range(float range_)
{
char query1[50];
if(range_>1)
{
snprintf(query1,sizeof(query1),"CONF:VOLT:AC %f\n",range_);
return Configuration(query1);
}
else
{
status_ estado;
estado.code=ERROR_PARAMETERS_OUT_OF_RANGE;
estado.description="ERROR_PARAMETERS_OUT_OF_RANGE";
return estado;
}
}
//_______________________________________________________________________
void Config::defaults()
{
// install default configuration
loadConfiguration( Configuration() );
// load shadows
loadShadowConfiguration( QPalette::Active, ShadowConfiguration( QPalette::Active ) );
loadShadowConfiguration( QPalette::Inactive, ShadowConfiguration( QPalette::Inactive ) );
// install default exceptions
ui->ui.exceptions->setExceptions( ExceptionList::defaultList() );
updateChanged();
}
status_ setCurrentDC_range_resolution(float range_, float resolution_)
{
char query1[50];
if(range_>1)
{
snprintf(query1,sizeof(query1),"CONF:CURR:DC %f , %f \n",range_,resolution_);
return Configuration(query1);
}
else
{
status_ estado;
estado.code=ERROR_PARAMETERS_OUT_OF_RANGE;
estado.description="ERROR_PARAMETERS_OUT_OF_RANGE";
return estado;
}
}
