/*!
* sets all of the active time LEDs to the given color.
*
* @param[in] red (uint8_t): amount of red color to set all the active time LEDs to.
* @param[in] green (uint8_t): amount of green color to set all the active time LEDs to.
* @param[in] blue (uint8_t): amount of blue color to set all the active time LEDs to.
*/
void LED_set_color(uint8_t red, uint8_t blue, uint8_t green)
{
LED_admin_ptr->colors.red = red;
LED_admin_ptr->colors.green = green;
LED_admin_ptr->colors.blue = blue;
save_colors(&LED_admin_ptr->colors);
}
/**
* Remove all edge groups and clear the container.
*/
void
SnowModel::RemoveEdgeGroups()
{
/* Remember colors of the previous edge groups */
if (m_rememberColors == false) {
m_vecRememberedColors.clear();
// clear edge group collection
for (eg_it it = edge_groups.begin(); it != edge_groups.end(); ++it) {
if (*it) delete(*it);
}
// load last saved colors
load_colors();
}
else if (edge_groups.size() > 0) {
m_vecRememberedColors.clear();
// clear edge group collection
for (eg_it it = edge_groups.begin(); it != edge_groups.end(); ++it) {
if (*it) {
m_vecRememberedColors.push_back((*it)->GetEdgeGroupFaceColor());
delete(*it);
}
}
save_colors();
} else {
// if there are no edge groups, load the saved colors
load_colors();
}
edge_groups.clear();
}
void
edosu_beatmap_save_objects(EdosuBeatmap *beatmap, osux_beatmap *osux_bm)
{
save_hitobjects(beatmap, osux_bm);
save_timingpoints(beatmap, osux_bm);
save_events(beatmap, osux_bm);
save_colors(beatmap, osux_bm);
}
static void save_options(void)
{
XFILE *file;
long n;
int error = 0, h;
graf_mouse(HOURGLASS, NULL);
if ((file = x_fopen(optname, O_DENYRW | O_WRONLY, &error)) != NULL)
{
if ((n = x_fwrite(file, &options, sizeof(Options))) == sizeof(Options))
{
if (options.cprefs & SAVE_COLORS)
error = save_colors(file);
if (error == 0)
if ((error = dsk_save(file)) == 0)
if ((error = ft_save(file)) == 0)
if ((error = icnt_save(file)) == 0)
if ((error = app_save(file)) == 0)
if ((error = prg_save(file)) == 0)
error = wd_save(file);
}
else
error = (int) n;
if (((h = x_fclose(file)) < 0) && (error == 0))
error = h;
}
graf_mouse(ARROW, NULL);
if (error != 0)
hndl_error(MSAVECFG, error);
wd_set_update(WD_UPD_COPIED, optname, NULL);
wd_do_update();
}
/**
* Generates edge groups over the mesh.
*/
void SnowModel::generateEdgeGroups()
{
std::cout << "[Snow Model] Generating edge groups" << std::endl;
std::vector< std::set<Mesh::face*>* > candidate_meshes;
::Utilities::Timer t;
t.start();
/* clear the current edge group container */
RemoveEdgeGroups();
/* go through every mesh */
#pragma omp parallel for
for (unsigned int i=0; i < m_meshPool->getNrMeshs(); ++i) {
/* copy the whole mesh to work on it */
Mesh* tmpMesh = m_meshPool->getMesh(i);
Mesh::face* f = tmpMesh->mesh()->face_source;
candidate_meshes.clear();
/* init all marks to false */
do {
f->marked = false;
f = f->next_face;
} while (f != NULL);
std::cout << "\t*Growing edge groups...";
std::flush(std::cout);
int percent_step = static_cast<int>(tmpMesh->mesh()->number_faces * 0.1f);
int step = 10;
if (percent_step < 1)
{
step = static_cast<int>(100.0f / tmpMesh->mesh()->number_faces);
percent_step = 1;
}
unsigned int percent_count = 0;
int percent = 0;
int face_count = 0;
/* go through all faces */
f = tmpMesh->mesh()->face_source;
unsigned int eg_count = 0;
do {
if (face_count > percent_count)
{
std::cout << " " << percent;
std::flush(std::cout);
percent_count += percent_step;
percent += step;
}
/* get only those faces that could potentially get
* covered with snow (slope angle < 90� and facing outside) */
if (!f->marked) {
if (f->slope_angle < ( PI_2 - NearlyZero) )
{
++eg_count;
std::set<Mesh::face*> * candidate_mesh = new std::set<Mesh::face*>();
candidate_meshes.push_back(candidate_mesh);
/* find the candidate faces that are reachable
* from the current face */
find_candidates(f, candidate_mesh, tmpMesh);
face_count += candidate_mesh->size();
} else {
++face_count;
}
}
f = f->next_face;
} while (f != NULL);
std::cout << " ...ready" << std::endl << "\t*Initializating " << candidate_meshes.size() << " edge groups...";
std::flush(std::cout);
percent_step = static_cast<int>(candidate_meshes.size() * 0.1f);
step = 10;
if (percent_step < 1)
{
step = static_cast<int>(100.0f / candidate_meshes.size());
percent_step = 1;
}
percent_count = 0;
percent = 0;
for (unsigned int i = 0; i < candidate_meshes.size(); ++i) {
try {
//std::cout << "\tFound new edge group (#" << (i + 1) << ")" << std::endl;
// TODO: go through the found candidates and see if they overlap in Y-Order (top)
EdgeGroup* eg = new EdgeGroup(m_world, candidate_meshes[i], m_iLaunchSiteOptimizations);
if ( m_rememberColors && i < m_vecRememberedColors.size() ) {
eg->SetEdgeGroupFaceColor(m_vecRememberedColors[i]);
}
edge_groups.push_back(eg);
if (i == percent_count)
{
std::cout << " " << percent;
std::flush(std::cout);
percent_count += percent_step;
percent += step;
}
} catch (exception &e) {
std::cerr << "[Error] Error within the creation of EdgeGroup " << i + 1 << ": " << e.what() << std::endl;
}
}
std::cout << " ...ready" << std::endl;
if (m_rememberColors) {
save_colors();
}
}
t.stop();
std::cout << "\tTime: " << t.diffTimeInMSec() << "msec" << std::endl;
}
int main(int argc, char ** argv)
{
GtkWidget * vbox;
GtkWidget * hpaned;
GtkWidget * sc_win, * sc_buffer;
GtkWidget * menu_bar;
GtkWidget * file_menu, * file_item, * open_item, * save_item, * quit_item, * exp_img_item, * save_raw_data_item;
GtkWidget * generate_menu, * generate_item, * mandelbrot_item, * julia_item, * palette_item, * random_noise_item, * from_clipboard_item;
GtkWidget * settings_menu, * settings_item;
GtkWidget * zoom_box, * zoom_button;
//init general
colors = (color_t *)malloc(56 * sizeof(color_t));
memset(mdata, 0, BUFFER_COUNT * sizeof(unsigned char *));
memset(icons, 0, BUFFER_COUNT * sizeof(GtkWidget *));
memset(icon_event_boxes, 0, BUFFER_COUNT * sizeof(GtkWidget *));
mdata[current_buffer] = (unsigned char *)malloc(128 * 128);
char * templine = malloc(13);
FILE * fcolors = fopen("colors", "r");
int i, r, g, b;
for(i = 0; fgets(templine, 13, fcolors) == templine; i++)
{
sscanf(templine, "%i,%i,%i", &r, &g, &b);
color_t color = {r, g, b};
colors[i] = color;
}
free(templine);
fclose(fcolors);
save_colors(colors, "colors.bin");
//load_colors(colors, "colors.bin");
srand(time(NULL));
config = config_new();
//init gtk
gtk_init(&argc, &argv);
//window
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "ImageToMap X v" VERSION_NUMBER);
g_signal_connect(window, "delete_event", G_CALLBACK(kill_window), NULL);
//vbox
#ifdef GTK2
vbox = gtk_vbox_new(FALSE, 0);
#else
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#endif
gtk_container_add(GTK_CONTAINER (window), vbox);
gtk_widget_show(vbox);
//////menu_bar
menu_bar = gtk_menu_bar_new();
gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, TRUE, 0);
gtk_widget_show(menu_bar);
////////file_menu
file_menu = gtk_menu_new();
//////////open_item
open_item = gtk_menu_item_new_with_label("Open");
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), open_item);
gtk_widget_show(open_item);
g_signal_connect_swapped (open_item, "activate",
G_CALLBACK (button_click),
(gpointer) "button.open");
//////////save_item
save_item = gtk_menu_item_new_with_label("Save");
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), save_item);
gtk_widget_show(save_item);
g_signal_connect_swapped (save_item, "activate",
G_CALLBACK (button_click),
(gpointer) "button.save");
//////////save_raw_data_item
save_raw_data_item = gtk_menu_item_new_with_label("Save Raw Map");
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), save_raw_data_item);
gtk_widget_show(save_raw_data_item);
g_signal_connect_swapped (save_raw_data_item, "activate",
G_CALLBACK (button_click),
(gpointer) "button.save_rm");
//////////exp_img_item
exp_img_item = gtk_menu_item_new_with_label("Export Image");
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), exp_img_item);
gtk_widget_show(exp_img_item);
g_signal_connect_swapped(exp_img_item, "activate",
G_CALLBACK (button_click),
(gpointer) "button.exp_img");
//////////quit_item
quit_item = gtk_menu_item_new_with_label("Quit");
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), quit_item);
gtk_widget_show(quit_item);
g_signal_connect_swapped (quit_item, "activate",
G_CALLBACK(kill_window),
(gpointer)"button.quit");
/////////file_item
file_item = gtk_menu_item_new_with_label("File");
gtk_widget_show(file_item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file_item), file_menu);
gtk_menu_shell_append((GtkMenuShell *)menu_bar, file_item);
////////generate_menu
generate_menu = gtk_menu_new();
//////////mandelbrot_item
mandelbrot_item = gtk_menu_item_new_with_label("Mandelbrot");
gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), mandelbrot_item);
gtk_widget_show(mandelbrot_item);
g_signal_connect_swapped(mandelbrot_item, "activate",
G_CALLBACK(button_click),
(gpointer) "button.mandelbrot");
//////////julia_item
julia_item = gtk_menu_item_new_with_label("Julia");
gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), julia_item);
gtk_widget_show(julia_item);
g_signal_connect_swapped(julia_item, "activate",
G_CALLBACK (button_click),
(gpointer) "button.julia");
//////////palette_item
palette_item = gtk_menu_item_new_with_label("Palette");
gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), palette_item);
gtk_widget_show(palette_item);
g_signal_connect_swapped(palette_item, "activate",
G_CALLBACK(button_click),
(gpointer)"button.palette");
//////////random_noise_item
random_noise_item = gtk_menu_item_new_with_label("Random Noise");
gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), random_noise_item);
gtk_widget_show(random_noise_item);
g_signal_connect_swapped(random_noise_item, "activate",
G_CALLBACK(button_click),
(gpointer)"button.random_noise");
//////////from_clipboard_item
from_clipboard_item = gtk_menu_item_new_with_label("From Clipboard");
gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), from_clipboard_item);
gtk_widget_show(from_clipboard_item);
g_signal_connect_swapped(from_clipboard_item, "activate",
G_CALLBACK(button_click),
(gpointer)"button.from_clipboard");
/////////generate_item
generate_item = gtk_menu_item_new_with_label("Generate");
gtk_widget_show(generate_item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(generate_item), generate_menu);
gtk_menu_shell_append((GtkMenuShell *)menu_bar, generate_item);
////////settings_menu
settings_menu = gtk_menu_new();
////////settings_item
settings_item = gtk_menu_item_new_with_label("Settings");
gtk_widget_show(settings_item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(settings_item), settings_menu);
gtk_menu_shell_append((GtkMenuShell *)menu_bar, settings_item);
//////////FSD_checkbox
FSD_checkbox = gtk_check_menu_item_new_with_label("Floyd–Steinberg dithering");
gtk_menu_shell_append(GTK_MENU_SHELL(settings_menu), FSD_checkbox);
gtk_widget_show(FSD_checkbox);
//drop_down_menu
init_drop_down_menu();
//hpaned
#ifdef GTK2
hpaned = gtk_hpaned_new();
#else
hpaned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
#endif
gtk_widget_set_size_request (hpaned, 220, -1);
gtk_box_pack_start(GTK_BOX(vbox), hpaned, TRUE, TRUE, 0);
gtk_widget_show(hpaned);
////sc_buffer
sc_buffer = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sc_buffer), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
#ifdef GTK2
gtk_widget_set_size_request(sc_buffer, 128 + 32, 512);
#else
gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(sc_buffer), 128 + 32);
gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sc_buffer), 512);
#endif
gtk_paned_pack2(GTK_PANED(hpaned), sc_buffer, FALSE, FALSE);
gtk_widget_show(sc_buffer);
//////list_vbox
#ifdef GTK2
list_vbox = gtk_vbox_new(FALSE, 0);
#else
list_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#endif
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sc_buffer), list_vbox);
gtk_widget_show(list_vbox);
////sc_win
sc_win = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sc_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
#ifdef GTK2
gtk_widget_set_size_request(sc_win, 128 * 4, 128 * 4);
gtk_window_resize(GTK_WINDOW(window), 128 * 4 + 200, 128 * 4 + 70);
#else
gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(sc_win), 128 * 4);
gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sc_win), 128 * 4);
#endif
gtk_paned_pack1(GTK_PANED(hpaned), sc_win, TRUE, FALSE);
gtk_widget_show(sc_win);
//////image
dimage = gdk_pixbuf_new_from_file("start.png", NULL);
image = gtk_image_new();
gtk_image_set_from_pixbuf(GTK_IMAGE(image), dimage);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sc_win), image);
gtk_widget_show(image);
////zoom_box
#ifdef GTK2
zoom_box = gtk_hbox_new(FALSE, 0);
#else
zoom_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#endif
gtk_box_pack_start(GTK_BOX(vbox), zoom_box, FALSE, FALSE, 0);
gtk_widget_show(zoom_box);
//////zoom_button (+)
zoom_button = gtk_button_new_with_label("+");
gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2);
g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoomp");
gtk_widget_show(zoom_button);
//////zoom_button (|)
zoom_button = gtk_button_new_with_label("|");
gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2);
g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoome");
gtk_widget_show(zoom_button);
//////zoom_button (-)
zoom_button = gtk_button_new_with_label("-");
gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2);
g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoomm");
gtk_widget_show(zoom_button);
//icon
gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("imagetomap.ico"));
//display window
gtk_widget_show (window);
gtk_main();
//clean up
free(colors);
for(i = 0; i < BUFFER_COUNT; i++)
free(mdata[i]);
config_free(config);
return 0;
}
/*
* Given an XEvent, process it if it pertains to a ColorBar, else do
* nothing with it.
* Input: event - the X event
* Output: whichcb - which colorbar this event pertained to.
* Return: 1 - if color table was changed.
* 2 - if reset key was pressed
* 3 - if <shift>+reset key was pressed
* 0 - if no change
*/
static int colorbar_process( LUI_COLORBAR *cb, XEvent *event )
{
static int p1 = 0, p2 = 0, p3 = 0, p4 = 0; /* red, green, blue, alpha */
static int pentry;
int i, modify, entry, result;
static int move_marker;
result = modify = 0;
if (event->type==KeyPress) {
char keybuf[50];
KeySym key;
XComposeStatus compose;
int count;
count = XLookupString( &event->xkey, keybuf, 50, &key, &compose );
if (count==1) {
if (keybuf[0]=='r') {
/* Reset RGB */
cb->params[DRAWFLAG] = 0.0;
result = LUI_RGB_RESET;
}
else if (keybuf[0]=='R') {
/* Reset alpha */
result = LUI_ALPHA_RESET;
cb->params[DRAWFLAG] = 0.0;
}
else if (keybuf[0]=='c' || keybuf[0]=='C') {
/* Copy current colors to clipboard */
copy_colors( cb );
}
else if (keybuf[0]=='p' || keybuf[0]=='P') {
/* Paste clipboard colors to current color widget */
paste_colors( cb );
LUI_ColorBarRedraw( cb );
result = LUI_RGB_CHANGE | LUI_ALPHA_CHANGE;
cb->params[DRAWFLAG] = 0.0;
result = LUI_RGB_CHANGE | LUI_ALPHA_CHANGE;
}
/* WLH 7-18-96 */
else if (keybuf[0]=='s' || keybuf[0]=='S') {
/* save colors to a file */
save_colors( cb );
}
else if (keybuf[0]=='l' || keybuf[0]=='L') {
/* load colors from a file */
load_colors( cb );
LUI_ColorBarRedraw( cb );
return 1;
}
else {
/* if unused key, toggle help display */
cb->helpflag = !cb->helpflag;
LUI_ColorBarRedraw( cb );
}
}
else if (key == XK_Left) {
/* rotate left */
cb->params[BIAS] -= 0.03/cb->params[CURVE];
result = LUI_RGB_SHAPE;
cb->params[DRAWFLAG] = 0.0;
}
else if (key == XK_Right) {
/* rotate right */
cb->params[BIAS] += 0.03/cb->params[CURVE];
result = LUI_RGB_SHAPE;
cb->params[DRAWFLAG] = 0.0;
}
else if (key == XK_Up) {
/* expand color map */
if (event->xkey.state & ANY_MODIFIER) {
cb->params[ALPHAPOW] -= 0.1;
if (cb->params[ALPHAPOW]<0.0)
cb->params[ALPHAPOW] = 0.0;
result = LUI_ALPHA_SHAPE;
cb->params[DRAWFLAG] = 0.0;
}
else {
cb->params[CURVE] -= 0.1;
result = LUI_RGB_SHAPE;
cb->params[DRAWFLAG] = 0.0;
}
}
else if (key == XK_Down) {
/* compress color map */
if (event->xkey.state & ANY_MODIFIER) {
cb->params[ALPHAPOW] += 0.1;
result = LUI_ALPHA_SHAPE;
cb->params[DRAWFLAG] = 0.0;
}
else {
cb->params[CURVE] += 0.1;
result = LUI_RGB_SHAPE;
cb->params[DRAWFLAG] = 0.0;
}
}
}
else if (event->type==Expose && event->xexpose.count==0) {
LUI_ColorBarRedraw( cb );
result = 0;
}
else if (event->type==ConfigureNotify) {
/* MJK 4.15.99 */
LUI_ColorBarSetSize( cb, event->xconfigure.width, event->xconfigure.height );
result = 0;
}
else if (event->type==ButtonPress ) {
if (event->xbutton.y<cb->wedge_y) {
/* change color function */
move_marker = 0;
}
else {
/* change marker position */
move_marker = 1;
}
/* determine which curve to modify */
if (event->xbutton.state&ANY_MODIFIER) {
p4 = 1;
}
else {
if (event->xbutton.button==Button1) p1 = 1;
if (event->xbutton.button==Button2) p2 = 1;
if (event->xbutton.button==Button3) p3 = 1;
}
pentry = x_to_index( cb, event->xbutton.x );
modify = 1;
}
else if (event->type==ButtonRelease) {
if (p1 || p2 || p3) {
result = LUI_RGB_CHANGE;
}
else {
result = LUI_ALPHA_CHANGE;
}
if (event->xbutton.button==Button1) p1 = 0;
if (event->xbutton.button==Button2) p2 = 0;
if (event->xbutton.button==Button3) p3 = 0;
p4 = 0;
}
else if (event->type==MotionNotify) {
/* Flush extra MotionNotify events */
while (QLength(LUI_Display)>0) {
XEvent next;
XPeekEvent(LUI_Display, &next);
if (next.type!=MotionNotify)
break;
XNextEvent(LUI_Display, event);
}
modify = 1;
}
/* Modify one or more of the color curves */
if (modify && (p1 || p2 || p3 || p4)) {
/* calculate which entry in color table to change */
entry = x_to_index( cb, event->xbutton.x );
/* update */
if (move_marker) {
/* changing marker position */
cb->markerpos = entry;
redraw_marker( cb );
}
else {
/* changing color graph */
int a, b, value;
value = y_to_intensity( cb, event->xbutton.y );
if (pentry<=entry) {
a = pentry;
b = entry;
}
else {
a = entry;
b = pentry;
}
/* update entries from 'pentry' to 'entry' */
for (i=a; i<=b; i++) {
int red, green, blue, alpha;
red = UNPACK_RED(cb->table[i]);
green = UNPACK_GREEN(cb->table[i]);
blue = UNPACK_BLUE(cb->table[i]);
alpha = UNPACK_ALPHA(cb->table[i]);
if (p1) {
/* modify red */
red = value;
}
if (p2) {
/* modify green */
green = value;
}
if (p3) {
/* modify blue */
blue = value;
}
if (p4) {
/* modify alpha */
alpha = value;
}
/* change the color table entry */
cb->table[i] = PACK_COLOR(red,green,blue,alpha);
} /* for */
/* redraw the color curves */
if (pentry<entry)
redraw_range( cb, pentry-1, entry+1 );
else
redraw_range( cb, entry-1, pentry+1 );
pentry = entry;
if (p4) {
/* update min,max alpha values */
cb->minalpha = 256;
cb->maxalpha = 0;
for (i=0;i<cb->table_size;i++) {
int a = UNPACK_ALPHA( cb->table[i] );
if (a<cb->minalpha) cb->minalpha = a;
if (a>cb->maxalpha) cb->maxalpha = a;
}
}
if (p4) {
result = LUI_ALPHA_MODIFY;
/*
result = LUI_ALPHA_CHANGE;
*/
}
else {
result = LUI_RGB_MODIFY;
/*
result = LUI_RGB_CHANGE;
*/
}
cb->params[DRAWFLAG] = 1.0;
}
} /*modify*/
if (result!=0 && cb->callback) {
(*cb->callback)(cb, result);
}
return result;
}
