← Back to branch summary

~ubuntu-branches/ubuntu/trusty/evince/trusty-proposed

« back to all changes in this revision

Viewing changes to shell/ev-view.c

Tags: upstream-0.7.0
Import upstream version 0.7.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
shell/ev-view.c
581
581
 
582
582
        view->jump_to_find_result = FALSE;
583
583
 
584
 
        if (view->presentation) {
 
584
        if (view->presentation || view->sizing_mode == EV_SIZING_BEST_FIT) {
585
585
                switch (scroll) {
586
586
                        case EV_SCROLL_PAGE_BACKWARD:
587
587
                        case EV_SCROLL_STEP_BACKWARD:
1051
1051
        return FALSE;
1052
1052
}
1053
1053
 
 
1054
static gboolean
 
1055
get_doc_point_from_offset (EvView *view, 
 
1056
                           gint    page, 
 
1057
                           gint    x_offset, 
 
1058
                           gint    y_offset, 
 
1059
                           gint   *x_new, 
 
1060
                           gint   *y_new)
 
1061
{
 
1062
        int width, height;
 
1063
        double x, y;
 
1064
 
 
1065
        ev_page_cache_get_size (view->page_cache, page,
 
1066
                                view->rotation,
 
1067
                                1.0,
 
1068
                                &width, &height);
 
1069
 
 
1070
        x_offset = x_offset / view->scale;
 
1071
        y_offset = y_offset / view->scale;
 
1072
 
 
1073
        if (view->rotation == 0) {
 
1074
                x = x_offset;
 
1075
                y = y_offset;
 
1076
        } else if (view->rotation == 90) {
 
1077
                x = y_offset;
 
1078
                y = width - x_offset;
 
1079
        } else if (view->rotation == 180) {
 
1080
                x = width - x_offset;
 
1081
                y = height - y_offset;
 
1082
        } else if (view->rotation == 270) {
 
1083
                x = height - y_offset; 
 
1084
                y = x_offset;
 
1085
        } else {
 
1086
                g_assert_not_reached ();
 
1087
        }
 
1088
 
 
1089
        *x_new = x;
 
1090
        *y_new = y;
 
1091
        
 
1092
        return TRUE;
 
1093
}
 
1094
 
1054
1095
/*** Hyperref ***/
1055
1096
static EvLink *
1056
1097
ev_view_get_link_at_location (EvView  *view,
1059
1100
{
1060
1101
        gint page = -1;
1061
1102
        gint x_offset = 0, y_offset = 0;
 
1103
        gint x_new = 0, y_new = 0;
1062
1104
        GList *link_mapping;
1063
1105
        
1064
1106
        x += view->scroll_x;
1069
1111
        if (page == -1)
1070
1112
                return NULL;
1071
1113
 
 
1114
        
 
1115
        if (get_doc_point_from_offset (view, page, x_offset, 
 
1116
                                       y_offset, &x_new, &y_new) == FALSE)
 
1117
                return NULL;
 
1118
 
1072
1119
        link_mapping = ev_pixbuf_cache_get_link_mapping (view->pixbuf_cache, page);
1073
1120
 
1074
1121
        if (link_mapping)
1075
 
                return ev_link_mapping_find (link_mapping, x_offset / view->scale, y_offset / view->scale);
 
1122
                return ev_link_mapping_find (link_mapping, x_new, y_new);
1076
1123
        else
1077
1124
                return NULL;
1078
1125
}
1739
1786
        return NULL;
1740
1787
}
1741
1788
 
 
1789
static void
 
1790
draw_end_presentation_page (EvView       *view,
 
1791
                            GdkRectangle *page_area)
 
1792
{
 
1793
        PangoLayout *layout;
 
1794
        PangoFontDescription *font_desc;
 
1795
        gchar *markup;
 
1796
        const gchar *text = _("End of presentation. Press Escape to exit.");
 
1797
 
 
1798
        if (view->presentation_state != EV_PRESENTATION_END)
 
1799
                return;
 
1800
 
 
1801
        layout = gtk_widget_create_pango_layout (GTK_WIDGET (view), NULL);
 
1802
        markup = g_strdup_printf ("<span foreground=\"white\">%s</span>", text);
 
1803
        pango_layout_set_markup (layout, markup, -1);
 
1804
        g_free (markup);
 
1805
 
 
1806
        font_desc = pango_font_description_new ();
 
1807
        pango_font_description_set_size (font_desc, 16 * PANGO_SCALE);
 
1808
        pango_layout_set_font_description (layout, font_desc);
 
1809
 
 
1810
        gtk_paint_layout (GTK_WIDGET (view)->style,
 
1811
                          GTK_WIDGET (view)->window,
 
1812
                          GTK_WIDGET_STATE (view),
 
1813
                          FALSE,
 
1814
                          page_area,
 
1815
                          GTK_WIDGET (view),
 
1816
                          NULL,
 
1817
                          page_area->x + 15,
 
1818
                          page_area->y + 15,
 
1819
                          layout);
 
1820
 
 
1821
        pango_font_description_free (font_desc);
 
1822
        g_object_unref (layout);
 
1823
}
 
1824
 
1742
1825
static gboolean
1743
1826
ev_view_expose_event (GtkWidget      *widget,
1744
1827
                      GdkEventExpose *event)
1746
1829
        EvView *view = EV_VIEW (widget);
1747
1830
        int i;
1748
1831
 
 
1832
        if (view->presentation) {
 
1833
                switch (view->presentation_state) {
 
1834
                        case EV_PRESENTATION_END: {
 
1835
                                GdkRectangle area = {0};
 
1836
 
 
1837
                                area.width = widget->allocation.width;
 
1838
                                area.height = widget->allocation.height;
 
1839
                                
 
1840
                                draw_end_presentation_page (view, &area);
 
1841
                        }
 
1842
                                return FALSE;
 
1843
                        case EV_PRESENTATION_BLACK:
 
1844
                        case EV_PRESENTATION_WHITE:
 
1845
                                return FALSE;
 
1846
                        case EV_PRESENTATION_NORMAL:
 
1847
                        default:
 
1848
                                break;
 
1849
                }
 
1850
        }
 
1851
        
1749
1852
        if (view->loading) {
1750
1853
                GdkRectangle area = {0};
1751
1854
                
2011
2114
 
2012
2115
                        return TRUE;
2013
2116
                }
2014
 
        /* For the Evince 0.4.x release, we limit links to un-rotated documents
2015
 
         * only.
2016
 
         */
2017
 
        } else if (view->pressed_button <= 0 &&
2018
 
                   view->rotation == 0) {
 
2117
        } else if (view->pressed_button <= 0) {
2019
2118
                handle_link_over_xy (view, x, y);
2020
2119
                return TRUE;
2021
2120
        }
2077
2176
        return FALSE;
2078
2177
}
2079
2178
 
 
2179
static gboolean
 
