← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to tests/poppler/glib/demo/fonts.c

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/poppler/glib/demo/fonts.c
 
1
/*
 
2
 * Copyright (C) 2007 Carlos Garcia Campos  <carlosgc@gnome.org>
 
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, or (at your option)
 
7
 * 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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
 
17
 */
 
18
 
 
19
#include <gtk/gtk.h>
 
20
 
 
21
#include "fonts.h"
 
22
 
 
23
enum {
 
24
        FONTS_NAME_COLUMN,
 
25
        FONTS_DETAILS_COLUMN,
 
26
        N_COLUMNS
 
27
};
 
28
 
 
29
typedef struct {
 
30
        PopplerDocument *doc;
 
31
        
 
32
        GtkWidget       *treeview;
 
33
        GtkWidget       *progress;
 
34
 
 
35
        guint            idle_id;
 
36
} PgdFontsDemo;
 
37
 
 
38
static void
 
39
pgd_fonts_free (PgdFontsDemo *demo)
 
40
{
 
41
        if (!demo)
 
42
                return;
 
43
 
 
44
        if (demo->idle_id > 0) {
 
45
                g_source_remove (demo->idle_id);
 
46
                demo->idle_id = 0;
 
47
        }
 
48
        
 
49
        if (demo->doc) {
 
50
                g_object_unref (demo->doc);
 
51
                demo->doc = NULL;
 
52
        }
 
53
 
 
54
        g_free (demo);
 
55
}
 
56
 
 
57
static void
 
58
pdg_fonts_cell_data_func (GtkTreeViewColumn *col,
 
59
                          GtkCellRenderer   *renderer,
 
60
                          GtkTreeModel      *model,
 
61
                          GtkTreeIter       *iter,
 
62
                          gpointer           user_data)
 
63
{
 
64
        char *name;
 
65
        char *details;
 
66
        char *markup;
 
67
 
 
68
        gtk_tree_model_get (model, iter,
 
69
                            FONTS_NAME_COLUMN, &name,
 
70
                            FONTS_DETAILS_COLUMN, &details,
 
71
                            -1);
 
72
 
 
73
        if (details) {
 
74
                markup = g_strdup_printf ("<b><big>%s</big></b>\n<small>%s</small>",
 
75
                                          name, details);
 
76
        } else {
 
77
                markup = g_strdup_printf ("<b><big>%s</big></b>", name);
 
78
        }
 
79
 
 
80
        g_object_set (renderer, "markup", markup, NULL);
 
81
 
 
82
        g_free (markup);
 
83
        g_free (details);
 
84
        g_free (name);
 
85
}
 
86
 
 
87
static const gchar *
 
88
font_type_to_string (PopplerFontType type)
 
89
{
 
90
        switch (type) {
 
91
        case POPPLER_FONT_TYPE_TYPE1:
 
92
                return "Type 1";
 
93
        case POPPLER_FONT_TYPE_TYPE1C:
 
94
                return "Type 1C";
 
95
        case POPPLER_FONT_TYPE_TYPE3:
 
96
                return "Type 3";
 
97
        case POPPLER_FONT_TYPE_TRUETYPE:
 
98
                return "TrueType";
 
99
        case POPPLER_FONT_TYPE_CID_TYPE0:
 
100
                return "Type 1 (CID)";
 
101
        case POPPLER_FONT_TYPE_CID_TYPE0C:
 
102
                return "Type 1C (CID)";
 
103
        case POPPLER_FONT_TYPE_CID_TYPE2:
 
104
                return "TrueType (CID)";
 
105
        default:
 
106
                return "Unknown font type";
 
107
        }
 
108
}
 
109
 
 
110
static void
 
111
pgd_fonts_update_progress (PgdFontsDemo *demo,
 
112
                           gint          n_pages,
 
113
                           gint          scanned)
 
114
{
 
115
        gchar *str;
 
116
 
 
117
        str = g_strdup_printf ("Scanning fonts (%d%%)",
 
118
                               MIN (scanned * 100 / n_pages, 100));
 
119
        gtk_progress_bar_set_text (GTK_PROGRESS_BAR (demo->progress), str);
 
120
        gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (demo->progress),
 
121
                                       MIN ((gdouble)scanned / n_pages, 1.0));
 
122
        g_free (str);
 
123
}
 
124
 
 
125
static gboolean
 
126
pgd_fonts_fill_model (PgdFontsDemo *demo)
 
