// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file tools.license for terms.

#ifndef tools_sg_senum
#define tools_sg_senum

#include "enums"
#include "lpat"

#include <string>
#include <vector>

namespace tools {
namespace sg {

typedef struct {char string[32];hjust value;} hjust_rec;
inline const hjust_rec* hjust_recs(unsigned int& a_num){
  static const hjust_rec list[] = { //read only static, then ok.
    {"left",     left},
    {"center",   center},
    {"right",    right}
  };
  a_num = sizeof(list)/sizeof(list[0]);
  return list;
}
inline bool shjust(const std::string& a_s,hjust& a_v){
  unsigned int number;
  const hjust_rec* list = hjust_recs(number);
  for(unsigned int count=0;count<number;count++) {
    if(a_s==list[count].string) {
      a_v = list[count].value;
      return true;
    }
  }
  a_v = left;
  return false;
}
inline const char* shjust(hjust a_v){
  unsigned int number;
  const hjust_rec* list = hjust_recs(number);
  for(unsigned int count=0;count<number;count++) {
    if(a_v==list[count].value) return list[count].string;
  }
  return 0;
}

typedef struct {char string[32];vjust value;} vjust_rec;
inline const vjust_rec* vjust_recs(unsigned int& a_num){
  static const vjust_rec list[] = { //read only static, then ok.
    {"bottom",   bottom},
    {"middle",   middle},
    {"top",      top}
  };
  a_num = sizeof(list)/sizeof(list[0]);
  return list;
}
inline bool svjust(const std::string& a_s,vjust& a_v){
  unsigned int number;
  const vjust_rec* list = vjust_recs(number);
  for(unsigned int count=0;count<number;count++) {
    if(a_s==list[count].string) {
      a_v = list[count].value;
      return true;
    }
  }
  a_v = bottom;
  return false;
}
inline const char* svjust(vjust a_v){
  unsigned int number;
  const vjust_rec* list = vjust_recs(number);
  for(unsigned int count=0;count<number;count++) {
    if(a_v==list[count].value) return list[count].string;
  }
  return 0;
}

typedef struct {char string[32];marker_style value;} marker_style_rec;
inline const marker_style_rec* marker_style_recs(unsigned int& a_num){
  static const marker_style_rec list[] = { //read only static, then ok.
    {"dot",         marker_dot},
    {"plus",        marker_plus},
    {"asterisk",    marker_asterisk},
    {"cross",       marker_cross},
    {"star",        marker_star},
    {"circle_line",         marker_circle_line},
    {"circle_filled",       marker_circle_filled},
    {"triangle_up_line",    marker_triangle_up_line},
    {"triangle_up_filled",  marker_triangle_up_filled},
    {"triangle_down_line",  marker_triangle_down_line},
    {"triangle_down_filled",marker_triangle_down_filled},
    {"david_star_line",     marker_david_star_line},
    {"david_star_filled",   marker_david_star_filled},
    {"swiss_cross_line",    marker_swiss_cross_line},
    {"swiss_cross_filled",  marker_swiss_cross_filled},
    {"diamond_line",        marker_diamond_line},
    {"diamond_filled",      marker_diamond_filled},
    {"square_line",         marker_square_line},
    {"square_filled",       marker_square_filled},
    {"penta_star_line",     marker_penta_star_line},
    {"penta_star_filled",   marker_penta_star_filled},
    {"minus",               marker_minus}
  };
  a_num = sizeof(list)/sizeof(list[0]);
  return list;
}
inline bool smarker_style(const std::string& a_s,marker_style& a_v){
  unsigned int number;
  const marker_style_rec* list = marker_style_recs(number);
  for(unsigned int count=0;count<number;count++) {
    if(a_s==list[count].string) {
      a_v = list[count].value;
      return true;
    }
  }
  a_v = marker_dot;
  return false;
}
inline const char* smarker_style(marker_style a_v){
  unsigned int number;
  const marker_style_rec* list = marker_style_recs(number);
  for(unsigned int count=0;count<number;count++) {
    if(a_v==list[count].value) return list[count].string;
  }
  return 0;
}
inline void smarker_styles(std::vector<std::string>& a_v){
  a_v.clear();
  unsigned int number;
  const marker_style_rec* list = marker_style_recs(number);
  for(unsigned int count=0;count<number;count++) {
    a_v.push_back(list[count].string);
  }
}

typedef struct {char string[16];area_style value;} area_style_rec;
inline const area_style_rec* area_style_recsList(unsigned int& a_num){
  static const area_style_rec list[] = { //read only static, then ok.
    {"solid",         area_solid},
    {"hatched",       area_hatched},
    {"checker",       area_checker},
    {"edged",         area_edged}
  };
  a_num = sizeof(list)/sizeof(list[0]);
  return list;
}
inline bool sarea_style(const std::string& a_s,area_style& a_v){
  unsigned int number;
  const area_style_rec* list = area_style_recsList(number);
  for(unsigned int count=0;count<number;count++) {
    if(a_s==list[count].string) {
      a_v = list[count].value;
      return true;
    }
  }
  a_v = area_solid;
  return false;
}
inline const char* sarea_style(area_style a_v){
  unsigned int number;
  const area_style_rec* list = area_style_recsList(number);
  for(unsigned int count=0;count<number;count++) {
    if(a_v==list[count].value) return list[count].string;
  }
  return 0;
}

typedef struct {char string[20];painting_policy value;} painting_policy_rec;
inline const painting_policy_rec* painting_policy_recsList(unsigned int& a_num){
  static const painting_policy_rec list[] = { //read only static, then ok.
    {"uniform",      painting_uniform},
    {"by_value",     painting_by_value},
    {"by_level",     painting_by_level},
    {"grey_scale",   painting_grey_scale},
    {"violet_to_red",painting_violet_to_red},
    {"grey_scale_inverse",painting_grey_scale_inverse}
  };
  a_num = sizeof(list)/sizeof(list[0]);
  return list;
}
inline void spainting_policies(std::vector<std::string>& a_v){
  a_v.clear();
  unsigned int number;
  const painting_policy_rec* list = painting_policy_recsList(number);
  for(unsigned int count=0;count<number;count++) {
    a_v.push_back(list[count].string);
  }
}
inline bool spainting_policy(const std::string& a_s,painting_policy& a_v){
  unsigned int number;
  const painting_policy_rec* list = painting_policy_recsList(number);
  for(unsigned int count=0;count<number;count++) {
    if(a_s==list[count].string) {
      a_v = list[count].value;
      return true;
    }
  }
  a_v = painting_uniform;
  return false;
}
inline const char* spainting_policy(painting_policy a_v){
  unsigned int number;
  const painting_policy_rec* list = painting_policy_recsList(number);
  for(unsigned int count=0;count<number;count++) {
    if(a_v==list[count].value) return list[count].string;
  }
  return 0;
}


typedef struct {char string[16];hatching_policy value;} hatching_policy_rec;
inline const hatching_policy_rec* hatching_policy_recsList(unsigned int& a_num){
  static const hatching_policy_rec list[] = { //read only static, then ok.
    {"none",           hatching_none},
    {"right",          hatching_right},
    {"left",           hatching_left},
    {"left_and_right", hatching_left_and_right}
  };
  a_num = sizeof(list)/sizeof(list[0]);
  return list;
}
inline bool shatching_policy(const std::string& a_s,hatching_policy& a_v){
  unsigned int number;
  const hatching_policy_rec* list = hatching_policy_recsList(number);
  for(unsigned int count=0;count<number;count++) {
    if(a_s==list[count].string) {
      a_v = list[count].value;
      return true;
    }
  }
  a_v = hatching_none;
  return false;
}
inline const char* shatching_policy(hatching_policy a_v){
  unsigned int number;
  const hatching_policy_rec* list = hatching_policy_recsList(number);
  for(unsigned int count=0;count<number;count++) {
    if(a_v==list[count].value) return list[count].string;
  }
  return 0;
}

typedef struct {char string[16];projection_type value;} projection_type_rec;
inline const projection_type_rec* projection_type_recsList(unsigned int& a_num){
  static const projection_type_rec list[] = { //read only static, then ok.
    {"none",     projection_none},
    {"rz",       projection_rz},
    {"phiz",     projection_phiz},
    {"zr",       projection_zr},
    {"zphi",     projection_zphi}
  };
  a_num = sizeof(list)/sizeof(list[0]);
  return list;
}
inline bool sprojection_type(const std::string& a_s,projection_type& a_v){
  unsigned int number;
  const projection_type_rec* list = projection_type_recsList(number);
  for(unsigned int count=0;count<number;count++) {
    if(a_s==list[count].string) {
      a_v = list[count].value;
      return true;
    }
  }
  a_v = projection_none;
  return false;
}
inline const char* sprojection_type(projection_type a_v){
  unsigned int number;
  const projection_type_rec* list = projection_type_recsList(number);
  for(unsigned int count=0;count<number;count++) {
    if(a_v==list[count].value) return list[count].string;
  }
  return 0;
}

inline bool sline_pattern(const std::string& a_s,lpat& aPattern){
  if(a_s=="solid") {
    aPattern = line_solid;
  } else if(a_s=="dashed") {
    aPattern = line_dashed;
  } else if(a_s=="dotted") {
    aPattern = line_dotted;
  } else if(a_s=="dash_dotted") {
    aPattern = line_dash_dotted;
  } else {
    aPattern = line_solid;
    return false;
  }
  return true;
}

///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
inline bool smove_type(const std::string& a_s,move_type& a_move) {
  if(a_s=="move_rotate_right") {a_move = move_rotate_right;return true;}
  if(a_s=="move_rotate_left") {a_move = move_rotate_left;return true;}
  if(a_s=="move_rotate_up") {a_move = move_rotate_up;return true;}
  if(a_s=="move_rotate_down") {a_move = move_rotate_down;return true;}
  if(a_s=="move_roll_plus") {a_move = move_roll_plus;return true;}
  if(a_s=="move_roll_minus") {a_move = move_roll_minus;return true;}
  if(a_s=="move_translate_right") {a_move = move_translate_right;return true;}
  if(a_s=="move_translate_left") {a_move = move_translate_left;return true;}
  if(a_s=="move_up") {a_move = move_up;return true;}
  if(a_s=="move_down") {a_move = move_down;return true;}
  if(a_s=="move_forward") {a_move = move_forward;return true;}
  if(a_s=="move_backward") {a_move = move_backward;return true;}
  if(a_s=="move_zoom_in") {a_move = move_zoom_in;return true;}
  if(a_s=="move_zoom_out") {a_move = move_zoom_out;return true;}
  if(a_s=="move_rotate_around_focal_right") {a_move = move_rotate_around_focal_right;return true;}
  if(a_s=="move_rotate_around_focal_left") {a_move = move_rotate_around_focal_left;return true;}
  if(a_s=="move_rotate_around_focal_up") {a_move = move_rotate_around_focal_up;return true;}
  if(a_s=="move_rotate_around_focal_down") {a_move = move_rotate_around_focal_down;return true;}
  if(a_s=="move_roll_around_focal_plus") {a_move = move_roll_around_focal_plus;return true;}
  if(a_s=="move_roll_around_focal_minus") {a_move = move_roll_around_focal_minus;return true;}
  if(a_s=="move_zoom_in_out") {a_move = move_zoom_in_out;return true;}
  if(a_s=="move_zoom_in_out_rot") {a_move = move_zoom_in_out_rot;return true;}
  if(a_s=="move_curve") {a_move = move_curve;return true;}
  a_move = move_rotate_left;
  return false;
}

}}

#endif