Merge branch 'master' of github.com:fairyglade/ly into xinitrc

src/config.c

@@ -167,6 +167,7 @@ void config_load(const char *cfg_path)
 		{"default_input", &config.default_input, config_handle_u8},
 		{"fg", &config.fg, config_handle_u8},
 		{"hide_borders", &config.hide_borders, config_handle_bool},
+		{"hide_f1_commands", &config.hide_f1_commands, config_handle_bool},
 		{"input_len", &config.input_len, config_handle_u8},
 		{"lang", &config.lang, config_handle_str},
 		{"load", &config.load, config_handle_bool},
@@ -271,7 +272,7 @@ void config_defaults()
 	config.blank_box = true;
 	config.blank_password = false;
 	config.console_dev = strdup("/dev/console");
-	config.default_input = PASSWORD_INPUT;
+	config.default_input = LOGIN_INPUT;
 	config.fg = 9;
 	config.hide_borders = false;
 	config.input_len = 34;

src/config.h

@@ -71,6 +71,7 @@ struct config
 	uint8_t default_input;
 	uint8_t fg;
 	bool hide_borders;
+	bool hide_f1_commands;
 	uint8_t input_len;
 	char* lang;
 	bool load;

src/draw.c

@@ -48,7 +48,7 @@ void draw_init(struct term_buf* buf)
 		+ (config.input_len + 1)
 		+ buf->labels_max_len;
 
-#if defined(__linux__)
+#if defined(__linux__) || defined(__FreeBSD__)
 	buf->box_chars.left_up = 0x250c;
 	buf->box_chars.left_down = 0x2514;
 	buf->box_chars.right_up = 0x2510;
@@ -69,11 +69,22 @@ void draw_init(struct term_buf* buf)
 #endif
 }
 
+static void doom_free(struct term_buf* buf);
+static void matrix_free(struct term_buf* buf);
+
 void draw_free(struct term_buf* buf)
 {
 	if (config.animate)
 	{
-		free(buf->tmp_buf);
+		switch (config.animation)
+		{
+			case 0:
+				doom_free(buf);
+				break;
+			case 1:
+				matrix_free(buf);
+				break;
+		}
 	}
 }
 
@@ -118,7 +129,7 @@ void draw_box(struct term_buf* buf)
 		struct tb_cell c1 = {buf->box_chars.top, config.fg, config.bg};
 		struct tb_cell c2 = {buf->box_chars.bot, config.fg, config.bg};
 