127
{
 
128
        GtkTreeModel     *model;
 
129
        PopplerFontInfo  *font_info;
 
130
        PopplerFontsIter *fonts_iter;
 
131
        gint              n_pages, scanned = 0;
 
132
 
 
133
        n_pages = poppler_document_get_n_pages (demo->doc);
 
134
        
 
135
        model = gtk_tree_view_get_model (GTK_TREE_VIEW (demo->treeview));
 
136
        g_object_ref (model);
 
137
 
 
138
        gtk_list_store_clear (GTK_LIST_STORE (model));
 
139
 
 
140
        font_info = poppler_font_info_new (demo->doc);
 
141
 
 
142
        while (poppler_font_info_scan (font_info, 20, &fonts_iter)) {
 
143
                pgd_fonts_update_progress (demo, n_pages, scanned);
 
144
                
 
145
                while (gtk_events_pending ())
 
146
                        gtk_main_iteration ();
 
147
 
 
148
                scanned += 20;
 
149
                
 
150
                if (!fonts_iter)
 
151
                        continue;
 
152
                
 
153
                do {
 
154
                        GtkTreeIter iter;
 
155
                        const gchar *name;
 
156
                        const gchar *type;
 
157
                        const gchar *embedded;
 
158
                        const gchar *filename;
 
159
                        gchar       *details;
 
160
 
 
161
                        name = poppler_fonts_iter_get_name (fonts_iter);
 
162
                        if (!name)
 
163
                                name = "No name";
 
164
 
 
165
                        type = font_type_to_string (poppler_fonts_iter_get_font_type (fonts_iter));
 
166
                        
 
167
                        if (poppler_fonts_iter_is_embedded (fonts_iter)) {
 
168
                                if (poppler_fonts_iter_is_subset (fonts_iter))
 
169
                                        embedded = "Embedded subset";
 
170
                                else
 
171
                                        embedded = "Embedded";
 
172
                        } else {
 
173
                                embedded = "Not embedded";
 
174
                        }
 
175
 
 
176
                        filename = poppler_fonts_iter_get_file_name (fonts_iter);
 
177
 
 
178
                        if (filename)
 
179
                                details = g_markup_printf_escaped ("%s\n%s (%s)", type, embedded, filename);
 
180
                        else
 
181
                                details = g_markup_printf_escaped ("%s\n%s", type, embedded);
 
182
 
 
183
                        gtk_list_store_append (GTK_LIST_STORE (model), &iter);
 
184
                        gtk_list_store_set (GTK_LIST_STORE (model), &iter,
 
185
                                            FONTS_NAME_COLUMN, name,
 
186
                                            FONTS_DETAILS_COLUMN, details,
 
187
                                            -1);
 
188
                        
 
189
                        g_free (details);
 
190
                } while (poppler_fonts_iter_next (fonts_iter));
 
191
                poppler_fonts_iter_free (fonts_iter);
 
192
        }
 
193
 
 
194
        pgd_fonts_update_progress (demo, n_pages, scanned);
 
195
        
 
196
        g_object_unref (font_info);
 
197
        g_object_unref (model);
 
198
 
 
199
        return FALSE;
 
200
}
 
201
 
 
202
static void
 
203
pgd_fonts_scan_button_clicked (GtkButton    *button,
 
204
                               PgdFontsDemo *demo)
 
205
{
 
206
        demo->idle_id = g_idle_add ((GSourceFunc)pgd_fonts_fill_model, demo);
 
207
}
 
208
 
 
209
GtkWidget *
 
210
pgd_fonts_create_widget (PopplerDocument *document)
 
211
{
 
212
        PgdFontsDemo      *demo;
 
213
        GtkWidget         *vbox;
 
214
        GtkListStore      *model;
 
215
        GtkCellRenderer   *renderer;
 
216
        GtkTreeViewColumn *column;
 
217
        GtkWidget         *swindow;
 
218
        GtkWidget         *hbox, *button;
 
219
 
 
220
        demo = g_new0 (PgdFontsDemo, 1);
 
221
 
 
222
        demo->doc = g_object_ref (document);
 
223
        
 
224
        vbox = gtk_vbox_new (FALSE, 12);
 
225
 
 
226
        hbox = gtk_hbox_new (FALSE, 6);
 
227
        
 
228
        demo->progress = gtk_progress_bar_new ();
 
229
        gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (demo->progress),
 
230
                                        PANGO_ELLIPSIZE_END);
 
231
        gtk_box_pack_start (GTK_BOX (hbox), demo->progress, TRUE, TRUE, 0);
 
232
        gtk_widget_show (demo->progress);
 
233
 
 
234
        button = gtk_button_new_with_label ("Scan");
 
235
        g_signal_connect (G_OBJECT (button), "clicked",
 
236
                          G_CALLBACK (pgd_fonts_scan_button_clicked),
 
237
                          (gpointer)demo);
 
238
        gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
 
239
        gtk_widget_show (button);
 
240
 
 
241
        gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 6);
 
242
        gtk_widget_show (hbox);
 
243
        
 
244
        swindow = gtk_scrolled_window_new (NULL, NULL);
 
245
        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
 
246
                                        GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 
247
 
 
248
        model = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING);
 
249
        demo->treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
 
250
        gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (demo->treeview), FALSE);
 
251
        gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (demo->treeview), TRUE);
 
252
        gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (demo->treeview)),
 
253
                                     GTK_SELECTION_NONE);
 
254
        g_object_unref (model);
 
255
 
 
256
        column = gtk_tree_view_column_new ();
 
257
        gtk_tree_view_append_column (GTK_TREE_VIEW (demo->treeview), column);
 
258
        
 
259
        renderer = gtk_cell_renderer_text_new ();
 
260
        gtk_tree_view_column_pack_start (GTK_TREE_VIEW_COLUMN (column), renderer, FALSE);
 
261
        gtk_tree_view_column_set_cell_data_func (column, renderer,
 
262
                                                 pdg_fonts_cell_data_func,
 
263
                                                 NULL, NULL);
 
264
 
 
265
        gtk_container_add (GTK_CONTAINER (swindow), demo->treeview);
 
266
        gtk_widget_show (demo->treeview);
 
267
 
 
268
        gtk_box_pack_start (GTK_BOX (vbox), swindow, TRUE, TRUE, 0);
 
269
        gtk_widget_show (swindow);
 
270
 
 
271
        g_object_weak_ref (G_OBJECT (swindow),
 
272
                           (GWeakNotify)pgd_fonts_free,
 
273
                           (gpointer)demo);
 
274
 
 
275
        return vbox;
 
276
}