users/turbomech/backupturbomech.c

   1 /* Copyright 2017 @TurboMech /u/TurboMech <discord> @A9entOran9e#6134
   2  *
   3  * This program is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 2 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15  */
  16
  17 #include "turbomech.h"
  18 #include "quantum.h"
  19 //#include "action_layer.h"
  20 #include "action.h"
  21 //#include "rgblight.h"
  22
  23 __attribute__ ((weak))
  24 void matrix_init_keymap(void) {}
  25
  26 __attribute__ ((weak))
  27 void matrix_scan_keymap(void) {}
  28
  29 __attribute__ ((weak))
  30 bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
  31   return true;
  32 }
  33 __attribute__ ((weak))
  34 uint32_t layer_state_set_keymap (uint32_t state) {
  35   return state;
  36 }
  37 __attribute__ ((weak))
  38 void led_set_keymap(uint8_t usb_led) {}
  39
  40 //#define default_layer _QWERTY (0)
  41 //extern keymap_config_t keymap_config;
  42
  43 extern rgblight_config_t rgblight_config;
  44
  45
  46 //#ifdef RGBLIGHT_ENABLE
  47 /*change the rgblight_setrgb(#, #, #) to what you want CAPS lock - currenlty red*/
  48  //#define rgblight_set_caps       rgblight_setrgb(255, 0, 0)
  49  //#define rgblight_base           rgblight_mode(RGB_current_mode)
  50 //#endif
  51 //
  52 //bool rgb_layer_change = true;
  53 //bool RGB_INIT = false;
  54 //bool TOG_STATUS = false;
  55 #ifdef RGBLIGHT_ENABLE
  56 bool rgb_layer_change = true;
  57 #endif
  58 int RGB_current_mode;
  59
  60 /*void matrix_init_user(void) {
  61   #ifdef RGBLIGHT_ENABLE
  62   rgblight_enable();
  63   if (true) {
  64   eeconfig_read_rgblight();
  65   rgblight_get_mode();
  66   eeconfig_update_rgblight_default();
  67
  68
  69  // eeconfig_debug_rgblight();
  70   //rgblight_init();
  71   }
  72   #endif
  73
  74 }
  75 */
  76
  77 /*void matrix_init_user(void) {
  78   #ifdef RGBLIGHT_ENABLE
  79   eeconfig_read_rgblight();
  80   eeconfig_update_rgblight_default();
  81   //rgblight_init();
  82   //rgblight_mode(RGB_current_mode);
  83   //rgblight_mode(RGB_current_mode);
  84   //RGB_current_mode = rgblight_config.mode;
  85   #endif
  86 }*/
  87
  88
  89 void persistent_default_layer_set(uint16_t default_layer) {
  90   eeconfig_update_default_layer(default_layer);
  91   default_layer_set(default_layer);
  92   default_layer = _QWERTY;
  93  // eeconfig_update_rgblight(rgblight_config.raw);
  94 }
  95
  96  //Setting ADJUST layer RGB back to default
  97 /*void update_tri_layer_RGB(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
  98   if (IS_LAYER_ON(layer1) && IS_LAYER_ON(layer2)) {
  99     rgblight_mode(RGB_current_mode);
 100     layer_on(layer1);
 101   } else {
 102     layer_off(layer2);
 103   }
 104 }*/
 105
 106
 107 void matrix_init_user(void) {
 108
 109   uint8_t default_layer = eeconfig_read_default_layer();
 110
 111   rgblight_enable();
 112
 113   if(true) {
 114    if (default_layer & (1UL << _QWERTY)) {
 115       //RGB_current_mode = rgblight_config.mode;
 116       rgblight_mode(11);
 117       }
 118  else {
 119       rgblight_mode (12);
 120       }
 121
 122     /*else if (default_layer & (1UL << _DVORAK)) {
 123       rgblight_set_green;
 124     }
 125     //else if (default_layer & (1UL << _WORKMAN)) {
 126       rgblight_set_purple;
 127     }
 128     else {
 129       rgblight_set_teal;*/
 130
 131
 132   }
 133
 134
 135 }
 136
 137 static bool is_capslocked = false;
 138 void led_set_user(uint8_t usb_led) {
 139   if (usb_led & (1<<USB_LED_CAPS_LOCK)) {
 140     is_capslocked = true;
 141    //     DDRB |= (1 << 2); PORTB &= ~(1 << 2);
 142   } else {
 143     is_capslocked = false;
 144   //  DDRB &= ~(1 << 2); PORTB &= ~(1 << 2);
 145   }
 146 }
 147   //rgblight_set();
 148
 149
 150 //static uint8_t is_capslocked = false;
 151 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
 152   switch (keycode) {
 153     case _QWERTY:
 154       persistent_default_layer_set(1UL << _QWERTY);
 155       return false;
 156       break;
 157     case KC_MAKE_ALU84:
 158       if (!record->event.pressed) {
 159         SEND_STRING("make alu84:TurboMech:dfu");
 160         SEND_STRING(SS_TAP(X_ENTER));
 161     }
 162     return false;
 163     break;
 164     case KC_QMK:
 165       if (!record->event.pressed) {
 166         SEND_STRING("cd QMK/qmk_firmware");
 167         SEND_STRING(SS_TAP(X_ENTER));
 168       }
 169       return false;
 170       break;
 171     case KC_RESET:
 172       if (!record->event.pressed) {
 173         #ifdef RGBLIGHT_ENABLE
 174           rgblight_enable();
 175           rgblight_mode(1);
 176           rgblight_setrgb(255, 255, 255);
 177         #endif
 178         //_delay_ms(2000);
 179         reset_keyboard();
 180       }
 181       return false;
 182       break;
 183     /*case RGB_MOD:
 184       //led operations - RGB mode change now updates the RGB_current_mode to allow the right RGB mode to be set after reactive keys are released
 185       if (record->event.pressed) {
 186        rgblight_mode(RGB_current_mode);
 187        RGB_current_mode = rgblight_config.mode;
 188         rgblight_step();
 189        // rgblight_mode(RGB_current_mode);
 190      //RGB_current_mode = rgblight_config.mode;
 191         // _delay_ms(50);
 192        // rgblight_set();
 193         RGB_current_mode = rgblight_config.mode;
 194     }
 195       else //if (rgblight_config.enable)
 196       {
 197         _delay_ms(50);
 198         rgblight_set();
 199         //rgblight_mode(rgblight_config.mode);
 200       // eeconfig_update_rgblight(rgblight_config.raw);
 201       }
 202
 203      return true;
 204       break;*/
 205
 206     /*case MO(1):
 207       if (record->event.realeased) {
 208         rgblight_mode(1);
 209         rgblight_set_red;
 210       }
 211       return true;
 212       break;*/
 213
 214    /*case KC_CAPS:
 215      if (record->event.pressed) {
 216         rgblight_mode(RGB_current_mode);
 217        register_code(KC_CAPS);
 218         rgblight_mode(1);
 219         rgblight_set_red;
 220       }
 221       else {
 222         unregister_code(KC_CAPS);
 223         rgblight_mode(RGB_current_mode);
 224
 225       }
 226       return false;
 227        break;*/
 228
 229        /* rgblight_mode(RGB_current_mode);
 230         register_code(KC_CAPS);
 231         rgblight_mode(1);
 232         rgblight_set_red;
 233       }
 234       else {
 235         unregister_code(KC_CAPS);
 236         rgblight_mode(RGB_current_mode);*/
 237
 238     //  }
 239     //  return true;
 240      //  break;
 241     /*case KC_RESET:
 242       if (record->event.pressed) {
 243       layer_off(_FUNCTION);
 244       rgblight_mode(RGB_current_mode);
 245      RGB_current_mode = rgblight_config.mode;
 246       layer_clear();
 247       _delay_ms(1000);
 248         reset_keyboard();
 249      }
 250      else{
 251       //layer_off(_FUNCTION);
 252      _delay_ms(1000);
 253      rgblight_mode(RGB_current_mode);
 254      RGB_current_mode = rgblight_config.mode;
 255
 256      //eeconfig_update_rgblight_default();
 257       }
 258
 259       return false;
 260       break;
 261     }*/
 262
 263
 264       return true;
 265       break;
 266
 267
 268
 269
 270
 271 /*case RGB_MOD:
 272 case RGB_HUI:
 273 case RGB_HUD:
 274 case RGB_SAI:
 275 case RGB_SAD:
 276 case RGB_VAI:
 277 case RGB_VAD:
 278 case RGB_MODE_PLAIN:
 279 case RGB_MODE_BREATHE:
 280 case RGB_MODE_RAINBOW:
 281 case RGB_MODE_SWIRL:
 282 case RGB_MODE_SNAKE:
 283 case RGB_MODE_KNIGHT:
 284 case RGB_MODE_XMAS:
 285 case RGB_MODE_GRADIENT:
 286     if (record->event.pressed) {
 287       rgb_layer_change = false;
 288     }
 289     break;
 290   }
 291   return true;*/
 292   }
 293
 294
 295  return process_record_keymap(keycode, record);
 296
 297 }
 298
 299 uint32_t layer_state_set_user(uint32_t state) {
 300 #ifdef RGBLIGHT_ENABLE
 301   uint8_t default_layer = eeconfig_read_default_layer();
 302   if (rgb_layer_change) {
 303     switch (biton32(state)) {
 304     case _FUNCTION:
 305       rgblight_set_blue;
 306      rgblight_mode(1);
 307      break;
 308     case _QWERTY:
 309
 310       rgblight_mode(11);
 311       break;
 312   // case _MOUS:
 313     //  rgblight_set_yellow;
 314     //  rgblight_mode(1);
 315    //   break;
 316     //case _MACROS:
 317       //rgblight_set_orange;
 318       //is_overwatch ? rgblight_mode(17) : rgblight_mode(18);
 319       //break;
 320     //case _MEDIA:
 321       //rgblight_set_green;
 322       //rgblight_mode(22);
 323       //break;
 324     default:
 325       if (is_capslocked) {
 326         rgblight_mode(1);
 327         rgblight_set_red;
 328       }
 329         else { if (default_layer & (1UL << _QWERTY)) {
 330         rgblight_mode(11);
 331         }
 332
 333         else if (default_layer & (1UL << _FUNCTION)) {
 334          rgblight_set_cyan;
 335         }
 336         //else if (default_layer & (1UL << _WORKMAN)) {
 337         //  rgblight_set_purple;
 338        // }
 339         else {
 340           rgblight_set_orange;
 341         }
 342       }
 343       rgblight_mode(1);
 344       break;
 345     }
 346   }
 347 #endif
 348   return state;
 349 }
 350
 351
 352 !!** possible for later
 353
 354 void set_single_persistent_default_layer(uint8_t default_layer);
 355
 356 void set_single_persistent_default_layer(uint8_t default_layer) {
 357   #if defined(AUDIO_ENABLE) && defined(DEFAULT_LAYER_SONGS)
 358     PLAY_SONG(default_layer_songs[default_layer]);
 359   #endif
 360   eeconfig_update_default_layer(1U<<default_layer);
 361   default_layer_set(1U<<default_layer);
 362
 363 void matrix_init_kb(void);
 364
 365 void matrix_init_user(void);
 366
 367 !!** line 31
 368
 369 __attribute__ ((weak))
 370 void matrix_init_keymap(void) {}
 371
 372 __attribute__ ((weak))
 373 void matrix_scan_keymap(void) {}
 374
 375 __attribute__ ((weak))
 376 bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
 377   return true;
 378 }
 379 __attribute__ ((weak))
 380 uint32_t layer_state_set_keymap (uint32_t state) {
 381   return state;
 382 }
 383 __attribute__ ((weak))
 384 void led_set_keymap(uint8_t usb_led) {}
 385
 386 Alt +30C4
 387 ¯\_(ツ)_/¯
 388
 389 Alt +00AF