gui_main.c

Aqualung is an advanced music player primarily targeted for the GNU/Linux operating system, but als

		}
		return TRUE;
	case GDK_k:
	case GDK_K:
        	create_skin_window();
                return TRUE;
	case GDK_o:
	case GDK_O:
                create_options_window();
                return TRUE;
	case GDK_1:
	        if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(repeat_button)))
        		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(repeat_button), FALSE);
                else
        		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(repeat_button), TRUE);
                return TRUE;
	case GDK_2:
	        if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(repeat_all_button)))
        		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(repeat_all_button), FALSE);
                else
        		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(repeat_all_button), TRUE);
                return TRUE;
	case GDK_3:
	        if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(shuffle_button)))
        		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(shuffle_button), FALSE);
                else
        		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(shuffle_button), TRUE);
                return TRUE;
#ifdef HAVE_SYSTRAY
	case GDK_Escape:
		hide_all_windows(NULL);
		return TRUE;
#endif /* HAVE_SYSTRAY */
	}
	

        if (options.playlist_is_embedded) {
		playlist_window_key_pressed(widget, event);
        }

	return FALSE;
}


gint
main_window_key_released(GtkWidget * widget, GdkEventKey * event) {

        shift_state = event->state & GDK_SHIFT_MASK;

	switch (event->keyval) {
        case GDK_Right:
        case GDK_Left:
                if (is_file_loaded && allow_seeks && refresh_scale == 0) {
                        seek_t seek;

                        refresh_scale = 1;
                        send_cmd = CMD_SEEKTO;
                        seek.seek_to_pos = gtk_adjustment_get_value(GTK_ADJUSTMENT(adj_pos))
                                / 100.0f * total_samples;
                        rb_write(rb_gui2disk, &send_cmd, 1);
                        rb_write(rb_gui2disk, (char *)&seek, sizeof(seek_t));
			try_waking_disk_thread();
			refresh_scale_suppress = 2;
                }
                break;
	}

	return FALSE;
}


gint
main_window_focus_out(GtkWidget * widget, GdkEventFocus * event, gpointer data) {

        refresh_scale = 1;

        return FALSE;
}


gint
main_window_state_changed(GtkWidget * widget, GdkEventWindowState * event, gpointer data) {

        if (options.united_minimization) {

                if (event->new_window_state == GDK_WINDOW_STATE_ICONIFIED) {
                        if (browser_on) {
                                gtk_window_iconify(GTK_WINDOW(browser_window));
			}

                        if (!options.playlist_is_embedded && playlist_on) {
                                gtk_window_iconify(GTK_WINDOW(playlist_window));
			}

                        if (vol_window) {
                                gtk_window_iconify(GTK_WINDOW(vol_window));
			}

                        if (info_window) {
                                gtk_window_iconify(GTK_WINDOW(info_window));
			}

#ifdef HAVE_LADSPA
                        if (fxbuilder_on) {
                                GtkTreeIter iter;
                                gpointer gp_instance;
                                int i = 0;

                                gtk_window_iconify(GTK_WINDOW(fxbuilder_window));

                                while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(running_store), &iter, NULL, i) &&
                                       i < MAX_PLUGINS) {
                                        gtk_tree_model_get(GTK_TREE_MODEL(running_store), &iter, 1, &gp_instance, -1);
                                        gtk_widget_hide(((plugin_instance *)gp_instance)->window);
                                        ++i;
                                }
                        }
#endif /* HAVE_LADSPA */
                }

                if (event->new_window_state == 0) {
                        if (browser_on) {
                                gtk_window_deiconify(GTK_WINDOW(browser_window));
			}

                        if (!options.playlist_is_embedded && playlist_on) {
                                gtk_window_deiconify(GTK_WINDOW(playlist_window));
			}

                        if (vol_window) {
                                gtk_window_deiconify(GTK_WINDOW(vol_window));
			}

                        if (info_window) {
                                gtk_window_deiconify(GTK_WINDOW(info_window));
			}

                        if (fxbuilder_on) {
                                gtk_window_deiconify(GTK_WINDOW(fxbuilder_window));
			}
                }
        }	

        return FALSE;
}


gint
main_window_button_pressed(GtkWidget * widget, GdkEventButton * event) {

	if (event->button == 3) {

		GtkWidget * fileinfo;

		if (options.playlist_is_embedded) {
			fileinfo = plist__fileinfo;
		} else {
			fileinfo = conf__fileinfo;
		}

		if (is_file_loaded && (current_file[0] != '\0')) {

			const char * name = gtk_label_get_text(GTK_LABEL(label_title));

			strncpy(fileinfo_name, name, MAXLEN-1);
			strncpy(fileinfo_file, current_file, MAXLEN-1);

			gtk_widget_set_sensitive(fileinfo, TRUE);
		} else {
			gtk_widget_set_sensitive(fileinfo, FALSE);
		}

		if (options.playlist_is_embedded) {
			gtk_widget_set_sensitive(plist__rva, (vol_window == NULL) ? TRUE : FALSE);
		}

                gtk_menu_popup(GTK_MENU(conf_menu), NULL, NULL, NULL, NULL,
			       event->button, event->time);
	}

	return TRUE;
}