2180
ev_view_key_press_event (GtkWidget   *widget,
 
2181
                         GdkEventKey *event)
 
2182
{
 
2183
        EvView *view = EV_VIEW (widget);
 
2184
        EvPresentationState current;
 
2185
 
 
2186
        if (!view->presentation ||
 
2187
            view->presentation_state == EV_PRESENTATION_END)
 
2188
                return gtk_bindings_activate_event (GTK_OBJECT (widget), event);
 
2189
 
 
2190
 
 
2191
        current = view->presentation_state;
 
2192
 
 
2193
        switch (event->keyval) {
 
2194
                case GDK_b:
 
2195
                case GDK_B:
 
2196
                        view->presentation_state =
 
2197
                                (view->presentation_state == EV_PRESENTATION_BLACK) ?
 
2198
                                EV_PRESENTATION_NORMAL : EV_PRESENTATION_BLACK;
 
2199
                        break;
 
2200
                case GDK_w:
 
2201
                case GDK_W:
 
2202
                        view->presentation_state =
 
2203
                                (view->presentation_state == EV_PRESENTATION_WHITE) ?
 
2204
                                EV_PRESENTATION_NORMAL : EV_PRESENTATION_WHITE;
 
2205
                        break;
 
2206
                default:
 
2207
                        if (view->presentation_state == EV_PRESENTATION_BLACK ||
 
2208
                            view->presentation_state == EV_PRESENTATION_WHITE) {
 
2209
                                view->presentation_state = EV_PRESENTATION_NORMAL;
 
2210
                        }
 
2211
        }
 
2212
 
 
2213
        if (current == view->presentation_state)
 
2214
                return gtk_bindings_activate_event (GTK_OBJECT (widget), event);
 
2215
 
 
2216
        switch (view->presentation_state) {
 
2217
                case EV_PRESENTATION_NORMAL:
 
2218
                case EV_PRESENTATION_BLACK:
 
2219
                        gdk_window_set_background (widget->window,
 
2220
                                                   &widget->style->black);
 
2221
                        break;
 
2222
                case EV_PRESENTATION_WHITE:
 
2223
                        gdk_window_set_background (widget->window,
 
2224
                                                   &widget->style->white);
 
2225
                        break;
 
2226
                default:
 
2227
                        return gtk_bindings_activate_event (GTK_OBJECT (widget), event);
 
2228
        }
 
2229
 
 
2230
        gtk_widget_queue_draw (widget);
 
2231
        return TRUE;
 
2232
}
 
2233
 
2080
2234
static gint
2081
2235
ev_view_focus_in (GtkWidget     *widget,
2082
2236
                  GdkEventFocus *event)
2228
2382
        double real_scale;
2229
2383
        int target_width;
2230
2384
 
 
2385
        /* Don't annoy users with loading messages during presentations.
 
2386
         * FIXME: Temporary "workaround" for
 
2387
         * http://bugzilla.gnome.org/show_bug.cgi?id=320352 */
 
2388
        if (view->presentation)
 
2389
                return;
 
2390
 
2231
2391
        const char *loading_text = _("Loading...");     
2232
2392
 
 
2393
        ev_document_fc_mutex_lock ();
 
2394
        
2233
2395
        layout = gtk_widget_create_pango_layout (GTK_WIDGET (view), loading_text);