-		for (uint8_t i = 0; i < buf->box_width; ++i)
+		for (uint16_t i = 0; i < buf->box_width; ++i)
 		{
 			tb_put_cell(
 				box_x + i,
@@ -134,7 +145,7 @@ void draw_box(struct term_buf* buf)
 		c1.ch = buf->box_chars.left;
 		c2.ch = buf->box_chars.right;
 
-		for (uint8_t i = 0; i < buf->box_height; ++i)
+		for (uint16_t i = 0; i < buf->box_height; ++i)
 		{
 			tb_put_cell(
 				box_x - 1,
@@ -152,9 +163,9 @@ void draw_box(struct term_buf* buf)
 	{
 		struct tb_cell blank = {' ', config.fg, config.bg};
 
-		for (uint8_t i = 0; i < buf->box_height; ++i)
+		for (uint16_t i = 0; i < buf->box_height; ++i)
 		{
-			for (uint8_t k = 0; k < buf->box_width; ++k)
+			for (uint16_t k = 0; k < buf->box_width; ++k)
 			{
 				tb_put_cell(
 					box_x + k,
@@ -481,18 +492,118 @@ static void doom_init(struct term_buf* buf)
 {
 	buf->init_width = buf->width;
 	buf->init_height = buf->height;
+	buf->astate.doom = malloc(sizeof(struct doom_state));
 
-	uint16_t tmp_len = buf->width * buf->height;
-	buf->tmp_buf = malloc(tmp_len);
-	tmp_len -= buf->width;
-
-	if (buf->tmp_buf == NULL)
+	if (buf->astate.doom == NULL)
 	{
 		dgn_throw(DGN_ALLOC);
 	}
 
-	memset(buf->tmp_buf, 0, tmp_len);
-	memset(buf->tmp_buf + tmp_len, DOOM_STEPS - 1, buf->width);
+	uint16_t tmp_len = buf->width * buf->height;
+	buf->astate.doom->buf = malloc(tmp_len);
+	tmp_len -= buf->width;
+
+	if (buf->astate.doom->buf == NULL)
+	{
+		dgn_throw(DGN_ALLOC);
+	}
+
+	memset(buf->astate.doom->buf, 0, tmp_len);
+	memset(buf->astate.doom->buf + tmp_len, DOOM_STEPS - 1, buf->width);
+}
+
+static void doom_free(struct term_buf* buf)
+{
+	free(buf->astate.doom->buf);
+	free(buf->astate.doom);
+}
+
+// Adapted from cmatrix
+static void matrix_init(struct term_buf* buf)
+{
+	buf->init_width = buf->width;
+	buf->init_height = buf->height;
+	buf->astate.matrix = malloc(sizeof(struct matrix_state));
+	struct matrix_state* s = buf->astate.matrix;
+
+	if (s == NULL)
+	{
+		dgn_throw(DGN_ALLOC);
+	}
+
+	uint16_t len = buf->height + 1;
+	s->grid = malloc(sizeof(struct matrix_dot*) * len);
+
+	if (s->grid == NULL)
+	{
+		dgn_throw(DGN_ALLOC);
+	}
+
+	len = (buf->height + 1) * buf->width;
+	(s->grid)[0] = malloc(sizeof(struct matrix_dot) * len);
+
+	if ((s->grid)[0] == NULL)
+	{
+		dgn_throw(DGN_ALLOC);
+	}
+
+	for (int i = 1; i <= buf->height; ++i)
+	{
+		s->grid[i] = s->grid[i - 1] + buf->width;
+
+		if (s->grid[i] == NULL)
+		{
+			dgn_throw(DGN_ALLOC);
+		}
+	}
+
+	s->length = malloc(buf->width * sizeof(int));
+
+	if (s->length == NULL)
+	{
+		dgn_throw(DGN_ALLOC);
+	}
+
+	s->spaces = malloc(buf->width * sizeof(int));
+
+	if (s->spaces == NULL)
+	{
+		dgn_throw(DGN_ALLOC);
+	}
+
+	s->updates = malloc(buf->width * sizeof(int));
+
+	if (s->updates == NULL)
+	{
+		dgn_throw(DGN_ALLOC);
+	}
+
+	// Initialize grid
+	for (int i = 0; i <= buf->height; ++i)
+	{
+		for (int j = 0; j <= buf->width - 1; j += 2)
+		{
+			s->grid[i][j].val = -1;
+		}
+	}
+
+	for (int j = 0; j < buf->width; j += 2)
+	{
+		s->spaces[j] = (int) rand() % buf->height + 1;
+		s->length[j] = (int) rand() % (buf->height - 3) + 3;
+		s->grid[1][j].val = ' ';
+		s->updates[j] = (int) rand() % 3 + 1;
+	}
+}
+
+static void matrix_free(struct term_buf* buf)
+{
+	free(buf->astate.matrix->grid[0]);
+	free(buf->astate.matrix->grid);
+	free(buf->astate.matrix->length);
+	free(buf->astate.matrix->spaces);
+	free(buf->astate.matrix->updates);
+	free(buf->astate.matrix);
 }
 
 void animate_init(struct term_buf* buf)
@@ -501,11 +612,16 @@ void animate_init(struct term_buf* buf)
 	{
 		switch(config.animation)
 		{
-			default:
+			case 0:
 			{
 				doom_init(buf);
 				break;
 			}
+			case 1:
+			{
+				matrix_init(buf);
+				break;
+			}
 		}
 	}
 }
@@ -534,7 +650,7 @@ static void doom(struct term_buf* term_buf)
 	uint16_t dst;
 
 	uint16_t w = term_buf->init_width;
-	uint8_t* tmp = term_buf->tmp_buf;
+	uint8_t* tmp = term_buf->astate.doom->buf;
 
 	if ((term_buf->width != term_buf->init_width) || (term_buf->height != term_buf->init_height))
 	{
@@ -573,6 +689,130 @@ static void doom(struct term_buf* term_buf)
 	}
 }
 
+// Adapted from cmatrix
+static void matrix(struct term_buf* buf)
+{
+	static int frame = 3;
+	const int frame_delay = 8;
+	static int count = 0;
+	bool first_col;
+	struct matrix_state* s = buf->astate.matrix;
+
+	// Allowed codepoints
+	const int randmin = 33;
+	const int randnum = 123 - randmin;
+	// Chars change mid-scroll
+	const bool changes = true;
+
+	if ((buf->width != buf->init_width) || (buf->height != buf->init_height))
+	{
+		return;
+	}
+
+	count += 1;
+	if (count > frame_delay) {
+		frame += 1;
+		if (frame > 4) frame = 1;
+		count = 0;
+
+		for (int j = 0; j < buf->width; j += 2)
+		{
+			int tail;
+			if (frame > s->updates[j])
+			{
+				if (s->grid[0][j].val == -1 && s->grid[1][j].val == ' ')
+				{
+					if (s->spaces[j] > 0)
+					{
+						s->spaces[j]--;
+					} else {
+						s->length[j] = (int) rand() % (buf->height - 3) + 3;
+						s->grid[0][j].val = (int) rand() % randnum + randmin;
+						s->spaces[j] = (int) rand() % buf->height + 1;
+					}
+				}
+
+				int i = 0, seg_len = 0;
+				first_col = 1;
+				while (i <= buf->height)
+				{
+					// Skip over spaces
+					while (i <= buf->height
+							&& (s->grid[i][j].val == ' ' || s->grid[i][j].val == -1))
+					{
+						i++;
+					}
+
+					if (i > buf->height) break;
+
+					// Find the head of this col
+					tail = i;
+					seg_len = 0;
+					while (i <= buf->height
+							&& (s->grid[i][j].val != ' ' && s->grid[i][j].val != -1))
+					{
+						s->grid[i][j].is_head = false;
+						if (changes)
+						{
+							if (rand() % 8 == 0)
+								s->grid[i][j].val = (int) rand() % randnum + randmin;
+						}
+						i++;
+						seg_len++;
+					}
+
+					// Head's down offscreen
+					if (i > buf->height)
+					{
+						s->grid[tail][j].val = ' ';
+						continue;
+					}
+
+					s->grid[i][j].val = (int) rand() % randnum + randmin;
+					s->grid[i][j].is_head = true;
+
+					if (seg_len > s->length[j] || !first_col) {
+						s->grid[tail][j].val = ' ';
+						s->grid[0][j].val = -1;
+					}
+					first_col = 0;
+					i++;
+				}
+			}
+		}
+	}
+
+	uint32_t blank;
+	utf8_char_to_unicode(&blank, " ");
+
+	for (int j = 0; j < buf->width; j += 2) {
+		for (int i = 1; i <= buf->height; ++i)
+		{
+			uint32_t c;
+			int fg = TB_GREEN;
+			int bg = TB_DEFAULT;
+
+			if (s->grid[i][j].val == -1 || s->grid[i][j].val == ' ')
+			{
+				tb_change_cell(j, i - 1, blank, fg, bg);
+				continue;
+			}
+
+			char tmp[2];
+			tmp[0] = s->grid[i][j].val;
+			tmp[1] = '\0';
+			if(utf8_char_to_unicode(&c, tmp))
+			{
+				if (s->grid[i][j].is_head)
+				{
+					fg = TB_WHITE | TB_BOLD;
+				}
+				tb_change_cell(j, i - 1, c, fg, bg);
+			}
+		}
+	}
+}
+
 void animate(struct term_buf* buf)
 {
 	buf->width = tb_width();
@@ -582,11 +822,16 @@ void animate(struct term_buf* buf)
 	{
 		switch(config.animation)
 		{
-			default:
+			case 0:
 			{
 				doom(buf);
 				break;
 			}
+			case 1:
+			{
+				matrix(buf);
+				break;
+			}
 		}
 	}
 }

src/draw.h

@@ -19,6 +19,31 @@ struct box
 	uint32_t right;
 };
 
+struct matrix_dot
+{
+	int val;
+	bool is_head;
+};
+
+struct matrix_state
+{
+	struct matrix_dot** grid;
+	int* length;
+	int* spaces;
+	int* updates;
+};
+
+struct doom_state
+{
+	uint8_t* buf;
+};
+
+union anim_state
+{
+	struct doom_state* doom;
+	struct matrix_state* matrix;
+};
+
 struct term_buf
 {
 	uint16_t width;
@@ -34,7 +59,7 @@ struct term_buf
 	uint16_t box_width;
 	uint16_t box_height;
 
-	uint8_t* tmp_buf;
+	union anim_state astate;
 };
 
 void draw_init(struct term_buf* buf);

src/login.c

@@ -213,22 +213,14 @@ void env_init(struct passwd* pwd)
 	char* lang = getenv("LANG");
 	// clean env
 	environ[0] = NULL;
-
-	if (term != NULL)
-	{
-		setenv("TERM", term, 1);
-	}
-	else
-	{
-		setenv("TERM", "linux", 1);
-	}
-
+	
+	setenv("TERM", term ? term : "linux", 1);
 	setenv("HOME", pwd->pw_dir, 1);
 	setenv("PWD", pwd->pw_dir, 1);
 	setenv("SHELL", pwd->pw_shell, 1);
 	setenv("USER", pwd->pw_name, 1);
 	setenv("LOGNAME", pwd->pw_name, 1);
-	setenv("LANG", lang, 1);
+	setenv("LANG", lang ? lang : "C", 1);
 
 	// Set PATH if specified in the configuration
 	if (strlen(config.path))
@@ -242,15 +234,8 @@ void env_init(struct passwd* pwd)
 	}
 }
 
-void env_xdg(const char* tty_id, const enum display_server display_server)
+void env_xdg_session(const enum display_server display_server)
 {
-	char user[15];
-	snprintf(user, 15, "/run/user/%d", getuid());
-	setenv("XDG_RUNTIME_DIR", user, 0);
-	setenv("XDG_SESSION_CLASS", "user", 0);
-	setenv("XDG_SEAT", "seat0", 0);
-	setenv("XDG_VTNR", tty_id, 0);
-
 	switch (display_server)
 	{
 		case DS_WAYLAND:
@@ -272,6 +257,17 @@ void env_xdg(const char* tty_id, const enum display_server display_server)
 	}
 }
 
+void env_xdg(const char* tty_id)
+{
+    char user[15];
+    snprintf(user, 15, "/run/user/%d", getuid());
+    setenv("XDG_RUNTIME_DIR", user, 0);
+    setenv("XDG_SESSION_CLASS", "user", 0);
+    setenv("XDG_SESSION_ID", "1", 0);
+    setenv("XDG_SEAT", "seat0", 0);
+    setenv("XDG_VTNR", tty_id, 0);
+}
+
 void add_utmp_entry(
 	struct utmp *entry,
 	char *username,
@@ -478,6 +474,9 @@ void auth(
 
 	ok = pam_start(config.service_name, NULL, &conv, &handle);
 
+    // Set XDG_SESSION_TYPE earlier to fix some bugs
+    env_xdg_session(desktop->display_server[desktop->cur]);
+
 	if (ok != PAM_SUCCESS)
 	{
 		pam_diagnose(ok, buf);
@@ -601,7 +600,7 @@ void auth(
 		}
 
 		// add xdg variables
-		env_xdg(tty_id, desktop->display_server[desktop->cur]);
+		env_xdg(tty_id);
 
 		// execute
 		int ok = chdir(pwd->pw_dir);

src/main.c

@@ -108,11 +108,7 @@ int main(int argc, char** argv)
 	}
 
 	config_load(config_path);
-
-	if (strcmp(config.lang, "en") != 0)
-	{
-		lang_load();
-	}
+	lang_load();
 
 	void* input_structs[3] =
 	{
@@ -139,13 +135,27 @@ int main(int argc, char** argv)
 	// init visible elements
 	struct tb_event event;
 	struct term_buf buf;
-	uint8_t active_input = config.default_input;
+	
+	//Place the curser on the login field if there is no saved username, if there is, place the curser on the password field
+	uint8_t active_input;
+        if (config.default_input == LOGIN_INPUT && login.text != login.end){
+        	active_input = PASSWORD_INPUT;
+        }
+        else{
+        	active_input = config.default_input;
+        }
 
-	(*input_handles[active_input])(input_structs[active_input], NULL);
 
 	// init drawing stuff
 	draw_init(&buf);
 
+	// draw_box and position_input are called because they need to be
+	// called before *input_handles[active_input] for the cursor to be
+	// positioned correctly
+	draw_box(&buf);
+	position_input(&buf, &desktop, &login, &password);
+	(*input_handles[active_input])(input_structs[active_input], NULL);
+
 	if (config.animate)
 	{
 		animate_init(&buf);
@@ -174,11 +184,13 @@ int main(int argc, char** argv)
 		{
 			if (auth_fails < 10)
 			{
+				(*input_handles[active_input])(input_structs[active_input], NULL);
 				tb_clear();
 				animate(&buf);
 				draw_box(&buf);
 				draw_labels(&buf);
-				draw_f_commands();
+				if(!config.hide_f1_commands)
+					draw_f_commands();
 				draw_lock_state(&buf);
 				position_input(&buf, &desktop, &login, &password);
 				draw_desktop(&desktop);
@@ -195,7 +207,11 @@ int main(int argc, char** argv)
 			tb_present();
 		}
 
-		error = tb_peek_event(&event, config.min_refresh_delta);
+		if (config.animate) {
+			error = tb_peek_event(&event, config.min_refresh_delta);
+		} else {
+			error = tb_poll_event(&event);
+		}
 
 		if (error < 0)
 		{
@@ -221,6 +237,7 @@ int main(int argc, char** argv)
 				if (active_input > 0)
 				{
 					input_text_clear(input_structs[active_input]);
+					update = true;
 				}
 				break;
 			case TB_KEY_ARROW_UP:
@@ -242,7 +259,7 @@ int main(int argc, char** argv)
 
 				if (active_input > 2)
 				{
-					active_input = PASSWORD_INPUT;
+					active_input = SESSION_SWITCH;
 				}
 				update = true;
 				break;