static gint
scale_button_press_event(GtkWidget * widget, GdkEventButton * event) {

	if (event->button == 3)
		return FALSE;

	if (!is_file_loaded)
		return FALSE;

	if (!allow_seeks)
		return FALSE;

	refresh_scale = 0;
	return FALSE;
}


static gint
scale_button_release_event(GtkWidget * widget, GdkEventButton * event) {

	seek_t seek;

	if (is_file_loaded) {
		
		if (!allow_seeks)
			return FALSE;
		
		if (refresh_scale == 0) {
			refresh_scale = 1;

			send_cmd = CMD_SEEKTO;
			seek.seek_to_pos = gtk_adjustment_get_value(GTK_ADJUSTMENT(adj_pos))
				/ 100.0f * total_samples;
			rb_write(rb_gui2disk, &send_cmd, 1);
			rb_write(rb_gui2disk, (char *)&seek, sizeof(seek_t));
			try_waking_disk_thread();
			refresh_scale_suppress = 2;
		}
	}

	return FALSE;
}


void
changed_pos(GtkAdjustment * adj, gpointer data) {

        char str[16];

	if (!is_file_loaded)
		gtk_adjustment_set_value(adj, 0.0f);

        if (options.enable_tooltips) {
                sprintf(str, _("Position: %d%%"), (gint)gtk_adjustment_get_value(GTK_ADJUSTMENT(adj))); 
                gtk_tooltips_set_tip (GTK_TOOLTIPS (aqualung_tooltips), scale_pos, str, NULL);
        }
}


gint
scale_vol_button_press_event(GtkWidget * widget, GdkEventButton * event) {

	char str[10];
	vol = gtk_adjustment_get_value(GTK_ADJUSTMENT(adj_vol));

        if(event->state & GDK_SHIFT_MASK) {  /* SHIFT */
		gtk_adjustment_set_value(GTK_ADJUSTMENT(adj_vol), 0);
		return TRUE;
	}

	if (vol < -40.5f) {
		sprintf(str, _("Mute"));
	} else {
		sprintf(str, _("%d dB"), (int)vol);
	}

	gtk_label_set_text(GTK_LABEL(time_labels[time_idx[0]]), str);
	
	refresh_time_label = 0;

	if (event->button == 3) {
		return TRUE;
	} else {
		return FALSE;
	}
}


void
changed_vol(GtkAdjustment * adj, gpointer date) {

	char str[10], str2[32];

	vol = gtk_adjustment_get_value(GTK_ADJUSTMENT(adj_vol));
	vol = (int)vol;
	gtk_adjustment_set_value(GTK_ADJUSTMENT(adj_vol), vol);

        if (vol < -40.5f) {
                sprintf(str, _("Mute"));
        } else {
                sprintf(str, _("%d dB"), (int)vol);
        }

        if(!shift_state && !refresh_time_label) {
		gtk_label_set_text(GTK_LABEL(time_labels[time_idx[0]]), str);
        }

        sprintf(str2, _("Volume: %s"), str);
        gtk_tooltips_set_tip (GTK_TOOLTIPS (aqualung_tooltips), scale_vol, str2, NULL);
}


gint
scale_vol_button_release_event(GtkWidget * widget, GdkEventButton * event) {

	refresh_time_label = 1;
	refresh_time_displays();

	return FALSE;
}


gint
scale_bal_button_press_event(GtkWidget * widget, GdkEventButton * event) {

	char str[10];
	bal = gtk_adjustment_get_value(GTK_ADJUSTMENT(adj_bal));

        if(event->state & GDK_SHIFT_MASK) {  /* SHIFT */
		gtk_adjustment_set_value(GTK_ADJUSTMENT(adj_bal), 0);
		return TRUE;
	}
	
	if (bal != 0.0f) {
		if (bal > 0.0f) {
			sprintf(str, _("%d%% R"), (int)bal);
		} else {
			sprintf(str, _("%d%% L"), -1*(int)bal);
		}
	} else {
		sprintf(str, _("C"));
	}

	gtk_label_set_text(GTK_LABEL(time_labels[time_idx[0]]), str);
	
	refresh_time_label = 0;

	if (event->button == 3) {
		return TRUE;
	} else {
		return FALSE;
	}
}


void
changed_bal(GtkAdjustment * adj, gpointer date) {

	char str[10], str2[32];

	bal = gtk_adjustment_get_value(GTK_ADJUSTMENT(adj_bal));
	bal = (int)bal;
	gtk_adjustment_set_value(GTK_ADJUSTMENT(adj_bal), bal);

        if (bal != 0.0f) {
                if (bal > 0.0f) {
                        sprintf(str, _("%d%% R"), (int)bal);
                } else {
                        sprintf(str, _("%d%% L"), -1*(int)bal);
                }
        } else {
                sprintf(str, _("C"));
        }
	
        if(!shift_state && !refresh_time_label) {  /* SHIFT */
		gtk_label_set_text(GTK_LABEL(time_labels[time_idx[0]]), str);
	}

        sprintf(str2, _("Balance: %s"), str);
        gtk_tooltips_set_tip (GTK_TOOLTIPS (aqualung_tooltips), scale_bal, str2, NULL);
}