2234
2396
 
2235
2397
        font_desc = pango_font_description_new ();
2260
2422
 
2261
2423
        pango_font_description_free (font_desc);
2262
2424
        g_object_unref (layout);
 
2425
 
 
2426
        ev_document_fc_mutex_unlock ();
2263
2427
}
2264
2428
 
2265
2429
static void
2552
2716
        widget_class->button_press_event = ev_view_button_press_event;
2553
2717
        widget_class->motion_notify_event = ev_view_motion_notify_event;
2554
2718
        widget_class->button_release_event = ev_view_button_release_event;
 
2719
        widget_class->key_press_event = ev_view_key_press_event;
2555
2720
        widget_class->focus_in_event = ev_view_focus_in;
2556
2721
        widget_class->focus_out_event = ev_view_focus_out;
2557
2722
        widget_class->get_accessible = ev_view_get_accessible;
2725
2890
        view->continuous = TRUE;
2726
2891
        view->dual_page = FALSE;
2727
2892
        view->presentation = FALSE;
 
2893
        view->presentation_state = EV_PRESENTATION_NORMAL;
2728
2894
        view->fullscreen = FALSE;
2729
2895
        view->sizing_mode = EV_SIZING_FIT_WIDTH;
2730
2896
        view->pending_scroll = SCROLL_TO_KEEP_POSITION;
3014
3180
        if (view->presentation == presentation)
3015
3181
                return;
3016
3182
 
 
3183
        if (!presentation)
 
3184
                view->presentation_state = EV_PRESENTATION_NORMAL;
 
3185
        
3017
3186
        view->presentation = presentation;
3018
3187
        view->pending_scroll = SCROLL_TO_PAGE_POSITION;
3019
3188
        gtk_widget_queue_resize (GTK_WIDGET (view));
3027
3196
                                                   &GTK_WIDGET (view)->style->mid [GTK_STATE_NORMAL]);
3028
3197
        }
3029
3198
 
3030
 
 
3031
3199
        g_object_notify (G_OBJECT (view), "presentation");
3032
3200
}
3033
3201
 
4125
4293
       ev_view_set_cursor (view, EV_VIEW_CURSOR_NORMAL);
4126
4294
}
4127
4295
 
 
4296
static void
 
4297
ev_view_reset_presentation_state (EvView *view)
 
4298
{
 
4299
        if (!view->presentation ||
 
4300
            view->presentation_state == EV_PRESENTATION_NORMAL)
 
4301
                return;
 
4302
 
 
4303
        view->presentation_state = EV_PRESENTATION_NORMAL;
 
4304
        gdk_window_set_background (GTK_WIDGET (view)->window,
 
4305
                                   &GTK_WIDGET (view)->style->black);
 
4306
        gtk_widget_queue_draw (GTK_WIDGET (view));
 
4307
}
 
4308
 
4128
4309
gboolean
4129
4310
ev_view_next_page (EvView *view)
4130
4311
{
4131
 
        int page;
 
4312
        int page, n_pages;
4132
4313
 
4133
4314
        g_return_val_if_fail (EV_IS_VIEW (view), FALSE);
4134
4315
        
4135
4316
        if (!view->page_cache)
4136
4317
                return FALSE;
4137
4318
 
 
4319
        ev_view_reset_presentation_state (view);
 
4320
        
4138
4321
        page = ev_page_cache_get_current_page (view->page_cache);
 
4322
        n_pages = ev_page_cache_get_n_pages (view->page_cache);
4139
4323
 
4140
4324
        if (view->dual_page && !view->presentation)
4141
4325
                page = page + 2; 
4142
4326
        else 
4143
4327
                page = page + 1;
4144
4328
 
4145
 
        if (page < ev_page_cache_get_n_pages (view->page_cache)) {
 
4329
        if (page < n_pages) {
4146
4330
                ev_page_cache_set_current_page (view->page_cache, page);
4147
4331
                return TRUE;
4148
 
        } else if (ev_view_get_dual_page (view) && page == ev_page_cache_get_n_pages (view->page_cache)) {
 
4332
        } else if (view->presentation && page == n_pages) {
 
4333
                view->presentation_state = EV_PRESENTATION_END;
 
4334
                gtk_widget_queue_draw (GTK_WIDGET (view));
 
4335
                return TRUE;
 
4336
        } else if (view->dual_page && page == n_pages) {
4149
4337
                ev_page_cache_set_current_page (view->page_cache, page - 1);
4150
4338
                return TRUE;
4151
4339
        } else {
4163
4351
        if (!view->page_cache)
4164
4352
                return FALSE;
4165
4353
 
 
4354
        if (view->presentation &&
 
4355
            view->presentation_state == EV_PRESENTATION_END) {
 
4356
                ev_view_reset_presentation_state (view);
 
4357
                return TRUE;
 
4358
        }
 
4359
 
 
4360
        ev_view_reset_presentation_state (view);
 
4361
 
4166
4362
        page = ev_page_cache_get_current_page (view->page_cache);
4167
4363
 
4168
4364
        if (view->dual_page && !view->presentation)