static gpointer thumbnail_thread (gpointer data) { ThreadData *thread_data = data; gint n_pages; gint i; n_pages = poppler_document_get_n_pages (thread_data->document); for (i = 0; i < n_pages; i++) { IdleData *idle_data = g_new0 (IdleData, 1); idle_data->selector = thread_data->selector; idle_data->page_no = i; /* FIXME get preferred size from somewhere? */ idle_data->pixbuf = get_thumbnail (thread_data->document, i, THUMBNAIL_SIZE); g_idle_add (idle_set_thumbnail, idle_data); if (thread_data->stop_thumbnailing) break; } return NULL; }
void test_font (void) { PopplerFontInfo *font_info; PopplerFontsIter *iter; gint n_pages; document = load_document ("slide.pdf"); n_pages = poppler_document_get_n_pages (document); font_info = poppler_font_info_new (document); while (poppler_font_info_scan (font_info, n_pages, &iter)) { if (iter) { do { actual_font_names = g_list_append (actual_font_names, g_strdup (poppler_fonts_iter_get_name (iter))); } while (poppler_fonts_iter_next (iter)); poppler_fonts_iter_free (iter); } } g_object_unref (font_info); expected_font_names = gcut_list_string_new ("IPAPMincho", "LiberationSans-Regular", NULL); gcut_assert_equal_list_string (expected_font_names, actual_font_names); }
cairo_surface_t* get_pdf_cairo_surface(char* filename, int n_page, int width, int height) { if (NULL != currentDocument) { free_doc(); } PopplerDocument* doc; GError* err = NULL; gchar* uri = g_strconcat("file:", filename, NULL); doc = poppler_document_new_from_file(uri, NULL, &err); if (NULL != err) { g_print(err->message); return NULL; } cairo_surface_t* result = cairo_image_surface_create(CAIRO_FORMAT_RGB24, width, height); render_pdf_page(doc, n_page, result, width, height); currentDocument = (document_page_t*)g_malloc(sizeof(document_page_t)); currentDocument->doc = doc; currentDocument->page = 0; currentDocument->page_count = poppler_document_get_n_pages(doc); currentDocument->surface = result; currentDocument->width = width; currentDocument->height = height; return result; }
static GString * extract_content_text (PopplerDocument *document, gsize n_bytes) { gint n_pages, i = 0; GString *string; GTimer *timer; gsize remaining_bytes = n_bytes; n_pages = poppler_document_get_n_pages (document); string = g_string_new (""); timer = g_timer_new (); while (i < n_pages && remaining_bytes > 0) { PopplerPage *page; gsize written_bytes = 0; gchar *text; page = poppler_document_get_page (document, i); i++; text = poppler_page_get_text (page); if (!text) { g_object_unref (page); continue; } if (tracker_text_validate_utf8 (text, MIN (strlen (text), remaining_bytes), &string, &written_bytes)) { g_string_append_c (string, ' '); } remaining_bytes -= written_bytes; g_debug ("Child: Extracted %" G_GSIZE_FORMAT " bytes from page %d, " "%" G_GSIZE_FORMAT " bytes remaining", written_bytes, i, remaining_bytes); g_free (text); g_object_unref (page); } g_debug ("Child: Content extraction finished: %d/%d pages indexed in %2.2f seconds, " "%" G_GSIZE_FORMAT " bytes extracted", i, n_pages, g_timer_elapsed (timer, NULL), (n_bytes - remaining_bytes)); g_timer_destroy (timer); return string; }
static GtkWidget * pgd_layers_create_viewer (PgdLayersDemo *demo) { GtkWidget *vbox, *hbox; GtkWidget *label; GtkWidget *swindow; GtkWidget *page_selector; guint n_pages; gchar *str; vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Page:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); n_pages = poppler_document_get_n_pages (demo->doc); page_selector = gtk_spin_button_new_with_range (1, n_pages, 1); g_signal_connect (G_OBJECT (page_selector), "value-changed", G_CALLBACK (pgd_layers_page_selector_value_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (hbox), page_selector, FALSE, TRUE, 0); gtk_widget_show (page_selector); str = g_strdup_printf ("of %d", n_pages); label = gtk_label_new (str); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); g_free (str); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); demo->darea = gtk_drawing_area_new (); g_signal_connect (G_OBJECT (demo->darea), "draw", G_CALLBACK (pgd_layers_viewer_drawing_area_draw), (gpointer)demo); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); #if GTK_CHECK_VERSION(3, 7, 8) gtk_container_add(GTK_CONTAINER(swindow), demo->darea); #else gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (swindow), demo->darea); #endif gtk_widget_show (demo->darea); gtk_box_pack_start (GTK_BOX (vbox), swindow, TRUE, TRUE, 0); gtk_widget_show (swindow); return vbox; }
int main(int argc, char *argv[]) { PopplerDocument *document; PopplerPage *page; GError *error; const char *pdf_file; gchar *absolute, *dir, *uri; int page_num, num_pages; char *tmpChar; if (argc < 2 && argc > 3) { printf ("Usage: pdftomapping input_file.pdf [page]\n"); return 0; } pdf_file = argv[1]; g_type_init (); error = NULL; if (g_path_is_absolute(pdf_file)) { absolute = g_strdup (pdf_file); } else { gchar *dir = g_get_current_dir (); absolute = g_build_filename (dir, pdf_file, (gchar *) 0); free (dir); } uri = g_filename_to_uri (absolute, NULL, &error); free (absolute); if (uri == NULL) { printf("%s\n", error->message); return 1; } document = poppler_document_new_from_file (uri, NULL, &error); if (document == NULL) { printf("%s\n", error->message); return 1; } num_pages = poppler_document_get_n_pages (document); int start = 1, end = num_pages; if (argc >= 3) { start = end = atoi(argv[2]); } for (page_num = start; page_num <= end ;page_num++) { page = poppler_document_get_page (document, page_num - 1); if (page == NULL) { printf("poppler fail: page not found\n"); return 1; } write_mapping(page_num, page); } return 0; }
static void view_page_down(struct view *view) { if(!view->document || view->page >= poppler_document_get_n_pages(view->document) - 1) { return; } view->page++; window_schedule_redraw(view->window); }
void test_new_from_file (void) { GError *error = NULL; const gchar *uri; uri = build_uri ("multi-pages.pdf"); document = poppler_document_new_from_file (uri, NULL, &error); gcut_assert_error (error); cut_assert_equal_int (3, poppler_document_get_n_pages (document)); }
int main(int argc, char const *argv[]) { char *path; PopplerDocument *doc; GError *err; gchar *gbuf; char *buf; page_t page_meta; int file_length, n; g_type_init(); if (argc != 2) { return 1; } err = NULL; buf = open_pdf_file(argv[1], &file_length); sandboxify(); doc = poppler_document_new_from_data(buf, file_length, NULL, &err); if (err != NULL) { fprintf(stderr, "Unable to open file: %s\n", err->message); return 2; } n = poppler_document_get_n_pages(doc); for (int i = 0; i < n; i++) { PopplerPage *page = poppler_document_get_page(doc, i); page_meta.pagenum = i; page_meta.text = poppler_page_get_text(page); page_meta.svg_len = 0; page_meta.svg = malloc(SVG_BUFLEN); if (!page_meta.svg) ERROR("Cannot allocate svg buffer, not enought memory?"); page_meta.free_space = SVG_BUFLEN; render_page(&page_meta, page); if (page_meta.text) free(page_meta.text); g_object_unref(page); } if (munmap(buf, file_length) == -1) PERROR("munmap()"); return 0; }
int render_init(char *fname) { char *path = realpath(fname, NULL); if (!path) return 1; char *uri = malloc(strlen(path) + 8); sprintf(uri, "file://%s", path); free(path); _pdf = realloc(_pdf, (_n + 1) * sizeof(PDF)); _pdf[_n].doc = poppler_document_new_from_file(uri, NULL, NULL); _pdf[_n].npage = poppler_document_get_n_pages(_pdf[_n].doc); ++_n; free(uri); return 0; }
void test_save_a_copy (void) { GError *error = NULL; gchar *copy_path; const gchar *copy_uri; document = load_document ("multi-pages.pdf"); cut_assert_equal_int (3, poppler_document_get_n_pages (document)); copy_path = g_build_filename (tmp_dir, "copied-multi-pages.pdf", NULL); copy_uri = cut_take_printf ("file://%s", copy_path); g_free (copy_path); poppler_document_save_a_copy (document, copy_uri, &error); gcut_assert_error (error); g_object_unref (document); document = poppler_document_new_from_file (copy_uri, NULL, &error); gcut_assert_error (error); cut_assert_equal_int (3, poppler_document_get_n_pages (document)); }
void DocumentView::drawTexImage(cairo_t* cr, TexImage* texImage) { XOJ_CHECK_TYPE(DocumentView); cairo_matrix_t defaultMatrix = { 0 }; cairo_get_matrix(cr, &defaultMatrix); PopplerDocument* pdf = texImage->getPdf(); cairo_surface_t* img = texImage->getImage(); if (pdf != nullptr) { if (poppler_document_get_n_pages(pdf) < 1) { g_warning("Got latex PDf without pages!: %s", texImage->getText().c_str()); return; } PopplerPage* page = poppler_document_get_page(pdf, 0); double pageWidth = 0; double pageHeight = 0; poppler_page_get_size(page, &pageWidth, &pageHeight); double xFactor = texImage->getElementWidth() / pageWidth; double yFactor = texImage->getElementHeight() / pageHeight; cairo_translate(cr, texImage->getX(), texImage->getY()); cairo_scale(cr, xFactor, yFactor); poppler_page_render(page, cr); } else if (img != nullptr) { int width = cairo_image_surface_get_width(img); int height = cairo_image_surface_get_height(img); cairo_set_operator(cr, CAIRO_OPERATOR_OVER); double xFactor = texImage->getElementWidth() / width; double yFactor = texImage->getElementHeight() / height; cairo_scale(cr, xFactor, yFactor); cairo_set_source_surface(cr, img, texImage->getX() / xFactor, texImage->getY() / yFactor); cairo_paint(cr); } cairo_set_matrix(cr, &defaultMatrix); }
// method: draw all the pages to appropriate recording surfaces and then get ink extents void evenodd_cropboxes(PopplerDocument *document, cairo_rectangle_t *odd_page_crop_box, cairo_rectangle_t *even_page_crop_box) { GError *error = NULL; int num_document_pages = poppler_document_get_n_pages(document); cairo_surface_t *odd_pages = cairo_recording_surface_create(CAIRO_CONTENT_COLOR_ALPHA, NULL); cairo_surface_t *even_pages = cairo_recording_surface_create(CAIRO_CONTENT_COLOR_ALPHA, NULL); int page_num; for (page_num = 0; page_num < num_document_pages; page_num++) { cairo_surface_t *surface = odd_pages; if (page_num % 2 == 1) { surface = even_pages; } cairo_t *cr = cairo_create(surface); PopplerPage *page = poppler_document_get_page(document, page_num); if (page == NULL) { printf("%s:%d: %s\n", __FILE__, __LINE__, error->message); exit(1); } poppler_page_render_for_printing(page, cr); g_object_unref(page); exit_if_cairo_status_not_success(cr, __FILE__, __LINE__); cairo_destroy(cr); } cairo_recording_surface_ink_extents(odd_pages, &odd_page_crop_box->x, &odd_page_crop_box->y, &odd_page_crop_box->width, &odd_page_crop_box->height); cairo_recording_surface_ink_extents(even_pages, &even_page_crop_box->x, &even_page_crop_box->y, &even_page_crop_box->width, &even_page_crop_box->height); // use to check extent and crop box handling // write_surface_to_file_showing_crop_box("odd.pdf", odd_pages, odd_page_crop_box); // write_surface_to_file_showing_crop_box("even.pdf", even_pages, even_page_crop_box); // cleanup surfaces used to get crop boxes cairo_surface_destroy(odd_pages); exit_if_cairo_surface_status_not_success(odd_pages, __FILE__, __LINE__); cairo_surface_destroy(even_pages); exit_if_cairo_surface_status_not_success(even_pages, __FILE__, __LINE__); }
struct pages_t* all_pages(PopplerDocument *document, struct options_t options) { struct pages_t *pages = malloc(sizeof(struct pages_t)); pages->npages = poppler_document_get_n_pages(document); pages->pages = malloc(sizeof(struct page_t)*pages->npages); int page_num; for (page_num = 0; page_num < pages->npages; page_num++) { struct page_t *page = &pages->pages[page_num]; page->num = page_num; } return pages; }
void add_per_page_cropboxes(PopplerDocument *document, struct pages_t *pages) { GError *error = NULL; int num_document_pages = poppler_document_get_n_pages(document); int page_num; for (page_num = 0; page_num < pages->npages; page_num++) { int document_page_num = pages->pages[page_num].num; printf("document_page_num: %d\n", document_page_num); if (document_page_num >= num_document_pages) { printf("ERROR: The document does not have page %d, it only has %d pages\n", document_page_num, num_document_pages); exit(2); } cairo_surface_t *surface = cairo_recording_surface_create(CAIRO_CONTENT_COLOR_ALPHA, NULL); cairo_t *cr = cairo_create(surface); PopplerPage *page = poppler_document_get_page(document, document_page_num); if (page == NULL) { printf("%s:%d: %s\n", __FILE__, __LINE__, error->message); exit(1); } poppler_page_render_for_printing(page, cr); g_object_unref(page); exit_if_cairo_status_not_success(cr, __FILE__, __LINE__); cairo_destroy(cr); cairo_rectangle_t *crop_box = malloc(sizeof(cairo_rectangle_t)); cairo_recording_surface_ink_extents(surface, &crop_box->x, &crop_box->y, &crop_box->width, &crop_box->height); // use to check extent and crop box handling // write_surface_to_file_showing_crop_box("per_page.pdf", surface, crop_box); // cleanup surfaces used to get crop boxes cairo_surface_destroy(surface); exit_if_cairo_surface_status_not_success(surface, __FILE__, __LINE__); pages->pages[page_num].crop_box = crop_box; } }
void test_new_from_data (void) { GError *error = NULL; gchar *data; gsize length; const gchar *path; path = cut_take_string (cut_build_fixture_data_path ("multi-pages.pdf", NULL)); g_file_get_contents (path, &data, &length, &error); gcut_assert_error (error); document = poppler_document_new_from_data (data, length, NULL, &error); g_free (data); gcut_assert_error (error); cut_assert_equal_int (3, poppler_document_get_n_pages (document)); }
static VALUE rg_each(VALUE self) { PopplerDocument *document; int i, n_pages; document = RVAL2DOC(self); n_pages = poppler_document_get_n_pages(document); for (i = 0; i < n_pages; i++) { PopplerPage *page; VALUE rb_page; page = poppler_document_get_page(document, i); rb_page = GOBJ2RVAL(page); if (page) g_object_unref(page); rb_yield(rb_page); } return self; }
/* operations for doc */ struct xv_doc_t * xv_doc_new(const char * file) { GError *err = NULL; struct xv_doc_t *xv_doc; xv_doc = g_malloc0(sizeof(struct xv_doc_t)); xv_doc->doc = poppler_document_new_from_file(file, NULL, &err); if (!xv_doc->doc) { printf("%s\n", err->message); g_error_free(err); g_free(xv_doc); return NULL; } xv_doc->n_pages = poppler_document_get_n_pages(xv_doc->doc); /* initialize the pages */ xv_doc->pages = g_malloc0(xv_doc->n_pages * sizeof(struct xv_page_t *)); /* initial the first page */ xv_doc->pages[0] = g_malloc0(sizeof(struct xv_page_t)); xv_doc->pages[0]-> page = poppler_document_get_page(xv_doc->doc, 0); if (!xv_doc->pages[0]->page) { printf("Could not open page %d of document\n", 0); g_object_unref(xv_doc->doc); g_free(xv_doc->pages[0]); g_free(xv_doc->pages); g_free(xv_doc); return NULL; } poppler_page_get_size(xv_doc->pages[0]->page, &xv_doc->pages[0]->width, &xv_doc->pages[0]->height); return xv_doc; }
void *render_threaded(void *arg) { Show *show = (Show *) arg; int i, j, n, x, y, grid = 0; int sw = show->w, sh = show->h; Pixmap thumb = 0x0; /* open pdf and create Show */ PopplerDocument *pdf = poppler_document_new_from_file(show->uri,NULL,NULL); if (!pdf) die("\"%s\" is not a pdf file\n",show->uri); show->count = poppler_document_get_n_pages(pdf); show->slide = (Pixmap *) calloc(show->count, sizeof(Pixmap)); show->flag = (int *) calloc(show->count, sizeof(int)); /* scaling calculations */ double pdfw, pdfh; PopplerPage *page = poppler_document_get_page(pdf,0); poppler_page_get_size(page,&pdfw,&pdfh); float hsc = show->w/pdfw, vsc = show->h/pdfh; if (hsc > vsc) { show->scale = vsc; show->w = pdfw * show->scale; show->x = (sw - show->w)/2; } else { show->scale = hsc; show->h = pdfh * show->scale; show->y = (sh - show->h)/2; } /* create sorter */ if (show->sorter) { /* scaling calculations sorter */ show->sorter->count = 1; show->sorter->slide = (Pixmap *) calloc(1, sizeof(Pixmap)); show->sorter->flag = (int *) calloc(1,sizeof(int)); grid = (int) ceil(sqrt(show->count)) ; vsc = ( (sh-10)/grid - 10) / pdfh; hsc = ( (sw-10)/grid - 10) / pdfw; show->sorter->flag[0] = grid; show->sorter->scale = (vsc > hsc ? hsc : vsc); show->sorter->h = pdfh * show->sorter->scale; show->sorter->w = pdfw * show->sorter->scale; show->sorter->x = (sw - (show->sorter->w+10)*grid + 10)/2; show->sorter->y = (sh - (show->sorter->h+10)*grid + 10)/2; /* create empty sorter frame */ thumb = XCreatePixmap(dpy,root,show->sorter->w, show->sorter->h,DefaultDepth(dpy,scr)); show->sorter->slide[0] = XCreatePixmap(dpy,root,sw,sh, DefaultDepth(dpy,scr)); XFillRectangle(dpy,show->sorter->slide[0],bgc,0,0,sw,sh); n = 0; y = show->sorter->y; for (i = 0; i < grid; i++, y += show->sorter->h + 10) { x = show->sorter->x; for (j = 0; j < grid; j++, x+= show->sorter->w + 10) { if (++n > show->count) break; XFillRectangle(dpy,show->sorter->slide[0],egc,x+2,y+2, show->sorter->w-5,show->sorter->h-5); } } } /* render pages */ cairo_surface_t *target; cairo_t *cairo; n = 0; x = (show->sorter ? show->sorter->x : 0); y = (show->sorter ? show->sorter->y : 0); for (i = 0; i < show->count && !(show->flag[0] & STOP_RENDER); i++) { show->slide[i] = XCreatePixmap(dpy,root,show->w,show->h, DefaultDepth(dpy,scr)); XFillRectangle(dpy,show->slide[i],sgc,0,0,show->w,show->h); page = poppler_document_get_page(pdf,i); target = cairo_xlib_surface_create(dpy,show->slide[i], DefaultVisual(dpy,scr),show->w,show->h); cairo = cairo_create(target); cairo_scale(cairo,show->scale,show->scale); poppler_page_render(page,cairo); cairo_surface_destroy(target); cairo_destroy(cairo); show->flag[i] |= RENDERED; if (show->sorter) { XFillRectangle(dpy,thumb,sgc,0,0,show->sorter->w,show->sorter->h); target = cairo_xlib_surface_create(dpy,thumb,DefaultVisual(dpy,scr), show->sorter->w,show->sorter->h); cairo = cairo_create(target); cairo_scale(cairo,show->sorter->scale,show->sorter->scale); poppler_page_render(page,cairo); cairo_surface_destroy(target); XCopyArea(dpy,thumb,show->sorter->slide[0],sgc,0,0,show->sorter->w, show->sorter->h,x,y); x += show->sorter->w + 10; if (++n == grid) { n = 0; x = show->sorter->x; y += show->sorter->h + 10; } } } if (show->sorter) XFreePixmap(dpy,thumb); return NULL; }
int main(int argn, char *args[]) { // Poppler stuff PopplerDocument *pdffile; PopplerPage *page; // Initialise the GType library g_type_init (); // Get command line arguments if ((argn < 3)||(argn > 4)) { printf("Usage: pdf2svg <in file.pdf> <out file.svg> [<page no>]\n"); return -2; } gchar *absoluteFileName = getAbsoluteFileName(args[1]); gchar *filename_uri = g_filename_to_uri(absoluteFileName, NULL, NULL); gchar *pageLabel = NULL; char* svgFilename = args[2]; g_free(absoluteFileName); if (argn == 4) { // Get page number pageLabel = g_strdup(args[3]); } // Open the PDF file pdffile = poppler_document_new_from_file(filename_uri, NULL, NULL); g_free(filename_uri); if (pdffile == NULL) { fprintf(stderr, "Unable to open file\n"); return -3; } int conversionErrors = 0; // Get the page if(pageLabel == NULL) { page = poppler_document_get_page(pdffile, 0); conversionErrors = convertPage(page, svgFilename); } else { if(strcmp(pageLabel, "all") == 0) { int curError; int pageCount = poppler_document_get_n_pages(pdffile); if(pageCount > 9999999) { fprintf(stderr, "Too many pages (>9,999,999)\n"); return -5; } size_t svgFilenameBufLen = strlen(svgFilename) + 1; char *svgFilenameBuffer = (char*)malloc(svgFilenameBufLen); assert(svgFilenameBuffer != NULL); int pageInd; for(pageInd = 0; pageInd < pageCount; pageInd++) { while (1) { size_t _wr_len = snprintf(svgFilenameBuffer, svgFilenameBufLen, svgFilename, pageInd + 1); if (_wr_len >= svgFilenameBufLen) { svgFilenameBufLen = _wr_len + 1; svgFilenameBuffer = (char*)realloc(svgFilenameBuffer, svgFilenameBufLen); assert(svgFilenameBuffer != NULL); continue; } break; } page = poppler_document_get_page(pdffile, pageInd); curError = convertPage(page, svgFilenameBuffer); if(curError != 0) conversionErrors = -1; } free(svgFilenameBuffer); } else { page = poppler_document_get_page_by_label(pdffile, pageLabel); conversionErrors = convertPage(page, svgFilename); g_free(pageLabel); } } g_object_unref(pdffile); if(conversionErrors != 0) { return -4; } else { return 0; } }
GtkWidget * pgd_text_create_widget (PopplerDocument *document) { PgdTextDemo *demo; GtkWidget *label; GtkWidget *vbox, *vbox2; GtkWidget *hbox, *page_selector, *area_hbox; GtkWidget *button; GtkWidget *swindow, *textview, *treeview; GtkTreeSelection *selection; GtkWidget *frame, *alignment, *table; GtkWidget *hpaned; GtkCellRenderer *renderer; gchar *str; gint n_pages; gint row = 0; demo = g_new0 (PgdTextDemo, 1); demo->doc = g_object_ref (document); n_pages = poppler_document_get_n_pages (document); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Page:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); page_selector = gtk_spin_button_new_with_range (1, n_pages, 1); g_signal_connect (G_OBJECT (page_selector), "value-changed", G_CALLBACK (pgd_text_page_selector_value_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (hbox), page_selector, FALSE, TRUE, 0); gtk_widget_show (page_selector); str = g_strdup_printf ("of %d", n_pages); label = gtk_label_new (str); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); g_free (str); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); area_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("X1:"); gtk_box_pack_start (GTK_BOX (area_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); demo->area_x1 = gtk_spin_button_new_with_range (0, 0, 0.01); g_signal_connect (demo->area_x1, "value-changed", G_CALLBACK (pgd_text_area_selector_value_changed), demo); gtk_box_pack_start (GTK_BOX (area_hbox), demo->area_x1, TRUE, TRUE, 0); gtk_widget_show (demo->area_x1); gtk_box_pack_start (GTK_BOX (hbox), area_hbox, FALSE, TRUE, 0); gtk_widget_show (area_hbox); area_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Y1:"); gtk_box_pack_start (GTK_BOX (area_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); demo->area_y1 = gtk_spin_button_new_with_range (0, 0, 0.01); g_signal_connect (demo->area_y1, "value-changed", G_CALLBACK (pgd_text_area_selector_value_changed), demo); gtk_box_pack_start (GTK_BOX (area_hbox), demo->area_y1, TRUE, TRUE, 0); gtk_widget_show (demo->area_y1); gtk_box_pack_start (GTK_BOX (hbox), area_hbox, FALSE, TRUE, 0); gtk_widget_show (area_hbox); area_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("X2:"); gtk_box_pack_start (GTK_BOX (area_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); demo->area_x2 = gtk_spin_button_new_with_range (0, 0, 0.01); g_signal_connect (demo->area_x2, "value-changed", G_CALLBACK (pgd_text_area_selector_value_changed), demo); gtk_box_pack_start (GTK_BOX (area_hbox), demo->area_x2, TRUE, TRUE, 0); gtk_widget_show (demo->area_x2); gtk_box_pack_start (GTK_BOX (hbox), area_hbox, FALSE, TRUE, 0); gtk_widget_show (area_hbox); area_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Y2:"); gtk_box_pack_start (GTK_BOX (area_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); demo->area_y2 = gtk_spin_button_new_with_range (0, 0, 0.01); g_signal_connect (demo->area_y2, "value-changed", G_CALLBACK (pgd_text_area_selector_value_changed), demo); gtk_box_pack_start (GTK_BOX (area_hbox), demo->area_y2, TRUE, TRUE, 0); gtk_widget_show (demo->area_y2); gtk_box_pack_start (GTK_BOX (hbox), area_hbox, FALSE, TRUE, 0); gtk_widget_show (area_hbox); pgd_text_area_selector_setup (demo); button = gtk_button_new_with_label ("Get Text"); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (pgd_text_get_text), (gpointer)demo); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); demo->timer_label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (demo->timer_label), "<i>No text found</i>"); g_object_set (G_OBJECT (demo->timer_label), "xalign", 1.0, NULL); gtk_box_pack_start (GTK_BOX (vbox), demo->timer_label, FALSE, TRUE, 0); gtk_widget_show (demo->timer_label); hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); gtk_paned_set_position (GTK_PANED (hpaned), 300); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); demo->model = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (demo->model)); demo->treeview = treeview; renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), TEXT_X1_COLUMN, "X1", renderer, "text", TEXT_X1_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), TEXT_Y1_COLUMN, "Y1", renderer, "text", TEXT_Y1_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), TEXT_X2_COLUMN, "X2", renderer, "text", TEXT_X2_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), TEXT_Y2_COLUMN, "Y2", renderer, "text", TEXT_Y2_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), TEXT_OFFSET_COLUMN, "Offset", renderer, "text", TEXT_OFFSET_COLUMN, NULL); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); g_signal_connect (selection, "changed", G_CALLBACK (pgd_text_selection_changed), (gpointer) demo); gtk_container_add (GTK_CONTAINER (swindow), treeview); gtk_widget_show (treeview); gtk_box_pack_start (GTK_BOX (vbox2), swindow, TRUE, TRUE, 0); gtk_widget_show (swindow); /* Text attributes */ frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<b>Text Attributes</b>"); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_widget_show (label); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 5, 5, 12, 5); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_widget_show (alignment); table = gtk_grid_new (); gtk_grid_set_column_spacing (GTK_GRID (table), 6); gtk_grid_set_row_spacing (GTK_GRID (table), 6); demo->font_name = gtk_label_new (NULL); pgd_table_add_property_with_custom_widget (GTK_GRID (table), "<b>Font Name:</b>", demo->font_name, &row); demo->font_size = gtk_label_new (NULL); pgd_table_add_property_with_custom_widget (GTK_GRID (table), "<b>Font Size:</b>", demo->font_size, &row); demo->is_underlined = gtk_label_new (NULL); pgd_table_add_property_with_custom_widget (GTK_GRID (table), "<b>Underlined:</b>", demo->is_underlined, &row); demo->text_color = gtk_image_new (); pgd_table_add_property_with_custom_widget (GTK_GRID (table), "<b>Color:</b>", demo->text_color, &row); gtk_container_add (GTK_CONTAINER (alignment), table); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (vbox2), frame, FALSE, FALSE, 12); gtk_widget_show (frame); gtk_paned_add1 (GTK_PANED (hpaned), vbox2); gtk_widget_show (vbox2); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); demo->buffer = gtk_text_buffer_new (NULL); textview = gtk_text_view_new_with_buffer (demo->buffer); g_signal_connect (textview, "query-tooltip", G_CALLBACK (pgd_text_view_query_tooltip), demo); g_signal_connect (demo->buffer, "notify::has-selection", G_CALLBACK (pgd_text_buffer_selection_changed), textview); gtk_container_add (GTK_CONTAINER (swindow), textview); gtk_widget_show (textview); gtk_paned_add2 (GTK_PANED (hpaned), swindow); gtk_widget_show (swindow); gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0); gtk_widget_show (hpaned); g_object_weak_ref (G_OBJECT (vbox), (GWeakNotify)pgd_text_free, demo); return vbox; }
int main(int argc, char **argv) { int i = 0, numframes; char *filename = NULL; gchar *notefile = NULL; FILE *fp = NULL; struct stat statbuf; char *databuf = NULL; GError *err = NULL; gtk_init(&argc, &argv); /* Load preferences first. Command line options will override those * preferences. */ loadPreferences(); /* Read defaults from preferences. */ filename = NULL; numframes = 2 * prefs.slide_context + 1; runpref.do_wrapping = prefs.do_wrapping; runpref.do_notectrl = prefs.do_notectrl; runpref.fit_mode = prefs.initial_fit_mode; /* get options via getopt */ while ((i = getopt(argc, argv, "s:wnN:CTv")) != -1) { switch (i) { case 's': numframes = 2 * atoi(optarg) + 1; if (numframes <= 1) { fprintf(stderr, "Invalid slide count specified.\n"); usage(argv[0]); exit(EXIT_FAILURE); } break; case 'w': runpref.do_wrapping = TRUE; break; case 'n': runpref.do_notectrl = TRUE; break; case 'N': notefile = g_strdup(optarg); break; case 'C': /* Force the timer to be a clock. */ prefs.timer_is_clock = TRUE; break; case 'T': /* Force the timer to be a timer (not a clock). */ prefs.timer_is_clock = FALSE; break; case 'v': printf("pdfpres version: %s\n", PDFPRES_VERSION); exit(EXIT_SUCCESS); break; case '?': exit(EXIT_FAILURE); break; } } /* retrieve file name via first non-option argument */ if (optind < argc) { filename = argv[optind]; } if (filename == NULL) { fprintf(stderr, "Invalid file path specified.\n"); usage(argv[0]); exit(EXIT_FAILURE); } /* try to load the file */ if (stat(filename, &statbuf) == -1) { perror("Could not stat file"); exit(EXIT_FAILURE); } /* note: this buffer must not be freed, it'll be used by poppler * later on. */ databuf = (char *)malloc(statbuf.st_size); g_assert(databuf); fp = fopen(filename, "rb"); if (!fp) { perror("Could not open file"); exit(EXIT_FAILURE); } /* Read 1 element of size "statbuf.st_size". fread() returns the * number of items successfully read. Thus, a return value of "1" * means "success" and anything else is an error. */ if (fread(databuf, statbuf.st_size, 1, fp) != 1) { fprintf(stderr, "Unexpected end of file.\n"); exit(EXIT_FAILURE); } fclose(fp); /* get document from data */ doc = poppler_document_new_from_data(databuf, statbuf.st_size, NULL, &err); if (!doc) { fprintf(stderr, "%s\n", err->message); g_error_free(err); exit(EXIT_FAILURE); } doc_n_pages = poppler_document_get_n_pages(doc); if (doc_n_pages <= 0) { fprintf(stderr, "Huh, no pages in that document.\n"); exit(EXIT_FAILURE); } PopplerPage *page = poppler_document_get_page(doc, doc_n_pages-1); doc_last_page = atoi(poppler_page_get_label(page)); g_object_unref(G_OBJECT(page)); initGUI(numframes, notefile); gtk_main(); exit(EXIT_SUCCESS); }
GtkWidget * pgd_render_properties_selector_create (PgdRenderDemo *demo) { GtkWidget *hbox, *vbox; GtkWidget *label; GtkWidget *page_hbox, *page_selector; GtkWidget *scale_hbox, *scale_selector; GtkWidget *rotate_hbox, *rotate_selector; GtkWidget *printing_selector; GtkWidget *slice_hbox; GtkWidget *button; gint n_pages; gchar *str; n_pages = poppler_document_get_n_pages (demo->doc); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); page_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Page:"); gtk_box_pack_start (GTK_BOX (page_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); page_selector = gtk_spin_button_new_with_range (1, n_pages, 1); g_signal_connect (G_OBJECT (page_selector), "value-changed", G_CALLBACK (pgd_render_page_selector_value_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (page_hbox), page_selector, TRUE, TRUE, 0); gtk_widget_show (page_selector); str = g_strdup_printf ("of %d", n_pages); label = gtk_label_new (str); gtk_box_pack_start (GTK_BOX (page_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); g_free (str); gtk_box_pack_start (GTK_BOX (hbox), page_hbox, FALSE, TRUE, 0); gtk_widget_show (page_hbox); scale_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Scale:"); gtk_box_pack_start (GTK_BOX (scale_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); scale_selector = gtk_spin_button_new_with_range (0, 10.0, 0.1); gtk_spin_button_set_value (GTK_SPIN_BUTTON (scale_selector), 1.0); g_signal_connect (G_OBJECT (scale_selector), "value-changed", G_CALLBACK (pgd_render_scale_selector_value_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (scale_hbox), scale_selector, TRUE, TRUE, 0); gtk_widget_show (scale_selector); gtk_box_pack_start (GTK_BOX (hbox), scale_hbox, FALSE, TRUE, 0); gtk_widget_show (scale_hbox); rotate_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Rotate:"); gtk_box_pack_start (GTK_BOX (rotate_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); rotate_selector = gtk_combo_box_text_new (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (rotate_selector), "0"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (rotate_selector), "90"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (rotate_selector), "180"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (rotate_selector), "270"); gtk_combo_box_set_active (GTK_COMBO_BOX (rotate_selector), 0); g_signal_connect (G_OBJECT (rotate_selector), "changed", G_CALLBACK (pgd_render_rotate_selector_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (rotate_hbox), rotate_selector, TRUE, TRUE, 0); gtk_widget_show (rotate_selector); gtk_box_pack_start (GTK_BOX (hbox), rotate_hbox, FALSE, TRUE, 0); gtk_widget_show (rotate_hbox); printing_selector = gtk_check_button_new_with_label ("Printing"); g_signal_connect (printing_selector, "toggled", G_CALLBACK (pgd_render_printing_selector_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (hbox), printing_selector, FALSE, TRUE, 0); gtk_widget_show (printing_selector); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); slice_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("x:"); gtk_box_pack_start (GTK_BOX (slice_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); demo->slice_x = gtk_spin_button_new_with_range (0, 0, 1.0); g_signal_connect (G_OBJECT (demo->slice_x), "value-changed", G_CALLBACK (pgd_render_slice_selector_value_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (slice_hbox), demo->slice_x, TRUE, TRUE, 0); gtk_widget_show (demo->slice_x); gtk_box_pack_start (GTK_BOX (hbox), slice_hbox, FALSE, TRUE, 0); gtk_widget_show (slice_hbox); slice_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("y:"); gtk_box_pack_start (GTK_BOX (slice_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); demo->slice_y = gtk_spin_button_new_with_range (0, 0, 1.0); g_signal_connect (G_OBJECT (demo->slice_y), "value-changed", G_CALLBACK (pgd_render_slice_selector_value_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (slice_hbox), demo->slice_y, TRUE, TRUE, 0); gtk_widget_show (demo->slice_y); gtk_box_pack_start (GTK_BOX (hbox), slice_hbox, FALSE, TRUE, 0); gtk_widget_show (slice_hbox); slice_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("width:"); gtk_box_pack_start (GTK_BOX (slice_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); demo->slice_w = gtk_spin_button_new_with_range (0, 0, 1.0); g_signal_connect (G_OBJECT (demo->slice_w), "value-changed", G_CALLBACK (pgd_render_slice_selector_value_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (slice_hbox), demo->slice_w, TRUE, TRUE, 0); gtk_widget_show (demo->slice_w); gtk_box_pack_start (GTK_BOX (hbox), slice_hbox, FALSE, TRUE, 0); gtk_widget_show (slice_hbox); slice_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("height:"); gtk_box_pack_start (GTK_BOX (slice_hbox), label, TRUE, TRUE, 0); gtk_widget_show (label); demo->slice_h = gtk_spin_button_new_with_range (0, 0, 1.0); g_signal_connect (G_OBJECT (demo->slice_h), "value-changed", G_CALLBACK (pgd_render_slice_selector_value_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (slice_hbox), demo->slice_h, TRUE, TRUE, 0); gtk_widget_show (demo->slice_h); gtk_box_pack_start (GTK_BOX (hbox), slice_hbox, FALSE, TRUE, 0); gtk_widget_show (slice_hbox); pgd_render_slice_selector_setup (demo); button = gtk_button_new_with_label ("Render"); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (pgd_render_start), (gpointer)demo); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, TRUE, 0); gtk_widget_show (button); demo->timer_label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (demo->timer_label), "<i>No page rendered</i>"); g_object_set (G_OBJECT (demo->timer_label), "xalign", 1.0, NULL); gtk_box_pack_end (GTK_BOX (vbox), demo->timer_label, FALSE, TRUE, 0); gtk_widget_show (demo->timer_label); return vbox; }
/* Main UI */ GtkWidget * pgd_annots_create_widget (PopplerDocument *document) { PgdAnnotsDemo *demo; GtkWidget *label; GtkWidget *vbox, *vbox2; GtkWidget *button; GtkWidget *hbox, *page_selector; GtkWidget *hpaned; GtkWidget *swindow, *treeview; GtkTreeSelection *selection; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkListStore *model; GtkTreeIter iter; gchar *str; gint n_pages; gint i; demo = g_new0 (PgdAnnotsDemo, 1); demo->doc = g_object_ref (document); demo->cursor = GDK_LAST_CURSOR; demo->mode = MODE_NORMAL; n_pages = poppler_document_get_n_pages (document); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Page:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); page_selector = gtk_spin_button_new_with_range (1, n_pages, 1); g_signal_connect (G_OBJECT (page_selector), "value-changed", G_CALLBACK (pgd_annots_page_selector_value_changed), (gpointer) demo); gtk_box_pack_start (GTK_BOX (hbox), page_selector, FALSE, TRUE, 0); gtk_widget_show (page_selector); str = g_strdup_printf ("of %d", n_pages); label = gtk_label_new (str); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); g_free (str); demo->remove_button = gtk_button_new_with_mnemonic ("_Remove"); gtk_widget_set_sensitive (demo->remove_button, FALSE); g_signal_connect (G_OBJECT (demo->remove_button), "clicked", G_CALLBACK (pgd_annots_remove_annot), (gpointer) demo); gtk_box_pack_end (GTK_BOX (hbox), demo->remove_button, FALSE, FALSE, 6); gtk_widget_show (demo->remove_button); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); button = gtk_button_new_with_mnemonic ("_Add"); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (pgd_annots_start_add_annot), (gpointer) demo); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); model = gtk_list_store_new(SELECTED_N_COLUMNS, G_TYPE_INT, G_TYPE_STRING); for (i = 0; i < G_N_ELEMENTS (supported_annots); i++) { gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, SELECTED_TYPE_COLUMN, supported_annots[i].type, SELECTED_LABEL_COLUMN, supported_annots[i].label, -1); } demo->type_selector = gtk_combo_box_new_with_model (GTK_TREE_MODEL (model)); g_object_unref (model); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (demo->type_selector), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (demo->type_selector), renderer, "text", SELECTED_LABEL_COLUMN, NULL); gtk_combo_box_set_active (GTK_COMBO_BOX (demo->type_selector), 0); gtk_box_pack_end (GTK_BOX (hbox), demo->type_selector, FALSE, FALSE, 0); gtk_widget_show (demo->type_selector); button = gtk_color_button_new (); demo->annot_color.red = 65535; demo->annot_color.alpha = 1.0; #if GTK_CHECK_VERSION(3,4,0) gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (button), &demo->annot_color); #else gtk_color_button_set_rgba (GTK_COLOR_BUTTON (button), &demo->annot_color); #endif g_signal_connect (button, "notify::color", G_CALLBACK (pgd_annot_color_changed), (gpointer)demo); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, TRUE, 0); gtk_widget_show (button); gtk_widget_show (hbox); demo->timer_label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (demo->timer_label), "<i>No annotations found</i>"); g_object_set (G_OBJECT (demo->timer_label), "xalign", 1.0, NULL); gtk_box_pack_start (GTK_BOX (vbox), demo->timer_label, FALSE, TRUE, 0); gtk_widget_show (demo->timer_label); hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); demo->annot_view = pgd_annot_view_new (); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); demo->model = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_OBJECT); treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (demo->model)); demo->tree_view = treeview; column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, "Type"); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_add_attribute (column, renderer, "pixbuf", ANNOTS_COLOR_COLUMN); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_add_attribute (column, renderer, "text", ANNOTS_TYPE_COLUMN); renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (renderer, "toggled", G_CALLBACK (pgd_annots_invisible_flag_toggled), (gpointer) demo); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), ANNOTS_FLAG_INVISIBLE_COLUMN, "Invisible", renderer, "active", ANNOTS_FLAG_INVISIBLE_COLUMN, NULL); renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (renderer, "toggled", G_CALLBACK (pgd_annots_hidden_flag_toggled), (gpointer) demo); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), ANNOTS_FLAG_HIDDEN_COLUMN, "Hidden", renderer, "active", ANNOTS_FLAG_HIDDEN_COLUMN, NULL); renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (renderer, "toggled", G_CALLBACK (pgd_annots_print_flag_toggled), (gpointer) demo); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), ANNOTS_FLAG_PRINT_COLUMN, "Print", renderer, "active", ANNOTS_FLAG_PRINT_COLUMN, NULL); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (pgd_annots_selection_changed), (gpointer) demo); /* Annotation's list */ gtk_container_add (GTK_CONTAINER (swindow), treeview); gtk_widget_show (treeview); gtk_box_pack_start (GTK_BOX (vbox2), swindow, TRUE, TRUE, 0); gtk_widget_show (swindow); /* Annotation Properties */ swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (swindow), demo->annot_view); gtk_widget_show (demo->annot_view); gtk_widget_show (swindow); gtk_box_pack_start (GTK_BOX (vbox2), swindow, TRUE, TRUE, 6); gtk_widget_show (swindow); gtk_paned_add1 (GTK_PANED (hpaned), vbox2); gtk_widget_show (vbox2); /* Demo Area (Render) */ demo->darea = gtk_drawing_area_new (); g_signal_connect (demo->darea, "draw", G_CALLBACK (pgd_annots_view_drawing_area_draw), demo); g_signal_connect (demo->darea, "realize", G_CALLBACK (pgd_annots_drawing_area_realize), (gpointer)demo); g_signal_connect (demo->darea, "button_press_event", G_CALLBACK (pgd_annots_drawing_area_button_press), (gpointer)demo); g_signal_connect (demo->darea, "motion_notify_event", G_CALLBACK (pgd_annots_drawing_area_motion_notify), (gpointer)demo); g_signal_connect (demo->darea, "button_release_event", G_CALLBACK (pgd_annots_drawing_area_button_release), (gpointer)demo); swindow = gtk_scrolled_window_new (NULL, NULL); #if GTK_CHECK_VERSION(3, 7, 8) gtk_container_add(GTK_CONTAINER(swindow), demo->darea); #else gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (swindow), demo->darea); #endif gtk_widget_show (demo->darea); gtk_paned_add2 (GTK_PANED (hpaned), swindow); gtk_widget_show (swindow); gtk_paned_set_position (GTK_PANED (hpaned), 300); gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0); gtk_widget_show (hpaned); g_object_weak_ref (G_OBJECT (vbox), (GWeakNotify)pgd_annots_free, demo); pgd_annots_viewer_queue_redraw (demo); pgd_annots_get_annots (demo); demo->main_box = vbox; return vbox; }
int getNumOfPages() { return _doc ? poppler_document_get_n_pages(_doc) : 0; }
GtkWidget * pgd_forms_create_widget (PopplerDocument *document) { PgdFormsDemo *demo; GtkWidget *label; GtkWidget *vbox; GtkWidget *hbox, *page_selector; GtkWidget *button; GtkWidget *hpaned; GtkWidget *swindow, *treeview; GtkTreeSelection *selection; GtkCellRenderer *renderer; gchar *str; gint n_pages; demo = g_new0 (PgdFormsDemo, 1); demo->doc = g_object_ref (document); n_pages = poppler_document_get_n_pages (document); vbox = gtk_vbox_new (FALSE, 12); hbox = gtk_hbox_new (FALSE, 6); label = gtk_label_new ("Page:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); page_selector = gtk_spin_button_new_with_range (1, n_pages, 1); g_signal_connect (G_OBJECT (page_selector), "value-changed", G_CALLBACK (pgd_forms_page_selector_value_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (hbox), page_selector, FALSE, TRUE, 0); gtk_widget_show (page_selector); str = g_strdup_printf ("of %d", n_pages); label = gtk_label_new (str); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); g_free (str); button = gtk_button_new_with_label ("Get Forms Fields"); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (pgd_forms_get_form_fields), (gpointer)demo); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); demo->timer_label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (demo->timer_label), "<i>No form fields found</i>"); g_object_set (G_OBJECT (demo->timer_label), "xalign", 1.0, NULL); gtk_box_pack_start (GTK_BOX (vbox), demo->timer_label, FALSE, TRUE, 0); gtk_widget_show (demo->timer_label); hpaned = gtk_hpaned_new (); demo->field_view = pgd_form_field_view_new (); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); demo->model = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_INT, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_OBJECT); treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (demo->model)); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 0, "Form Field Type", renderer, "text", FORMS_FIELD_TYPE_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 1, "Form Field Id", renderer, "text", FORMS_ID_COLUMN, NULL); renderer = gtk_cell_renderer_toggle_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 2, "Read Only", renderer, "active", FORMS_READ_ONLY_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 3, "X1", renderer, "text", FORMS_X1_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 4, "Y1", renderer, "text", FORMS_Y1_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 5, "X2", renderer, "text", FORMS_X2_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), 6, "Y2", renderer, "text", FORMS_Y2_COLUMN, NULL); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (pgd_forms_selection_changed), (gpointer)demo); gtk_container_add (GTK_CONTAINER (swindow), treeview); gtk_widget_show (treeview); gtk_paned_add1 (GTK_PANED (hpaned), swindow); gtk_widget_show (swindow); gtk_paned_add2 (GTK_PANED (hpaned), demo->field_view); gtk_widget_show (demo->field_view); gtk_paned_set_position (GTK_PANED (hpaned), 300); gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0); gtk_widget_show (hpaned); g_object_weak_ref (G_OBJECT (vbox), (GWeakNotify)pgd_forms_free, demo); return vbox; }
int main(int argc, char **argv) { int i = 0, numframes; char *filename = NULL; gchar *notefile = NULL; FILE *fp = NULL; struct stat statbuf; char *databuf = NULL; GError *err = NULL; gtk_init(&argc, &argv); /* Load preferences first. Command line options will override those * preferences. */ loadPreferences(); /* Read defaults from preferences. */ filename = NULL; numframes = 2 * prefs.slide_context + 1; runpref.do_wrapping = prefs.do_wrapping; runpref.do_notectrl = prefs.do_notectrl; runpref.cache_max = prefs.cache_max; runpref.fit_mode = prefs.initial_fit_mode; /* get options via getopt */ while ((i = getopt(argc, argv, "s:wnc:N:CTv")) != -1) { switch (i) { case 's': numframes = 2 * atoi(optarg) + 1; if (numframes <= 1) { fprintf(stderr, "Invalid slide count specified.\n"); usage(argv[0]); exit(EXIT_FAILURE); } break; case 'w': runpref.do_wrapping = TRUE; break; case 'n': runpref.do_notectrl = TRUE; break; case 'c': /* don't care if that number is invalid. it'll get * re-adjusted anyway if it's too small. */ runpref.cache_max = atoi(optarg); break; case 'N': notefile = g_strdup(optarg); break; case 'C': /* Force the timer to be a clock. */ prefs.timer_is_clock = TRUE; break; case 'T': /* Force the timer to be a timer (not a clock). */ prefs.timer_is_clock = FALSE; break; case 'v': printf("pdfpres version: %s\n", PDFPRES_VERSION); exit(EXIT_SUCCESS); break; case '?': exit(EXIT_FAILURE); break; } } /* retrieve file name via first non-option argument */ if (optind < argc) { filename = argv[optind]; } if (filename == NULL) { fprintf(stderr, "Invalid file path specified.\n"); usage(argv[0]); exit(EXIT_FAILURE); } /* for the cache to be useful, we'll need at least "some" items. * that is 2 items (prev and next) per preview viewport and 2 * items for the beamer port. * * this means that switching to the previous and next slide will * always be fast. * * note: numframes is not negative (see above), so that cast is okay. */ if (runpref.cache_max < (guint)((numframes + 1) * 2)) runpref.cache_max = (guint)((numframes + 1) * 2); /* try to load the file */ if (stat(filename, &statbuf) == -1) { perror("Could not stat file"); exit(EXIT_FAILURE); } /* note: this buffer must not be freed, it'll be used by poppler * later on. */ databuf = (char *)malloc(statbuf.st_size); g_assert(databuf); fp = fopen(filename, "rb"); if (!fp) { perror("Could not open file"); exit(EXIT_FAILURE); } /* Read 1 element of size "statbuf.st_size". fread() returns the * number of items successfully read. Thus, a return value of "1" * means "success" and anything else is an error. */ if (fread(databuf, statbuf.st_size, 1, fp) != 1) { fprintf(stderr, "Unexpected end of file.\n"); exit(EXIT_FAILURE); } fclose(fp); /* get document from data */ doc = poppler_document_new_from_data(databuf, statbuf.st_size, NULL, &err); if (!doc) { fprintf(stderr, "%s\n", err->message); g_error_free(err); exit(EXIT_FAILURE); } doc_n_pages = poppler_document_get_n_pages(doc); if (doc_n_pages <= 0) { fprintf(stderr, "Huh, no pages in that document.\n"); exit(EXIT_FAILURE); } initGUI(numframes, notefile); /* queue initial prerendering. */ preQueued = TRUE; g_idle_add(idleFillCaches, NULL); gtk_main(); exit(EXIT_SUCCESS); }
GtkWidget * pgd_text_create_widget (PopplerDocument *document) { PgdTextDemo *demo; GtkWidget *label; GtkWidget *vbox; GtkWidget *hbox, *page_selector; GtkWidget *button; GtkWidget *swindow, *textview; gchar *str; gint n_pages; demo = g_new0 (PgdTextDemo, 1); demo->doc = g_object_ref (document); n_pages = poppler_document_get_n_pages (document); vbox = gtk_vbox_new (FALSE, 12); hbox = gtk_hbox_new (FALSE, 6); label = gtk_label_new ("Page:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); page_selector = gtk_spin_button_new_with_range (1, n_pages, 1); g_signal_connect (G_OBJECT (page_selector), "value-changed", G_CALLBACK (pgd_text_page_selector_value_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (hbox), page_selector, FALSE, TRUE, 0); gtk_widget_show (page_selector); str = g_strdup_printf ("of %d", n_pages); label = gtk_label_new (str); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); g_free (str); button = gtk_button_new_with_label ("Get Text"); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (pgd_text_get_text), (gpointer)demo); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); demo->timer_label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (demo->timer_label), "<i>No text found</i>"); g_object_set (G_OBJECT (demo->timer_label), "xalign", 1.0, NULL); gtk_box_pack_start (GTK_BOX (vbox), demo->timer_label, FALSE, TRUE, 0); gtk_widget_show (demo->timer_label); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); demo->buffer = gtk_text_buffer_new (NULL); textview = gtk_text_view_new_with_buffer (demo->buffer); gtk_container_add (GTK_CONTAINER (swindow), textview); gtk_widget_show (textview); gtk_box_pack_start (GTK_BOX (vbox), swindow, TRUE, TRUE, 0); gtk_widget_show (swindow); g_object_weak_ref (G_OBJECT (vbox), (GWeakNotify)pgd_text_free, demo); return vbox; }
GtkWidget * pgd_find_create_widget (PopplerDocument *document) { PgdFindDemo *demo; GtkWidget *vbox, *hbox; GtkWidget *button; GtkWidget *swindow; GtkWidget *checkbutton; GtkTreeModel *model; GtkWidget *treeview; GtkCellRenderer *renderer; GtkWidget *hpaned; GtkTreeSelection *selection; demo = g_new0 (PgdFindDemo, 1); demo->doc = g_object_ref (document); demo->n_pages = poppler_document_get_n_pages (document); demo->selected_page = -1; demo->options = POPPLER_FIND_DEFAULT; hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); gtk_paned_set_position (GTK_PANED (hpaned), 300); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); demo->entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (hbox), demo->entry, FALSE, TRUE, 0); gtk_widget_show (demo->entry); demo->progress = gtk_progress_bar_new (); gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (demo->progress), PANGO_ELLIPSIZE_END); gtk_box_pack_start (GTK_BOX (hbox), demo->progress, TRUE, TRUE, 0); gtk_widget_show (demo->progress); button = gtk_button_new_with_label ("Find"); gtk_widget_set_sensitive (button, FALSE); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (pgd_find_button_clicked), (gpointer)demo); g_signal_connect_swapped (G_OBJECT (demo->entry), "changed", G_CALLBACK (pgd_find_button_sensitivity_cb), (gpointer)button); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 6); gtk_widget_show (hbox); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); checkbutton = gtk_check_button_new_with_label ("Case sensitive"); g_signal_connect (checkbutton, "toggled", G_CALLBACK (pgd_find_case_sensitive_toggled), demo); gtk_box_pack_start (GTK_BOX (hbox), checkbutton, FALSE, FALSE, 0); gtk_widget_show (checkbutton); checkbutton = gtk_check_button_new_with_label ("Backwards"); g_signal_connect (checkbutton, "toggled", G_CALLBACK (pgd_find_backwards_toggled), demo); gtk_box_pack_start (GTK_BOX (hbox), checkbutton, FALSE, FALSE, 0); gtk_widget_show (checkbutton); checkbutton = gtk_check_button_new_with_label ("Whole words only"); g_signal_connect (checkbutton, "toggled", G_CALLBACK (pgd_find_whole_words_toggled), demo); gtk_box_pack_start (GTK_BOX (hbox), checkbutton, FALSE, FALSE, 0); gtk_widget_show (checkbutton); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); model = pgd_find_create_model (); treeview = gtk_tree_view_new_with_model (model); g_object_unref (model); demo->treeview = treeview; gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (selection, "changed", G_CALLBACK (pgd_find_selection_changed), demo); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), TITLE_COLUMN, "Matches", renderer, "text", TITLE_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), X1_COLUMN, "X1", renderer, "text", X1_COLUMN, "visible", VISIBLE_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), Y1_COLUMN, "Y1", renderer, "text", Y1_COLUMN, "visible", VISIBLE_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), X2_COLUMN, "X2", renderer, "text", X2_COLUMN, "visible", VISIBLE_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), Y2_COLUMN, "Y2", renderer, "text", Y2_COLUMN, "visible", VISIBLE_COLUMN, NULL); gtk_container_add (GTK_CONTAINER (swindow), treeview); gtk_widget_show (treeview); gtk_paned_add1 (GTK_PANED (hpaned), swindow); gtk_widget_show (swindow); demo->darea = gtk_drawing_area_new (); g_signal_connect (demo->darea, "draw", G_CALLBACK (pgd_find_viewer_drawing_area_draw), demo); swindow = gtk_scrolled_window_new (NULL, NULL); #if GTK_CHECK_VERSION(3, 7, 8) gtk_container_add(GTK_CONTAINER(swindow), demo->darea); #else gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (swindow), demo->darea); #endif gtk_widget_show (demo->darea); gtk_paned_add2 (GTK_PANED (hpaned), swindow); gtk_widget_show (swindow); gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0); gtk_widget_show (hpaned); g_object_weak_ref (G_OBJECT (vbox), (GWeakNotify)pgd_find_free, (gpointer)demo); return vbox; }
GtkWidget * pgd_page_create_widget (PopplerDocument *document) { PgdPageDemo *demo; GtkWidget *vbox; GtkWidget *hbox, *page_selector; GtkWidget *button; GtkWidget *frame, *alignment; GtkWidget *table; GtkWidget *label; GtkWidget *thumnail_box; gchar *str; gint n_pages; gint row = 0; demo = g_new0 (PgdPageDemo, 1); demo->doc = g_object_ref (document); n_pages = poppler_document_get_n_pages (document); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); label = gtk_label_new ("Page:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); page_selector = gtk_spin_button_new_with_range (1, n_pages, 1); g_signal_connect (G_OBJECT (page_selector), "value-changed", G_CALLBACK (pgd_page_page_selector_value_changed), (gpointer)demo); gtk_box_pack_start (GTK_BOX (hbox), page_selector, FALSE, TRUE, 0); gtk_widget_show (page_selector); str = g_strdup_printf ("of %d", n_pages); label = gtk_label_new (str); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_widget_show (label); g_free (str); button = gtk_button_new_with_label ("Get Info"); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (pgd_page_get_info), (gpointer)demo); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<b>Page Properties</b>"); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_widget_show (label); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 5, 5, 12, 5); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_widget_show (alignment); table = gtk_grid_new (); gtk_grid_set_column_spacing (GTK_GRID (table), 6); gtk_grid_set_row_spacing (GTK_GRID (table), 6); pgd_table_add_property_with_value_widget (GTK_GRID (table), "<b>Page Index:</b>", &(demo->index), NULL, &row); pgd_table_add_property_with_value_widget (GTK_GRID (table), "<b>Page Label:</b>", &(demo->label), NULL, &row); pgd_table_add_property_with_value_widget (GTK_GRID (table), "<b>Page Size:</b>", &(demo->size), NULL, &row); pgd_table_add_property_with_value_widget (GTK_GRID (table), "<b>Page Duration:</b>", &(demo->duration), NULL, &row); gtk_container_add (GTK_CONTAINER (alignment), table); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); gtk_frame_set_label_align (GTK_FRAME (frame), 0.5, 0.5); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<b>Page Thumbnail</b>"); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_widget_show (label); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 5, 5, 12, 5); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_widget_show (alignment); thumnail_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); demo->thumbnail = gtk_image_new (); gtk_box_pack_start (GTK_BOX (thumnail_box), demo->thumbnail, TRUE, TRUE, 0); gtk_widget_show (demo->thumbnail); demo->thumbnail_size = gtk_label_new (NULL); g_object_set (G_OBJECT (demo->thumbnail_size), "xalign", 0.5, NULL); gtk_box_pack_start (GTK_BOX (thumnail_box), demo->thumbnail_size, TRUE, TRUE, 0); gtk_widget_show (demo->thumbnail_size); gtk_container_add (GTK_CONTAINER (alignment), thumnail_box); gtk_widget_show (thumnail_box); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); gtk_widget_show (hbox); g_object_weak_ref (G_OBJECT (vbox), (GWeakNotify)pgd_page_free, (gpointer)demo); return vbox; }