/* ===============================================================
*
* BUTTON DEMO
*
* ===============================================================*/
static void
ui_header(struct nk_context *ctx, struct media *media, const char *title)
{
nk_style_set_font(ctx, &media->font_18->handle);
nk_layout_row_dynamic(ctx, 20, 1);
nk_label(ctx, title, NK_TEXT_LEFT);
}
void draw_thread_popup(struct nk_context *ctx, int *show_thread_popup)
{
static struct nk_rect s = { 100, 100, 300, 175 };
static const float ratio[] = { 0.85f, 0.15f };
if (nk_popup_begin(ctx, NK_POPUP_STATIC, "File Read Error",
NK_WINDOW_TITLE | NK_WINDOW_NO_SCROLLBAR | NK_WINDOW_BORDER, s))
{
nk_layout_row_dynamic(ctx, 25, 1);
nk_label(ctx, "Cannot read file.", NK_TEXT_CENTERED);
nk_layout_row_dynamic(ctx, 60, 1);
nk_label_wrap(ctx, "Make sure the directory isn't write protected OR you are running the program with write permissions.");
nk_layout_row(ctx, NK_DYNAMIC, 25, 2, ratio);
nk_spacing(ctx, 1);
if(nk_button_label(ctx, "OK"))
{
*show_thread_popup = nk_false;
nk_popup_close(ctx);
}
nk_popup_end(ctx);
}
else
*show_thread_popup = nk_false;
}
void nk_menu_wnd_test(nk_menu_handle_t *zr)
{
struct nk_panel layout;
struct nk_context *ctx = &zr->ctx;
const int id = ZRMENU_WND_TEST;
settings_t *settings = config_get_ptr();
if (nk_begin(ctx, &layout, "Test", nk_rect(140, 90, 500, 600),
NK_WINDOW_CLOSABLE|NK_WINDOW_MINIMIZABLE|NK_WINDOW_MOVABLE|
NK_WINDOW_SCALABLE|NK_WINDOW_BORDER))
{
unsigned size;
struct nk_panel combo;
menu_entry_t entry;
static const char *themes[] = {"Dark", "Light"};
enum nk_menu_theme old = zr->theme;
nk_layout_row_dynamic(ctx, 30, 2);
nk_layout_row_dynamic(ctx, 30, 4);
//nk_checkbox_bool(ctx, "Show FPS", &(settings->fps_show));
//nk_checkbox_bool(ctx, "Show FPS", &(settings->fps_show));
//nk_checkbox_bool(ctx, "Show FPS", &(settings->fps_show));
//nk_checkbox_bool(ctx, "Show FPS", &(settings->fps_show));
nk_layout_row_dynamic(ctx, 30, 2);
nk_label(ctx, "Volume:", NK_TEXT_LEFT);
nk_slider_float(ctx, -80, &settings->audio.volume, 12, 0.5);
nk_layout_row_dynamic(ctx, 30, 1);
nk_property_int(ctx, "Max Users:", 1, (int*)&(settings->input.max_users),
MAX_USERS, 1, 1);
nk_label(ctx, "History:", NK_TEXT_LEFT);
size = menu_entries_get_size();
}
/* save position and size to restore after context reset */
nk_menu_set_state(zr, id, nk_window_get_position(ctx), nk_window_get_size(ctx));
nk_end(ctx);
}
/* ===============================================================
*
* GRID
*
* ===============================================================*/
static void
grid_demo(struct nk_context *ctx, struct media *media)
{
static char text[3][64];
static int text_len[3];
static const char *items[] = {"Item 0","item 1","item 2"};
static int selected_item = 0;
static int check = 1;
int i;
nk_style_set_font(ctx, &media->font_20->handle);
if (nk_begin(ctx, "Grid Demo", nk_rect(600, 350, 275, 250),
NK_WINDOW_TITLE|NK_WINDOW_BORDER|NK_WINDOW_MOVABLE|
NK_WINDOW_NO_SCROLLBAR))
{
nk_style_set_font(ctx, &media->font_18->handle);
nk_layout_row_dynamic(ctx, 30, 2);
nk_label(ctx, "Floating point:", NK_TEXT_RIGHT);
nk_edit_string(ctx, NK_EDIT_FIELD, text[0], &text_len[0], 64, nk_filter_float);
nk_label(ctx, "Hexadecimal:", NK_TEXT_RIGHT);
nk_edit_string(ctx, NK_EDIT_FIELD, text[1], &text_len[1], 64, nk_filter_hex);
nk_label(ctx, "Binary:", NK_TEXT_RIGHT);
nk_edit_string(ctx, NK_EDIT_FIELD, text[2], &text_len[2], 64, nk_filter_binary);
nk_label(ctx, "Checkbox:", NK_TEXT_RIGHT);
nk_checkbox_label(ctx, "Check me", &check);
nk_label(ctx, "Combobox:", NK_TEXT_RIGHT);
if (nk_combo_begin_label(ctx, items[selected_item], nk_vec2(nk_widget_width(ctx), 200))) {
nk_layout_row_dynamic(ctx, 25, 1);
for (i = 0; i < 3; ++i)
if (nk_combo_item_label(ctx, items[i], NK_TEXT_LEFT))
selected_item = i;
nk_combo_end(ctx);
}
}
nk_end(ctx);
nk_style_set_font(ctx, &media->font_14->handle);
}
int main(void)
{
struct nk_context *ctx;
struct nk_color background;
WNDCLASSW wc;
RECT rect = { 0, 0, WINDOW_WIDTH, WINDOW_HEIGHT };
DWORD style = WS_OVERLAPPEDWINDOW;
DWORD exstyle = WS_EX_APPWINDOW;
HWND wnd;
int running = 1;
HRESULT hr;
D3D_FEATURE_LEVEL feature_level;
DXGI_SWAP_CHAIN_DESC swap_chain_desc;
/* Win32 */
memset(&wc, 0, sizeof(wc));
wc.lpfnWndProc = WindowProc;
wc.hInstance = GetModuleHandleW(0);
wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.lpszClassName = L"NuklearWindowClass";
RegisterClassW(&wc);
AdjustWindowRectEx(&rect, style, FALSE, exstyle);
wnd = CreateWindowExW(exstyle, wc.lpszClassName, L"Nuklear Demo",
style | WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT,
rect.right - rect.left, rect.bottom - rect.top,
NULL, NULL, wc.hInstance, NULL);
/* D3D11 setup */
memset(&swap_chain_desc, 0, sizeof(swap_chain_desc));
swap_chain_desc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
swap_chain_desc.BufferDesc.RefreshRate.Numerator = 60;
swap_chain_desc.BufferDesc.RefreshRate.Denominator = 1;
swap_chain_desc.SampleDesc.Count = 1;
swap_chain_desc.SampleDesc.Quality = 0;
swap_chain_desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swap_chain_desc.BufferCount = 1;
swap_chain_desc.OutputWindow = wnd;
swap_chain_desc.Windowed = TRUE;
swap_chain_desc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
swap_chain_desc.Flags = 0;
if (FAILED(D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE,
NULL, 0, NULL, 0, D3D11_SDK_VERSION, &swap_chain_desc,
&swap_chain, &device, &feature_level, &context)))
{
/* if hardware device fails, then try WARP high-performance
software rasterizer, this is useful for RDP sessions */
hr = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_WARP,
NULL, 0, NULL, 0, D3D11_SDK_VERSION, &swap_chain_desc,
&swap_chain, &device, &feature_level, &context);
assert(SUCCEEDED(hr));
}
set_swap_chain_size(WINDOW_WIDTH, WINDOW_HEIGHT);
/* GUI */
ctx = nk_d3d11_init(device, WINDOW_WIDTH, WINDOW_HEIGHT, MAX_VERTEX_BUFFER, MAX_INDEX_BUFFER);
/* Load Fonts: if none of these are loaded a default font will be used */
{struct nk_font_atlas *atlas;
nk_d3d11_font_stash_begin(&atlas);
/*struct nk_font *droid = nk_font_atlas_add_from_file(atlas, "../../../extra_font/DroidSans.ttf", 14, 0);*/
/*struct nk_font *robot = nk_font_atlas_add_from_file(atlas, "../../../extra_font/Robot-Regular.ttf", 14, 0);*/
/*struct nk_font *future = nk_font_atlas_add_from_file(atlas, "../../../extra_font/kenvector_future_thin.ttf", 13, 0);*/
/*struct nk_font *clean = nk_font_atlas_add_from_file(atlas, "../../../extra_font/ProggyClean.ttf", 12, 0);*/
/*struct nk_font *tiny = nk_font_atlas_add_from_file(atlas, "../../../extra_font/ProggyTiny.ttf", 10, 0);*/
/*struct nk_font *cousine = nk_font_atlas_add_from_file(atlas, "../../../extra_font/Cousine-Regular.ttf", 13, 0);*/
nk_d3d11_font_stash_end();
/*nk_style_set_font(ctx, &droid->handle)*/;}
/* style.c */
/*set_style(ctx, THEME_WHITE);*/
/*set_style(ctx, THEME_RED);*/
/*set_style(ctx, THEME_BLUE);*/
/*set_style(ctx, THEME_DARK);*/
background = nk_rgb(28,48,62);
while (running)
{
/* Input */
MSG msg;
nk_input_begin(ctx);
while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
{
if (msg.message == WM_QUIT)
running = 0;
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
nk_input_end(ctx);
/* GUI */
{struct nk_panel layout;
if (nk_begin(ctx, &layout, "Demo", nk_rect(50, 50, 230, 250),
NK_WINDOW_BORDER|NK_WINDOW_MOVABLE|NK_WINDOW_SCALABLE|
NK_WINDOW_MINIMIZABLE|NK_WINDOW_TITLE))
{
enum {EASY, HARD};
static int op = EASY;
static int property = 20;
nk_layout_row_static(ctx, 30, 80, 1);
if (nk_button_label(ctx, "button", NK_BUTTON_DEFAULT))
fprintf(stdout, "button pressed\n");
nk_layout_row_dynamic(ctx, 30, 2);
if (nk_option_label(ctx, "easy", op == EASY)) op = EASY;
if (nk_option_label(ctx, "hard", op == HARD)) op = HARD;
nk_layout_row_dynamic(ctx, 22, 1);
nk_property_int(ctx, "Compression:", 0, &property, 100, 10, 1);
{struct nk_panel combo;
nk_layout_row_dynamic(ctx, 20, 1);
nk_label(ctx, "background:", NK_TEXT_LEFT);
nk_layout_row_dynamic(ctx, 25, 1);
if (nk_combo_begin_color(ctx, &combo, background, 400)) {
nk_layout_row_dynamic(ctx, 120, 1);
background = nk_color_picker(ctx, background, NK_RGBA);
nk_layout_row_dynamic(ctx, 25, 1);
background.r = (nk_byte)nk_propertyi(ctx, "#R:", 0, background.r, 255, 1,1);
background.g = (nk_byte)nk_propertyi(ctx, "#G:", 0, background.g, 255, 1,1);
background.b = (nk_byte)nk_propertyi(ctx, "#B:", 0, background.b, 255, 1,1);
background.a = (nk_byte)nk_propertyi(ctx, "#A:", 0, background.a, 255, 1,1);
nk_combo_end(ctx);
}}
}
nk_end(ctx);}
if (nk_window_is_closed(ctx, "Demo")) break;
/* -------------- EXAMPLES ---------------- */
/*calculator(ctx);*/
/*overview(ctx);*/
/*node_editor(ctx);*/
/* ----------------------------------------- */
{/* Draw */
float bg[4];
nk_color_fv(bg, background);
ID3D11DeviceContext_ClearRenderTargetView(context, rt_view, bg);
ID3D11DeviceContext_OMSetRenderTargets(context, 1, &rt_view, NULL);
nk_d3d11_render(context, NK_ANTI_ALIASING_ON);
hr = IDXGISwapChain_Present(swap_chain, 1, 0);
if (hr == DXGI_ERROR_DEVICE_RESET || hr == DXGI_ERROR_DEVICE_REMOVED) {
/* to recover from this, you'll need to recreate device and all the resources */
MessageBoxW(NULL, L"D3D11 device is lost or removed!", L"Error", 0);
break;
} else if (hr == DXGI_STATUS_OCCLUDED) {
/* window is not visible, so vsync won't work. Let's sleep a bit to reduce CPU usage */
Sleep(10);
}
assert(SUCCEEDED(hr));}
}
ID3D11DeviceContext_ClearState(context);
nk_d3d11_shutdown();
ID3D11ShaderResourceView_Release(rt_view);
ID3D11DeviceContext_Release(context);
ID3D11Device_Release(device);
IDXGISwapChain_Release(swap_chain);
UnregisterClassW(wc.lpszClassName, wc.hInstance);
return 0;
}
int main(void)
{
/* Platform */
static GLFWwindow *win;
int width = 0, height = 0;
struct nk_context *ctx;
struct nk_color background;
/* GLFW */
glfwSetErrorCallback(error_callback);
if (!glfwInit()) {
fprintf(stdout, "[GFLW] failed to init!\n");
exit(1);
}
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
#ifdef __APPLE__
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#endif
win = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, "Demo", NULL, NULL);
glfwMakeContextCurrent(win);
glfwGetWindowSize(win, &width, &height);
/* OpenGL */
glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);
glewExperimental = 1;
if (glewInit() != GLEW_OK) {
fprintf(stderr, "Failed to setup GLEW\n");
exit(1);
}
ctx = nk_glfw3_init(win, NK_GLFW3_INSTALL_CALLBACKS);
/* Load Fonts: if none of these are loaded a default font will be used */
{struct nk_font_atlas *atlas;
nk_glfw3_font_stash_begin(&atlas);
/*struct nk_font *droid = nk_font_atlas_add_from_file(atlas, "../../../extra_font/DroidSans.ttf", 14, 0);*/
/*struct nk_font *roboto = nk_font_atlas_add_from_file(atlas, "../../../extra_font/Roboto-Regular.ttf", 14, 0);*/
/*struct nk_font *future = nk_font_atlas_add_from_file(atlas, "../../../extra_font/kenvector_future_thin.ttf", 13, 0);*/
/*struct nk_font *clean = nk_font_atlas_add_from_file(atlas, "../../../extra_font/ProggyClean.ttf", 12, 0);*/
/*struct nk_font *tiny = nk_font_atlas_add_from_file(atlas, "../../../extra_font/ProggyTiny.ttf", 10, 0);*/
/*struct nk_font *cousine = nk_font_atlas_add_from_file(atlas, "../../../extra_font/Cousine-Regular.ttf", 13, 0);*/
nk_glfw3_font_stash_end();
/*nk_style_set_font(ctx, &droid->handle);*/}
background = nk_rgb(28,48,62);
while (!glfwWindowShouldClose(win))
{
/* Input */
glfwPollEvents();
nk_glfw3_new_frame();
/* GUI */
{struct nk_panel layout;
if (nk_begin(ctx, &layout, "Demo", nk_rect(50, 50, 230, 250),
NK_WINDOW_BORDER|NK_WINDOW_MOVABLE|NK_WINDOW_SCALABLE|
NK_WINDOW_MINIMIZABLE|NK_WINDOW_TITLE))
{
enum {EASY, HARD};
static int op = EASY;
static int property = 20;
nk_layout_row_static(ctx, 30, 80, 1);
if (nk_button_label(ctx, "button", NK_BUTTON_DEFAULT))
fprintf(stdout, "button pressed\n");
nk_layout_row_dynamic(ctx, 30, 2);
if (nk_option_label(ctx, "easy", op == EASY)) op = EASY;
if (nk_option_label(ctx, "hard", op == HARD)) op = HARD;
nk_layout_row_dynamic(ctx, 25, 1);
nk_property_int(ctx, "Compression:", 0, &property, 100, 10, 1);
{struct nk_panel combo;
nk_layout_row_dynamic(ctx, 20, 1);
nk_label(ctx, "background:", NK_TEXT_LEFT);
nk_layout_row_dynamic(ctx, 25, 1);
if (nk_combo_begin_color(ctx, &combo, background, 400)) {
nk_layout_row_dynamic(ctx, 120, 1);
background = nk_color_picker(ctx, background, NK_RGBA);
nk_layout_row_dynamic(ctx, 25, 1);
background.r = (nk_byte)nk_propertyi(ctx, "#R:", 0, background.r, 255, 1,1);
background.g = (nk_byte)nk_propertyi(ctx, "#G:", 0, background.g, 255, 1,1);
background.b = (nk_byte)nk_propertyi(ctx, "#B:", 0, background.b, 255, 1,1);
background.a = (nk_byte)nk_propertyi(ctx, "#A:", 0, background.a, 255, 1,1);
nk_combo_end(ctx);
}}
}
nk_end(ctx);}
/* Draw */
{float bg[4];
nk_color_fv(bg, background);
glfwGetWindowSize(win, &width, &height);
glViewport(0, 0, width, height);
glClear(GL_COLOR_BUFFER_BIT);
glClearColor(bg[0], bg[1], bg[2], bg[3]);
nk_glfw3_render(NK_ANTI_ALIASING_ON, MAX_VERTEX_BUFFER, MAX_ELEMENT_BUFFER);
glfwSwapBuffers(win);}
}
nk_glfw3_shutdown();
glfwTerminate();
return 0;
}
int main(void)
{
int jid, hat_buttons = GLFW_FALSE;
struct nk_context* nk;
struct nk_font_atlas* atlas;
memset(joysticks, 0, sizeof(joysticks));
glfwSetErrorCallback(error_callback);
if (!glfwInit())
exit(EXIT_FAILURE);
window = glfwCreateWindow(800, 600, "Joystick Test", NULL, NULL);
if (!window)
{
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwMakeContextCurrent(window);
gladLoadGLLoader((GLADloadproc) glfwGetProcAddress);
glfwSwapInterval(1);
nk = nk_glfw3_init(window, NK_GLFW3_INSTALL_CALLBACKS);
nk_glfw3_font_stash_begin(&atlas);
nk_glfw3_font_stash_end();
for (jid = GLFW_JOYSTICK_1; jid <= GLFW_JOYSTICK_LAST; jid++)
{
if (glfwJoystickPresent(jid))
joysticks[joystick_count++] = jid;
}
glfwSetJoystickCallback(joystick_callback);
while (!glfwWindowShouldClose(window))
{
int i, width, height;
glfwGetWindowSize(window, &width, &height);
glClear(GL_COLOR_BUFFER_BIT);
nk_glfw3_new_frame();
if (nk_begin(nk,
"Joysticks",
nk_rect(width - 200.f, 0.f, 200.f, (float) height),
NK_WINDOW_MINIMIZABLE |
NK_WINDOW_TITLE))
{
nk_layout_row_dynamic(nk, 30, 1);
nk_checkbox_label(nk, "Hat buttons", &hat_buttons);
if (joystick_count)
{
for (i = 0; i < joystick_count; i++)
{
if (nk_button_label(nk, joystick_label(joysticks[i])))
nk_window_set_focus(nk, joystick_label(joysticks[i]));
}
}
else
nk_label(nk, "No joysticks connected", NK_TEXT_LEFT);
}
nk_end(nk);
for (i = 0; i < joystick_count; i++)
{
if (nk_begin(nk,
joystick_label(joysticks[i]),
nk_rect(i * 20.f, i * 20.f, 550.f, 570.f),
NK_WINDOW_BORDER |
NK_WINDOW_MOVABLE |
NK_WINDOW_SCALABLE |
NK_WINDOW_MINIMIZABLE |
NK_WINDOW_TITLE))
{
int j, axis_count, button_count, hat_count;
const float* axes;
const unsigned char* buttons;
const unsigned char* hats;
GLFWgamepadstate state;
nk_layout_row_dynamic(nk, 30, 1);
nk_label(nk, "Joystick state", NK_TEXT_LEFT);
axes = glfwGetJoystickAxes(joysticks[i], &axis_count);
buttons = glfwGetJoystickButtons(joysticks[i], &button_count);
hats = glfwGetJoystickHats(joysticks[i], &hat_count);
if (!hat_buttons)
button_count -= hat_count * 4;
for (j = 0; j < axis_count; j++)
nk_slide_float(nk, -1.f, axes[j], 1.f, 0.1f);
nk_layout_row_dynamic(nk, 30, 12);
for (j = 0; j < button_count; j++)
{
char name[16];
snprintf(name, sizeof(name), "%i", j + 1);
nk_select_label(nk, name, NK_TEXT_CENTERED, buttons[j]);
}
nk_layout_row_dynamic(nk, 30, 8);
for (j = 0; j < hat_count; j++)
hat_widget(nk, hats[j]);
nk_layout_row_dynamic(nk, 30, 1);
if (glfwGetGamepadState(joysticks[i], &state))
{
int hat = 0;
const char* names[GLFW_GAMEPAD_BUTTON_LAST + 1 - 4] =
{
"A", "B", "X", "Y",
"LB", "RB",
"Back", "Start", "Guide",
"LT", "RT",
};
nk_label(nk, "Gamepad state", NK_TEXT_LEFT);
nk_layout_row_dynamic(nk, 30, 2);
for (j = 0; j <= GLFW_GAMEPAD_AXIS_LAST; j++)
nk_slide_float(nk, -1.f, state.axes[j], 1.f, 0.1f);
nk_layout_row_dynamic(nk, 30, GLFW_GAMEPAD_BUTTON_LAST + 1 - 4);
for (j = 0; j <= GLFW_GAMEPAD_BUTTON_LAST - 4; j++)
nk_select_label(nk, names[j], NK_TEXT_CENTERED, state.buttons[j]);
if (state.buttons[GLFW_GAMEPAD_BUTTON_DPAD_UP])
hat |= GLFW_HAT_UP;
if (state.buttons[GLFW_GAMEPAD_BUTTON_DPAD_RIGHT])
hat |= GLFW_HAT_RIGHT;
if (state.buttons[GLFW_GAMEPAD_BUTTON_DPAD_DOWN])
hat |= GLFW_HAT_DOWN;
if (state.buttons[GLFW_GAMEPAD_BUTTON_DPAD_LEFT])
hat |= GLFW_HAT_LEFT;
nk_layout_row_dynamic(nk, 30, 8);
hat_widget(nk, hat);
}
else
nk_label(nk, "Joystick has no gamepad mapping", NK_TEXT_LEFT);
}
nk_end(nk);
}
nk_glfw3_render(NK_ANTI_ALIASING_ON, 10000, 1000);
glfwSwapBuffers(window);
glfwPollEvents();
}
glfwTerminate();
exit(EXIT_SUCCESS);
}
int main(void)
{
/* Platform */
static GLFWwindow *win;
int width = 0, height = 0;
struct nk_context *ctx;
struct nk_colorf bg;
/* GLFW */
glfwSetErrorCallback(error_callback);
if (!glfwInit()) {
fprintf(stdout, "[GFLW] failed to init!\n");
exit(1);
}
win = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, "Demo", NULL, NULL);
glfwMakeContextCurrent(win);
glfwGetWindowSize(win, &width, &height);
/* GUI */
ctx = nk_glfw3_init(win, NK_GLFW3_INSTALL_CALLBACKS);
/* Load Fonts: if none of these are loaded a default font will be used */
/* Load Cursor: if you uncomment cursor loading please hide the cursor */
{struct nk_font_atlas *atlas;
nk_glfw3_font_stash_begin(&atlas);
/*struct nk_font *droid = nk_font_atlas_add_from_file(atlas, "../../../extra_font/DroidSans.ttf", 14, 0);*/
/*struct nk_font *roboto = nk_font_atlas_add_from_file(atlas, "../../../extra_font/Roboto-Regular.ttf", 14, 0);*/
/*struct nk_font *future = nk_font_atlas_add_from_file(atlas, "../../../extra_font/kenvector_future_thin.ttf", 13, 0);*/
/*struct nk_font *clean = nk_font_atlas_add_from_file(atlas, "../../../extra_font/ProggyClean.ttf", 12, 0);*/
/*struct nk_font *tiny = nk_font_atlas_add_from_file(atlas, "../../../extra_font/ProggyTiny.ttf", 10, 0);*/
/*struct nk_font *cousine = nk_font_atlas_add_from_file(atlas, "../../../extra_font/Cousine-Regular.ttf", 13, 0);*/
nk_glfw3_font_stash_end();
/*nk_style_load_all_cursors(ctx, atlas->cursors);*/
/*nk_style_set_font(ctx, &droid->handle);*/}
#ifdef INCLUDE_STYLE
/*set_style(ctx, THEME_WHITE);*/
/*set_style(ctx, THEME_RED);*/
/*set_style(ctx, THEME_BLUE);*/
/*set_style(ctx, THEME_DARK);*/
#endif
bg.r = 0.10f, bg.g = 0.18f, bg.b = 0.24f, bg.a = 1.0f;
while (!glfwWindowShouldClose(win))
{
/* Input */
glfwPollEvents();
nk_glfw3_new_frame();
/* GUI */
if (nk_begin(ctx, "Demo", nk_rect(50, 50, 230, 250),
NK_WINDOW_BORDER|NK_WINDOW_MOVABLE|NK_WINDOW_SCALABLE|
NK_WINDOW_MINIMIZABLE|NK_WINDOW_TITLE))
{
enum {EASY, HARD};
static int op = EASY;
static int property = 20;
nk_layout_row_static(ctx, 30, 80, 1);
if (nk_button_label(ctx, "button"))
fprintf(stdout, "button pressed\n");
nk_layout_row_dynamic(ctx, 30, 2);
if (nk_option_label(ctx, "easy", op == EASY)) op = EASY;
if (nk_option_label(ctx, "hard", op == HARD)) op = HARD;
nk_layout_row_dynamic(ctx, 25, 1);
nk_property_int(ctx, "Compression:", 0, &property, 100, 10, 1);
nk_layout_row_dynamic(ctx, 20, 1);
nk_label(ctx, "background:", NK_TEXT_LEFT);
nk_layout_row_dynamic(ctx, 25, 1);
if (nk_combo_begin_color(ctx, nk_rgb_cf(bg), nk_vec2(nk_widget_width(ctx),400))) {
nk_layout_row_dynamic(ctx, 120, 1);
bg = nk_color_picker(ctx, bg, NK_RGBA);
nk_layout_row_dynamic(ctx, 25, 1);
bg.r = nk_propertyf(ctx, "#R:", 0, bg.r, 1.0f, 0.01f,0.005f);
bg.g = nk_propertyf(ctx, "#G:", 0, bg.g, 1.0f, 0.01f,0.005f);
bg.b = nk_propertyf(ctx, "#B:", 0, bg.b, 1.0f, 0.01f,0.005f);
bg.a = nk_propertyf(ctx, "#A:", 0, bg.a, 1.0f, 0.01f,0.005f);
nk_combo_end(ctx);
}
}
nk_end(ctx);
/* -------------- EXAMPLES ---------------- */
#ifdef INCLUDE_CALCULATOR
calculator(ctx);
#endif
#ifdef INCLUDE_OVERVIEW
overview(ctx);
#endif
#ifdef INCLUDE_NODE_EDITOR
node_editor(ctx);
#endif
/* ----------------------------------------- */
/* Draw */
glfwGetWindowSize(win, &width, &height);
glViewport(0, 0, width, height);
glClear(GL_COLOR_BUFFER_BIT);
glClearColor(bg.r, bg.g, bg.b, bg.a);
/* IMPORTANT: `nk_glfw_render` modifies some global OpenGL state
* with blending, scissor, face culling and depth test and defaults everything
* back into a default state. Make sure to either save and restore or
* reset your own state after drawing rendering the UI. */
nk_glfw3_render(NK_ANTI_ALIASING_ON);
glfwSwapBuffers(win);
}
nk_glfw3_shutdown();
glfwTerminate();
return 0;
}
int main(int argc, char **argv)
{
/* Platform */
int running = 1;
struct XWindow win;
GLXContext glContext;
struct nk_context *ctx;
struct nk_color background;
memset(&win, 0, sizeof(win));
win.dpy = XOpenDisplay(NULL);
if (!win.dpy) die("Failed to open X display\n");
{
/* check glx version */
int glx_major, glx_minor;
if (!glXQueryVersion(win.dpy, &glx_major, &glx_minor))
die("[X11]: Error: Failed to query OpenGL version\n");
if ((glx_major == 1 && glx_minor < 3) || (glx_major < 1))
die("[X11]: Error: Invalid GLX version!\n");
}
{
/* find and pick matching framebuffer visual */
int fb_count;
static GLint attr[] = {
GLX_X_RENDERABLE, True,
GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
GLX_RENDER_TYPE, GLX_RGBA_BIT,
GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR,
GLX_RED_SIZE, 8,
GLX_GREEN_SIZE, 8,
GLX_BLUE_SIZE, 8,
GLX_ALPHA_SIZE, 8,
GLX_DEPTH_SIZE, 24,
GLX_STENCIL_SIZE, 8,
GLX_DOUBLEBUFFER, True,
None
};
GLXFBConfig *fbc;
fbc = glXChooseFBConfig(win.dpy, DefaultScreen(win.dpy), attr, &fb_count);
if (!fbc) die("[X11]: Error: failed to retrieve framebuffer configuration\n");
{
/* pick framebuffer with most samples per pixel */
int i;
int fb_best = -1, best_num_samples = -1;
for (i = 0; i < fb_count; ++i) {
XVisualInfo *vi = glXGetVisualFromFBConfig(win.dpy, fbc[i]);
if (vi) {
int sample_buffer, samples;
glXGetFBConfigAttrib(win.dpy, fbc[i], GLX_SAMPLE_BUFFERS, &sample_buffer);
glXGetFBConfigAttrib(win.dpy, fbc[i], GLX_SAMPLES, &samples);
if ((fb_best < 0) || (sample_buffer && samples > best_num_samples))
fb_best = i; best_num_samples = samples;
}
}
win.fbc = fbc[fb_best];
XFree(fbc);
win.vis = glXGetVisualFromFBConfig(win.dpy, win.fbc);
}
}
{
/* create window */
win.cmap = XCreateColormap(win.dpy, RootWindow(win.dpy, win.vis->screen), win.vis->visual, AllocNone);
win.swa.colormap = win.cmap;
win.swa.background_pixmap = None;
win.swa.border_pixel = 0;
win.swa.event_mask =
ExposureMask | KeyPressMask | KeyReleaseMask |
ButtonPress | ButtonReleaseMask| ButtonMotionMask |
Button1MotionMask | Button3MotionMask | Button4MotionMask | Button5MotionMask|
PointerMotionMask| StructureNotifyMask;
win.win = XCreateWindow(win.dpy, RootWindow(win.dpy, win.vis->screen), 0, 0,
WINDOW_WIDTH, WINDOW_HEIGHT, 0, win.vis->depth, InputOutput,
win.vis->visual, CWBorderPixel|CWColormap|CWEventMask, &win.swa);
if (!win.win) die("[X11]: Failed to create window\n");
XFree(win.vis);
XStoreName(win.dpy, win.win, "Demo");
XMapWindow(win.dpy, win.win);
}
{
/* create opengl context */
typedef GLXContext(*glxCreateContext)(Display*, GLXFBConfig, GLXContext, Bool, const int*);
int(*old_handler)(Display*, XErrorEvent*) = XSetErrorHandler(gl_error_handler);
const char *extensions_str = glXQueryExtensionsString(win.dpy, DefaultScreen(win.dpy));
glxCreateContext create_context = (glxCreateContext)
glXGetProcAddressARB((const GLubyte*)"glXCreateContextAttribsARB");
gl_err = FALSE;
if (!has_extension(extensions_str, "GLX_ARB_create_context") || !create_context) {
fprintf(stdout, "[X11]: glXCreateContextAttribARB() not found...\n");
fprintf(stdout, "[X11]: ... using old-style GLX context\n");
glContext = glXCreateNewContext(win.dpy, win.fbc, GLX_RGBA_TYPE, 0, True);
} else {
GLint attr[] = {
GLX_CONTEXT_MAJOR_VERSION_ARB, 3,
GLX_CONTEXT_MINOR_VERSION_ARB, 0,
None
};
glContext = create_context(win.dpy, win.fbc, 0, True, attr);
XSync(win.dpy, False);
if (gl_err || !glContext) {
/* Could not create GL 3.0 context. Fallback to old 2.x context.
* If a version below 3.0 is requested, implementations will
* return the newest context version compatible with OpenGL
* version less than version 3.0.*/
attr[1] = 1; attr[3] = 0;
gl_err = FALSE;
fprintf(stdout, "[X11] Failed to create OpenGL 3.0 context\n");
fprintf(stdout, "[X11] ... using old-style GLX context!\n");
glContext = create_context(win.dpy, win.fbc, 0, True, attr);
}
}
XSync(win.dpy, False);
XSetErrorHandler(old_handler);
if (gl_err || !glContext)
die("[X11]: Failed to create an OpenGL context\n");
glXMakeCurrent(win.dpy, win.win, glContext);
}
ctx = nk_x11_init(win.dpy, win.win);
/* Load Fonts: if none of these are loaded a default font will be used */
{struct nk_font_atlas *atlas;
nk_x11_font_stash_begin(&atlas);
/*struct nk_font *droid = nk_font_atlas_add_from_file(atlas, "../../../extra_font/DroidSans.ttf", 14, 0);*/
/*struct nk_font *roboto = nk_font_atlas_add_from_file(atlas, "../../../extra_font/Roboto-Regular.ttf", 14, 0);*/
/*struct nk_font *future = nk_font_atlas_add_from_file(atlas, "../../../extra_font/kenvector_future_thin.ttf", 13, 0);*/
/*struct nk_font *clean = nk_font_atlas_add_from_file(atlas, "../../../extra_font/ProggyClean.ttf", 12, 0);*/
/*struct nk_font *tiny = nk_font_atlas_add_from_file(atlas, "../../../extra_font/ProggyTiny.ttf", 10, 0);*/
/*struct nk_font *cousine = nk_font_atlas_add_from_file(atlas, "../../../extra_font/Cousine-Regular.ttf", 13, 0);*/
nk_x11_font_stash_end();
/*nk_style_set_font(ctx, &droid->handle);*/}
/* style.c */
/*set_style(ctx, THEME_WHITE);*/
/*set_style(ctx, THEME_RED);*/
/*set_style(ctx, THEME_BLUE);*/
/*set_style(ctx, THEME_DARK);*/
background = nk_rgb(28,48,62);
while (running)
{
/* Input */
XEvent evt;
nk_input_begin(ctx);
while (XCheckWindowEvent(win.dpy, win.win, win.swa.event_mask, &evt)){
if (XFilterEvent(&evt, win.win)) continue;
nk_x11_handle_event(&evt);
}
nk_input_end(ctx);
/* GUI */
{struct nk_panel layout;
if (nk_begin(ctx, &layout, "Demo", nk_rect(50, 50, 200, 200),
NK_WINDOW_BORDER|NK_WINDOW_MOVABLE|NK_WINDOW_SCALABLE|
NK_WINDOW_CLOSABLE|NK_WINDOW_MINIMIZABLE|NK_WINDOW_TITLE))
{
enum {EASY, HARD};
static int op = EASY;
static int property = 20;
nk_layout_row_static(ctx, 30, 80, 1);
if (nk_button_label(ctx, "button", NK_BUTTON_DEFAULT))
fprintf(stdout, "button pressed\n");
nk_layout_row_dynamic(ctx, 30, 2);
if (nk_option_label(ctx, "easy", op == EASY)) op = EASY;
if (nk_option_label(ctx, "hard", op == HARD)) op = HARD;
nk_layout_row_dynamic(ctx, 25, 1);
nk_property_int(ctx, "Compression:", 0, &property, 100, 10, 1);
{struct nk_panel combo;
nk_layout_row_dynamic(ctx, 20, 1);
nk_label(ctx, "background:", NK_TEXT_LEFT);
nk_layout_row_dynamic(ctx, 25, 1);
if (nk_combo_begin_color(ctx, &combo, background, 400)) {
nk_layout_row_dynamic(ctx, 120, 1);
background = nk_color_picker(ctx, background, NK_RGBA);
nk_layout_row_dynamic(ctx, 25, 1);
background.r = (nk_byte)nk_propertyi(ctx, "#R:", 0, background.r, 255, 1,1);
background.g = (nk_byte)nk_propertyi(ctx, "#G:", 0, background.g, 255, 1,1);
background.b = (nk_byte)nk_propertyi(ctx, "#B:", 0, background.b, 255, 1,1);
background.a = (nk_byte)nk_propertyi(ctx, "#A:", 0, background.a, 255, 1,1);
nk_combo_end(ctx);
}}
}
nk_end(ctx);}
if (nk_window_is_closed(ctx, "Demo")) break;
/* -------------- EXAMPLES ---------------- */
/*calculator(ctx);*/
/*overview(ctx);*/
/*node_editor(ctx);*/
/* ----------------------------------------- */
/* Draw */
{float bg[4];
nk_color_fv(bg, background);
XGetWindowAttributes(win.dpy, win.win, &win.attr);
glViewport(0, 0, win.width, win.height);
glClear(GL_COLOR_BUFFER_BIT);
glClearColor(bg[0], bg[1], bg[2], bg[3]);
/* IMPORTANT: `nk_x11_render` modifies some global OpenGL state
* with blending, scissor, face culling, depth test and viewport and
* defaults everything back into a default state.
* Make sure to either a.) save and restore or b.) reset your own state after
* rendering the UI. */
nk_x11_render(NK_ANTI_ALIASING_ON, MAX_VERTEX_BUFFER, MAX_ELEMENT_BUFFER);
glXSwapBuffers(win.dpy, win.win);}
}
nk_x11_shutdown();
glXMakeCurrent(win.dpy, 0, 0);
glXDestroyContext(win.dpy, glContext);
XUnmapWindow(win.dpy, win.win);
XFreeColormap(win.dpy, win.cmap);
XDestroyWindow(win.dpy, win.win);
XCloseDisplay(win.dpy);
return 0;
}
void draw_output_tab(struct nk_context *ctx, int *tab_screen_height, struct output_tab *output, struct main_tab *main_settings)
{
const float roll_limit_ratio[] = { 0.55f, 0.45f };
nk_flags active;
static int len;
static int cap_len;
static int color_len = 6;
const float gen_enc_ratio[] = { 0.701f, 0.302f };
const float type_ratio[] = { 0.3f,0.7f };
const float out_file_ratio[] = { 0.3f,0.53f,0.17f };
const float cap_file_ratio[] = { 0.2f,0.63f,0.17f };
const float delay_ratio[] = { 0.5f, 0.2f, 0.3f };
const float color_roll_ratio[] = { 0.6f,0.401f };
const float color_check_ratio[] = { 0.6f,0.23f,0.07f,0.1f };
*tab_screen_height = 472;
nk_layout_row(ctx, NK_DYNAMIC, 160, 2, gen_enc_ratio);
//General Group
if (nk_group_begin(ctx, "General", NK_WINDOW_TITLE |NK_WINDOW_NO_SCROLLBAR | NK_WINDOW_BORDER))
{
int delay_secs = atoi(output->delay_sec_buffer);
//Output Type
nk_layout_row(ctx, NK_DYNAMIC, 20, 2, type_ratio);
nk_label(ctx, "Output Type:", NK_TEXT_LEFT);
output->type_select = nk_combo(ctx, output->type, 13, output->type_select, 25, nk_vec2(225, 200));
//Output File
nk_layout_row(ctx, NK_DYNAMIC, 25, 3, out_file_ratio);
nk_checkbox_label(ctx, "Output File:", &output->is_filename);
nk_edit_string(ctx, NK_EDIT_SIMPLE, output->filename, &output->filename_len, 255, nk_filter_ascii);
if (nk_button_label(ctx, "Browse"))
{
main_settings->scaleWindowForFileBrowser = nk_true;
output->is_output_browser_active = nk_true;
}
//Subtitle Delay
nk_layout_row(ctx, NK_DYNAMIC, 25, 3, delay_ratio);
nk_checkbox_label(ctx, "Add delay in subtitles for", &output->is_delay);
delay_secs = nk_propertyi(ctx, "", 0, delay_secs, 1000, 1, 1);
sprintf(output->delay_sec_buffer, "%d", delay_secs);
nk_label(ctx, "seconds", NK_TEXT_LEFT);
//Export XDS info
nk_layout_row_dynamic(ctx, 25, 1);
nk_checkbox_label(ctx, "Export XDS information (transcripts)", &output->is_export_xds);
nk_group_end(ctx);
}
//Encoding Group
if (nk_group_begin(ctx, "Encoding", NK_WINDOW_TITLE |NK_WINDOW_NO_SCROLLBAR | NK_WINDOW_BORDER))
{
static int option = UTF;
nk_layout_row_dynamic(ctx, 20, 1);
if (nk_option_label(ctx, "Latin", output->encoding == LATIN)) {
output->encoding = LATIN;
}
nk_layout_row_dynamic(ctx, 20, 1);
if (nk_option_label(ctx, "Unicode", output->encoding == UNIC)) {
output->encoding = UNIC;
}
nk_layout_row_dynamic(ctx, 20, 1);
if (nk_option_label(ctx, "UTF-8", output->encoding == UTF)) {
output->encoding = UTF;
}
nk_layout_row_dynamic(ctx, 20, 1);
nk_checkbox_label(ctx, "Byte Order Mark*", &output->is_bom);
nk_layout_row_dynamic(ctx, 20, 1);
nk_label(ctx, "*( For UNIX programs )", NK_TEXT_LEFT);
nk_group_end(ctx);
}
nk_layout_row(ctx, NK_DYNAMIC, 100, 2, gen_enc_ratio);
//Capitalization Group
if(nk_group_begin(ctx, "Capitalization", NK_WINDOW_TITLE|NK_WINDOW_NO_SCROLLBAR | NK_WINDOW_BORDER))
{
nk_layout_row_dynamic(ctx, 20, 1);
nk_checkbox_label(ctx, "Standard capitalization rules.", &output->is_cap_standard);
nk_layout_row(ctx, NK_DYNAMIC, 25, 3, cap_file_ratio);
nk_checkbox_label(ctx, "Cap file:", &output->is_cap_file);
nk_edit_string(ctx, NK_EDIT_SIMPLE, output->cap_dictionary, &output->cap_dictionary_len, 255, nk_filter_ascii);
if (nk_button_label(ctx, "Browse"))
{
main_settings->scaleWindowForFileBrowser = nk_true;
output->is_cap_browser_active = nk_true;
}
nk_group_end(ctx);
}
//Line Endings
if (nk_group_begin(ctx, "Line Endings:", NK_WINDOW_TITLE | NK_WINDOW_NO_SCROLLBAR |NK_WINDOW_BORDER))
{
nk_layout_row_dynamic(ctx, 20, 1);
if (nk_option_label(ctx, "CRLF (Windows)", output->line_ending == CRLF)) {
output->line_ending = CRLF;
}
nk_layout_row_dynamic(ctx, 25, 1);
if (nk_option_label(ctx, "LF (UNIX-like)", output->line_ending == LF)) {
output->line_ending = LF;
}
nk_group_end(ctx);
}
nk_layout_row(ctx, NK_DYNAMIC, 170, 2, color_roll_ratio);
//Colors and Styles Group
if (nk_group_begin(ctx, "Colors and Styles", NK_WINDOW_TITLE | NK_WINDOW_BORDER))
{
nk_layout_row_dynamic(ctx, 20, 1);
nk_checkbox_label(ctx, "Center Text (remove left and right spaces)", &output->is_center);
nk_layout_row_dynamic(ctx, 20, 1);
nk_checkbox_label(ctx, "Add dash (-) when speaker changes (for .srt)", &output->is_dash);
nk_layout_row_dynamic(ctx, 20, 1);
nk_checkbox_label(ctx, "Don't add typesetting tags(bold, italic, etc.)", &output->no_typesetting);
nk_layout_row_dynamic(ctx, 20, 1);
if(nk_option_label(ctx, "Don't add color information", output->font_color == NO_COLOR)) {
output->font_color = NO_COLOR;
}
nk_layout_row(ctx, NK_DYNAMIC, 20, 4, color_check_ratio);
if (nk_option_label(ctx, "Default color (RRGGBB)#", output->font_color == DEFAULT_COLOR)) {
output->font_color = DEFAULT_COLOR;
}
active = nk_edit_string(ctx, NK_EDIT_FIELD|NK_EDIT_SIG_ENTER, output->color_hex, &color_len, 7, nk_filter_hex);
nk_label(ctx, "or", NK_TEXT_CENTERED);
if (nk_button_color(ctx, output->color_rgb))
output->color_popup = nk_true;
if (show_color_from_picker)
{
sprintf(output->color_hex, "%02X%02X%02X", output->color_rgb.r, output->color_rgb.g, output->color_rgb.b);
show_color_from_picker = nk_false;
}
/*if (active & NK_EDIT_COMMITED) {
output->color_rgb.r = (int)strtol(strncat(output->color_hex[0], output->color_hex[1], 2), NULL, 16);
output->color_rgb.g = (int)strtol(strncat(output->color_hex[2], output->color_hex[3], 2), NULL, 16);
output->color_rgb.b = (int)strtol(strncat(output->color_hex[4], output->color_hex[5], 2), NULL, 16);
printf("%d%d%d", output->color_rgb.r, output->color_rgb.g, output->color_rgb.b);
}*/
nk_group_end(ctx);
}
//Roll-up Captions Group
if (nk_group_begin(ctx, "Roll-up Captions", NK_WINDOW_TITLE | NK_WINDOW_NO_SCROLLBAR | NK_WINDOW_BORDER))
{
nk_layout_row_dynamic(ctx, 25, 1);
if (nk_option_label(ctx, "Letters appear in realtime", output->onetime_or_realtime == REALTIME)) {
output->onetime_or_realtime = REALTIME;
}
nk_layout_row_dynamic(ctx, 25, 1);
nk_label(ctx, "(Allows duplication of content)", NK_TEXT_LEFT);
nk_layout_row(ctx, NK_DYNAMIC, 20, 2, roll_limit_ratio);
nk_label(ctx, "Limit visible lines", NK_TEXT_LEFT);
output->roll_limit_select = nk_combo(ctx, output->roll_limit, 4, output->roll_limit_select, 25, nk_vec2(80, 80));
nk_layout_row_dynamic(ctx, 20, 1);
if (nk_option_label(ctx, "Letters appear line by line", output->onetime_or_realtime == ONETIME)) {
output->onetime_or_realtime = ONETIME;
}
nk_layout_row_dynamic(ctx, 25, 1);
nk_label(ctx, "(No duplication of content)", NK_TEXT_LEFT);
nk_group_end(ctx);
}
}
/*Tab specific functions*/
void draw_input_tab(struct nk_context *ctx, int *tab_screen_height, struct input_tab *input,
struct decoders_tab *decoders)
{
const float screenful_limit_ratio[] = { 0.47f, 0.3f };
static struct time from_time, until_time;
const float stream_type_pid_ratio[] = { 0.7f,0.3f };
const float mpeg_type_ratio[] = { 0.7f,0.3f };
const float teletext_page_ratio[] = { 0.75f,0.25f };
const float stream_teletext_ratio[] = { 0.5f, 0.501f };
const float wait_data_ratio[] = { 0.6f, 0.25f, 0.15f };
const float gen_type_ratio[] = { 0.3f, 0.7f };
const float gen_time_ratio[] = { 0.6f ,0.401f};
const char *split_type[] = { "Individual Files", "Parts of same video. Cut by generic tool", "Parts of same video. Cut by video tool" };
static int split_num;
*tab_screen_height = 472;
nk_layout_row(ctx, NK_DYNAMIC, 150, 2, gen_time_ratio);
//General Group
if (nk_group_begin(ctx, "General", NK_WINDOW_TITLE | NK_WINDOW_NO_SCROLLBAR | NK_WINDOW_BORDER))
{
//Input Type
nk_layout_row(ctx, NK_DYNAMIC, 25, 2, gen_type_ratio);
nk_label(ctx, "Input Type:", NK_TEXT_LEFT);
input->type_select = nk_combo(ctx, input->type, 9, input->type_select, 25, nk_vec2(225, 200));
//Split Type
nk_layout_row(ctx, NK_DYNAMIC, 25, 2, gen_type_ratio);
nk_label(ctx, "Split Type:", NK_TEXT_LEFT);
split_num = nk_combo(ctx, split_type, 3, split_num, 25, nk_vec2(240, 200));
if (split_num == 2)
input->is_split = nk_true;
nk_layout_row_dynamic(ctx, 20, 1);
nk_checkbox_label(ctx, "Live Stream.*", &input->is_live_stream);
nk_layout_row(ctx, NK_DYNAMIC, 21, 3, wait_data_ratio);
nk_label(ctx, "*Wait when no data arrives for", NK_TEXT_LEFT);
nk_edit_string(ctx, NK_EDIT_SIMPLE, input->wait_data_sec, &input->wait_data_sec_len, 999, nk_filter_decimal);
nk_label(ctx, "sec", NK_TEXT_LEFT);
nk_group_end(ctx);
}
//Timing Group
if (nk_group_begin(ctx, "Timing", NK_WINDOW_TITLE | NK_WINDOW_NO_SCROLLBAR | NK_WINDOW_BORDER))
{
//Process From
nk_layout_row_dynamic(ctx, 20, 1);
nk_checkbox_label(ctx, "Process From: (HH:MM:SS)", &input->is_process_from);
nk_layout_row_dynamic(ctx, 25, 1);
if (nk_combo_begin_label(ctx, input->from_time_buffer, nk_vec2(180, 250))) {
sprintf(input->from_time_buffer, "%02d:%02d:%02d", from_time.hours, from_time.minutes, from_time.seconds);
nk_layout_row_dynamic(ctx, 25, 1);
from_time.seconds = nk_propertyi(ctx, "#Seconds:", 0, from_time.seconds, 60, 1, 1);
from_time.minutes = nk_propertyi(ctx, "#Minutes:", 0, from_time.minutes, 60, 1, 1);
from_time.hours = nk_propertyi(ctx, "#Hours:", 0, from_time.hours, 99, 1, 1);
nk_combo_end(ctx);
}
//Process Until
nk_layout_row_dynamic(ctx, 20, 1);
nk_checkbox_label(ctx, "Process Until: (HH:MM:SS)", &input->is_process_until);
nk_layout_row_dynamic(ctx, 25, 1);
if (nk_combo_begin_label(ctx, input->until_time_buffer, nk_vec2(180, 250))) {
sprintf(input->until_time_buffer, "%02d:%02d:%02d", until_time.hours, until_time.minutes, until_time.seconds);
nk_layout_row_dynamic(ctx, 25, 1);
until_time.seconds = nk_propertyi(ctx, "#Seconds:", 0, until_time.seconds, 60, 1, 1);
until_time.minutes = nk_propertyi(ctx, "#Minutes:", 0, until_time.minutes, 60, 1, 1);
until_time.hours = nk_propertyi(ctx, "#Hours:", 0, until_time.hours, 99, 1, 1);
nk_combo_end(ctx);
}
nk_group_end(ctx);
}
nk_layout_row(ctx, NK_DYNAMIC, 150, 2, stream_teletext_ratio);
//Elementary Stream Group
if (nk_group_begin(ctx, "Elementary Stream", NK_WINDOW_NO_SCROLLBAR | NK_WINDOW_TITLE | NK_WINDOW_BORDER))
{
nk_layout_row_dynamic(ctx, 20, 1);
if (nk_option_label(ctx, "Auto", input->elementary_stream == AUTO_DETECT)) {
input->elementary_stream = AUTO_DETECT;
}
nk_layout_row(ctx, NK_DYNAMIC, 25, 2, stream_type_pid_ratio);
if (nk_option_label(ctx, "Process stream of type:", input->elementary_stream == STREAM_TYPE)) {
input->elementary_stream = STREAM_TYPE;
}
nk_edit_string(ctx, NK_EDIT_SIMPLE, input->stream_type, &input->stream_type_len, 9, nk_filter_decimal);
nk_layout_row(ctx, NK_DYNAMIC, 25, 2, stream_type_pid_ratio);
if (nk_option_label(ctx, "Process stream with PID:", input->elementary_stream == STREAM_PID)) {
input->elementary_stream = STREAM_PID;
}
nk_edit_string(ctx, NK_EDIT_SIMPLE, input->stream_pid, &input->stream_pid_len, 9, nk_filter_decimal);
nk_layout_row(ctx, NK_DYNAMIC, 25, 2, mpeg_type_ratio);
nk_checkbox_label(ctx, "Assume MPEG type is:", &input->is_assume_mpeg);
nk_edit_string(ctx, NK_EDIT_SIMPLE, input->mpeg_type, &input->mpeg_type_len, 9, nk_filter_decimal);
if(input->teletext_decoder == FORCE)
{
input->elementary_stream = STREAM_PID;
}
nk_group_end(ctx);
}
//Teletext Group
if (nk_group_begin(ctx, "Teletext", NK_WINDOW_NO_SCROLLBAR | NK_WINDOW_TITLE | NK_WINDOW_BORDER))
{
if(decoders->teletext_dvb == DVB){
nk_layout_row_dynamic(ctx, 40, 1);
nk_label_colored_wrap(ctx, "Teletext is disabled in Decoders->Teletext or DVB.", nk_rgb(255, 56, 38));
}
else
{
nk_layout_row_dynamic(ctx, 20, 1);
if (nk_option_label(ctx, "Auto", input->teletext_decoder == AUTO_DECODE)) {
input->teletext_decoder = AUTO_DECODE;
}
nk_layout_row_dynamic(ctx, 25, 1);
if (nk_option_label(ctx, "Force Teletext decoder", input->teletext_decoder == FORCE)) {
input->teletext_decoder = FORCE;
}
nk_layout_row_dynamic(ctx, 25, 1);
if (nk_option_label(ctx, "Disable Teletext decoder", input->teletext_decoder == DISABLE)) {
input->teletext_decoder = DISABLE;
}
nk_layout_row(ctx, NK_DYNAMIC, 20, 2, teletext_page_ratio);
nk_checkbox_label(ctx, "Process Teletext Page #", &input->is_process_teletext_page);
nk_edit_string(ctx, NK_EDIT_SIMPLE, input->teletext_page_number, &input->teletext_page_numer_len, 99999, nk_filter_decimal);
}
nk_group_end(ctx);
}
//Screenfuls limit group
nk_layout_row(ctx, NK_DYNAMIC, 95, 2, stream_teletext_ratio);
if (nk_group_begin(ctx, "'Screenfuls' limit", NK_WINDOW_BORDER | NK_WINDOW_TITLE | NK_WINDOW_NO_SCROLLBAR))
{
int screenful_limits = atoi(input->screenful_limit_buffer);
nk_layout_row_dynamic(ctx, 20, 1);
if (nk_option_label(ctx, "No limit", input->is_limit == NO_LIMIT))
{
input->is_limit = NO_LIMIT;
}
nk_layout_row(ctx, NK_DYNAMIC, 25, 2, screenful_limit_ratio);
if (nk_option_label(ctx, "Screenful Limit:", input->is_limit == LIMITED)) {
input->is_limit = LIMITED;
}
screenful_limits = nk_propertyi(ctx, "", 0, screenful_limits, 999, 1, 1);
sprintf(input->screenful_limit_buffer, "%d", screenful_limits);
nk_group_end(ctx);
}
//Clock group
if (nk_group_begin(ctx, "Clock", NK_WINDOW_BORDER | NK_WINDOW_TITLE | NK_WINDOW_NO_SCROLLBAR))
{
nk_layout_row_dynamic(ctx, 20, 3);
if (nk_option_label(ctx, "Auto", input->clock_input == AUTO))
{
input->clock_input = AUTO;
}
if (nk_option_label(ctx, "GOP", input->clock_input == GOP)) {
input->clock_input = GOP;
}
if (nk_option_label(ctx, "PTS", input->clock_input == PTS)) {
input->clock_input = PTS;
}
nk_group_end(ctx);
}
}
void draw_burned_subs_tab(struct nk_context *ctx, int *tab_screen_height, struct burned_subs_tab *burned_subs)
{
*tab_screen_height = 472;
const float color_mode_ratio[] = { 0.65f, 0.351f};
const float preset_ratio[] = { 0.4f, 0.5f };
const float custom_ratio[] = { 0.4f, 0.5f};
const float delay_ratio[] = { 0.4f, 0.2f, 0.2f };
const float threshold_ratio[] = { 0.9f, 0.1f };
static char buffer[5];
nk_layout_row_dynamic(ctx, 30, 1);
#if ENABLE_OCR
nk_checkbox_label(ctx, "Enable Burned-in Subtitle Extraction", &burned_subs->is_burned_subs);
#else
nk_label_colored(ctx, "Required Library not found. Cannot perform Burned subtitle extraction.", NK_TEXT_LEFT, nk_rgb(255, 56, 38));
#endif
nk_layout_row(ctx, NK_DYNAMIC, 140, 2, color_mode_ratio);
if(nk_group_begin(ctx, "Subtitle Color", NK_WINDOW_TITLE | NK_WINDOW_NO_SCROLLBAR | NK_WINDOW_BORDER))
{
nk_layout_row(ctx, NK_DYNAMIC, 25, 2, preset_ratio);
if(nk_option_label(ctx, "Preset color:", burned_subs->color_type == PRESET)){
burned_subs->color_type = PRESET;
}
burned_subs->subs_color_select = nk_combo(ctx, burned_subs->subs_color, 7, burned_subs->subs_color_select, 25, nk_vec2(100, 100));
nk_layout_row(ctx, NK_DYNAMIC, 25, 2, custom_ratio);
if(nk_option_label(ctx, "Custom Hue:", burned_subs->color_type == CUSTOM)){
burned_subs->color_type = CUSTOM;
}
nk_edit_string(ctx, NK_EDIT_SIMPLE, burned_subs->custom_hue, &burned_subs->custom_hue_len, 4, nk_filter_decimal);
nk_layout_row_dynamic(ctx, 20, 1);
nk_label_wrap(ctx, "Custom Hue can be between 1 and 360");
nk_layout_row_dynamic(ctx, 20, 1);
nk_label_wrap(ctx, "Refer to HSV color chart.");
nk_group_end(ctx);
}
if(nk_group_begin(ctx, "OCR mode", NK_WINDOW_TITLE|NK_WINDOW_NO_SCROLLBAR|NK_WINDOW_BORDER))
{
nk_layout_row_dynamic(ctx, 25, 1);
if(nk_option_label(ctx, "Frame - wise", burned_subs->ocr_mode == FRAME_WISE)){
burned_subs->ocr_mode = FRAME_WISE;
}
nk_layout_row_dynamic(ctx, 25, 1);
if(nk_option_label(ctx, "Word - wise", burned_subs->ocr_mode == WORD_WISE)){
burned_subs->ocr_mode = WORD_WISE;
}
nk_layout_row_dynamic(ctx, 25, 1);
if(nk_option_label(ctx, "Letter - wise", burned_subs->ocr_mode == LETTER_WISE)){
burned_subs->ocr_mode = LETTER_WISE;
}
if(burned_subs->is_italic)
{
burned_subs->ocr_mode = WORD_WISE;
}
nk_group_end(ctx);
}
nk_layout_row_dynamic(ctx, 120, 1);
if(nk_group_begin(ctx, "Minimum Subtitle Duration", NK_WINDOW_TITLE|NK_WINDOW_NO_SCROLLBAR|NK_WINDOW_BORDER))
{
nk_layout_row(ctx, NK_DYNAMIC, 25, 3, delay_ratio);
nk_label(ctx, "Set the minimum subtitle duration to:", NK_TEXT_LEFT);
nk_edit_string(ctx, NK_EDIT_SIMPLE, burned_subs->min_duration, &burned_subs->min_duration_len, 4, nk_filter_float);
nk_label(ctx, "seconds", NK_TEXT_LEFT);
nk_layout_row_dynamic(ctx, 25, 1);
nk_label(ctx, "Lower values give better results but take more time.", NK_TEXT_LEFT);
nk_layout_row_dynamic(ctx, 25, 1);
nk_label(ctx, "0.5 is the recommended value.", NK_TEXT_LEFT);
nk_group_end(ctx);
}
if(!burned_subs->subs_color_select && burned_subs->color_type == PRESET)
{
nk_layout_row_dynamic(ctx, 60, 1);
if(nk_group_begin(ctx, "Luminance Threshold", NK_WINDOW_TITLE|NK_WINDOW_NO_SCROLLBAR | NK_WINDOW_BORDER))
{
nk_layout_row(ctx, NK_DYNAMIC, 20, 2, threshold_ratio);
nk_slider_int(ctx, 0, &burned_subs->luminance_threshold, 100, 1);
sprintf(buffer, "%d", burned_subs->luminance_threshold);
nk_label(ctx, buffer, NK_TEXT_LEFT);
nk_group_end(ctx);
}
}
nk_layout_row_dynamic(ctx, 60, 1);
if(nk_group_begin(ctx, "Confidence Threshold", NK_WINDOW_TITLE|NK_WINDOW_NO_SCROLLBAR | NK_WINDOW_BORDER))
{
nk_layout_row(ctx, NK_DYNAMIC, 20, 2, threshold_ratio);
nk_slider_int(ctx, 0, &burned_subs->confidence_threshold, 100, 1);
sprintf(buffer, "%d", burned_subs->confidence_threshold);
nk_label(ctx, buffer, NK_TEXT_LEFT);
nk_group_end(ctx);
}
nk_layout_row_dynamic(ctx, 30, 1);
nk_checkbox_label(ctx, "Enable italics detection.", &burned_subs->is_italic);
}
int main(int argc, char** argv)
{
if (argc > 2)
message_and_abort_fmt("Usage: %s [filename]", argv[0]);
Render::RenderSettings renderSettings;
renderSettings.windowWidth = 800;
renderSettings.windowHeight = 600;
renderSettings.fullscreen = false;
NuklearMisc::StandaloneGuiHandler guiHandler("Cel Viewer", renderSettings);
nk_context* ctx = guiHandler.getNuklearContext();
Settings::Settings settings;
settings.loadFromFile("resources/celview.ini");
bool faioInitDone = false;
std::string listFile = settings.get<std::string>("celview", "listFile", "Diablo I.txt");
std::string mpqFile = settings.get<std::string>("celview", "mpqFile", "DIABDAT.MPQ");
std::vector<std::string> celFiles;
std::string selectedImage = "";
std::unique_ptr<NuklearMisc::GuiSprite> image;
std::unique_ptr<NuklearMisc::GuiSprite> nextImage;
int animate = false;
int32_t frame = 0;
float rowHeight = 30;
auto lastFrame = std::chrono::high_resolution_clock::now();
bool quit = false;
while (!quit)
{
auto now = std::chrono::high_resolution_clock::now();
if (nextImage)
image = std::unique_ptr<NuklearMisc::GuiSprite>(nextImage.release());
renderSettings = Render::getWindowSize();
if (nk_begin(ctx, "main_window", nk_rect(0, 0, renderSettings.windowWidth, renderSettings.windowHeight), NK_WINDOW_NO_SCROLLBAR))
{
struct nk_rect bounds = nk_window_get_content_region(ctx);
nk_layout_row_dynamic(ctx, bounds.h, 2);
if (nk_group_begin(ctx, "image", 0))
{
nk_layout_row_dynamic(ctx, rowHeight, 1);
std::string label = selectedImage;
if (selectedImage == "")
label = "No image selected";
nk_label(ctx, label.c_str(), NK_TEXT_CENTERED);
nk_checkbox_label(ctx, "Animate", &animate);
if (image)
{
nk_label(ctx, (boost::format("Number of Frames: %1%") % image.get()->getSprite()->size()).str().c_str(), NK_TEXT_LEFT);
nk_label(ctx, (boost::format("Width: %1%") % image->getSprite()->getWidth()).str().c_str(), NK_TEXT_LEFT);
nk_label(ctx, (boost::format("Height: %1%") % image->getSprite()->getHeight()).str().c_str(), NK_TEXT_LEFT);
frame = nk_propertyi(ctx, "Frame", 0, frame, image->getSprite()->size(), 1, 0.2f);
if (nk_button_label(ctx, "save as png"))
{
nfdchar_t* outPath = NULL;
nfdresult_t result = NFD_SaveDialog("png", NULL, &outPath);
if (result == NFD_OKAY)
{
Render::SpriteGroup::toPng(selectedImage, outPath);
free(outPath);
}
}
if (nk_button_label(ctx, "save as gif"))
{
nfdchar_t* outPath = NULL;
nfdresult_t result = NFD_SaveDialog("gif", NULL, &outPath);
if (result == NFD_OKAY)
{
Render::SpriteGroup::toGif(selectedImage, outPath);
free(outPath);
}
}
auto msSinceLastFrame = std::chrono::duration_cast<std::chrono::milliseconds>(now - lastFrame).count();
if (animate && msSinceLastFrame > 100)
{
lastFrame = now;
frame++;
}
if (frame >= (int32_t)image.get()->getSprite()->size())
frame = 0;
Render::Sprite sprite = image.get()->getSprite()->operator[](frame);
int32_t w, h;
Render::spriteSize(sprite, w, h);
nk_layout_space_begin(ctx, NK_STATIC, h, 1);
{
nk_layout_space_push(ctx, nk_rect(0, 0, w, h));
auto canvas = nk_window_get_canvas(ctx);
struct nk_rect imageRect;
nk_widget(&imageRect, ctx);
nk_fill_rect(canvas, imageRect, 0.0, nk_rgb(0, 255, 0));
auto img = image.get()->getNkImage(frame);
nk_draw_image(canvas, imageRect, &img, nk_rgb(255, 255, 255));
}
nk_layout_space_end(ctx);
}
nk_group_end(ctx);
}
if (nk_group_begin(ctx, "file list", 0))
{
if (!faioInitDone)
{
nk_layout_row_dynamic(ctx, rowHeight * 2, 1);
NuklearMisc::nk_file_pick(ctx, "DIABDAT.MPQ", mpqFile, "mpq,MPQ", rowHeight);
NuklearMisc::nk_file_pick(ctx, "Diablo listfile", listFile, "txt", rowHeight);
if (nk_button_label(ctx, "load"))
{
FAIO::init(mpqFile, listFile);
celFiles = FAIO::listMpqFiles("*.cel");
auto tmp = FAIO::listMpqFiles("*.cl2");
celFiles.insert(celFiles.end(), tmp.begin(), tmp.end());
std::sort(celFiles.begin(), celFiles.end());
settings.set<std::string>("celview", "listFile", listFile);
settings.set<std::string>("celview", "mpqFile", mpqFile);
settings.save();
faioInitDone = true;
if (argc > 1)
{
selectedImage = argv[1];
frame = 0;
nextImage = std::unique_ptr<NuklearMisc::GuiSprite>(guiHandler.getSprite(new Render::SpriteGroup(selectedImage)));
}
}
}
nk_layout_row_dynamic(ctx, rowHeight, 1);
for (size_t i = 0; i < celFiles.size(); i++)
{
auto buttonStyle = ctx->style.button;
if (selectedImage == celFiles[i])
buttonStyle.normal = buttonStyle.hover;
if (nk_button_label_styled(ctx, &buttonStyle, celFiles[i].c_str()))
{
selectedImage = celFiles[i];
frame = 0;
nextImage = std::unique_ptr<NuklearMisc::GuiSprite>(guiHandler.getSprite(new Render::SpriteGroup(selectedImage)));
}
}
nk_group_end(ctx);
}
}
nk_end(ctx);
quit = guiHandler.update();
}
FAIO::quit();
return 0;
}
void drawUI(nk_context* ctx, nk_colorf& bg)
{
nk_glfw3_new_frame();
/* GUI */
if (nk_begin(ctx, "Buttons", nk_rect(1093, 0, 273, 360),
NK_WINDOW_BORDER | NK_WINDOW_BACKGROUND)) {
nk_layout_row_static(ctx, 30, 80, 1);
nk_label(ctx, "Actions", NK_TEXT_LEFT);
nk_layout_row_static(ctx, 30, 100, 2);
if (nk_button_label(ctx, "Pause")) {
Logger::ButtonPress(3);
if (Controller::getInstance().state != Controller::paused) {
prevstate = Controller::getInstance().state;
Controller::getInstance().state = Controller::paused;
}
}
if (nk_button_label(ctx, "Continue")) {
Logger::ButtonPress(1);
if (Controller::getInstance().state > 1)
Controller::getInstance().state = prevstate;
}
if (nk_button_label(ctx, "Generate")) {
Logger::ButtonPress(2);
Controller::getInstance().way = Controller::getInstance().solver.Solve();
if (Controller::getInstance().state == Controller::idle)
Controller::getInstance().state = Controller::prepare;
}
if (nk_button_label(ctx, "Stop")) {
Logger::ButtonPress(0);
if (Controller::getInstance().way[0])
Controller::getInstance().way = std::vector<spin>(1, Controller::getInstance().way[0]);
}
nk_layout_row_static(ctx, 30, 80, 1);
nk_label(ctx, "Manual inputs", NK_TEXT_LEFT);
nk_layout_row_begin(ctx, NK_STATIC, 30, 3); {
nk_layout_row_push(ctx, 60);
if (nk_button_label(ctx, "Left")) {
wayoverride(WL);
}
nk_label(ctx, "White", NK_TEXT_CENTERED);
if (nk_button_label(ctx, "Right")) {
wayoverride(WR);
}
nk_layout_row_push(ctx, 60);
if (nk_button_label(ctx, "Left")) {
wayoverride(YL);
}
nk_label(ctx, "Yellow", NK_TEXT_CENTERED);
if (nk_button_label(ctx, "Right")) {
wayoverride(YR);
}
nk_layout_row_push(ctx, 60);
if (nk_button_label(ctx, "Left")) {
wayoverride(RL);
}
nk_label(ctx, "Red", NK_TEXT_CENTERED);
if (nk_button_label(ctx, "Right")) {
wayoverride(RR);
}
nk_layout_row_push(ctx, 60);
if (nk_button_label(ctx, "Left")) {
wayoverride(BL);
}
nk_label(ctx, "Blue", NK_TEXT_CENTERED);
if (nk_button_label(ctx, "Right")) {
wayoverride(BR);
}
nk_layout_row_push(ctx, 60);
if (nk_button_label(ctx, "Left")) {
wayoverride(OL);
}
nk_label(ctx, "Orange", NK_TEXT_CENTERED);
if (nk_button_label(ctx, "Right")) {
wayoverride(OR);
}
nk_layout_row_push(ctx, 60);
if (nk_button_label(ctx, "Left")) {
wayoverride(GL);
}
nk_label(ctx, "Green", NK_TEXT_CENTERED);
if (nk_button_label(ctx, "Right")) {
wayoverride(GR);
}
}
nk_layout_row_end(ctx);
}
nk_end(ctx);
if (nk_begin(ctx, "Code", nk_rect(1093, 350, 273, 350),
NK_WINDOW_BORDER)) {
static char linenums[256];
std::string buf;
std::istringstream str(Compiler::code);
int linecount = 0;
strcpy(linenums, "");
while (std::getline(str, buf)) strcat(linenums, (std::to_string(++linecount) + "\n").c_str());
strcat(linenums, (std::to_string(++linecount) + "\n").c_str());
nk_layout_row_begin(ctx, NK_STATIC, 200, 2); {
nk_layout_row_push(ctx, 40);
if (nk_group_begin(ctx, "nums", NK_WINDOW_NO_SCROLLBAR)) {
nk_layout_row_static(ctx, 1000, 40, 1);
nk_edit_string_zero_terminated(ctx, NK_EDIT_BOX, linenums, sizeof(linenums), nk_filter_default);
nk_group_end(ctx);
}
nk_layout_row_push(ctx, 200);
if (nk_group_begin(ctx, "text", 0)) {
nk_layout_row_static(ctx, 1000, 176, 1);
nk_edit_string_zero_terminated(ctx, NK_EDIT_BOX, Compiler::code, sizeof(Compiler::code), nk_filter_default);
nk_group_end(ctx);
}
nk_uint *x = new nk_uint(0), *y = new nk_uint(0);
nk_group_get_scroll(ctx, "text", x, y);
nk_group_set_scroll(ctx, "nums", *x, *y);
delete(x); delete(y);
}
nk_layout_row_begin(ctx, NK_STATIC, 30, 2); {
nk_layout_row_push(ctx, 60);
if (nk_button_label(ctx, "Run")) {
Compiler::Compile();
}
if (nk_button_label(ctx, "Save")) {
Compiler::Save();
}
}
nk_layout_row_dynamic(ctx, 200, 1);
nk_edit_string_zero_terminated(ctx, NK_EDIT_BOX, Compiler::output, sizeof(Compiler::output), nk_filter_default);
}
nk_end(ctx);
}
void draw_network_popup(struct nk_context *ctx, struct network_popup *network_settings)
{
const float save_ok_ratio[] = { 0.8f,0.1f,0.1f };
const float udp_tcp_ratio[] = { 0.45f,0.1f,0.45f };
static char udp_ipv4_buffer[30];
static int udp_ipv4_len[30];
static char tcp_pass_buf[30];
static int tcp_pass_len[30];
static char tcp_desc_buf[30];
static int tcp_desc_len[30];
static char send_port_buf[30];
static int send_port_len[30];
static char send_host_buf[30];
static int send_host_len[30];
const char network_attr[][30] = { "-udp port:", "-udp [host:]port:","-sendto host[:port]:","-tcp port:","-tcppassword password:"******"-tcpdesc description:" };
static struct nk_rect s = { 20,30,480,500 };
if (nk_popup_begin(ctx, NK_POPUP_STATIC, "Network Settings", NK_WINDOW_CLOSABLE|NK_WINDOW_NO_SCROLLBAR, s))
{
nk_layout_row_dynamic(ctx, 220, 1);
if(nk_group_begin(ctx, "Receive", NK_WINDOW_TITLE ))
{
nk_layout_row(ctx, NK_DYNAMIC, 21, 3, udp_tcp_ratio);
nk_spacing(ctx, 1);
nk_label(ctx, "UDP:", NK_TEXT_CENTERED);
nk_layout_row_static(ctx, 20, 200, 2);
nk_label(ctx, "Hostname/IPv4 Address:", NK_TEXT_LEFT);
nk_edit_string(ctx, NK_EDIT_SIMPLE, network_settings->udp_ipv4, &network_settings->udp_ipv4_len, 50, nk_filter_default);
nk_layout_row(ctx, NK_DYNAMIC, 21, 3, udp_tcp_ratio);
nk_spacing(ctx, 1);
nk_label(ctx, "TCP:", NK_TEXT_CENTERED);
nk_layout_row_static(ctx, 20, 200, 2);
nk_label(ctx, "Password:"******"Description:", NK_TEXT_LEFT);
nk_edit_string(ctx, NK_EDIT_SIMPLE, network_settings->tcp_desc, &network_settings->tcp_desc_len, 25, nk_filter_default);
nk_group_end(ctx);
}
nk_layout_row_dynamic(ctx, 200, 1);
if (nk_group_begin(ctx, "Send", NK_WINDOW_TITLE ))
{
nk_layout_row(ctx, NK_DYNAMIC, 21, 3, udp_tcp_ratio);
nk_spacing(ctx, 1);
nk_label(ctx, "Send to:", NK_TEXT_CENTERED);
nk_layout_row_static(ctx, 20, 200, 2);
nk_label(ctx, "Port:", NK_TEXT_LEFT);
nk_edit_string(ctx, NK_EDIT_SIMPLE, network_settings->send_port, &network_settings->send_port_len, 25, nk_filter_default);
nk_layout_row_static(ctx, 20, 200, 2);
nk_label(ctx, "Host:", NK_TEXT_LEFT);
nk_edit_string(ctx, NK_EDIT_SIMPLE, network_settings->send_host, &network_settings->send_host_len, 25, nk_filter_default);
nk_group_end(ctx);
}
/*nk_layout_row_static(ctx, 20, 200, 2);
nk_label(ctx, network_attr[5], NK_TEXT_LEFT);
nk_edit_string(ctx, NK_EDIT_SIMPLE, text_buffer[5], &text_len[5], 50, nk_filter_default);*/
//OK Button
nk_layout_row(ctx, NK_DYNAMIC, 27, 3, save_ok_ratio);
nk_spacing(ctx, 1);
if (nk_button_label(ctx, "Save")) {
network_settings->save_network_settings = nk_true;
network_settings->show_network_settings = nk_false;
nk_popup_close(ctx);
}
if (nk_button_label(ctx, "OK")) {
network_settings->save_network_settings = nk_false;
network_settings->show_network_settings = nk_false;
nk_popup_close(ctx);
}
nk_popup_end(ctx);
}
else
network_settings->show_network_settings = nk_false;
}
/* ===============================================================
*
* DEMO
*
* ===============================================================*/
int main(void)
{
/* Platform */
sf::ContextSettings settings(24, 8, 4, 2, 2);
sf::Window win(sf::VideoMode(WINDOW_WIDTH, WINDOW_HEIGHT), "Demo", sf::Style::Default, settings);
win.setVerticalSyncEnabled(true);
win.setActive(true);
glViewport(0, 0, win.getSize().x, win.getSize().y);
/* GUI */
struct nk_context *ctx;
ctx = nk_sfml_init(&win);
/* Load Fonts: if none of these are loaded a default font will be used */
/* Load Cursor: if you uncomment cursor loading please hide the cursor */
struct nk_font_atlas *atlas;
nk_sfml_font_stash_begin(&atlas);
/*struct nk_font *droid = nk_font_atlas_add_from_file(atlas, "../../../extra_font/DroidSans.ttf", 14, 0);*/
/*struct nk_font *roboto = nk_font_atlas_add_from_file(atlas, "../../../extra_font/Roboto-Regular.ttf", 14, 0);*/
/*struct nk_font *future = nk_font_atlas_add_from_file(atlas, "../../../extra_font/kenvector_future_thin.ttf", 13, 0);*/
/*struct nk_font *clean = nk_font_atlas_add_from_file(atlas, "../../../extra_font/ProggyClean.ttf", 12, 0);*/
/*struct nk_font *tiny = nk_font_atlas_add_from_file(atlas, "../../../extra_font/ProggyTiny.ttf", 10, 0);*/
/*struct nk_font *cousine = nk_font_atlas_add_from_file(atlas, "../../../extra_font/Cousine-Regular.ttf", 13, 0);*/
nk_sfml_font_stash_end();
/*nk_style_load_all_cursors(ctx, atlas->cursors);*/
/*nk_style_set_font(ctx, &droid->handle);*/
/* style.c */
#ifdef INCLUDE_STYLE
/*set_style(ctx, THEME_WHITE);*/
/*set_style(ctx, THEME_RED);*/
/*set_style(ctx, THEME_BLUE);*/
/*set_style(ctx, THEME_DARK);*/
#endif
struct nk_colorf bg;
bg.r = 0.10f, bg.g = 0.18f, bg.b = 0.24f, bg.a = 1.0f;
while (win.isOpen())
{
/* Input */
sf::Event evt;
nk_input_begin(ctx);
while(win.pollEvent(evt)) {
if(evt.type == sf::Event::Closed)
win.close();
else if(evt.type == sf::Event::Resized)
glViewport(0, 0, evt.size.width, evt.size.height);
nk_sfml_handle_event(&evt);
}
nk_input_end(ctx);
/* GUI */
if (nk_begin(ctx, "Demo", nk_rect(50, 50, 230, 250),
NK_WINDOW_BORDER|NK_WINDOW_MOVABLE|NK_WINDOW_SCALABLE|
NK_WINDOW_MINIMIZABLE|NK_WINDOW_TITLE))
{
enum {EASY, HARD};
static int op = EASY;
static int property = 20;
nk_layout_row_static(ctx, 30, 80, 1);
if (nk_button_label(ctx, "button"))
fprintf(stdout, "button pressed\n");
nk_layout_row_dynamic(ctx, 30, 2);
if (nk_option_label(ctx, "easy", op == EASY)) op = EASY;
if (nk_option_label(ctx, "hard", op == HARD)) op = HARD;
nk_layout_row_dynamic(ctx, 25, 1);
nk_property_int(ctx, "Compression:", 0, &property, 100, 10, 1);
nk_layout_row_dynamic(ctx, 20, 1);
nk_label(ctx, "background:", NK_TEXT_LEFT);
nk_layout_row_dynamic(ctx, 25, 1);
if (nk_combo_begin_color(ctx, nk_rgb_cf(bg), nk_vec2(nk_widget_width(ctx),400))) {
nk_layout_row_dynamic(ctx, 120, 1);
bg = nk_color_picker(ctx, bg, NK_RGBA);
nk_layout_row_dynamic(ctx, 25, 1);
bg.r = nk_propertyf(ctx, "#R:", 0, bg.r, 1.0f, 0.01f,0.005f);
bg.g = nk_propertyf(ctx, "#G:", 0, bg.g, 1.0f, 0.01f,0.005f);
bg.b = nk_propertyf(ctx, "#B:", 0, bg.b, 1.0f, 0.01f,0.005f);
bg.a = nk_propertyf(ctx, "#A:", 0, bg.a, 1.0f, 0.01f,0.005f);
nk_combo_end(ctx);
}
}
nk_end(ctx);
/* -------------- EXAMPLES ---------------- */
#ifdef INCLUDE_CALCULATOR
calculator(ctx);
#endif
#ifdef INCLUDE_OVERVIEW
overview(ctx);
#endif
#ifdef INCLUDE_NODE_EDITOR
node_editor(ctx);
#endif
/* ----------------------------------------- */
/* Draw */
win.setActive(true);
nk_color_fv(bg, background);
glClear(GL_COLOR_BUFFER_BIT);
glClearColor(bg.r, bg.g, bg.b, bg.a);
/* IMPORTANT: `nk_sfml_render` modifies some global OpenGL state
* with blending, scissor, face culling and depth test and defaults everything
* back into a default state. Make sure to either save and restore or
* reset your own state after drawing rendering the UI. */
nk_sfml_render(NK_ANTI_ALIASING_ON);
win.display();
}
nk_sfml_shutdown();
return 0;
}
void draw_decoders_tab(struct nk_context *ctx, int *tab_screen_height, struct decoders_tab *decoders)
{
*tab_screen_height = 472;
const float field_channel_ratio[] = { 0.5f, 0.5f };
const float services_ratio[] = { 0.3f, 0.002f, 0.2f };
const float min_distance_ratio[] = { 0.45f, 0.01f, 0.2f };
const float max_distance_ratio[] = { 0.73f, 0.01f, 0.2f };
nk_layout_row_dynamic(ctx, 160, 1);
if(nk_group_begin(ctx, "608 Decoder", NK_WINDOW_TITLE|NK_WINDOW_BORDER|NK_WINDOW_NO_SCROLLBAR))
{
nk_layout_row(ctx, NK_DYNAMIC, 85, 2, field_channel_ratio);
if(nk_group_begin(ctx, "Field", NK_WINDOW_TITLE|NK_WINDOW_NO_SCROLLBAR))
{
nk_layout_row_dynamic(ctx, 20, 1);
nk_checkbox_label(ctx, "Extract captions from field 1", &decoders->is_field1);
nk_layout_row_dynamic(ctx, 20, 1);
nk_checkbox_label(ctx, "Extract captions from field 2", &decoders->is_field2);
nk_group_end(ctx);
}
if(nk_group_begin(ctx, "Channel", NK_WINDOW_TITLE|NK_WINDOW_NO_SCROLLBAR))
{
nk_layout_row_dynamic(ctx, 20, 1);
if(nk_option_label(ctx, "Extract captions from channel 1", decoders->channel == CHANNEL_1))
{
decoders->channel = CHANNEL_1;
}
nk_layout_row_dynamic(ctx, 20, 1);
if(nk_option_label(ctx, "Extract captions from channel 2", decoders->channel == CHANNEL_2))
{
decoders->channel = CHANNEL_2;
}
nk_group_end(ctx);
}
nk_layout_row_dynamic(ctx, 40, 1);
nk_label_wrap(ctx, "In general, if you want English subtitles you don't need to use these options. "
"If you want the second language (usually "
"Spanish), you may need to try other combinations.");
nk_group_end(ctx);
}
nk_layout_row_dynamic(ctx, 125, 1);
if(nk_group_begin(ctx, "708 Decoder", NK_WINDOW_TITLE|NK_WINDOW_BORDER|NK_WINDOW_NO_SCROLLBAR))
{
nk_layout_row_dynamic(ctx, 20, 1);
nk_checkbox_label(ctx, "Enable 708 Decoder", &decoders->is_708);
nk_layout_row(ctx, NK_DYNAMIC, 20, 3, services_ratio);
nk_label(ctx, "Process these services", NK_TEXT_LEFT);
nk_spacing(ctx, 1);
nk_edit_string(ctx, NK_EDIT_SIMPLE, decoders->services, &decoders->services_len, 15, nk_filter_ascii);
nk_layout_row_dynamic(ctx, 45, 1);
nk_label_wrap(ctx, "The service list is a comma seperated list of services to process. "
"Valid values: 1 to 63. Ranges are NOT supported.");
nk_group_end(ctx);
}
nk_layout_row_dynamic(ctx, 63, 1);
if(nk_group_begin(ctx, "Teletext or DVB (if both are present)", NK_WINDOW_TITLE|NK_WINDOW_BORDER|NK_WINDOW_NO_SCROLLBAR))
{
nk_layout_row_dynamic(ctx,20, 2);
if(nk_option_label(ctx, "Teletext", decoders->teletext_dvb == TELETEXT)){
decoders->teletext_dvb = TELETEXT;
}
if(nk_option_label(ctx, "DVB", decoders->teletext_dvb == DVB)){
decoders->teletext_dvb = DVB;
}
nk_group_end(ctx);
}
if(decoders->teletext_dvb == TELETEXT)
{
nk_layout_row_dynamic(ctx, 95, 1);
if(nk_group_begin(ctx, "Teletext line duplication", NK_WINDOW_TITLE|NK_WINDOW_BORDER|NK_WINDOW_NO_SCROLLBAR))
{
nk_layout_row(ctx, NK_DYNAMIC, 25, 3, min_distance_ratio);
nk_label(ctx, "Minimum allowed distance (default 2)", NK_TEXT_LEFT);
nk_spacing(ctx, 1);
nk_edit_string(ctx, NK_EDIT_SIMPLE, decoders->min_distance, &decoders->min_distance_len, 3, nk_filter_decimal);
nk_layout_row(ctx, NK_DYNAMIC, 25, 3, max_distance_ratio);
nk_label(ctx, "Maximum allowed distance, as a %age of length (default is 10)", NK_TEXT_LEFT);
nk_spacing(ctx, 1);
nk_edit_string(ctx, NK_EDIT_SIMPLE, decoders->max_distance, &decoders->max_distance_len, 3, nk_filter_decimal);
nk_group_end(ctx);
}
}
}
void draw_credits_tab(struct nk_context *ctx, int *tab_screen_height, struct credits_tab *credits)
{
static struct time before_time, after_time;
const float start_time_ratio[] = { 0.005f, 0.26f, 0.18f, 0.1f, 0.25f, 0.18f };
const float atleast_atmost_ratio[] = { 0.005f, 0.28, 0.1f, 0.36f, 0.1f, 0.1f };
static int start_atleast_int, start_atmost_int;
*tab_screen_height = 472;
//Start Credits Group
nk_layout_row_dynamic(ctx, 210, 1);
if(nk_group_begin(ctx, "Start Credits", NK_WINDOW_TITLE|NK_WINDOW_BORDER|NK_WINDOW_NO_SCROLLBAR))
{
nk_layout_row_dynamic(ctx, 20, 1);
nk_checkbox_label(ctx, "Enable, write below text as soon as possible.", &credits->is_start_text);
nk_layout_row_dynamic(ctx, 85, 1);
nk_edit_string(ctx, NK_EDIT_BOX, credits->start_text, &credits->start_text_len, 1000, nk_filter_ascii);
nk_layout_row(ctx, NK_DYNAMIC, 25, 6, start_time_ratio);
nk_spacing(ctx, 1);
nk_checkbox_label(ctx, "Before (MM:SS)", &credits->is_before);
if (nk_combo_begin_label(ctx, credits->before_time_buffer, nk_vec2(100, 100))) {
nk_layout_row_dynamic(ctx, 25, 1);
sprintf(credits->before_time_buffer, "%02d:%02d", before_time.minutes, before_time.seconds);
before_time.seconds = nk_propertyi(ctx, "#S:", 0, before_time.seconds, 60, 1, 1);
before_time.minutes = nk_propertyi(ctx, "#M:", 0, before_time.minutes, 60, 1, 1);
nk_combo_end(ctx);
}
nk_spacing(ctx, 1);
nk_checkbox_label(ctx, "After (MM:SS)", &credits->is_after);
if (nk_combo_begin_label(ctx, credits->after_time_buffer, nk_vec2(100, 100))) {
nk_layout_row_dynamic(ctx, 25, 1);
sprintf(credits->after_time_buffer, "%02d:%02d", after_time.minutes, after_time.seconds);
after_time.seconds = nk_propertyi(ctx, "#S:", 0, after_time.seconds, 60, 1, 1);
after_time.minutes = nk_propertyi(ctx, "#M:", 0, after_time.minutes, 60, 1, 1);
nk_combo_end(ctx);
}
nk_layout_row(ctx, NK_DYNAMIC, 25, 6, atleast_atmost_ratio);
nk_spacing(ctx, 1);
nk_label(ctx, "Display credits at least", NK_TEXT_LEFT);
nk_edit_string(ctx, NK_EDIT_SIMPLE, credits->start_atleast_sec, &credits->start_atleast_sec_len, 3, nk_filter_decimal);
nk_label(ctx, "seconds and not longer than", NK_TEXT_CENTERED);
nk_edit_string(ctx, NK_EDIT_SIMPLE, credits->start_atmost_sec, &credits->start_atmost_sec_len, 3, nk_filter_decimal);
nk_label(ctx, "seconds", NK_TEXT_RIGHT);
nk_group_end(ctx);
}
//End Credits Group
nk_layout_row_dynamic(ctx, 180, 1);
if(nk_group_begin(ctx, "End Credits", NK_WINDOW_TITLE|NK_WINDOW_BORDER|NK_WINDOW_NO_SCROLLBAR))
{
nk_layout_row_dynamic(ctx, 20, 1);
nk_checkbox_label(ctx, "Enable, write below text after last caption and as close as possible to video end.", &credits->is_end_text);
nk_layout_row_dynamic(ctx, 85, 1);
nk_edit_string(ctx, NK_EDIT_BOX, credits->end_text, &credits->end_text_len, 1000, nk_filter_ascii);
nk_layout_row(ctx,NK_DYNAMIC, 25, 6, atleast_atmost_ratio);
nk_spacing(ctx, 1);
nk_label(ctx, "Display credits at least", NK_TEXT_LEFT);
nk_edit_string(ctx, NK_EDIT_SIMPLE, credits->end_atleast_sec, &credits->end_atleast_sec_len, 3, nk_filter_decimal);
nk_label(ctx, "seconds and not longer than", NK_TEXT_CENTERED);
nk_edit_string(ctx, NK_EDIT_SIMPLE, credits->end_atmost_sec, &credits->end_atmost_sec_len, 3, nk_filter_decimal);
nk_label(ctx, "seconds", NK_TEXT_RIGHT);
nk_group_end(ctx);
}
}
/* ===============================================================
*
* DEMO
*
* ===============================================================*/
int
main(int argc, char* argv[])
{
/* Platform */
SDL_Window *win;
SDL_GLContext glContext;
struct nk_color background;
int win_width, win_height;
int running = 1;
/* GUI */
struct nk_context *ctx;
/* SDL setup */
SDL_SetHint(SDL_HINT_VIDEO_HIGHDPI_DISABLED, "0");
SDL_Init(SDL_INIT_VIDEO|SDL_INIT_TIMER|SDL_INIT_EVENTS);
SDL_GL_SetAttribute (SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG);
SDL_GL_SetAttribute (SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
win = SDL_CreateWindow("Demo",
SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
WINDOW_WIDTH, WINDOW_HEIGHT, SDL_WINDOW_OPENGL|SDL_WINDOW_SHOWN|SDL_WINDOW_ALLOW_HIGHDPI);
glContext = SDL_GL_CreateContext(win);
SDL_GetWindowSize(win, &win_width, &win_height);
/* OpenGL setup */
glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);
glewExperimental = 1;
if (glewInit() != GLEW_OK) {
fprintf(stderr, "Failed to setup GLEW\n");
exit(1);
}
ctx = nk_sdl_init(win);
/* Load Fonts: if none of these are loaded a default font will be used */
{struct nk_font_atlas *atlas;
nk_sdl_font_stash_begin(&atlas);
/*struct nk_font *droid = nk_font_atlas_add_from_file(atlas, "../../../extra_font/DroidSans.ttf", 14, 0);*/
/*struct nk_font *roboto = nk_font_atlas_add_from_file(atlas, "../../../extra_font/Roboto-Regular.ttf", 16, 0);*/
/*struct nk_font *future = nk_font_atlas_add_from_file(atlas, "../../../extra_font/kenvector_future_thin.ttf", 13, 0);*/
/*struct nk_font *clean = nk_font_atlas_add_from_file(atlas, "../../../extra_font/ProggyClean.ttf", 12, 0);*/
/*struct nk_font *tiny = nk_font_atlas_add_from_file(atlas, "../../../extra_font/ProggyTiny.ttf", 10, 0);*/
/*struct nk_font *cousine = nk_font_atlas_add_from_file(atlas, "../../../extra_font/Cousine-Regular.ttf", 13, 0);*/
nk_sdl_font_stash_end();
/*nk_style_set_font(ctx, &roboto->handle)*/;}
/* style.c */
/*set_style(ctx, THEME_WHITE);*/
/*set_style(ctx, THEME_RED);*/
/*set_style(ctx, THEME_BLUE);*/
/*set_style(ctx, THEME_DARK);*/
background = nk_rgb(28,48,62);
while (running)
{
/* Input */
SDL_Event evt;
nk_input_begin(ctx);
while (SDL_PollEvent(&evt)) {
if (evt.type == SDL_QUIT) goto cleanup;
nk_sdl_handle_event(&evt);
}
nk_input_end(ctx);
/* GUI */
{struct nk_panel layout;
if (nk_begin(ctx, &layout, "Demo", nk_rect(200, 200, 210, 250),
NK_WINDOW_BORDER|NK_WINDOW_MOVABLE|NK_WINDOW_SCALABLE|
NK_WINDOW_MINIMIZABLE|NK_WINDOW_TITLE))
{
enum {EASY, HARD};
static int op = EASY;
static int property = 20;
nk_layout_row_static(ctx, 30, 80, 1);
if (nk_button_label(ctx, "button", NK_BUTTON_DEFAULT))
fprintf(stdout, "button pressed\n");
nk_layout_row_dynamic(ctx, 30, 2);
if (nk_option_label(ctx, "easy", op == EASY)) op = EASY;
if (nk_option_label(ctx, "hard", op == HARD)) op = HARD;
nk_layout_row_dynamic(ctx, 25, 1);
nk_property_int(ctx, "Compression:", 0, &property, 100, 10, 1);
{struct nk_panel combo;
nk_layout_row_dynamic(ctx, 20, 1);
nk_label(ctx, "background:", NK_TEXT_LEFT);
nk_layout_row_dynamic(ctx, 25, 1);
if (nk_combo_begin_color(ctx, &combo, background, 400)) {
nk_layout_row_dynamic(ctx, 120, 1);
background = nk_color_picker(ctx, background, NK_RGBA);
nk_layout_row_dynamic(ctx, 25, 1);
background.r = (nk_byte)nk_propertyi(ctx, "#R:", 0, background.r, 255, 1,1);
background.g = (nk_byte)nk_propertyi(ctx, "#G:", 0, background.g, 255, 1,1);
background.b = (nk_byte)nk_propertyi(ctx, "#B:", 0, background.b, 255, 1,1);
background.a = (nk_byte)nk_propertyi(ctx, "#A:", 0, background.a, 255, 1,1);
nk_combo_end(ctx);
}}
}
nk_end(ctx);}
/* -------------- EXAMPLES ---------------- */
/*calculator(ctx);*/
/*overview(ctx);*/
/*node_editor(ctx);*/
/* ----------------------------------------- */
/* Draw */
{float bg[4];
nk_color_fv(bg, background);
SDL_GetWindowSize(win, &win_width, &win_height);
glViewport(0, 0, win_width, win_height);
glClear(GL_COLOR_BUFFER_BIT);
glClearColor(bg[0], bg[1], bg[2], bg[3]);
/* IMPORTANT: `nk_sdl_render` modifies some global OpenGL state
* with blending, scissor, face culling, depth test and viewport and
* defaults everything back into a default state.
* Make sure to either a.) save and restore or b.) reset your own state after
* rendering the UI. */
nk_sdl_render(NK_ANTI_ALIASING_ON, MAX_VERTEX_MEMORY, MAX_ELEMENT_MEMORY);
SDL_GL_SwapWindow(win);}
}
cleanup:
nk_sdl_shutdown();
SDL_GL_DeleteContext(glContext);
SDL_DestroyWindow(win);
SDL_Quit();
return 0;
}
void draw_hd_homerun_tab(struct nk_context *ctx, int *tab_screen_height,
struct hd_homerun_tab *hd_homerun,
struct main_tab *main_settings)
{
*tab_screen_height = 472;
int setup_device = nk_false;
const float location_ratio[] = { 0.35f, 0.5f, 0.15f };
const float devices_ratio[] = { 0.8f, 0.2f };
const float tuner_ratio[] = { .35f, 0.4f, 0.13 };
const float channel_ratio[] = { 0.35f, 0.4f };
const float program_ratio[] = { 0.35f, 0.4f };
const float done_ratio[] = { 0.45f, 0.1f };
const float ipv4_ratio[] = { 0.35f, 0.4f};
const float port_ratio[] = { 0.35f, 0.4f };
static int before_selected, after_selected;
static int done = nk_false;
#if HD_HOMERUN
nk_layout_row_dynamic(ctx, 25, 1);
nk_label_colored_wrap(ctx, "'hdhomerun_config' command line utility found in environment.", nk_rgb(60, 255, 60));
#else
nk_layout_row(ctx, NK_DYNAMIC, 25, 3, location_ratio);
nk_label(ctx, "'hdhomerun_config' utility*:", NK_TEXT_LEFT);
nk_edit_string(ctx, NK_EDIT_SIMPLE, hd_homerun->location, &hd_homerun->location_len, 260, nk_filter_ascii);
if(nk_button_label(ctx, "Browse"))
{
hd_homerun->is_homerun_browser_active = nk_true;
main_settings->scaleWindowForFileBrowser = nk_true;
}
nk_layout_row_dynamic(ctx, 40, 1);
nk_label_wrap(ctx, "*Absolute location of 'hdhomerun_config' executable. Displaying this message means "
"either utility is not installed or environment variables aren't set for proper detection.");
#endif
nk_layout_row_dynamic(ctx, 120, 1);
if(nk_group_begin(ctx, "Choose a device:", NK_WINDOW_TITLE|NK_WINDOW_BORDER))
{
if(hd_homerun->device_num == 0)
{
nk_layout_row_dynamic(ctx, 20, 1);
nk_label_wrap(ctx, "No devices found, yet. Please check your settings and try again.");
}
else
{
nk_layout_row_dynamic(ctx, 20, 1);
for(int i = 0; i < hd_homerun->device_num; i++)
{
nk_selectable_label(ctx, hd_homerun->devices[i], NK_TEXT_LEFT, &hd_homerun->device_select[i]);
if(hd_homerun->device_select[i])
{
before_selected = i - 1;
after_selected = i + 1;
for( int j = 0; j <= before_selected; j++)
hd_homerun->device_select[j] = nk_false;
for(int j = after_selected; j < hd_homerun->device_num; j++)
hd_homerun->device_select[j] = nk_false;
}
}
for(int i = 0; i < hd_homerun->device_num; i++)
{
if(hd_homerun->device_select[i] == nk_true)
{
hd_homerun->selected = i;
break;
}
else
hd_homerun->selected = -1;
}
}
nk_group_end(ctx);
}
nk_layout_row(ctx, NK_DYNAMIC, 25, 2, devices_ratio);
nk_spacing(ctx, 1);
if(hd_homerun->selected == -1)
{
if(nk_button_label(ctx, "Find Devices"))
{
pthread_attr_init(&attr_find);
int err = pthread_create(&tid_find, &attr_find, find_hd_homerun_devices, hd_homerun);
if(!err)
printf("Find Device thread created!\n");
}
}
if(hd_homerun->selected != -1 && done == nk_false)
{
nk_layout_row(ctx, NK_DYNAMIC, 25, 3, tuner_ratio);
nk_label(ctx, "Tuner number in use:", NK_TEXT_LEFT);
nk_edit_string(ctx, NK_EDIT_SIMPLE, hd_homerun->tuner, &hd_homerun->tuner_len, 2, nk_filter_decimal);
nk_label(ctx, "(default is 0)", NK_TEXT_RIGHT);
nk_layout_row(ctx, NK_DYNAMIC, 25, 2, channel_ratio);
nk_label(ctx, "Channel number to select:", NK_TEXT_LEFT);
nk_edit_string(ctx, NK_EDIT_SIMPLE, hd_homerun->channel, &hd_homerun->channel_len, 5, nk_filter_decimal);
nk_layout_row(ctx, NK_DYNAMIC, 25, 2, program_ratio);
nk_label(ctx, "Program number for extraction:", NK_TEXT_LEFT);
nk_edit_string(ctx, NK_EDIT_SIMPLE, hd_homerun->program, &hd_homerun->program_len, 10, nk_filter_decimal);
nk_layout_row(ctx, NK_DYNAMIC, 25, 2,ipv4_ratio);
nk_label(ctx, "Target IPv4 address:", NK_TEXT_LEFT);
nk_edit_string(ctx, NK_EDIT_SIMPLE, hd_homerun->ipv4_address, &hd_homerun->ipv4_address_len, 16, nk_filter_ascii);
nk_layout_row(ctx, NK_DYNAMIC, 25, 2, port_ratio);
nk_label(ctx, "Target Port number:", NK_TEXT_LEFT);
nk_edit_string(ctx, NK_EDIT_SIMPLE, hd_homerun->port_number, &hd_homerun->port_number_len, 7, nk_filter_decimal);
nk_layout_row(ctx, NK_DYNAMIC, 25, 2, done_ratio);
nk_spacing(ctx, 1);
if(nk_button_label(ctx, "Done"))
{
pthread_attr_init(&attr_setup);
int err = pthread_create(&tid_setup, &attr_setup, setup_hd_homerun_device, hd_homerun);
if(!err)
printf("Setup Device thread created!\n");
pthread_join(tid_setup, NULL);
done = nk_true;
}
}
if (done == nk_true)
{
nk_layout_row_dynamic(ctx, 20, 1);
nk_label(ctx, "Stream is being transimitted to target.", NK_TEXT_CENTERED);
nk_layout_row_dynamic(ctx, 20, 1);
nk_label(ctx, "Please start CCExtractor with UDP settings if not started.", NK_TEXT_CENTERED);
}
}
void nk_wnd_main(nk_menu_handle_t *nk, const char* title)
{
unsigned i;
video_shader_ctx_t shader_info;
struct nk_panel layout;
struct nk_context *ctx = &nk->ctx;
const int id = NK_WND_MAIN;
settings_t *settings = config_get_ptr();
char core_basename[PATH_MAX_LENGTH] = {0};
static char picker_filter[PATH_MAX_LENGTH];
static char picker_title[PATH_MAX_LENGTH];
static char* picker_startup_dir;
int len_core, len_content = 0;
strlcpy(core_basename, path_basename(core), sizeof(core_basename));
if (!out)
out = core;
if (!string_is_empty(core))
len_core = strlen(path_basename(core));
if (!string_is_empty(content))
len_content = strlen(content);
if (nk->window[NK_WND_FILE_PICKER].open)
{
if (nk_wnd_file_picker(nk, picker_title, picker_startup_dir, out, picker_filter))
{
RARCH_LOG ("%s selected\n", out);
nk_window_close(&nk->ctx, picker_title);
}
}
if (nk_begin(ctx, &layout, title, nk_rect(240, 10, 600, 400),
NK_WINDOW_CLOSABLE|NK_WINDOW_MINIMIZABLE|NK_WINDOW_MOVABLE|
NK_WINDOW_SCALABLE|NK_WINDOW_BORDER))
{
nk_layout_row_dynamic(ctx, 30, 1);
nk_label(ctx,"Core:", NK_TEXT_LEFT);
nk_layout_row(ctx, NK_DYNAMIC, 30, 3, ratio);
nk_edit_string(ctx, NK_EDIT_SIMPLE, core_basename, &len_core, 64, nk_filter_default);
if (nk_button_text(ctx, "...", 3, NK_BUTTON_DEFAULT))
{
out = core;
strlcpy(picker_title, "Select core", sizeof(picker_title));
strlcpy(picker_filter, ".dll", sizeof(picker_filter));
picker_startup_dir = settings->directory.libretro;
nk->window[NK_WND_FILE_PICKER].open = true;
}
nk_layout_row_dynamic(ctx, 30, 1);
nk_label(ctx,"Content:", NK_TEXT_LEFT);
nk_layout_row(ctx, NK_DYNAMIC, 30, 3, ratio);
nk_edit_string(ctx, NK_EDIT_SIMPLE, content, &len_content, 64, nk_filter_default);
if (nk_button_text(ctx, "...", 3, NK_BUTTON_DEFAULT))
{
out = content;
strlcpy(picker_title, "Select content", sizeof(picker_title));
strlcpy(picker_filter, ".zip", sizeof(picker_filter));
picker_startup_dir = settings->directory.menu_content;
nk->window[NK_WND_FILE_PICKER].open = true;
}
}
/* save position and size to restore after context reset */
nk_wnd_set_state(nk, id, nk_window_get_position(ctx), nk_window_get_size(ctx));
nk_end(ctx);
}
int initialize(int w, int h)
{
struct nk_color background;
int running = 1;
float bg[4];
int draw_buffer[1024 * 16];
ctx = nk_headless_init(w, h, 8, 8);
background = nk_rgb(28,48,62);
while (running)
{
/* Input */
nk_input_begin(ctx);
if (nk_headless_handle_event() == nk_false) {
goto cleanup;
}
nk_input_end(ctx);
/* GUI */
{struct nk_panel layout;
if (nk_begin(ctx, &layout, "Demo", nk_rect(50, 50, 210, 250),
NK_WINDOW_BORDER|NK_WINDOW_MOVABLE|NK_WINDOW_SCALABLE|
NK_WINDOW_MINIMIZABLE|NK_WINDOW_TITLE))
{
enum {EASY, HARD};
static int op = EASY;
static int property = 20;
static char buffer[64];
static int len;
nk_layout_row_static(ctx, 30, 80, 1);
if (nk_button_label(ctx, "button", NK_BUTTON_DEFAULT))
fprintf(stdout, "button pressed\n");
nk_layout_row_dynamic(ctx, 30, 2);
if (nk_option_label(ctx, "easy", op == EASY)) op = EASY;
if (nk_option_label(ctx, "hard", op == HARD)) op = HARD;
nk_layout_row_dynamic(ctx, 25, 1);
nk_property_int(ctx, "Compression:", 0, &property, 100, 10, 1);
nk_edit_string(ctx, NK_EDIT_SIMPLE, buffer, &len, 64, 0);
{struct nk_panel combo;
nk_layout_row_dynamic(ctx, 30, 1);
nk_label(ctx, "background:", NK_TEXT_LEFT);
nk_layout_row_dynamic(ctx, 25, 1);
if (nk_combo_begin_color(ctx, &combo, background, 400)) {
nk_layout_row_dynamic(ctx, 120, 1);
background = nk_color_picker(ctx, background, NK_RGBA);
nk_layout_row_dynamic(ctx, 25, 1);
background.r = (nk_byte)nk_propertyi(ctx, "#R:", 0, background.r, 255, 1,1);
background.g = (nk_byte)nk_propertyi(ctx, "#G:", 0, background.g, 255, 1,1);
background.b = (nk_byte)nk_propertyi(ctx, "#B:", 0, background.b, 255, 1,1);
background.a = (nk_byte)nk_propertyi(ctx, "#A:", 0, background.a, 255, 1,1);
nk_combo_end(ctx);
}}
}
nk_end(ctx);}
/* Draw */
nk_color_fv(bg, background);
nk_headless_clear(nk_rgb(30,30,30));
nk_headless_render(draw_buffer);
}
cleanup:
nk_headless_shutdown();
/*SDL_Quit();*/
return 0;
}
