main.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775
  1. #include "main.h"
  2. #include <errno.h>
  3. #include <fcntl.h>
  4. #include <linux/videodev2.h>
  5. #include <linux/media.h>
  6. #include <linux/v4l2-subdev.h>
  7. #include <sys/ioctl.h>
  8. #include <sys/mman.h>
  9. #include <sys/stat.h>
  10. #include <time.h>
  11. #include <assert.h>
  12. #include <limits.h>
  13. #include <linux/kdev_t.h>
  14. #include <sys/sysmacros.h>
  15. #include <asm/errno.h>
  16. #include <wordexp.h>
  17. #include <gtk/gtk.h>
  18. #include <locale.h>
  19. #include <zbar.h>
  20. #include "camera_config.h"
  21. #include "quickpreview.h"
  22. #include "io_pipeline.h"
  23. enum user_control { USER_CONTROL_ISO, USER_CONTROL_SHUTTER };
  24. static bool camera_is_initialized = false;
  25. static const struct mp_camera_config *camera = NULL;
  26. static MPCameraMode mode;
  27. static int preview_width = -1;
  28. static int preview_height = -1;
  29. static bool gain_is_manual = false;
  30. static int gain;
  31. static int gain_max;
  32. static bool exposure_is_manual = false;
  33. static int exposure;
  34. static bool has_auto_focus_continuous;
  35. static bool has_auto_focus_start;
  36. static cairo_surface_t *surface = NULL;
  37. static cairo_surface_t *status_surface = NULL;
  38. static char last_path[260] = "";
  39. static MPZBarScanResult *zbar_result = NULL;
  40. static int burst_length = 3;
  41. static enum user_control current_control;
  42. // Widgets
  43. GtkWidget *preview;
  44. GtkWidget *error_box;
  45. GtkWidget *error_message;
  46. GtkWidget *main_stack;
  47. GtkWidget *open_last_stack;
  48. GtkWidget *thumb_last;
  49. GtkWidget *process_spinner;
  50. GtkWidget *control_box;
  51. GtkWidget *control_name;
  52. GtkAdjustment *control_slider;
  53. GtkWidget *control_auto;
  54. int
  55. remap(int value, int input_min, int input_max, int output_min, int output_max)
  56. {
  57. const long long factor = 1000000000;
  58. long long output_spread = output_max - output_min;
  59. long long input_spread = input_max - input_min;
  60. long long zero_value = value - input_min;
  61. zero_value *= factor;
  62. long long percentage = zero_value / input_spread;
  63. long long zero_output = percentage * output_spread / factor;
  64. long long result = output_min + zero_output;
  65. return (int)result;
  66. }
  67. static void
  68. update_io_pipeline()
  69. {
  70. struct mp_io_pipeline_state io_state = {
  71. .camera = camera,
  72. .burst_length = burst_length,
  73. .preview_width = preview_width,
  74. .preview_height = preview_height,
  75. .gain_is_manual = gain_is_manual,
  76. .gain = gain,
  77. .exposure_is_manual = exposure_is_manual,
  78. .exposure = exposure,
  79. };
  80. mp_io_pipeline_update_state(&io_state);
  81. }
  82. static bool
  83. update_state(const struct mp_main_state *state)
  84. {
  85. if (!camera_is_initialized) {
  86. camera_is_initialized = true;
  87. }
  88. if (camera == state->camera) {
  89. mode = state->mode;
  90. if (!gain_is_manual) {
  91. gain = state->gain;
  92. }
  93. gain_max = state->gain_max;
  94. if (!exposure_is_manual) {
  95. exposure = state->exposure;
  96. }
  97. has_auto_focus_continuous = state->has_auto_focus_continuous;
  98. has_auto_focus_start = state->has_auto_focus_start;
  99. }
  100. return false;
  101. }
  102. void
  103. mp_main_update_state(const struct mp_main_state *state)
  104. {
  105. struct mp_main_state *state_copy = malloc(sizeof(struct mp_main_state));
  106. *state_copy = *state;
  107. g_main_context_invoke_full(g_main_context_default(), G_PRIORITY_DEFAULT_IDLE,
  108. (GSourceFunc)update_state, state_copy, free);
  109. }
  110. static bool set_zbar_result(MPZBarScanResult *result)
  111. {
  112. if (zbar_result) {
  113. for (uint8_t i = 0; i < zbar_result->size; ++i) {
  114. free(zbar_result->codes[i].data);
  115. }
  116. free(zbar_result);
  117. }
  118. zbar_result = result;
  119. gtk_widget_queue_draw(preview);
  120. return false;
  121. }
  122. void mp_main_set_zbar_result(MPZBarScanResult *result)
  123. {
  124. g_main_context_invoke_full(g_main_context_default(), G_PRIORITY_DEFAULT_IDLE,
  125. (GSourceFunc)set_zbar_result, result, NULL);
  126. }
  127. static bool
  128. set_preview(cairo_surface_t *image)
  129. {
  130. if (surface) {
  131. cairo_surface_destroy(surface);
  132. }
  133. surface = image;
  134. gtk_widget_queue_draw(preview);
  135. return false;
  136. }
  137. void
  138. mp_main_set_preview(cairo_surface_t *image)
  139. {
  140. g_main_context_invoke_full(g_main_context_default(), G_PRIORITY_DEFAULT_IDLE,
  141. (GSourceFunc)set_preview, image, NULL);
  142. }
  143. static void transform_centered(cairo_t *cr, uint32_t dst_width, uint32_t dst_height,
  144. int src_width, int src_height)
  145. {
  146. cairo_translate(cr, dst_width / 2, dst_height / 2);
  147. double scale = MIN(dst_width / (double)src_width, dst_height / (double)src_height);
  148. cairo_scale(cr, scale, scale);
  149. cairo_translate(cr, -src_width / 2, -src_height / 2);
  150. }
  151. void
  152. draw_surface_scaled_centered(cairo_t *cr, uint32_t dst_width, uint32_t dst_height,
  153. cairo_surface_t *surface)
  154. {
  155. cairo_save(cr);
  156. int width = cairo_image_surface_get_width(surface);
  157. int height = cairo_image_surface_get_height(surface);
  158. transform_centered(cr, dst_width, dst_height, width, height);
  159. cairo_set_source_surface(cr, surface, 0, 0);
  160. cairo_paint(cr);
  161. cairo_restore(cr);
  162. }
  163. struct capture_completed_args {
  164. cairo_surface_t *thumb;
  165. char *fname;
  166. };
  167. static bool
  168. capture_completed(struct capture_completed_args *args)
  169. {
  170. strncpy(last_path, args->fname, 259);
  171. gtk_image_set_from_surface(GTK_IMAGE(thumb_last), args->thumb);
  172. gtk_spinner_stop(GTK_SPINNER(process_spinner));
  173. gtk_stack_set_visible_child(GTK_STACK(open_last_stack), thumb_last);
  174. cairo_surface_destroy(args->thumb);
  175. g_free(args->fname);
  176. return false;
  177. }
  178. void
  179. mp_main_capture_completed(cairo_surface_t *thumb, const char *fname)
  180. {
  181. struct capture_completed_args *args = malloc(sizeof(struct capture_completed_args));
  182. args->thumb = thumb;
  183. args->fname = g_strdup(fname);
  184. g_main_context_invoke_full(g_main_context_default(), G_PRIORITY_DEFAULT_IDLE,
  185. (GSourceFunc)capture_completed, args, free);
  186. }
  187. static void
  188. draw_controls()
  189. {
  190. cairo_t *cr;
  191. char iso[6];
  192. int temp;
  193. char shutterangle[6];
  194. if (exposure_is_manual) {
  195. temp = (int)((float)exposure / (float)camera->capture_mode.height *
  196. 360);
  197. sprintf(shutterangle, "%d\u00b0", temp);
  198. } else {
  199. sprintf(shutterangle, "auto");
  200. }
  201. if (gain_is_manual) {
  202. temp = remap(gain - 1, 0, gain_max, camera->iso_min,
  203. camera->iso_max);
  204. sprintf(iso, "%d", temp);
  205. } else {
  206. sprintf(iso, "auto");
  207. }
  208. if (status_surface)
  209. cairo_surface_destroy(status_surface);
  210. // Make a service to show status of controls, 32px high
  211. if (gtk_widget_get_window(preview) == NULL) {
  212. return;
  213. }
  214. status_surface =
  215. gdk_window_create_similar_surface(gtk_widget_get_window(preview),
  216. CAIRO_CONTENT_COLOR_ALPHA,
  217. preview_width, 32);
  218. cr = cairo_create(status_surface);
  219. cairo_set_source_rgba(cr, 0, 0, 0, 0.0);
  220. cairo_paint(cr);
  221. // Draw the outlines for the headings
  222. cairo_select_font_face(cr, "sans-serif", CAIRO_FONT_SLANT_NORMAL,
  223. CAIRO_FONT_WEIGHT_BOLD);
  224. cairo_set_font_size(cr, 9);
  225. cairo_set_source_rgba(cr, 0, 0, 0, 1);
  226. cairo_move_to(cr, 16, 16);
  227. cairo_text_path(cr, "ISO");
  228. cairo_stroke(cr);
  229. cairo_move_to(cr, 60, 16);
  230. cairo_text_path(cr, "Shutter");
  231. cairo_stroke(cr);
  232. // Draw the fill for the headings
  233. cairo_set_source_rgba(cr, 1, 1, 1, 1);
  234. cairo_move_to(cr, 16, 16);
  235. cairo_show_text(cr, "ISO");
  236. cairo_move_to(cr, 60, 16);
  237. cairo_show_text(cr, "Shutter");
  238. // Draw the outlines for the values
  239. cairo_select_font_face(cr, "sans-serif", CAIRO_FONT_SLANT_NORMAL,
  240. CAIRO_FONT_WEIGHT_NORMAL);
  241. cairo_set_font_size(cr, 11);
  242. cairo_set_source_rgba(cr, 0, 0, 0, 1);
  243. cairo_move_to(cr, 16, 26);
  244. cairo_text_path(cr, iso);
  245. cairo_stroke(cr);
  246. cairo_move_to(cr, 60, 26);
  247. cairo_text_path(cr, shutterangle);
  248. cairo_stroke(cr);
  249. // Draw the fill for the values
  250. cairo_set_source_rgba(cr, 1, 1, 1, 1);
  251. cairo_move_to(cr, 16, 26);
  252. cairo_show_text(cr, iso);
  253. cairo_move_to(cr, 60, 26);
  254. cairo_show_text(cr, shutterangle);
  255. cairo_destroy(cr);
  256. gtk_widget_queue_draw_area(preview, 0, 0, preview_width, 32);
  257. }
  258. static gboolean
  259. preview_draw(GtkWidget *widget, cairo_t *cr, gpointer data)
  260. {
  261. if (!camera_is_initialized) {
  262. return FALSE;
  263. }
  264. // Clear preview area with black
  265. cairo_paint(cr);
  266. if (surface) {
  267. // Draw camera preview
  268. cairo_save(cr);
  269. int width = cairo_image_surface_get_width(surface);
  270. int height = cairo_image_surface_get_height(surface);
  271. transform_centered(cr, preview_width, preview_height, width, height);
  272. cairo_set_source_surface(cr, surface, 0, 0);
  273. cairo_paint(cr);
  274. // Draw zbar image
  275. if (zbar_result) {
  276. for (uint8_t i = 0; i < zbar_result->size; ++i) {
  277. MPZBarCode *code = &zbar_result->codes[i];
  278. cairo_set_source_rgba(cr, 1, 1, 1, 0.5);
  279. cairo_new_path(cr);
  280. cairo_move_to(cr, code->bounds_x[0], code->bounds_y[0]);
  281. for (uint8_t i = 0; i < 4; ++i) {
  282. cairo_line_to(cr, code->bounds_x[i], code->bounds_y[i]);
  283. }
  284. cairo_close_path(cr);
  285. cairo_stroke(cr);
  286. cairo_save(cr);
  287. cairo_translate(cr, code->bounds_x[0], code->bounds_y[0]);
  288. cairo_show_text(cr, code->data);
  289. cairo_restore(cr);
  290. }
  291. }
  292. cairo_restore(cr);
  293. }
  294. // Draw control overlay
  295. cairo_set_source_surface(cr, status_surface, 0, 0);
  296. cairo_paint(cr);
  297. return FALSE;
  298. }
  299. static gboolean
  300. preview_configure(GtkWidget *widget, GdkEventConfigure *event)
  301. {
  302. int new_preview_width = gtk_widget_get_allocated_width(widget);
  303. int new_preview_height = gtk_widget_get_allocated_height(widget);
  304. if (preview_width != new_preview_width ||
  305. preview_height != new_preview_height) {
  306. preview_width = new_preview_width;
  307. preview_height = new_preview_height;
  308. update_io_pipeline();
  309. }
  310. draw_controls();
  311. return TRUE;
  312. }
  313. void
  314. on_open_last_clicked(GtkWidget *widget, gpointer user_data)
  315. {
  316. char uri[275];
  317. GError *error = NULL;
  318. if (strlen(last_path) == 0) {
  319. return;
  320. }
  321. sprintf(uri, "file://%s", last_path);
  322. if (!g_app_info_launch_default_for_uri(uri, NULL, &error)) {
  323. g_printerr("Could not launch image viewer for '%s': %s\n", uri, error->message);
  324. }
  325. }
  326. void
  327. on_open_directory_clicked(GtkWidget *widget, gpointer user_data)
  328. {
  329. char uri[270];
  330. GError *error = NULL;
  331. sprintf(uri, "file://%s", g_get_user_special_dir(G_USER_DIRECTORY_PICTURES));
  332. if (!g_app_info_launch_default_for_uri(uri, NULL, &error)) {
  333. g_printerr("Could not launch image viewer: %s\n", error->message);
  334. }
  335. }
  336. void
  337. on_shutter_clicked(GtkWidget *widget, gpointer user_data)
  338. {
  339. gtk_spinner_start(GTK_SPINNER(process_spinner));
  340. gtk_stack_set_visible_child(GTK_STACK(open_last_stack), process_spinner);
  341. mp_io_pipeline_capture();
  342. }
  343. static bool
  344. check_point_inside_bounds(int x, int y, int *bounds_x, int *bounds_y)
  345. {
  346. bool right = false, left = false, top = false, bottom = false;
  347. for (int i = 0; i < 4; ++i) {
  348. if (x <= bounds_x[i])
  349. left = true;
  350. if (x >= bounds_x[i])
  351. right = true;
  352. if (y <= bounds_y[i])
  353. top = true;
  354. if (y >= bounds_y[i])
  355. bottom = true;
  356. }
  357. return right && left && top && bottom;
  358. }
  359. static void
  360. on_zbar_code_tapped(GtkWidget *widget, const MPZBarCode *code)
  361. {
  362. GtkWidget *dialog;
  363. GtkDialogFlags flags = GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT;
  364. bool data_is_url = strncmp(code->data, "http://", 7) == 0
  365. || strncmp(code->data, "https://", 8) == 0
  366. || strncmp(code->data, "gemini://", 9) == 0;
  367. char* data = strdup(code->data);
  368. if (data_is_url) {
  369. dialog = gtk_message_dialog_new(
  370. GTK_WINDOW(gtk_widget_get_toplevel(widget)),
  371. flags,
  372. GTK_MESSAGE_QUESTION,
  373. GTK_BUTTONS_NONE,
  374. "Found a URL '%s' encoded in a %s code.",
  375. code->data,
  376. code->type);
  377. gtk_dialog_add_buttons(
  378. GTK_DIALOG(dialog),
  379. "_Open URL",
  380. GTK_RESPONSE_YES,
  381. NULL);
  382. } else {
  383. dialog = gtk_message_dialog_new(
  384. GTK_WINDOW(gtk_widget_get_toplevel(widget)),
  385. flags,
  386. GTK_MESSAGE_QUESTION,
  387. GTK_BUTTONS_NONE,
  388. "Found '%s' encoded in a %s code.",
  389. code->data,
  390. code->type);
  391. }
  392. gtk_dialog_add_buttons(
  393. GTK_DIALOG(dialog),
  394. "_Copy",
  395. GTK_RESPONSE_ACCEPT,
  396. "_Cancel",
  397. GTK_RESPONSE_CANCEL,
  398. NULL);
  399. int result = gtk_dialog_run(GTK_DIALOG(dialog));
  400. GError *error = NULL;
  401. switch (result) {
  402. case GTK_RESPONSE_YES:
  403. if (!g_app_info_launch_default_for_uri(data,
  404. NULL, &error)) {
  405. g_printerr("Could not launch browser: %s\n",
  406. error->message);
  407. }
  408. case GTK_RESPONSE_ACCEPT:
  409. gtk_clipboard_set_text(
  410. gtk_clipboard_get(GDK_SELECTION_PRIMARY),
  411. data, -1);
  412. case GTK_RESPONSE_CANCEL:
  413. break;
  414. default:
  415. g_printerr("Wrong dialog result: %d\n", result);
  416. }
  417. gtk_widget_destroy(dialog);
  418. }
  419. void
  420. on_preview_tap(GtkWidget *widget, GdkEventButton *event, gpointer user_data)
  421. {
  422. if (event->type != GDK_BUTTON_PRESS)
  423. return;
  424. // Handle taps on the controls
  425. if (event->y < 32) {
  426. if (gtk_widget_is_visible(control_box)) {
  427. gtk_widget_hide(control_box);
  428. return;
  429. } else {
  430. gtk_widget_show(control_box);
  431. }
  432. if (event->x < 60) {
  433. // ISO
  434. current_control = USER_CONTROL_ISO;
  435. gtk_label_set_text(GTK_LABEL(control_name), "ISO");
  436. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(control_auto),
  437. !gain_is_manual);
  438. gtk_adjustment_set_lower(control_slider, 0.0);
  439. gtk_adjustment_set_upper(control_slider, (float)gain_max);
  440. gtk_adjustment_set_value(control_slider, (double)gain);
  441. } else if (event->x > 60 && event->x < 120) {
  442. // Shutter angle
  443. current_control = USER_CONTROL_SHUTTER;
  444. gtk_label_set_text(GTK_LABEL(control_name), "Shutter");
  445. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(control_auto),
  446. !exposure_is_manual);
  447. gtk_adjustment_set_lower(control_slider, 1.0);
  448. gtk_adjustment_set_upper(control_slider, 360.0);
  449. gtk_adjustment_set_value(control_slider, (double)exposure);
  450. }
  451. return;
  452. }
  453. // Tapped zbar result
  454. if (zbar_result) {
  455. // Transform the event coordinates to the image
  456. int width = cairo_image_surface_get_width(surface);
  457. int height = cairo_image_surface_get_height(surface);
  458. double scale = MIN(preview_width / (double)width, preview_height / (double)height);
  459. int x = (event->x - preview_width / 2) / scale + width / 2;
  460. int y = (event->y - preview_height / 2) / scale + height / 2;
  461. for (uint8_t i = 0; i < zbar_result->size; ++i) {
  462. MPZBarCode *code = &zbar_result->codes[i];
  463. if (check_point_inside_bounds(x, y, code->bounds_x, code->bounds_y)) {
  464. on_zbar_code_tapped(widget, code);
  465. return;
  466. }
  467. }
  468. }
  469. // Tapped preview image itself, try focussing
  470. if (has_auto_focus_start) {
  471. mp_io_pipeline_focus();
  472. }
  473. }
  474. void
  475. on_error_close_clicked(GtkWidget *widget, gpointer user_data)
  476. {
  477. gtk_widget_hide(error_box);
  478. }
  479. void
  480. on_camera_switch_clicked(GtkWidget *widget, gpointer user_data)
  481. {
  482. size_t next_index = camera->index + 1;
  483. const struct mp_camera_config *next_camera =
  484. mp_get_camera_config(next_index);
  485. if (!next_camera) {
  486. next_index = 0;
  487. next_camera = mp_get_camera_config(next_index);
  488. }
  489. camera = next_camera;
  490. update_io_pipeline();
  491. }
  492. void
  493. on_settings_btn_clicked(GtkWidget *widget, gpointer user_data)
  494. {
  495. gtk_stack_set_visible_child_name(GTK_STACK(main_stack), "settings");
  496. }
  497. void
  498. on_back_clicked(GtkWidget *widget, gpointer user_data)
  499. {
  500. gtk_stack_set_visible_child_name(GTK_STACK(main_stack), "main");
  501. }
  502. void
  503. on_control_auto_toggled(GtkToggleButton *widget, gpointer user_data)
  504. {
  505. bool is_manual = gtk_toggle_button_get_active(widget) ? false : true;
  506. bool has_changed;
  507. switch (current_control) {
  508. case USER_CONTROL_ISO:
  509. if (gain_is_manual != is_manual) {
  510. gain_is_manual = is_manual;
  511. has_changed = true;
  512. }
  513. break;
  514. case USER_CONTROL_SHUTTER:
  515. if (exposure_is_manual != is_manual) {
  516. exposure_is_manual = is_manual;
  517. has_changed = true;
  518. }
  519. break;
  520. }
  521. if (has_changed) {
  522. // The slider might have been moved while Auto mode is active. When entering
  523. // Manual mode, first read the slider value to sync with those changes.
  524. double value = gtk_adjustment_get_value(control_slider);
  525. switch (current_control) {
  526. case USER_CONTROL_ISO:
  527. if (value != gain) {
  528. gain = (int)value;
  529. }
  530. break;
  531. case USER_CONTROL_SHUTTER: {
  532. // So far all sensors use exposure time in number of sensor rows
  533. int new_exposure =
  534. (int)(value / 360.0 * camera->capture_mode.height);
  535. if (new_exposure != exposure) {
  536. exposure = new_exposure;
  537. }
  538. break;
  539. }
  540. }
  541. update_io_pipeline();
  542. draw_controls();
  543. }
  544. }
  545. void
  546. on_control_slider_changed(GtkAdjustment *widget, gpointer user_data)
  547. {
  548. double value = gtk_adjustment_get_value(widget);
  549. bool has_changed = false;
  550. switch (current_control) {
  551. case USER_CONTROL_ISO:
  552. if (value != gain) {
  553. gain = (int)value;
  554. has_changed = true;
  555. }
  556. break;
  557. case USER_CONTROL_SHUTTER: {
  558. // So far all sensors use exposure time in number of sensor rows
  559. int new_exposure =
  560. (int)(value / 360.0 * camera->capture_mode.height);
  561. if (new_exposure != exposure) {
  562. exposure = new_exposure;
  563. has_changed = true;
  564. }
  565. break;
  566. }
  567. }
  568. if (has_changed) {
  569. update_io_pipeline();
  570. draw_controls();
  571. }
  572. }
  573. int
  574. main(int argc, char *argv[])
  575. {
  576. if (!mp_load_config())
  577. return 1;
  578. setenv("LC_NUMERIC", "C", 1);
  579. gtk_init(&argc, &argv);
  580. g_object_set(gtk_settings_get_default(), "gtk-application-prefer-dark-theme",
  581. TRUE, NULL);
  582. GtkBuilder *builder = gtk_builder_new_from_resource(
  583. "/org/postmarketos/Megapixels/camera.glade");
  584. GtkWidget *window = GTK_WIDGET(gtk_builder_get_object(builder, "window"));
  585. GtkWidget *shutter = GTK_WIDGET(gtk_builder_get_object(builder, "shutter"));
  586. GtkWidget *switch_btn =
  587. GTK_WIDGET(gtk_builder_get_object(builder, "switch_camera"));
  588. GtkWidget *settings_btn =
  589. GTK_WIDGET(gtk_builder_get_object(builder, "settings"));
  590. GtkWidget *settings_back =
  591. GTK_WIDGET(gtk_builder_get_object(builder, "settings_back"));
  592. GtkWidget *error_close =
  593. GTK_WIDGET(gtk_builder_get_object(builder, "error_close"));
  594. GtkWidget *open_last =
  595. GTK_WIDGET(gtk_builder_get_object(builder, "open_last"));
  596. GtkWidget *open_directory =
  597. GTK_WIDGET(gtk_builder_get_object(builder, "open_directory"));
  598. preview = GTK_WIDGET(gtk_builder_get_object(builder, "preview"));
  599. error_box = GTK_WIDGET(gtk_builder_get_object(builder, "error_box"));
  600. error_message = GTK_WIDGET(gtk_builder_get_object(builder, "error_message"));
  601. main_stack = GTK_WIDGET(gtk_builder_get_object(builder, "main_stack"));
  602. open_last_stack = GTK_WIDGET(gtk_builder_get_object(builder, "open_last_stack"));
  603. thumb_last = GTK_WIDGET(gtk_builder_get_object(builder, "thumb_last"));
  604. process_spinner = GTK_WIDGET(gtk_builder_get_object(builder, "process_spinner"));
  605. control_box = GTK_WIDGET(gtk_builder_get_object(builder, "control_box"));
  606. control_name = GTK_WIDGET(gtk_builder_get_object(builder, "control_name"));
  607. control_slider =
  608. GTK_ADJUSTMENT(gtk_builder_get_object(builder, "control_adj"));
  609. control_auto = GTK_WIDGET(gtk_builder_get_object(builder, "control_auto"));
  610. g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
  611. g_signal_connect(shutter, "clicked", G_CALLBACK(on_shutter_clicked), NULL);
  612. g_signal_connect(error_close, "clicked", G_CALLBACK(on_error_close_clicked),
  613. NULL);
  614. g_signal_connect(switch_btn, "clicked", G_CALLBACK(on_camera_switch_clicked),
  615. NULL);
  616. g_signal_connect(settings_btn, "clicked",
  617. G_CALLBACK(on_settings_btn_clicked), NULL);
  618. g_signal_connect(settings_back, "clicked", G_CALLBACK(on_back_clicked),
  619. NULL);
  620. g_signal_connect(open_last, "clicked", G_CALLBACK(on_open_last_clicked),
  621. NULL);
  622. g_signal_connect(open_directory, "clicked",
  623. G_CALLBACK(on_open_directory_clicked), NULL);
  624. g_signal_connect(preview, "draw", G_CALLBACK(preview_draw), NULL);
  625. g_signal_connect(preview, "configure-event", G_CALLBACK(preview_configure),
  626. NULL);
  627. gtk_widget_set_events(preview, gtk_widget_get_events(preview) |
  628. GDK_BUTTON_PRESS_MASK |
  629. GDK_POINTER_MOTION_MASK);
  630. g_signal_connect(preview, "button-press-event", G_CALLBACK(on_preview_tap),
  631. NULL);
  632. g_signal_connect(control_auto, "toggled",
  633. G_CALLBACK(on_control_auto_toggled), NULL);
  634. g_signal_connect(control_slider, "value-changed",
  635. G_CALLBACK(on_control_slider_changed), NULL);
  636. GtkCssProvider *provider = gtk_css_provider_new();
  637. if (access("camera.css", F_OK) != -1) {
  638. gtk_css_provider_load_from_path(provider, "camera.css", NULL);
  639. } else {
  640. gtk_css_provider_load_from_resource(
  641. provider, "/org/postmarketos/Megapixels/camera.css");
  642. }
  643. GtkStyleContext *context = gtk_widget_get_style_context(error_box);
  644. gtk_style_context_add_provider(context, GTK_STYLE_PROVIDER(provider),
  645. GTK_STYLE_PROVIDER_PRIORITY_USER);
  646. context = gtk_widget_get_style_context(control_box);
  647. gtk_style_context_add_provider(context, GTK_STYLE_PROVIDER(provider),
  648. GTK_STYLE_PROVIDER_PRIORITY_USER);
  649. mp_io_pipeline_start();
  650. camera = mp_get_camera_config(0);
  651. update_io_pipeline();
  652. gtk_widget_show(window);
  653. gtk_main();
  654. mp_io_pipeline_stop();
  655. return 0;
  656. }