gint
scale_bal_button_release_event(GtkWidget * widget, GdkEventButton * event) {

	refresh_time_label = 1;
	refresh_time_displays();

	return FALSE;
}


/******** Cue functions *********/

void
toggle_noeffect(int id, int state) {
	switch (id) {
	case PLAY:
		g_signal_handler_block(G_OBJECT(play_button), play_id);
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(play_button), state);
		g_signal_handler_unblock(G_OBJECT(play_button), play_id);
		break;
	case PAUSE:
		g_signal_handler_block(G_OBJECT(pause_button), pause_id);
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pause_button), state);
		g_signal_handler_unblock(G_OBJECT(pause_button), pause_id);
		break;
	default:
		printf("error in gui_main.c/toggle_without_effect(): unknown id value %d\n", id);
		break;
	}
}


void
mark_track(GtkTreeIter * piter) {

        int j, n;
        char * track_name;
	char *str;
        char counter[MAXLEN];
	char tmptrackname[MAXLEN];


	gtk_tree_model_get(GTK_TREE_MODEL(play_store), piter, 2, &str, -1);
	if (strcmp(str, pl_color_active) == 0) {
		g_free(str);
		return;
	}
	g_free(str);

        n = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(play_store), piter);

        if (n) {
		GtkTreeIter iter_child;

                gtk_tree_model_get(GTK_TREE_MODEL(play_store), piter, 0, &track_name, -1);
                strncpy(tmptrackname, track_name, MAXLEN-1);

                j = 0;
		while (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(play_store), &iter_child, piter, j++)) {
			gtk_tree_model_get(GTK_TREE_MODEL(play_store), &iter_child, 2, &str, -1);
			if (strcmp(str, pl_color_active) == 0) {
				g_free(str);
                                break;
			}
			g_free(str);
		}

		if (j > n) {
			return;
		}

                sprintf(counter, _(" (%d/%d)"), j, n);
                strncat(tmptrackname, counter, MAXLEN-1);
		gtk_tree_store_set(play_store, piter, 0, tmptrackname, -1);
                g_free(track_name);
        }

	gtk_tree_store_set(play_store, piter, 2, pl_color_active, -1);
	if (options.show_active_track_name_in_bold) {
		gtk_tree_store_set(play_store, piter, 7, PANGO_WEIGHT_BOLD, -1);
	}

	if (gtk_tree_store_iter_depth(play_store, piter)) { /* track node of album */
		GtkTreeIter iter_parent;

		gtk_tree_model_iter_parent(GTK_TREE_MODEL(play_store), &iter_parent, piter);
		mark_track(&iter_parent);
	}
}


void
unmark_track(GtkTreeIter * piter) {

	int n;

	gtk_tree_store_set(play_store, piter, 2, pl_color_inactive, -1);
	gtk_tree_store_set(play_store, piter, 7, PANGO_WEIGHT_NORMAL, -1);

        n = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(play_store), piter);

        if (n) {
		/* unmarking an album node: cut the counter string from the end */

		char * name;
		char * pack;
		int len1, len2;

		gtk_tree_model_get(GTK_TREE_MODEL(play_store), piter, 0, &name, 1, &pack, -1);

		sscanf(pack, "%04X%04X", &len1, &len2);

		/* the +2 in the index below is the length of the ": "
		   string which is put between the artist and album
		   names in music_browser.c: record_addlist_iter() */
		name[len1 + len2 + 2] = '\0';

		gtk_tree_store_set(play_store, piter, 0, name, -1);

		g_free(pack);
		g_free(name);
	}

	if (gtk_tree_store_iter_depth(play_store, piter)) { /* track node of album */
		GtkTreeIter iter_parent;

		gtk_tree_model_iter_parent(GTK_TREE_MODEL(play_store), &iter_parent, piter);
		unmark_track(&iter_parent);
	}
}


void
cue_track_for_playback(GtkTreeIter * piter, cue_t * cue) {

	char * str;

	gtk_tree_model_get(GTK_TREE_MODEL(play_store), piter, 1, &str, 3, &(cue->voladj), -1);
	cue->filename = strdup(str);
	strncpy(current_file, str, MAXLEN-1);
	g_free(str);
}


/* retcode for choose_X_track(): 1->success, 0->empty list */
int
choose_first_track(GtkTreeIter * piter) {

	if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(play_store), piter)) {
		if (gtk_tree_model_iter_has_child(GTK_TREE_MODEL(play_store), piter)) {
			GtkTreeIter iter_parent = *piter;
			gtk_tree_model_iter_children(GTK_TREE_MODEL(play_store), piter, &iter_parent);
		}
		return 1;
	}
	return 0;
}


/* get first or last child iter */
void
get_child_iter(GtkTreeIter * piter, int first) {
	
	GtkTreeIter iter;
	if (first) {