A Simple X Image Viewer
 
 
 
 
 
 

361 lines
7.4 KiB

  1. /* sxiv: image.c
  2. * Copyright (c) 2011 Bert Muennich <muennich at informatik.hu-berlin.de>
  3. *
  4. * This program is free software; you can redistribute it and/or modify
  5. * it under the terms of the GNU General Public License as published by
  6. * the Free Software Foundation; either version 2 of the License, or
  7. * (at your option) any later version.
  8. *
  9. * This program is distributed in the hope that it will be useful,
  10. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. * GNU General Public License for more details.
  13. *
  14. * You should have received a copy of the GNU General Public License
  15. * along with this program; if not, write to the Free Software
  16. * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17. */
  18. #include <unistd.h>
  19. #include "config.h"
  20. #include "icon.h"
  21. #include "image.h"
  22. #include "options.h"
  23. #include "util.h"
  24. int zl_cnt;
  25. float zoom_min;
  26. float zoom_max;
  27. Imlib_Image *im_broken;
  28. void img_init(img_t *img, win_t *win) {
  29. zl_cnt = sizeof(zoom_levels) / sizeof(zoom_levels[0]);
  30. zoom_min = zoom_levels[0] / 100.0;
  31. zoom_max = zoom_levels[zl_cnt - 1] / 100.0;
  32. im_broken = imlib_create_image_using_data(32, 32, icon_broken);
  33. if (img) {
  34. img->im = NULL;
  35. img->zoom = options->zoom;
  36. img->zoom = MAX(img->zoom, zoom_min);
  37. img->zoom = MIN(img->zoom, zoom_max);
  38. img->aa = options->aa;
  39. }
  40. if (win) {
  41. imlib_context_set_display(win->env.dpy);
  42. imlib_context_set_visual(win->env.vis);
  43. imlib_context_set_colormap(win->env.cmap);
  44. }
  45. }
  46. void img_free(img_t* img) {
  47. imlib_context_set_image(im_broken);
  48. imlib_free_image();
  49. }
  50. int img_check(const char *filename) {
  51. Imlib_Image *im;
  52. if (!filename)
  53. return 0;
  54. if (!access(filename, F_OK) && (im = imlib_load_image(filename))) {
  55. imlib_context_set_image(im);
  56. imlib_image_set_changes_on_disk();
  57. imlib_free_image();
  58. return 1;
  59. } else {
  60. warn("could not open file: %s", filename);
  61. return 0;
  62. }
  63. }
  64. int img_load(img_t *img, const char *filename) {
  65. if (!img || !filename)
  66. return 0;
  67. if (!access(filename, F_OK) && (img->im = imlib_load_image(filename))) {
  68. imlib_context_set_image(img->im);
  69. imlib_image_set_changes_on_disk();
  70. imlib_context_set_anti_alias(img->aa);
  71. img->scalemode = options->scalemode;
  72. } else {
  73. warn("could not open file: %s", filename);
  74. imlib_context_set_image(im_broken);
  75. imlib_context_set_anti_alias(0);
  76. img->scalemode = SCALE_DOWN;
  77. }
  78. img->re = 0;
  79. img->checkpan = 0;
  80. img->w = imlib_image_get_width();
  81. img->h = imlib_image_get_height();
  82. return 1;
  83. }
  84. void img_close(img_t *img, int decache) {
  85. if (img && img->im) {
  86. imlib_context_set_image(img->im);
  87. if (decache)
  88. imlib_free_image_and_decache();
  89. else
  90. imlib_free_image();
  91. img->im = NULL;
  92. }
  93. }
  94. void img_check_pan(img_t *img, win_t *win) {
  95. if (!img || !win)
  96. return;
  97. if (img->w * img->zoom > win->w) {
  98. if (img->x > 0 && img->x + img->w * img->zoom > win->w)
  99. img->x = 0;
  100. if (img->x < 0 && img->x + img->w * img->zoom < win->w)
  101. img->x = win->w - img->w * img->zoom;
  102. } else {
  103. img->x = (win->w - img->w * img->zoom) / 2;
  104. }
  105. if (img->h * img->zoom > win->h) {
  106. if (img->y > 0 && img->y + img->h * img->zoom > win->h)
  107. img->y = 0;
  108. if (img->y < 0 && img->y + img->h * img->zoom < win->h)
  109. img->y = win->h - img->h * img->zoom;
  110. } else {
  111. img->y = (win->h - img->h * img->zoom) / 2;
  112. }
  113. }
  114. int img_fit(img_t *img, win_t *win) {
  115. float oz, zw, zh;
  116. if (!img || !win)
  117. return 0;
  118. oz = img->zoom;
  119. zw = (float) win->w / (float) img->w;
  120. zh = (float) win->h / (float) img->h;
  121. img->zoom = MIN(zw, zh);
  122. img->zoom = MAX(img->zoom, zoom_min);
  123. img->zoom = MIN(img->zoom, zoom_max);
  124. return oz != img->zoom;
  125. }
  126. void img_render(img_t *img, win_t *win) {
  127. int sx, sy, sw, sh;
  128. int dx, dy, dw, dh;
  129. if (!img || !win)
  130. return;
  131. if (img->scalemode != SCALE_ZOOM) {
  132. img_fit(img, win);
  133. if (img->scalemode == SCALE_DOWN && img->zoom > 1.0)
  134. img->zoom = 1.0;
  135. }
  136. if (!img->re) {
  137. /* rendered for the first time */
  138. img->re = 1;
  139. if (img->zoom * img->w <= win->w)
  140. img->x = (win->w - img->w * img->zoom) / 2;
  141. else
  142. img->x = 0;
  143. if (img->zoom * img->h <= win->h)
  144. img->y = (win->h - img->h * img->zoom) / 2;
  145. else
  146. img->y = 0;
  147. }
  148. if (img->checkpan) {
  149. img_check_pan(img, win);
  150. img->checkpan = 0;
  151. }
  152. /* calculate source and destination offsets */
  153. if (img->x < 0) {
  154. sx = -img->x / img->zoom;
  155. sw = win->w / img->zoom;
  156. dx = 0;
  157. dw = win->w;
  158. } else {
  159. sx = 0;
  160. sw = img->w;
  161. dx = img->x;
  162. dw = img->w * img->zoom;
  163. }
  164. if (img->y < 0) {
  165. sy = -img->y / img->zoom;
  166. sh = win->h / img->zoom;
  167. dy = 0;
  168. dh = win->h;
  169. } else {
  170. sy = 0;
  171. sh = img->h;
  172. dy = img->y;
  173. dh = img->h * img->zoom;
  174. }
  175. win_clear(win);
  176. if (img->im)
  177. imlib_context_set_image(img->im);
  178. else
  179. imlib_context_set_image(im_broken);
  180. imlib_context_set_drawable(win->pm);
  181. imlib_render_image_part_on_drawable_at_size(sx, sy, sw, sh, dx, dy, dw, dh);
  182. win_draw(win);
  183. }
  184. int img_fit_win(img_t *img, win_t *win) {
  185. if (!img || !img->im || !win)
  186. return 0;
  187. img->scalemode = SCALE_FIT;
  188. return img_fit(img, win);
  189. }
  190. int img_center(img_t *img, win_t *win) {
  191. int ox, oy;
  192. if (!img || !win)
  193. return 0;
  194. ox = img->x;
  195. oy = img->y;
  196. img->x = (win->w - img->w * img->zoom) / 2;
  197. img->y = (win->h - img->h * img->zoom) / 2;
  198. return ox != img->x || oy != img->y;
  199. }
  200. int img_zoom(img_t *img, float z) {
  201. if (!img || !img->im)
  202. return 0;
  203. z = MAX(z, zoom_min);
  204. z = MIN(z, zoom_max);
  205. img->scalemode = SCALE_ZOOM;
  206. if (z != img->zoom) {
  207. img->x -= (img->w * z - img->w * img->zoom) / 2;
  208. img->y -= (img->h * z - img->h * img->zoom) / 2;
  209. img->zoom = z;
  210. img->checkpan = 1;
  211. return 1;
  212. } else {
  213. return 0;
  214. }
  215. }
  216. int img_zoom_in(img_t *img) {
  217. int i;
  218. if (!img || !img->im)
  219. return 0;
  220. for (i = 1; i < zl_cnt; ++i) {
  221. if (zoom_levels[i] > img->zoom * 100.0)
  222. return img_zoom(img, zoom_levels[i] / 100.0);
  223. }
  224. return 0;
  225. }
  226. int img_zoom_out(img_t *img) {
  227. int i;
  228. if (!img || !img->im)
  229. return 0;
  230. for (i = zl_cnt - 2; i >= 0; --i) {
  231. if (zoom_levels[i] < img->zoom * 100.0)
  232. return img_zoom(img, zoom_levels[i] / 100.0);
  233. }
  234. return 0;
  235. }
  236. int img_move(img_t *img, win_t *win, int dx, int dy) {
  237. int ox, oy;
  238. if (!img || !img->im || !win)
  239. return 0;
  240. ox = img->x;
  241. oy = img->y;
  242. img->x += dx;
  243. img->y += dy;
  244. img_check_pan(img, win);
  245. return ox != img->x || oy != img->y;
  246. }
  247. int img_pan(img_t *img, win_t *win, pandir_t dir) {
  248. if (!img || !img->im || !win)
  249. return 0;
  250. switch (dir) {
  251. case PAN_LEFT:
  252. return img_move(img, win, win->w / 5, 0);
  253. case PAN_RIGHT:
  254. return img_move(img, win, win->w / 5 * -1, 0);
  255. case PAN_UP:
  256. return img_move(img, win, 0, win->h / 5);
  257. case PAN_DOWN:
  258. return img_move(img, win, 0, win->h / 5 * -1);
  259. }
  260. return 0;
  261. }
  262. void img_rotate(img_t *img, win_t *win, int d) {
  263. int ox, oy, tmp;
  264. if (!img || !img->im || !win)
  265. return;
  266. ox = d == 1 ? img->x : win->w - img->x - img->w * img->zoom;
  267. oy = d == 3 ? img->y : win->h - img->y - img->h * img->zoom;
  268. imlib_context_set_image(img->im);
  269. imlib_image_orientate(d);
  270. img->x = oy + (win->w - win->h) / 2;
  271. img->y = ox + (win->h - win->w) / 2;
  272. tmp = img->w;
  273. img->w = img->h;
  274. img->h = tmp;
  275. img->checkpan = 1;
  276. }
  277. void img_rotate_left(img_t *img, win_t *win) {
  278. img_rotate(img, win, 3);
  279. }
  280. void img_rotate_right(img_t *img, win_t *win) {
  281. img_rotate(img, win, 1);
  282. }
  283. void img_toggle_antialias(img_t *img) {
  284. if (img && img->im) {
  285. img->aa ^= 1;
  286. imlib_context_set_image(img->im);
  287. imlib_context_set_anti_alias(img->aa);
  288. }
  289. }