lib/common/CicoAilItems.cpp

   1 /*
   2  * Copyright (c) 2013, TOYOTA MOTOR CORPORATION.
   3  *
   4  * This program is licensed under the terms and conditions of the
   5  * Apache License, version 2.0.  The full text of the Apache License is at
   6  * http://www.apache.org/licenses/LICENSE-2.0
   7  *
   8  */
   9
  10 #include <iostream>
  11 #include <string>
  12 #include <sstream>
  13 #include <vector>
  14 #include <utility>
  15 #include <cstdlib>
  16
  17 #include <ico_log.h>
  18 #include "CicoAilItems.h"
  19 #include "CicoConf.h"
  20 #include "CicoSystemConfig.h"
  21 #include "CicoLibString.h"
  22
  23 using namespace std;
  24
  25 /**
  26  * @brief constructor
  27  */
  28 CicoAilItems::CicoAilItems()
  29 {
  30     ICO_TRA("start");
  31     init();
  32     ICO_TRA("end");
  33 }
  34
  35 /**
  36  * @brief constructor
  37  * @param pkg package name(appid) by ail information data
  38  * @param icon icon path and file name by ail information data
  39  * @param nam name by ail information data
  40  * @param ctgry category by ail information data
  41  * @param exe exec path by ail information data
  42  * @param cateforys environ file data
  43  */
  44 CicoAilItems::CicoAilItems(const char* pkg, const char* icon,
  45                                const char* nam, const char* ctgry,
  46                                const char* typ, const char* exe,
  47                                const std::string categorys, bool ndisp)
  48 {
  49     ICO_TRA("start");
  50     init();
  51     setup(pkg, icon, nam, ctgry, typ, exe, categorys, ndisp);
  52     ICO_TRA("end");
  53 }
  54
  55 CicoAilItems::CicoAilItems(const CicoAilItems &s)
  56 {
  57     m_appid = s.m_appid;    // PACKAGE NAME
  58     m_icon = s.m_icon;  // ICON
  59     m_name = s.m_name;  // NAME
  60     m_execPath = s.m_execPath;  // EXEC
  61     m_type = s.m_type;  // TYPE
  62
  63     m_categories = s.m_categories; // CATEGORIES
  64
  65     m_nodeID = s.m_nodeID;  // "run=xxx" xxx change to id
  66     m_kindID = s.m_kindID;  // "kind=xxx" xxx change to id
  67     m_categoryID = s.m_categoryID;  // "category=xxx" xxx change to id
  68
  69     m_display = s.m_display; //
  70     m_layer = s.m_layer;
  71     m_displayZone = s.m_displayZone; // display zone number
  72     m_soundZone = s.m_soundZone;  // sound zone number
  73     m_sound = s.m_sound;
  74     m_inputDev = s.m_inputDev;   // input device number
  75     m_switch = s.m_switch;
  76     m_noIcon = s.m_noIcon;
  77     m_animation = s.m_animation;
  78     m_animationTime = s.m_animationTime;
  79     m_invisibleCPU = s.m_invisibleCPU;
  80     m_memnuOverlap = s.m_memnuOverlap;
  81     m_autoStart = s.m_autoStart; // auto start flag
  82
  83     m_group = s.m_group;
  84     m_location = s.m_location;
  85     m_resumeShow = s.m_resumeShow;
  86 }
  87
  88 /**
  89  * @brief
  90  */
  91 CicoAilItems::~CicoAilItems()
  92 {
  93     ICO_TRA("start");
  94     ICO_TRA("end");
  95 }
  96 /**
  97  * @brief init member
  98  */
  99 void CicoAilItems::init()
 100 {
 101     m_appid.clear();      // PACKAGE NAME
 102     m_icon.clear();       // ICON
 103     m_name.clear();       // NAME
 104     m_execPath.clear();   // EXEC
 105     m_type.clear();       // TYPE
 106
 107     m_categories.clear(); // CATEGORIES
 108
 109     const CicoSCDefaultConf* oCSCDC;
 110     oCSCDC = CicoSystemConfig::getInstance()->getDefaultConf();
 111     if (NULL != oCSCDC) {
 112         ICO_DBG("CicoAilItems::init base CicoSCDefaultConf");
 113         m_nodeID      = oCSCDC->node;
 114         m_kindID      = oCSCDC->appkind;
 115         m_categoryID  = oCSCDC->category;
 116
 117         m_display     = oCSCDC->display;
 118         m_layer       = oCSCDC->layer;
 119         m_displayZone = oCSCDC->displayzone;
 120
 121         m_sound       = oCSCDC->sound;
 122         m_soundZone   = oCSCDC->soundzone;
 123
 124         m_inputDev    = oCSCDC->inputdev;
 125         m_switch      = oCSCDC->inputsw;
 126     }
 127     else {
 128         ICO_DBG("CicoAilItems::init base define");
 129         m_nodeID      = DINITm_nodeID; // "run=xxx" xxx change to id
 130         m_kindID      = DINITm_kindID; // "kind=xxx" xxx change to id
 131         m_categoryID  = DINITm_categoryID; // "category=xxx" xxx change to id
 132
 133         m_display     = DINITm_display; //
 134         m_layer       = DINITm_layer;
 135         m_displayZone = DINITm_displayZone; // display zone
 136
 137         m_soundZone   = DINITm_soundZone; // sound zone
 138         m_sound       = DINITm_sound;
 139
 140         m_inputDev    = DINITm_inputDev; // input device
 141         m_switch      = DINITm_switch;
 142     }
 143
 144     m_noIcon = false;
 145     m_animation.clear();
 146     m_animationTime = DINITm_animationTime;
 147     m_invisibleCPU = DINITm_invisibleCPU;
 148     m_memnuOverlap = false;
 149     m_autoStart = false; // auto start flag
 150
 151     m_group.clear();
 152     m_location.clear();
 153     m_resumeShow = false;
 154 }
 155
 156 /**
 157  * @brief constructor
 158  * @param pkg package name(appid) by ail information data
 159  * @param icon icon path and file name by ail information data
 160  * @param nam name by ail information data
 161  * @param ctgry category by ail information data
 162  * @param exe exec path by ail information data
 163  * @param cateforys environ file data
 164  */
 165 void CicoAilItems::setup(const char* pkg, const char* icon,
 166                            const char* nam, const char* ctgry,
 167                            const char* typ, const char* exe,
 168                            std::string categorys, bool ndisp)
 169 {
 170     ICO_TRA("start");
 171     m_appid.assign(pkg);
 172     ICO_DBG("package name=%s", pkg? pkg: "(NULL)");
 173
 174     m_noIcon = ndisp;
 175     if (NULL != icon) {
 176         m_icon.assign(icon);
 177         ICO_DBG("icon path=%s", icon? icon: "(NULL)");
 178     }
 179
 180     if (NULL != nam) {
 181         m_name.assign(nam);
 182         ICO_DBG("name=%s", nam? nam: "(NULL)");
 183     }
 184
 185     if (NULL != exe) {
 186         m_execPath.assign(exe);
 187         ICO_DBG("exec path=%s", exe? exe: "(NULL)");
 188     }
 189
 190     if (NULL != typ) {
 191         m_type.assign(typ);
 192         ICO_DBG("type=%s", typ? typ: "(NULL)");
 193     }
 194
 195     categoryParse(categorys);
 196     ICO_TRA("end");
 197 }
 198
 199 const string s_run("run");
 200 const string s_kind("kind");
 201 const string s_category("category");
 202 const string s_display("display");
 203 const string s_layer("layer");
 204 const string s_dispzone("dispzone");
 205 const string s_sound("sound");
 206 const string s_input("input");
 207 const string s_NoDisplay("NoDisplay");
 208 const string s_Animation("Animation");
 209 const string s_invisiblecpu("invisiblecpu");
 210 const string s_noconfigure("noconfigure");
 211 const string s_menuoverlap("menuoverlap");
 212 const string s_auto("auto");
 213 const string s_noauto("noauto");
 214
 215 const string s_soundzone("soundzone");
 216 const string s_Animation_time("Animation_time");
 217
 218 /**
 219  * @brief category string parse
 220  * @parm category string data split code ";"
 221  */
 222 void CicoAilItems::categoryParse(const std::string categorys)
 223 {
 224     ICO_TRA("start");
 225     if (categorys.empty()) {
 226         ICO_TRA("end no category");
 227         return;
 228     }
 229     vector<string> x;
 230     split(categorys, ';', x);
 231     vector<string>::iterator it = x.begin(); // iterator
 232     string displayName;
 233     string layerName;
 234     string dispZoneName;
 235     string soundName;
 236     string soundZoneName;
 237     string inputDevName;
 238     string switchName;
 239
 240     displayName.clear();
 241     layerName.clear();
 242     dispZoneName.clear();
 243     soundName.clear();
 244     soundZoneName.clear();
 245     inputDevName.clear();
 246     switchName.clear();
 247
 248     CicoSystemConfig* CSCSC = CicoSystemConfig::getInstance();
 249
 250     ICO_DBG("category def size = %d", x.size());
 251     for (it = x.begin(); it != x.end(); it++) {
 252
 253         // run
 254         if (0 == strncasecmp(it->c_str(), s_run.c_str(), s_run.size())) {
 255             if (true == categoryParseRun(*it)) {
 256                 ICO_DBG("Parse OK %s", it->c_str());
 257                 continue;
 258             }
 259         }
 260
 261         // kind
 262         if (0 == strncasecmp(it->c_str(), s_kind.c_str(), s_kind.size())) {
 263             if (true == categoryParseKind(*it)) {
 264                 ICO_DBG("Parse OK %s", it->c_str());
 265                 continue;
 266             }
 267         }
 268
 269         // category
 270         if (0 == strncasecmp(it->c_str(), s_category.c_str(),
 271                              s_category.size())) {
 272             if (true == categoryParseCategory(*it)) {
 273                 ICO_DBG("Parse OK %s", it->c_str());
 274                 continue;
 275             }
 276         }
 277
 278         // display
 279         if (0 == strncasecmp(it->c_str(), s_display.c_str(),
 280                              s_display.size())) {
 281             if (true == categoryParseGetValue(*it, s_display, displayName)) {
 282                 ICO_DBG("Parse OK %s", it->c_str());
 283                 continue;
 284             }
 285         }
 286
 287         // layer
 288         if (0 == strncasecmp(it->c_str(), s_layer.c_str(), s_layer.size())) {
 289             if (true == categoryParseGetValue(*it, s_layer, layerName)) {
 290                 ICO_DBG("Parse OK %s", it->c_str());
 291                 continue;
 292             }
 293         }
 294
 295         // dispzone
 296         if (0 == strncasecmp(it->c_str(), s_dispzone.c_str(),
 297                              s_dispzone.size())) {
 298             if (true == categoryParseGetValue(*it, s_dispzone, dispZoneName)) {
 299                 ICO_DBG("Parse OK %s", it->c_str());
 300                 continue;
 301             }
 302         }
 303
 304         // sound / soundzone
 305         if (0 == strncasecmp(it->c_str(), s_soundzone.c_str(),
 306                              s_soundzone.size())) {
 307             if (true == categoryParseGetValue(*it, s_soundzone,
 308                                               soundZoneName)) {
 309                 ICO_DBG("Parse OK %s", it->c_str());
 310                 continue;
 311             }
 312         }
 313         if (0 == strncasecmp(it->c_str(), s_sound.c_str(), s_sound.size())) {
 314             if (true == categoryParseGetValue(*it, s_sound, soundName)) {
 315                 ICO_DBG("Parse OK %s", it->c_str());
 316                 continue;
 317             }
 318         }
 319
 320         // input
 321         if (0 == strncasecmp(it->c_str(), s_input.c_str(), s_input.size())) {
 322             if (true == categoryParseGetValue(*it, s_input, inputDevName)) {
 323                 ICO_DBG("Parse OK %s", it->c_str());
 324                 continue;
 325             }
 326         }
 327 // TODO mk_k not get switchName
 328 //     switchName
 329 // TODO mk_k not get switchName
 330
 331         // NoDisplay
 332         if (0 == strncasecmp(it->c_str(), s_NoDisplay.c_str(),
 333                              s_NoDisplay.size())) {
 334             if (true == categoryParseNodisplay(*it)) {
 335                 ICO_DBG("Parse OK %s", it->c_str());
 336                 continue;
 337             }
 338         }
 339
 340         // Animation / Animation_time
 341         if (0 == strncasecmp(it->c_str(), s_Animation.c_str(),
 342                              s_Animation.size())) {
 343             if (true == categoryParseAnimation(*it)) {
 344                 ICO_DBG("Parse OK %s", it->c_str());
 345                 continue;
 346             }
 347         }
 348
 349         // invisiblecpu
 350         if (0 == strncasecmp(it->c_str(), s_invisiblecpu.c_str(),
 351                              s_invisiblecpu.size())) {
 352             if (true == categoryParseInvisiblecpu(*it)) {
 353                 ICO_DBG("Parse OK %s", it->c_str());
 354                 continue;
 355             }
 356         }
 357
 358         // noconfigure
 359         if (0 == strncasecmp(it->c_str(), s_noconfigure.c_str(),
 360                              s_noconfigure.size())) {
 361             if (true == categoryParseNoconfigure(*it)) {
 362                 ICO_DBG("Parse OK %s", it->c_str());
 363                 continue;
 364             }
 365         }
 366
 367         // menuoverlap
 368         if (0 == strncasecmp(it->c_str(), s_menuoverlap.c_str(),
 369                              s_menuoverlap.size())) {
 370             if (true == categoryParseMenuoverlap(*it)) {
 371                 ICO_DBG("Parse OK %s", it->c_str());
 372                 continue;
 373             }
 374         }
 375
 376         // auto
 377         if (0 == strncasecmp(it->c_str(), s_auto.c_str(), s_auto.size())) {
 378             if (true == categoryParseAuto(*it)) {
 379                 ICO_DBG("Parse OK %s", it->c_str());
 380                 continue;
 381             }
 382         }
 383
 384         // noauto
 385         if (0 == strncasecmp(it->c_str(), s_noauto.c_str(),
 386                              s_noauto.size())) {
 387             if (true == categoryParseNoauto(*it)) {
 388                 ICO_DBG("Parse OK %s", it->c_str());
 389                 continue;
 390             }
 391         }
 392
 393         int categoryID = CSCSC->getCategoryIdbyName(*it);
 394         const char* ttt = it->c_str()? it->c_str(): "(NULL)";
 395         ICO_DBG("Category %s->%d", ttt, categoryID);
 396         if (-1 != categoryID) {
 397             ICO_DBG("Category %d -> %d(%s)", m_categoryID, categoryID, ttt);
 398             m_categoryID = categoryID;
 399             continue;
 400         }
 401
 402         ICO_DBG("Parse UNKNOWN %s", it->c_str());
 403     }
 404     categoryGetDisplay(displayName, layerName, dispZoneName);
 405     categoryGetSound(soundName, soundZoneName);
 406     categoryGetInput(inputDevName, switchName);
 407     ICO_TRA("end");
 408 }
 409
 410 /**
 411  * @brief category string parse
 412  * @param category string
 413  * @retval true parse success
 414  * @retval false parse fail
 415  */
 416 bool CicoAilItems::categoryParseRun(const string& s)
 417 {
 418     ICO_TRA("start");
 419     const char* ps = s.c_str();
 420     int c = s_run.size();
 421     if ('=' != ps[c]) {
 422         ICO_TRA("end");
 423         return false;
 424     }
 425     // "run=xxx"
 426 // TODO mk_k START getHostID(..) request order
 427     CicoSystemConfig* CSCSC = CicoSystemConfig::getInstance();
 428     int nodeID = CSCSC->getNodeIdbyName(&ps[c+1]);
 429 // TODO mk_k int nodeID = -1;
 430 // TODO mk_k int nodeID = CSCSC->getHostID(&ps[c+1]);
 431 // TODO mk_k END getHostID(..) request order
 432     if (nodeID==-1) {
 433         ICO_TRA("end");
 434         return false;
 435     }
 436     m_nodeID = nodeID;
 437     ICO_TRA("end %d", m_nodeID);
 438     return true;
 439 }
 440
 441 /**
 442  * @brief category string parse
 443  * @param category string
 444  * @retval true parse success
 445  * @retval false parse fail
 446  */
 447 bool CicoAilItems::categoryParseKind(const string& s)
 448 {
 449     ICO_TRA("start");
 450     const char* ps = s.c_str();
 451     int c = s_kind.size();
 452     if ('=' != ps[c]) {
 453         ICO_TRA("end");
 454         return false;
 455     }
 456     // "kind=xxx" xxx change to id
 457     CicoSystemConfig* CSCSC = CicoSystemConfig::getInstance();
 458     int kindID = CSCSC->getAppKindIdbyName(&ps[c+1]);
 459     if (kindID==-1) {
 460         ICO_TRA("end");
 461         return false;
 462     }
 463     m_kindID = kindID;
 464     ICO_TRA("end %d", m_kindID);
 465     return true;
 466 }
 467
 468 /**
 469  * @brief category string parse
 470  * @param category string
 471  * @retval true parse success
 472  * @retval false parse fail
 473  */
 474 bool CicoAilItems::categoryParseCategory(const string& s)
 475 {
 476     ICO_TRA("start");
 477     const char* ps = s.c_str();
 478     int c = s_category.size();
 479     if ('=' != ps[c]) {
 480         ICO_TRA("end");
 481         return false;  // not "category=xxx"
 482     }
 483     // "category=xxx" xxx change to id
 484     CicoSystemConfig* CSCSC = CicoSystemConfig::getInstance();
 485     int categoryID = CSCSC->getCategoryIdbyName(&ps[c+1]);
 486     if (categoryID==-1) {
 487         ICO_TRA("end");
 488         return false; // unkown category xxx
 489     }
 490     m_categoryID = categoryID;
 491     ICO_TRA("end %d", m_categoryID);
 492     return true;
 493 }
 494
 495 /**
 496  * @brief value get
 497  * @param s "key=value" string
 498  * @param k key string
 499  * @param val store value
 500  * @retval true get value success
 501  * @retval false get not good
 502  */
 503 bool CicoAilItems::categoryParseGetValue(const std::string& s,
 504                                            const std::string& k,
 505                                            std::string & val)
 506 {
 507     ICO_TRA("start, %s, %s", s.c_str(), k.c_str());
 508     const char* ps = s.c_str();
 509     int c = k.size();
 510     int c2;
 511 #if 0 // TODO mk_k x!?
 512     int x = -1;
 513 #endif // TODO mk_k x!?
 514     if ('=' == ps[c]) {
 515 #if 0 // TODO mk_k x!?
 516         x = 0;
 517 #endif // TODO mk_k x!?
 518         c2 = c+1;
 519     }
 520 #if 0 // TODO mk_k .[0-9] !?
 521     else if (('.' == ps[c]) &&
 522              (0 != isdigit((int)ps[c+1])) &&
 523              ('=' == ps[c+2])) {
 524         x = (int) ps[c+1] - '0';
 525         c2 = c+3;
 526
 527     }
 528 #endif // TODO mk_k .[0-9] !?
 529     else {
 530         ICO_TRA("end NG");
 531         return false;
 532     }
 533     val = s.substr(c2);
 534     ICO_TRA("end %s", val.c_str());
 535     return true;
 536 }
 537
 538 /**
 539  * @brief get
 540  * @param disp display key name
 541  * @param layer display layer key name
 542  * @param zone display zone key name
 543  * @retval true parse success
 544  * @retval false parse fail
 545  */
 546 bool CicoAilItems::categoryGetDisplay(const string& disp,
 547                                         const string& layer,
 548                                         const string& zone)
 549 {
 550     ICO_TRA("start");
 551     if (true == disp.empty()) {
 552         ICO_TRA("end not get display's data");
 553         return false;
 554     }
 555
 556     CicoSystemConfig* CSCSC = CicoSystemConfig::getInstance();
 557     m_display = CSCSC->getDisplayIdbyName(disp);
 558     ICO_DBG("display %s->%d", disp.c_str(), m_display);
 559     if (false == layer.empty()) {
 560         m_layer = CSCSC->getLayerIdfbyName(disp, layer);
 561         ICO_DBG("layer %s, %s->%d", disp.c_str(), layer.c_str(), m_layer);
 562     }
 563     if (false == zone.empty()) {
 564         m_displayZone = CSCSC->getDizplayZoneIdbyName(disp, zone);
 565         ICO_DBG("zone %s, %s->%d", disp.c_str(), zone.c_str(), m_displayZone);
 566     }
 567     ICO_TRA("end d:%d l:%d z:%d", m_display, m_layer, m_displayZone);
 568     return true;
 569 }
 570
 571 /**
 572  * @brief get sound config data
 573  * @param sound name key
 574  * @param soundZone name key
 575  * @retval true get data
 576  * @retval false param fail
 577  */
 578 bool CicoAilItems::categoryGetSound(const string& sound, const string& zone)
 579 {
 580     ICO_TRA("start");
 581     if (true == sound.empty()) {
 582         ICO_TRA("end not get sound's data");
 583         return false;
 584     }
 585
 586     CicoSystemConfig* CSCSC = CicoSystemConfig::getInstance();
 587     m_sound = CSCSC->getSoundIdbyName(sound);
 588     ICO_DBG("sound %s->%d", sound.c_str(), m_sound);
 589     if (false == zone.empty()) {
 590         m_soundZone = CSCSC->getSoundZoneIdbyName(sound, zone);
 591         ICO_DBG("zone %s, %s->%d", sound.c_str(), zone.c_str(), m_soundZone);
 592     }
 593     ICO_TRA("end s:%d z:%d", m_sound, m_soundZone);
 594     return true;
 595 }
 596
 597 bool CicoAilItems::categoryGetInput(const string& inputDev,
 598                                       const string& sw)
 599 {
 600     ICO_TRA("start");
 601     if (true == inputDev.empty()) {
 602         ICO_TRA("end not get input Device's data");
 603         return false;
 604     }
 605
 606     CicoSystemConfig* CSCSC = CicoSystemConfig::getInstance();
 607     m_inputDev = CSCSC->getInputDevIdbyName(inputDev);
 608     ICO_DBG("sound %s->%d", inputDev.c_str(), m_sound);
 609     if (false == sw.empty()) {
 610         m_switch = CSCSC->getSwitchIdbyName(inputDev, sw);
 611         ICO_DBG("switch %s, %s->%d", inputDev.c_str(), sw.c_str(), m_switch);
 612     }
 613     ICO_TRA("end idev:%d i:%d", m_inputDev, m_switch);
 614     return true;
 615 }
 616
 617 /**
 618  * @brief category string parse
 619  * @param category string
 620  * @retval true parse success
 621  * @retval false parse fail
 622  */
 623 bool CicoAilItems::categoryParseNodisplay(const string& s)
 624 {
 625     ICO_TRA("start");
 626     const char* ps = s.c_str();
 627     int c = s_NoDisplay.size();
 628     if ('=' != ps[c]) {
 629         ICO_TRA("end");
 630         return false;  // not "NoDisplay=true/false"
 631     }
 632     if (0 == strcasecmp(&ps[c+1], "false")) {
 633         m_noIcon = false;
 634     }
 635     else {
 636         m_noIcon = true;
 637     }
 638     ICO_TRA("end %s", m_noIcon? "true": "false");
 639     return true;
 640 }
 641
 642 /**
 643  * @brief category string parse
 644  * @param category string
 645  * @retval true parse success
 646  * @retval false parse fail
 647  */
 648 bool CicoAilItems::categoryParseAnimation(const string& s)
 649 {
 650     ICO_TRA("start");
 651     const char* ps = s.c_str();
 652     int c = s_Animation_time.size();
 653     bool b_at = false;  // animation time flag off
 654     if (0 == strncasecmp(ps, s_Animation_time.c_str(), c)) {
 655         b_at = true;    // flag on
 656     }
 657     else {
 658         c = s_Animation.size(); // not Animation_time
 659     }
 660     if ('=' != ps[c]) {
 661         ICO_TRA("end");
 662         return false;  // not "Animation=xxx" / "Animation_time=xxx"
 663     }
 664     if (true == b_at) {
 665         // Animation_time
 666         m_animationTime = (int)strtol(&ps[c+1], (char **)0, 0);
 667     }
 668     else {
 669         // Animation
 670         m_animation = &ps[c+1];
 671     }
 672     ICO_TRA("end");
 673     return true;
 674 }
 675
 676 /**
 677  * @brief category string parse
 678  * @param category string
 679  * @retval true parse success
 680  * @retval false parse fail
 681  */
 682 bool CicoAilItems::categoryParseInvisiblecpu(const string& s)
 683 {
 684     ICO_TRA("start");
 685     const char* ps = s.c_str();
 686     int c = s_invisiblecpu.size();
 687     if ('=' != ps[c]) {
 688         ICO_TRA("end");
 689         return false;  // not "invisibluecpu=xxx"
 690     }
 691     if (0 == strcasecmp(&ps[c+1], "yes")) {
 692         m_invisibleCPU = 100;
 693     }
 694     else if (0 != strcasecmp(&ps[c+1], "no")) {
 695         m_invisibleCPU = (int)strtol(&ps[c+1], (char **)0, 0);
 696     }
 697     else { // "no"
 698         m_invisibleCPU = 0;
 699     }
 700     ICO_TRA("end %s,%d", &ps[c+1], m_invisibleCPU);
 701     return true;
 702 }
 703
 704 /**
 705  * @brief category string parse
 706  * @param category string
 707  * @retval true parse success
 708  * @retval false parse fail
 709  */
 710 bool CicoAilItems::categoryParseNoconfigure(const string&)
 711 {
 712 // TODO mk_k
 713     ICO_TRA("start");
 714 //    m_noconfigure = true;
 715     ICO_TRA("end");
 716 //    return true;
 717     return false;
 718 }
 719
 720 /**
 721  * @brief category string parse
 722  * @param category string
 723  * @retval true parse success
 724  * @retval false parse fail
 725  */
 726 bool CicoAilItems::categoryParseMenuoverlap(const string&)
 727 {
 728     ICO_TRA("start");
 729     m_memnuOverlap = true;
 730     ICO_TRA("end");
 731     return true;
 732 }
 733
 734 /**
 735  * @brief category string parse
 736  * @param category string
 737  * @retval true parse success
 738  * @retval false parse fail
 739  */
 740 bool CicoAilItems::categoryParseAuto(const string&)
 741 {
 742     ICO_TRA("start");
 743     m_autoStart = true;
 744     ICO_TRA("end");
 745     return true;
 746 }
 747
 748 /**
 749  * @brief category string parse
 750  * @param category string
 751  * @retval true parse success
 752  * @retval false parse fail
 753  */
 754 bool CicoAilItems::categoryParseNoauto(const string&)
 755 {
 756     ICO_TRA("start");
 757     m_autoStart = false;
 758     ICO_TRA("end");
 759     return true;
 760 }
 761 // vim:set expandtab ts=4 sw=4: