/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * This file is part of the LibreOffice project. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #include #include #include #include #include #include #include #include #include #define LOK_USE_UNSTABLE_API #include #include #ifndef g_info #define g_info(...) g_log(G_LOG_DOMAIN, G_LOG_LEVEL_INFO, __VA_ARGS__) #endif static int help() { fprintf( stderr, "Usage: gtktiledviewer \n" ); return 1; } /// Represents the row or column header widget for spreadsheets. class TiledRowColumnBar { public: /// Stores size and content of a single row header. struct Header { int m_nSize; std::string m_aText; Header(int nSize, const std::string& rText) : m_nSize(nSize), m_aText(rText) { } }; enum TiledBarType { ROW, COLUMN }; static const int ROW_HEADER_WIDTH = 50; static const int COLUMN_HEADER_HEIGHT = 20; GtkWidget* m_pDrawingArea; std::vector
m_aHeaders; /// Height for row bar, width for column bar. int m_nSizePixel; /// Left/top position for the column/row bar -- initially 0, then may grow due to scrolling. int m_nPositionPixel; TiledBarType m_eType; TiledRowColumnBar(TiledBarType eType); static gboolean draw(GtkWidget* pWidget, cairo_t* pCairo, gpointer pData); gboolean drawImpl(GtkWidget* pWidget, cairo_t* pCairo); static gboolean docConfigureEvent(GtkWidget* pWidget, GdkEventConfigure* pEvent, gpointer pData); /// Adjustments of the doc widget changed -- horizontal or vertical scroll. static void docAdjustmentChanged(GtkAdjustment* pAdjustment, gpointer pData); /// Draws rText at the center of rRectangle on pCairo. static void drawText(cairo_t* pCairo, const GdkRectangle& rRectangle, const std::string& rText); }; /// Represents the button at the top left corner for spreadsheets. class TiledCornerButton { public: GtkWidget* m_pDrawingArea; TiledCornerButton(); static gboolean draw(GtkWidget* pWidget, cairo_t* pCairo, gpointer pData); static gboolean drawImpl(GtkWidget* pWidget, cairo_t* pCairo); }; /// Represents all the state that is specific to one GtkWindow of this app. class TiledWindow { public: GtkWidget* m_pDocView; GtkWidget* m_pStatusBar; GtkWidget* m_pProgressBar; GtkWidget* m_pStatusbarLabel; GtkWidget* m_pZoomLabel; GtkToolItem* m_pEnableEditing; GtkToolItem* m_pBold; GtkToolItem* m_pItalic; GtkToolItem* m_pUnderline; GtkToolItem* m_pStrikethrough; GtkToolItem* m_pSuperscript; GtkToolItem* m_pSubscript; GtkToolItem* m_pLeftpara; GtkToolItem* m_pCenterpara; GtkToolItem* m_pRightpara; GtkToolItem* m_pJustifypara; GtkWidget* m_pScrolledWindow; std::map m_aToolItemCommandNames; std::map m_aCommandNameToolItems; bool m_bToolItemBroadcast; GtkWidget* m_pVBox; GtkComboBoxText* m_pPartSelector; GtkWidget* m_pPartModeComboBox; /// Should the part selector avoid calling lok::Document::setPart()? bool m_bPartSelectorBroadcast; GtkWidget* m_pFindbar; GtkWidget* m_pFindbarEntry; GtkWidget* m_pFindbarLabel; bool m_bFindAll; std::shared_ptr m_pRowBar; std::shared_ptr m_pColumnBar; std::shared_ptr m_pCornerButton; TiledWindow() : m_pDocView(0), m_pStatusBar(0), m_pProgressBar(0), m_pStatusbarLabel(0), m_pZoomLabel(0), m_pEnableEditing(0), m_pBold(0), m_pItalic(0), m_pUnderline(0), m_pStrikethrough(0), m_pSuperscript(0), m_pSubscript(0), m_pLeftpara(0), m_pCenterpara(0), m_pRightpara(0), m_pJustifypara(0), m_pScrolledWindow(0), m_bToolItemBroadcast(true), m_pVBox(0), m_pPartSelector(0), m_pPartModeComboBox(0), m_bPartSelectorBroadcast(true), m_pFindbar(0), m_pFindbarEntry(0), m_pFindbarLabel(0), m_bFindAll(false) { } }; static std::map g_aWindows; static void setupDocView(GtkWidget* pDocView); static GtkWidget* createWindow(TiledWindow& rWindow); static void openDocumentCallback (GObject* source_object, GAsyncResult* res, gpointer userdata); static TiledWindow& lcl_getTiledWindow(GtkWidget* pWidget) { GtkWidget* pToplevel = gtk_widget_get_toplevel(pWidget); assert(g_aWindows.find(pToplevel) != g_aWindows.end()); return g_aWindows[pToplevel]; } TiledRowColumnBar::TiledRowColumnBar(TiledBarType eType) : m_pDrawingArea(gtk_drawing_area_new()), m_nSizePixel(0), m_eType(eType) { if (m_eType == ROW) gtk_widget_set_size_request(m_pDrawingArea, ROW_HEADER_WIDTH, -1); else gtk_widget_set_size_request(m_pDrawingArea, -1, COLUMN_HEADER_HEIGHT); g_signal_connect(m_pDrawingArea, "draw", G_CALLBACK(TiledRowColumnBar::draw), this); } gboolean TiledRowColumnBar::draw(GtkWidget* pWidget, cairo_t* pCairo, gpointer pData) { return static_cast(pData)->drawImpl(pWidget, pCairo); } void TiledRowColumnBar::drawText(cairo_t* pCairo, const GdkRectangle& rRectangle, const std::string& rText) { cairo_text_extents_t extents; cairo_text_extents(pCairo, rText.c_str(), &extents); // Cairo reference point for text is the bottom left corner. cairo_move_to(pCairo, rRectangle.x + rRectangle.width / 2 - extents.width / 2, rRectangle.y + rRectangle.height / 2 + extents.height / 2); cairo_show_text(pCairo, rText.c_str()); } gboolean TiledRowColumnBar::drawImpl(GtkWidget* /*pWidget*/, cairo_t* pCairo) { cairo_set_source_rgb(pCairo, 0, 0, 0); int nTotal = 0; for (const Header& rHeader : m_aHeaders) { GdkRectangle aRectangle; if (m_eType == ROW) { aRectangle.x = 0; aRectangle.y = nTotal - 1; aRectangle.width = ROW_HEADER_WIDTH - 1; aRectangle.height = rHeader.m_nSize; // Left line. cairo_rectangle(pCairo, aRectangle.x, aRectangle.y, 1, aRectangle.height); cairo_fill(pCairo); // Bottom line. cairo_rectangle(pCairo, aRectangle.x, aRectangle.y + aRectangle.height, aRectangle.width, 1); cairo_fill(pCairo); // Right line. cairo_rectangle(pCairo, aRectangle.width, aRectangle.y, 1, aRectangle.height); cairo_fill(pCairo); } else { aRectangle.x = nTotal - 1; aRectangle.y = 0; aRectangle.width = rHeader.m_nSize; aRectangle.height = COLUMN_HEADER_HEIGHT - 1; // Top line. cairo_rectangle(pCairo, aRectangle.x, aRectangle.y, aRectangle.width, 1); cairo_fill(pCairo); // Right line. cairo_rectangle(pCairo, aRectangle.x + aRectangle.width , aRectangle.y, 1, aRectangle.height); cairo_fill(pCairo); // Bottom line. cairo_rectangle(pCairo, aRectangle.x, aRectangle.height, aRectangle.width, 1); cairo_fill(pCairo); } drawText(pCairo, aRectangle, rHeader.m_aText); nTotal += rHeader.m_nSize; if (nTotal > m_nSizePixel) break; } return FALSE; } void TiledRowColumnBar::docAdjustmentChanged(GtkAdjustment* /*pAdjustment*/, gpointer pData) { GtkWidget* pDocView = static_cast(pData); docConfigureEvent(pDocView, 0, 0); } gboolean TiledRowColumnBar::docConfigureEvent(GtkWidget* pDocView, GdkEventConfigure* /*pEvent*/, gpointer /*pData*/) { TiledWindow& rWindow = lcl_getTiledWindow(pDocView); GtkAdjustment* pVAdjustment = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(rWindow.m_pScrolledWindow)); rWindow.m_pRowBar->m_nSizePixel = gtk_adjustment_get_page_size(pVAdjustment); rWindow.m_pRowBar->m_nPositionPixel = gtk_adjustment_get_value(pVAdjustment); GtkAdjustment* pHAdjustment = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(rWindow.m_pScrolledWindow)); rWindow.m_pColumnBar->m_nSizePixel = gtk_adjustment_get_page_size(pHAdjustment); rWindow.m_pColumnBar->m_nPositionPixel = gtk_adjustment_get_value(pHAdjustment); LibreOfficeKitDocument* pDocument = lok_doc_view_get_document(LOK_DOC_VIEW(pDocView)); if (pDocument && pDocument->pClass->getDocumentType(pDocument) == LOK_DOCTYPE_SPREADSHEET) { g_info("lok::Document::getCommandValues(.uno:ViewRowColumnHeaders)"); char* pValues = pDocument->pClass->getCommandValues(pDocument, ".uno:ViewRowColumnHeaders"); std::stringstream aStream(pValues); free(pValues); assert(!aStream.str().empty()); boost::property_tree::ptree aTree; boost::property_tree::read_json(aStream, aTree); gtk_widget_show(rWindow.m_pCornerButton->m_pDrawingArea); rWindow.m_pRowBar->m_aHeaders.clear(); int nTotal = 0; for (boost::property_tree::ptree::value_type& rValue : aTree.get_child("rows")) { int nSize = lok_doc_view_twip_to_pixel(LOK_DOC_VIEW(pDocView), std::atof(rValue.second.get("size").c_str())); int nScrolledSize = nSize; if (nTotal + nSize >= rWindow.m_pRowBar->m_nPositionPixel) { if (nTotal < rWindow.m_pRowBar->m_nPositionPixel) // First visible row: reduce height because the row is only partially visible. nScrolledSize = nTotal + nSize - rWindow.m_pRowBar->m_nPositionPixel; Header aHeader(nScrolledSize, rValue.second.get("text")); rWindow.m_pRowBar->m_aHeaders.push_back(aHeader); } nTotal += nSize; } gtk_widget_show(rWindow.m_pRowBar->m_pDrawingArea); gtk_widget_queue_draw(rWindow.m_pRowBar->m_pDrawingArea); rWindow.m_pColumnBar->m_aHeaders.clear(); nTotal = 0; for (boost::property_tree::ptree::value_type& rValue : aTree.get_child("columns")) { int nSize = lok_doc_view_twip_to_pixel(LOK_DOC_VIEW(pDocView), std::atof(rValue.second.get("size").c_str())); int nScrolledSize = nSize; if (nTotal + nSize >= rWindow.m_pColumnBar->m_nPositionPixel) { if (nTotal < rWindow.m_pColumnBar->m_nPositionPixel) // First visible column: reduce width because the column is only partially visible. nScrolledSize = nTotal + nSize - rWindow.m_pColumnBar->m_nPositionPixel; Header aHeader(nScrolledSize, rValue.second.get("text")); rWindow.m_pColumnBar->m_aHeaders.push_back(aHeader); } nTotal += nSize; } gtk_widget_show(rWindow.m_pColumnBar->m_pDrawingArea); gtk_widget_queue_draw(rWindow.m_pColumnBar->m_pDrawingArea); } return TRUE; } TiledCornerButton::TiledCornerButton() : m_pDrawingArea(gtk_drawing_area_new()) { gtk_widget_set_size_request(m_pDrawingArea, TiledRowColumnBar::ROW_HEADER_WIDTH, TiledRowColumnBar::COLUMN_HEADER_HEIGHT); g_signal_connect(m_pDrawingArea, "draw", G_CALLBACK(TiledCornerButton::draw), this); } gboolean TiledCornerButton::draw(GtkWidget* pWidget, cairo_t* pCairo, gpointer) { return drawImpl(pWidget, pCairo); } gboolean TiledCornerButton::drawImpl(GtkWidget* /*pWidget*/, cairo_t* pCairo) { cairo_set_source_rgb(pCairo, 0, 0, 0); GdkRectangle aRectangle; aRectangle.x = 0; aRectangle.y = 0; aRectangle.width = TiledRowColumnBar::ROW_HEADER_WIDTH; aRectangle.height = TiledRowColumnBar::COLUMN_HEADER_HEIGHT; cairo_rectangle(pCairo, aRectangle.x, aRectangle.y, aRectangle.width, aRectangle.height); cairo_stroke(pCairo); return FALSE; } static void lcl_registerToolItem(TiledWindow& rWindow, GtkToolItem* pItem, const std::string& rName) { rWindow.m_aToolItemCommandNames[pItem] = rName; rWindow.m_aCommandNameToolItems[rName] = pItem; } const float fZooms[] = { 0.25, 0.5, 0.75, 1.0, 1.5, 2.0, 3.0, 5.0 }; /// Get the visible area of the scrolled window static void getVisibleAreaTwips(GtkWidget* pDocView, GdkRectangle* pArea) { TiledWindow& rWindow = lcl_getTiledWindow(pDocView); GtkAdjustment* pHAdjustment = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(rWindow.m_pScrolledWindow)); GtkAdjustment* pVAdjustment = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(rWindow.m_pScrolledWindow)); pArea->x = lok_doc_view_pixel_to_twip(LOK_DOC_VIEW(pDocView), gtk_adjustment_get_value(pHAdjustment)); pArea->y = lok_doc_view_pixel_to_twip(LOK_DOC_VIEW(pDocView), gtk_adjustment_get_value(pVAdjustment)); pArea->width = lok_doc_view_pixel_to_twip(LOK_DOC_VIEW(pDocView), gtk_adjustment_get_page_size(pHAdjustment)); pArea->height = lok_doc_view_pixel_to_twip(LOK_DOC_VIEW(pDocView), gtk_adjustment_get_page_size(pVAdjustment)); } static void changeZoom( GtkWidget* pButton, gpointer /* pItem */ ) { TiledWindow& rWindow = lcl_getTiledWindow(pButton); GtkWidget* pDocView = rWindow.m_pDocView; const char *sName = gtk_tool_button_get_icon_name( GTK_TOOL_BUTTON(pButton) ); float fZoom = 0; float fCurrentZoom = 0; if ( pDocView ) { fCurrentZoom = lok_doc_view_get_zoom( LOK_DOC_VIEW(pDocView) ); } if ( strcmp(sName, "zoom-in-symbolic") == 0) { for ( unsigned int i = 0; i < sizeof( fZooms ) / sizeof( fZooms[0] ); i++ ) { if ( fCurrentZoom < fZooms[i] ) { fZoom = fZooms[i]; break; } } } else if ( strcmp(sName, "zoom-original-symbolic") == 0) { fZoom = 1; } else if ( strcmp(sName, "zoom-out-symbolic") == 0) { for ( unsigned int i = 0; i < sizeof( fZooms ) / sizeof( fZooms[0] ); i++ ) { if ( fCurrentZoom > fZooms[i] ) { fZoom = fZooms[i]; } } } if ( fZoom != 0 ) { if ( pDocView ) { lok_doc_view_set_zoom( LOK_DOC_VIEW(pDocView), fZoom ); } } std::string aZoom = std::to_string(int(fZoom * 100)) + std::string("%"); gtk_label_set_text(GTK_LABEL(rWindow.m_pZoomLabel), aZoom.c_str()); } /// User clicked on the button -> inform LOKDocView. static void toggleEditing(GtkWidget* pButton, gpointer /*pItem*/) { TiledWindow& rWindow = lcl_getTiledWindow(pButton); LOKDocView* pLOKDocView = LOK_DOC_VIEW(rWindow.m_pDocView); bool bActive = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(rWindow.m_pEnableEditing)); if (bool(lok_doc_view_get_edit(pLOKDocView)) != bActive) lok_doc_view_set_edit(pLOKDocView, bActive); } /// Toggles if search should find all results or only the first one. static void toggleFindAll(GtkWidget* pButton, gpointer /*pItem*/) { TiledWindow& rWindow = lcl_getTiledWindow(pButton); rWindow.m_bFindAll = !rWindow.m_bFindAll; } /// Toggle the visibility of the findbar. static void toggleFindbar(GtkWidget* pButton, gpointer /*pItem*/) { TiledWindow& rWindow = lcl_getTiledWindow(pButton); if (gtk_widget_get_visible(rWindow.m_pFindbar)) { gtk_widget_hide(rWindow.m_pFindbar); } else { gtk_widget_show_all(rWindow.m_pFindbar); gtk_widget_grab_focus(rWindow.m_pFindbarEntry); } } /// Common initialization, regardless if it's just a new view or a full init. static TiledWindow& setupWidgetAndCreateWindow(GtkWidget* pDocView) { setupDocView(pDocView); TiledWindow aWindow; aWindow.m_pDocView = pDocView; GtkWidget* pWindow = createWindow(aWindow); return lcl_getTiledWindow(pWindow); } /// Creates a new view, i.e. no LOK init or document load. static void createView(GtkWidget* pButton, gpointer /*pItem*/) { TiledWindow& rWindow = lcl_getTiledWindow(pButton); GtkWidget* pDocView = lok_doc_view_new_from_widget(LOK_DOC_VIEW(rWindow.m_pDocView)); TiledWindow& rNewWindow = setupWidgetAndCreateWindow(pDocView); // Hide the unused progress bar. gtk_widget_show_all(rNewWindow.m_pStatusBar); gtk_widget_hide(rNewWindow.m_pProgressBar); } /// Creates a new model, i.e. LOK init and document load, one view implicitly. static void createModelAndView(const char* pLOPath, const char* pDocPath) { GtkWidget* pDocView = lok_doc_view_new(pLOPath, 0, 0); setupWidgetAndCreateWindow(pDocView); lok_doc_view_open_document(LOK_DOC_VIEW(pDocView), pDocPath, 0, openDocumentCallback, pDocView); } /// Our GtkClipboardGetFunc implementation for HTML. static void htmlGetFunc(GtkClipboard* /*pClipboard*/, GtkSelectionData* pSelectionData, guint /*info*/, gpointer pUserData) { GdkAtom aAtom(gdk_atom_intern("text/html", false)); const gchar* pSelection = static_cast(pUserData); gtk_selection_data_set(pSelectionData, aAtom, 8, reinterpret_cast(pSelection), strlen(pSelection)); } /// Our GtkClipboardClearFunc implementation for HTML. static void htmlClearFunc(GtkClipboard* /*pClipboard*/, gpointer pData) { g_free(pData); } /// Same as gtk_clipboard_set_text(), but sets HTML. static void clipboardSetHtml(GtkClipboard* pClipboard, const char* pSelection) { GtkTargetList* pList = gtk_target_list_new(0, 0); GdkAtom aAtom(gdk_atom_intern("text/html", false)); gtk_target_list_add(pList, aAtom, 0, 0); gint nTargets = 0; GtkTargetEntry* pTargets = gtk_target_table_new_from_list(pList, &nTargets); gtk_clipboard_set_with_data(pClipboard, pTargets, nTargets, htmlGetFunc, htmlClearFunc, g_strdup(pSelection)); gtk_target_table_free(pTargets, nTargets); gtk_target_list_unref(pList); } /// Handler for the copy button: write clipboard. static void doCopy(GtkWidget* pButton, gpointer /*pItem*/) { TiledWindow& rWindow = lcl_getTiledWindow(pButton); LOKDocView* pLOKDocView = LOK_DOC_VIEW(rWindow.m_pDocView); LibreOfficeKitDocument* pDocument = lok_doc_view_get_document(pLOKDocView); char* pUsedFormat = 0; char* pSelection = pDocument->pClass->getTextSelection(pDocument, "text/html", &pUsedFormat); GtkClipboard* pClipboard = gtk_clipboard_get_for_display(gtk_widget_get_display(rWindow.m_pDocView), GDK_SELECTION_CLIPBOARD); std::string aUsedFormat(pUsedFormat); if (aUsedFormat == "text/plain;charset=utf-8") gtk_clipboard_set_text(pClipboard, pSelection, -1); else clipboardSetHtml(pClipboard, pSelection); free(pSelection); free(pUsedFormat); } static void doPaste(GtkWidget* pButton, gpointer /*pItem*/) { TiledWindow& rWindow = lcl_getTiledWindow(pButton); LOKDocView* pLOKDocView = LOK_DOC_VIEW(rWindow.m_pDocView); LibreOfficeKitDocument* pDocument = lok_doc_view_get_document(pLOKDocView); GtkClipboard* pClipboard = gtk_clipboard_get_for_display(gtk_widget_get_display(rWindow.m_pDocView), GDK_SELECTION_CLIPBOARD); GdkAtom* pTargets; gint nTargets; boost::optional oTarget; if (gtk_clipboard_wait_for_targets(pClipboard, &pTargets, &nTargets)) { for (gint i = 0; i < nTargets; ++i) { gchar* pName = gdk_atom_name(pTargets[i]); if (std::string(pName) == "text/html") oTarget = pTargets[i]; g_free(pName); } g_free(pTargets); } if (oTarget) { GtkSelectionData* pSelectionData = gtk_clipboard_wait_for_contents(pClipboard, *oTarget); gint nLength; const guchar* pData = gtk_selection_data_get_data_with_length(pSelectionData, &nLength); bool bSuccess = pDocument->pClass->paste(pDocument, "text/html", reinterpret_cast(pData), nLength); gtk_selection_data_free(pSelectionData); if (bSuccess) return; } gchar* pText = gtk_clipboard_wait_for_text(pClipboard); if (pText) pDocument->pClass->paste(pDocument, "text/plain;charset=utf-8", pText, strlen(pText)); } /// Searches for the next or previous text of TiledWindow::m_pFindbarEntry. static void doSearch(GtkWidget* pButton, bool bBackwards) { TiledWindow& rWindow = lcl_getTiledWindow(pButton); GtkEntry* pEntry = GTK_ENTRY(rWindow.m_pFindbarEntry); const char* pText = gtk_entry_get_text(pEntry); boost::property_tree::ptree aTree; aTree.put(boost::property_tree::ptree::path_type("SearchItem.SearchString/type", '/'), "string"); aTree.put(boost::property_tree::ptree::path_type("SearchItem.SearchString/value", '/'), pText); aTree.put(boost::property_tree::ptree::path_type("SearchItem.Backward/type", '/'), "boolean"); aTree.put(boost::property_tree::ptree::path_type("SearchItem.Backward/value", '/'), bBackwards); if (rWindow.m_bFindAll) { aTree.put(boost::property_tree::ptree::path_type("SearchItem.Command/type", '/'), "unsigned short"); // SvxSearchCmd::FIND_ALL aTree.put(boost::property_tree::ptree::path_type("SearchItem.Command/value", '/'), "1"); } LOKDocView* pLOKDocView = LOK_DOC_VIEW(rWindow.m_pDocView); GdkRectangle aArea; getVisibleAreaTwips(rWindow.m_pDocView, &aArea); aTree.put(boost::property_tree::ptree::path_type("SearchItem.SearchStartPointX/type", '/'), "long"); aTree.put(boost::property_tree::ptree::path_type("SearchItem.SearchStartPointX/value", '/'), aArea.x); aTree.put(boost::property_tree::ptree::path_type("SearchItem.SearchStartPointY/type", '/'), "long"); aTree.put(boost::property_tree::ptree::path_type("SearchItem.SearchStartPointY/value", '/'), aArea.y); std::stringstream aStream; boost::property_tree::write_json(aStream, aTree); lok_doc_view_post_command(pLOKDocView, ".uno:ExecuteSearch", aStream.str().c_str(), false); } /// Click handler for the search next button. static void signalSearchNext(GtkWidget* pButton, gpointer /*pItem*/) { doSearch(pButton, /*bBackwards=*/false); } /// Click handler for the search previous button. static void signalSearchPrev(GtkWidget* pButton, gpointer /*pItem*/) { doSearch(pButton, /*bBackwards=*/true); } /// Handles the key-press-event of the search entry widget. static gboolean signalFindbar(GtkWidget* pWidget, GdkEventKey* pEvent, gpointer /*pData*/) { TiledWindow& rWindow = lcl_getTiledWindow(pWidget); gtk_label_set_text(GTK_LABEL(rWindow.m_pFindbarLabel), ""); switch(pEvent->keyval) { case GDK_KEY_Return: { // Search forward. doSearch(pWidget, /*bBackwards=*/false); return TRUE; } case GDK_KEY_Escape: { // Hide the findbar. gtk_widget_hide(rWindow.m_pFindbar); return TRUE; } } return FALSE; } /// LOKDocView changed edit state -> inform the tool button. static void signalEdit(LOKDocView* pLOKDocView, gboolean bWasEdit, gpointer /*pData*/) { TiledWindow& rWindow = lcl_getTiledWindow(GTK_WIDGET(pLOKDocView)); gboolean bEdit = lok_doc_view_get_edit(pLOKDocView); g_info("signalEdit: %d -> %d", bWasEdit, lok_doc_view_get_edit(pLOKDocView)); if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(rWindow.m_pEnableEditing)) != bEdit) gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(rWindow.m_pEnableEditing), bEdit); } /// LOKDocView changed command state -> inform the tool button. static void signalCommand(LOKDocView* pLOKDocView, char* pPayload, gpointer /*pData*/) { TiledWindow& rWindow = lcl_getTiledWindow(GTK_WIDGET(pLOKDocView)); std::string aPayload(pPayload); size_t nPosition = aPayload.find("="); if (nPosition != std::string::npos) { std::string aKey = aPayload.substr(0, nPosition); std::string aValue = aPayload.substr(nPosition + 1); if (rWindow.m_aCommandNameToolItems.find(aKey) != rWindow.m_aCommandNameToolItems.end()) { GtkToolItem* pItem = rWindow.m_aCommandNameToolItems[aKey]; gboolean bEdit = aValue == "true"; if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(pItem)) != bEdit) { // Avoid invoking lok_doc_view_post_command(). rWindow.m_bToolItemBroadcast = false; gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(pItem), bEdit); rWindow.m_bToolItemBroadcast = true; } } } } /// LOKDocView command finished -> just write it to the console, not that useful for the viewer. static void signalCommandResult(LOKDocView* /*pLOKDocView*/, char* pPayload, gpointer /*pData*/) { fprintf(stderr, "Command finished: %s\n", pPayload); } static void loadChanged(LOKDocView* /*pLOKDocView*/, gdouble fValue, gpointer pData) { GtkWidget* pProgressBar = GTK_WIDGET (pData); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(pProgressBar), fValue); } /// LOKDocView found no search matches -> set the search label accordingly. static void signalSearch(LOKDocView* pLOKDocView, char* /*pPayload*/, gpointer /*pData*/) { TiledWindow& rWindow = lcl_getTiledWindow(GTK_WIDGET(pLOKDocView)); gtk_label_set_text(GTK_LABEL(rWindow.m_pFindbarLabel), "Search key not found"); } /// LOKDocView found some search matches -> set the search label accordingly. static void signalSearchResultCount(LOKDocView* pLOKDocView, char* pPayload, gpointer /*pData*/) { TiledWindow& rWindow = lcl_getTiledWindow(GTK_WIDGET(pLOKDocView)); std::stringstream ss; ss << pPayload << " match(es)"; gtk_label_set_text(GTK_LABEL(rWindow.m_pFindbarLabel), ss.str().c_str()); } static void signalPart(LOKDocView* pLOKDocView, int nPart, gpointer /*pData*/) { TiledWindow& rWindow = lcl_getTiledWindow(GTK_WIDGET(pLOKDocView)); rWindow.m_bPartSelectorBroadcast = false; gtk_combo_box_set_active(GTK_COMBO_BOX(rWindow.m_pPartSelector), nPart); rWindow.m_bPartSelectorBroadcast = true; } /// User clicked on a command button -> inform LOKDocView. static void signalHyperlink(LOKDocView* /*pLOKDocView*/, char* pPayload, gpointer /*pData*/) { GError* pError = NULL; gtk_show_uri(NULL, pPayload, GDK_CURRENT_TIME, &pError); if (pError != NULL) { g_warning("Unable to show URI %s : %s", pPayload, pError->message); g_error_free(pError); } } /// Cursor position changed static void cursorChanged(LOKDocView* pDocView, gint nX, gint nY, gint /*nWidth*/, gint /*nHeight*/, gpointer /*pData*/) { TiledWindow& rWindow = lcl_getTiledWindow(GTK_WIDGET(pDocView)); GtkAdjustment* vadj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(rWindow.m_pScrolledWindow)); GtkAdjustment* hadj = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(rWindow.m_pScrolledWindow)); GdkRectangle visArea; gdouble upper; gint x = -1, y = -1; getVisibleAreaTwips(GTK_WIDGET(pDocView), &visArea); // check vertically if (nY < visArea.y) { y = nY - visArea.height/2; if (y < 0) y = gtk_adjustment_get_lower(vadj); } else if (nY > visArea.y + visArea.height) { y = nY - visArea.height/2; upper = lok_doc_view_pixel_to_twip(LOK_DOC_VIEW(pDocView), gtk_adjustment_get_upper(vadj)); if (y > upper) y = upper; } if (nX < visArea.x) { x = nX - visArea.width/2; if (x < 0) x = gtk_adjustment_get_lower(hadj); } else if (nX > visArea.x + visArea.width) { x = nX - visArea.width/2; upper = lok_doc_view_pixel_to_twip(LOK_DOC_VIEW(pDocView), gtk_adjustment_get_upper(hadj)); if (x > upper) x = upper; } if (y!=-1) gtk_adjustment_set_value(vadj, lok_doc_view_twip_to_pixel(LOK_DOC_VIEW(pDocView), y)); if (x!=-1) gtk_adjustment_set_value(hadj, lok_doc_view_twip_to_pixel(LOK_DOC_VIEW(pDocView), x)); } static void toggleToolItem(GtkWidget* pWidget, gpointer /*pData*/) { TiledWindow& rWindow = lcl_getTiledWindow(pWidget); if (rWindow.m_bToolItemBroadcast) { LOKDocView* pLOKDocView = LOK_DOC_VIEW(rWindow.m_pDocView); GtkToolItem* pItem = GTK_TOOL_ITEM(pWidget); const std::string& rString = rWindow.m_aToolItemCommandNames[pItem]; g_info("toggleToolItem: lok_doc_view_post_command('%s')", rString.c_str()); // notify about the finished Save gboolean bNotify = (rString == ".uno:Save"); lok_doc_view_post_command(pLOKDocView, rString.c_str(), 0, bNotify); } } static void populatePartSelector(LOKDocView* pLOKDocView) { TiledWindow& rWindow = lcl_getTiledWindow(GTK_WIDGET(pLOKDocView)); gtk_list_store_clear( GTK_LIST_STORE( gtk_combo_box_get_model( GTK_COMBO_BOX(rWindow.m_pPartSelector) )) ); if (!pLOKDocView) { return; } const int nMaxLength = 50; char sText[nMaxLength]; int nParts = lok_doc_view_get_parts(pLOKDocView); for ( int i = 0; i < nParts; i++ ) { char* pName = lok_doc_view_get_part_name(pLOKDocView, i); assert( pName ); snprintf( sText, nMaxLength, "%i (%s)", i+1, pName ); free( pName ); gtk_combo_box_text_append_text( rWindow.m_pPartSelector, sText ); } gtk_combo_box_set_active(GTK_COMBO_BOX(rWindow.m_pPartSelector), lok_doc_view_get_part(pLOKDocView)); } static void signalSize(LOKDocView* pLOKDocView, gpointer /*pData*/) { TiledWindow& rWindow = lcl_getTiledWindow(GTK_WIDGET(pLOKDocView)); rWindow.m_bPartSelectorBroadcast = false; populatePartSelector(pLOKDocView); rWindow.m_bPartSelectorBroadcast = true; } static void changePart( GtkWidget* pSelector, gpointer /* pItem */ ) { int nPart = gtk_combo_box_get_active( GTK_COMBO_BOX(pSelector) ); TiledWindow& rWindow = lcl_getTiledWindow(pSelector); if (rWindow.m_bPartSelectorBroadcast && rWindow.m_pDocView) lok_doc_view_set_part( LOK_DOC_VIEW(rWindow.m_pDocView), nPart ); lok_doc_view_reset_view(LOK_DOC_VIEW(rWindow.m_pDocView)); } static void removeChildrenFromStatusbar(GtkWidget* children, gpointer pData) { GtkWidget* pStatusBar = static_cast(pData); gtk_container_remove(GTK_CONTAINER(pStatusBar), children); } static void populatePartModeSelector( GtkComboBoxText* pSelector ) { gtk_combo_box_text_append_text( pSelector, "Standard" ); gtk_combo_box_text_append_text( pSelector, "Notes" ); gtk_combo_box_set_active( GTK_COMBO_BOX(pSelector), 0 ); } static void changePartMode( GtkWidget* pSelector, gpointer /* pItem */ ) { // Just convert directly back to the LibreOfficeKitPartMode enum. // I.e. the ordering above should match the enum member ordering. LibreOfficeKitPartMode ePartMode = LibreOfficeKitPartMode( gtk_combo_box_get_active( GTK_COMBO_BOX(pSelector) ) ); TiledWindow& rWindow = lcl_getTiledWindow(pSelector); if ( rWindow.m_pDocView ) { lok_doc_view_set_partmode( LOK_DOC_VIEW(rWindow.m_pDocView), ePartMode ); } } static void openDocumentCallback (GObject* source_object, GAsyncResult* res, gpointer /*userdata*/) { LOKDocView* pDocView = LOK_DOC_VIEW (source_object); TiledWindow& rWindow = lcl_getTiledWindow(GTK_WIDGET(pDocView)); GError* error = NULL; GList *focusChain = NULL; if (!lok_doc_view_open_document_finish(pDocView, res, &error)) { GtkDialogFlags eFlags = GTK_DIALOG_DESTROY_WITH_PARENT; GtkWidget* pDialog = gtk_message_dialog_new(GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(pDocView))), eFlags, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Error occurred while opening the document: '%s'", error->message); gtk_dialog_run(GTK_DIALOG(pDialog)); gtk_widget_destroy(pDialog); g_error_free(error); gtk_widget_destroy(GTK_WIDGET(pDocView)); gtk_main_quit(); return; } populatePartSelector(pDocView); populatePartModeSelector( GTK_COMBO_BOX_TEXT(rWindow.m_pPartModeComboBox) ); // Connect these signals after populating the selectors, to avoid re-rendering on setting the default part/partmode. g_signal_connect(G_OBJECT(rWindow.m_pPartModeComboBox), "changed", G_CALLBACK(changePartMode), 0); g_signal_connect(G_OBJECT(rWindow.m_pPartSelector), "changed", G_CALLBACK(changePart), 0); focusChain = g_list_append( focusChain, pDocView ); gtk_container_set_focus_chain ( GTK_CONTAINER (rWindow.m_pVBox), focusChain ); gtk_widget_show_all(rWindow.m_pStatusBar); gtk_widget_hide(rWindow.m_pProgressBar); } /// Creates the GtkWindow that has main widget as children and registers it in the window map. static GtkWidget* createWindow(TiledWindow& rWindow) { GtkWidget *pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(pWindow), "LibreOfficeKit GTK Tiled Viewer"); gtk_window_set_default_size(GTK_WINDOW(pWindow), 1024, 768); g_signal_connect(pWindow, "destroy", G_CALLBACK(gtk_main_quit), 0); rWindow.m_pVBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_container_add(GTK_CONTAINER(pWindow), rWindow.m_pVBox); // Upper toolbar. GtkWidget* pUpperToolbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(pUpperToolbar), GTK_TOOLBAR_ICONS); // Save. GtkToolItem* pSave = gtk_tool_button_new(NULL, NULL); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(pSave), "document-save-symbolic"); gtk_tool_item_set_tooltip_text(pSave, "Save"); gtk_toolbar_insert(GTK_TOOLBAR(pUpperToolbar), pSave, -1); gtk_toolbar_insert(GTK_TOOLBAR(pUpperToolbar), gtk_separator_tool_item_new(), -1); g_signal_connect(G_OBJECT(pSave), "clicked", G_CALLBACK(toggleToolItem), NULL); lcl_registerToolItem(rWindow, pSave, ".uno:Save"); // Copy and paste. GtkToolItem* pCopyButton = gtk_tool_button_new( NULL, NULL); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(pCopyButton), "edit-copy-symbolic"); gtk_tool_item_set_tooltip_text(pCopyButton, "Copy"); gtk_toolbar_insert(GTK_TOOLBAR(pUpperToolbar), pCopyButton, -1); g_signal_connect(G_OBJECT(pCopyButton), "clicked", G_CALLBACK(doCopy), NULL); GtkToolItem* pPasteButton = gtk_tool_button_new( NULL, NULL); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(pPasteButton), "edit-paste-symbolic"); gtk_tool_item_set_tooltip_text(pPasteButton, "Paste"); gtk_toolbar_insert(GTK_TOOLBAR(pUpperToolbar), pPasteButton, -1); g_signal_connect(G_OBJECT(pPasteButton), "clicked", G_CALLBACK(doPaste), NULL); gtk_toolbar_insert( GTK_TOOLBAR(pUpperToolbar), gtk_separator_tool_item_new(), -1); // Undo and redo. GtkToolItem* pUndo = gtk_tool_button_new(NULL, NULL); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(pUndo), "edit-undo-symbolic"); gtk_tool_item_set_tooltip_text(pUndo, "Undo"); gtk_toolbar_insert(GTK_TOOLBAR(pUpperToolbar), pUndo, -1); g_signal_connect(G_OBJECT(pUndo), "clicked", G_CALLBACK(toggleToolItem), NULL); lcl_registerToolItem(rWindow, pUndo, ".uno:Undo"); GtkToolItem* pRedo = gtk_tool_button_new(NULL, NULL); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(pRedo), "edit-redo-symbolic"); gtk_tool_item_set_tooltip_text(pRedo, "Redo"); gtk_toolbar_insert(GTK_TOOLBAR(pUpperToolbar), pRedo, -1); g_signal_connect(G_OBJECT(pRedo), "clicked", G_CALLBACK(toggleToolItem), NULL); lcl_registerToolItem(rWindow, pRedo, ".uno:Redo"); gtk_toolbar_insert(GTK_TOOLBAR(pUpperToolbar), gtk_separator_tool_item_new(), -1); // Find. GtkToolItem* pFindButton = gtk_tool_button_new( NULL, NULL); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON (pFindButton), "edit-find-symbolic"); gtk_tool_item_set_tooltip_text(pFindButton, "Find"); gtk_toolbar_insert(GTK_TOOLBAR(pUpperToolbar), pFindButton, -1); g_signal_connect(G_OBJECT(pFindButton), "clicked", G_CALLBACK(toggleFindbar), NULL); gtk_toolbar_insert(GTK_TOOLBAR(pUpperToolbar), gtk_separator_tool_item_new(), -1); // Misc upper toolbar. GtkToolItem* pZoomIn = gtk_tool_button_new(NULL, NULL); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON (pZoomIn), "zoom-in-symbolic"); gtk_tool_item_set_tooltip_text(pZoomIn, "Zoom In"); gtk_toolbar_insert(GTK_TOOLBAR(pUpperToolbar), pZoomIn, -1); g_signal_connect(G_OBJECT(pZoomIn), "clicked", G_CALLBACK(changeZoom), NULL); GtkToolItem* pZoom1 = gtk_tool_button_new(NULL, NULL); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(pZoom1), "zoom-original-symbolic"); gtk_tool_item_set_tooltip_text(pZoom1, "Normal Size"); gtk_toolbar_insert(GTK_TOOLBAR(pUpperToolbar), pZoom1, -1); g_signal_connect(G_OBJECT(pZoom1), "clicked", G_CALLBACK(changeZoom), NULL); GtkToolItem* pZoomOut = gtk_tool_button_new(NULL, NULL); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON (pZoomOut), "zoom-out-symbolic"); gtk_tool_item_set_tooltip_text(pZoomOut, "Zoom Out"); gtk_toolbar_insert(GTK_TOOLBAR(pUpperToolbar), pZoomOut, -1); g_signal_connect(G_OBJECT(pZoomOut), "clicked", G_CALLBACK(changeZoom), NULL); GtkToolItem* pPartSelectorToolItem = gtk_tool_item_new(); GtkWidget* pComboBox = gtk_combo_box_text_new(); gtk_container_add(GTK_CONTAINER(pPartSelectorToolItem), pComboBox); gtk_toolbar_insert(GTK_TOOLBAR(pUpperToolbar), pPartSelectorToolItem, -1); rWindow.m_pPartSelector = GTK_COMBO_BOX_TEXT(pComboBox); GtkToolItem* pPartModeSelectorToolItem = gtk_tool_item_new(); rWindow.m_pPartModeComboBox = gtk_combo_box_text_new(); gtk_container_add(GTK_CONTAINER(pPartModeSelectorToolItem), rWindow.m_pPartModeComboBox); gtk_toolbar_insert(GTK_TOOLBAR(pUpperToolbar), pPartModeSelectorToolItem, -1); GtkToolItem* pEnableEditing = gtk_toggle_tool_button_new(); rWindow.m_pEnableEditing = pEnableEditing; gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON (pEnableEditing), "insert-text-symbolic"); gtk_tool_item_set_tooltip_text(pEnableEditing, "Edit"); gtk_toolbar_insert(GTK_TOOLBAR(pUpperToolbar), pEnableEditing, -1); g_signal_connect(G_OBJECT(pEnableEditing), "toggled", G_CALLBACK(toggleEditing), NULL); GtkToolItem* pNewViewButton = gtk_tool_button_new( NULL, NULL); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON (pNewViewButton), "view-continuous-symbolic"); gtk_tool_item_set_tooltip_text(pNewViewButton, "New View"); gtk_toolbar_insert(GTK_TOOLBAR(pUpperToolbar), pNewViewButton, -1); g_signal_connect(G_OBJECT(pNewViewButton), "clicked", G_CALLBACK(createView), NULL); gtk_box_pack_start(GTK_BOX(rWindow.m_pVBox), pUpperToolbar, FALSE, FALSE, 0 ); // Adds to top. // Lower toolbar. GtkWidget* pLowerToolbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(pLowerToolbar), GTK_TOOLBAR_ICONS); // Bold, italic, underline and strikethrough. rWindow.m_pBold = gtk_toggle_tool_button_new(); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(rWindow.m_pBold), "format-text-bold-symbolic"); gtk_tool_item_set_tooltip_text(rWindow.m_pBold, "Bold"); gtk_toolbar_insert(GTK_TOOLBAR(pLowerToolbar), rWindow.m_pBold, -1); g_signal_connect(G_OBJECT(rWindow.m_pBold), "toggled", G_CALLBACK(toggleToolItem), NULL); lcl_registerToolItem(rWindow, rWindow.m_pBold, ".uno:Bold"); rWindow.m_pItalic = gtk_toggle_tool_button_new(); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON (rWindow.m_pItalic), "format-text-italic-symbolic"); gtk_tool_item_set_tooltip_text(rWindow.m_pItalic, "Italic"); gtk_toolbar_insert(GTK_TOOLBAR(pLowerToolbar), rWindow.m_pItalic, -1); g_signal_connect(G_OBJECT(rWindow.m_pItalic), "toggled", G_CALLBACK(toggleToolItem), NULL); lcl_registerToolItem(rWindow, rWindow.m_pItalic, ".uno:Italic"); rWindow.m_pUnderline = gtk_toggle_tool_button_new(); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON (rWindow.m_pUnderline), "format-text-underline-symbolic"); gtk_tool_item_set_tooltip_text(rWindow.m_pUnderline, "Underline"); gtk_toolbar_insert(GTK_TOOLBAR(pLowerToolbar), rWindow.m_pUnderline, -1); g_signal_connect(G_OBJECT(rWindow.m_pUnderline), "toggled", G_CALLBACK(toggleToolItem), NULL); lcl_registerToolItem(rWindow, rWindow.m_pUnderline, ".uno:Underline"); rWindow.m_pStrikethrough = gtk_toggle_tool_button_new (); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(rWindow.m_pStrikethrough), "format-text-strikethrough-symbolic"); gtk_tool_item_set_tooltip_text(rWindow.m_pStrikethrough, "Strikethrough"); gtk_toolbar_insert(GTK_TOOLBAR(pLowerToolbar), rWindow.m_pStrikethrough, -1); g_signal_connect(G_OBJECT(rWindow.m_pStrikethrough), "toggled", G_CALLBACK(toggleToolItem), NULL); lcl_registerToolItem(rWindow, rWindow.m_pStrikethrough, ".uno:Strikeout"); gtk_toolbar_insert(GTK_TOOLBAR(pLowerToolbar), gtk_separator_tool_item_new(), -1); // Superscript and subscript. rWindow.m_pSuperscript = gtk_toggle_tool_button_new(); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(rWindow.m_pSuperscript), "go-up-symbolic"); gtk_tool_item_set_tooltip_text(rWindow.m_pSuperscript, "Superscript"); gtk_toolbar_insert(GTK_TOOLBAR(pLowerToolbar), rWindow.m_pSuperscript, -1); g_signal_connect(G_OBJECT(rWindow.m_pSuperscript), "toggled", G_CALLBACK(toggleToolItem), NULL); lcl_registerToolItem(rWindow, rWindow.m_pSuperscript, ".uno:SuperScript"); rWindow.m_pSubscript = gtk_toggle_tool_button_new(); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(rWindow.m_pSubscript), "go-down-symbolic"); gtk_tool_item_set_tooltip_text(rWindow.m_pSubscript, "Subscript"); gtk_toolbar_insert(GTK_TOOLBAR(pLowerToolbar), rWindow.m_pSubscript, -1); g_signal_connect(G_OBJECT(rWindow.m_pSubscript), "toggled", G_CALLBACK(toggleToolItem), NULL); lcl_registerToolItem(rWindow, rWindow.m_pSubscript, ".uno:SubScript"); gtk_toolbar_insert(GTK_TOOLBAR(pLowerToolbar), gtk_separator_tool_item_new(), -1); // Align left, center horizontally, align right and justified. rWindow.m_pLeftpara = gtk_toggle_tool_button_new(); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(rWindow.m_pLeftpara), "format-justify-left-symbolic"); gtk_tool_item_set_tooltip_text(rWindow.m_pLeftpara, "Align Left"); gtk_toolbar_insert(GTK_TOOLBAR(pLowerToolbar), rWindow.m_pLeftpara, -1); g_signal_connect(G_OBJECT(rWindow.m_pLeftpara), "toggled", G_CALLBACK(toggleToolItem), NULL); lcl_registerToolItem(rWindow, rWindow.m_pLeftpara, ".uno:LeftPara"); rWindow.m_pCenterpara = gtk_toggle_tool_button_new(); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(rWindow.m_pCenterpara), "format-justify-center-symbolic"); gtk_tool_item_set_tooltip_text(rWindow.m_pCenterpara, "Center Horizontally"); gtk_toolbar_insert(GTK_TOOLBAR(pLowerToolbar), rWindow.m_pCenterpara, -1); g_signal_connect(G_OBJECT(rWindow.m_pCenterpara), "toggled", G_CALLBACK(toggleToolItem), NULL); lcl_registerToolItem(rWindow, rWindow.m_pCenterpara, ".uno:CenterPara"); rWindow.m_pRightpara = gtk_toggle_tool_button_new(); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(rWindow.m_pRightpara), "format-justify-right-symbolic"); gtk_tool_item_set_tooltip_text(rWindow.m_pRightpara, "Align Right"); gtk_toolbar_insert(GTK_TOOLBAR(pLowerToolbar), rWindow.m_pRightpara, -1); g_signal_connect(G_OBJECT(rWindow.m_pRightpara), "toggled", G_CALLBACK(toggleToolItem), NULL); lcl_registerToolItem(rWindow, rWindow.m_pRightpara, ".uno:RightPara"); rWindow.m_pJustifypara = gtk_toggle_tool_button_new(); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(rWindow.m_pJustifypara), "format-justify-fill-symbolic"); gtk_tool_item_set_tooltip_text(rWindow.m_pJustifypara, "Justified"); gtk_toolbar_insert(GTK_TOOLBAR(pLowerToolbar), rWindow.m_pJustifypara, -1); g_signal_connect(G_OBJECT(rWindow.m_pJustifypara), "toggled", G_CALLBACK(toggleToolItem), NULL); lcl_registerToolItem(rWindow, rWindow.m_pJustifypara, ".uno:JustifyPara"); gtk_box_pack_start(GTK_BOX(rWindow.m_pVBox), pLowerToolbar, FALSE, FALSE, 0 ); // Adds to top. // Findbar rWindow.m_pFindbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(rWindow.m_pFindbar), GTK_TOOLBAR_ICONS); GtkToolItem* pFindbarClose = gtk_tool_button_new( NULL, NULL); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON (pFindbarClose), "window-close-symbolic"); gtk_toolbar_insert(GTK_TOOLBAR(rWindow.m_pFindbar), pFindbarClose, -1); g_signal_connect(G_OBJECT(pFindbarClose), "clicked", G_CALLBACK(toggleFindbar), NULL); GtkToolItem* pEntryContainer = gtk_tool_item_new(); rWindow.m_pFindbarEntry = gtk_entry_new(); gtk_container_add(GTK_CONTAINER(pEntryContainer), rWindow.m_pFindbarEntry); g_signal_connect(rWindow.m_pFindbarEntry, "key-press-event", G_CALLBACK(signalFindbar), 0); gtk_toolbar_insert(GTK_TOOLBAR(rWindow.m_pFindbar), pEntryContainer, -1); GtkToolItem* pFindbarNext = gtk_tool_button_new( NULL, NULL); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON (pFindbarNext), "go-down-symbolic"); gtk_toolbar_insert(GTK_TOOLBAR(rWindow.m_pFindbar), pFindbarNext, -1); g_signal_connect(G_OBJECT(pFindbarNext), "clicked", G_CALLBACK(signalSearchNext), NULL); GtkToolItem* pFindbarPrev = gtk_tool_button_new( NULL, NULL); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON (pFindbarPrev), "go-up-symbolic"); gtk_toolbar_insert(GTK_TOOLBAR(rWindow.m_pFindbar), pFindbarPrev, -1); g_signal_connect(G_OBJECT(pFindbarPrev), "clicked", G_CALLBACK(signalSearchPrev), NULL); GtkToolItem* pFindAll = gtk_toggle_tool_button_new(); gtk_tool_button_set_label(GTK_TOOL_BUTTON(pFindAll), "Highlight All"); gtk_toolbar_insert(GTK_TOOLBAR(rWindow.m_pFindbar), pFindAll, -1); g_signal_connect(G_OBJECT(pFindAll), "toggled", G_CALLBACK(toggleFindAll), NULL); GtkToolItem* pFindbarLabelContainer = gtk_tool_item_new(); rWindow.m_pFindbarLabel = gtk_label_new(""); gtk_container_add(GTK_CONTAINER(pFindbarLabelContainer), rWindow.m_pFindbarLabel); gtk_toolbar_insert(GTK_TOOLBAR(rWindow.m_pFindbar), pFindbarLabelContainer, -1); gtk_box_pack_end(GTK_BOX(rWindow.m_pVBox), rWindow.m_pFindbar, FALSE, FALSE, 0); // Grid for the row/column bar + doc view. GtkWidget* pGrid = gtk_grid_new(); gtk_container_add(GTK_CONTAINER(rWindow.m_pVBox), pGrid); rWindow.m_pCornerButton.reset(new TiledCornerButton()); // "A1" cell of the grid. gtk_grid_attach(GTK_GRID(pGrid), rWindow.m_pCornerButton->m_pDrawingArea, 0, 0, 1, 1); rWindow.m_pRowBar.reset(new TiledRowColumnBar(TiledRowColumnBar::ROW)); // "A2" cell of the grid. gtk_grid_attach(GTK_GRID(pGrid), rWindow.m_pRowBar->m_pDrawingArea, 0, 1, 1, 1); rWindow.m_pColumnBar.reset(new TiledRowColumnBar(TiledRowColumnBar::COLUMN)); // "B1" cell of the grid. gtk_grid_attach(GTK_GRID(pGrid), rWindow.m_pColumnBar->m_pDrawingArea, 1, 0, 1, 1); // Scrolled window for DocView rWindow.m_pScrolledWindow = gtk_scrolled_window_new(0, 0); gtk_widget_set_hexpand(rWindow.m_pScrolledWindow, TRUE); gtk_widget_set_vexpand(rWindow.m_pScrolledWindow, TRUE); // "B2" cell of the grid gtk_grid_attach(GTK_GRID(pGrid), rWindow.m_pScrolledWindow, 1, 1, 1, 1); gtk_container_add(GTK_CONTAINER(rWindow.m_pScrolledWindow), rWindow.m_pDocView); GtkAdjustment* pHAdjustment = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(rWindow.m_pScrolledWindow)); g_signal_connect(pHAdjustment, "value-changed", G_CALLBACK(TiledRowColumnBar::docAdjustmentChanged), rWindow.m_pDocView); GtkAdjustment* pVAdjustment = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(rWindow.m_pScrolledWindow)); g_signal_connect(pVAdjustment, "value-changed", G_CALLBACK(TiledRowColumnBar::docAdjustmentChanged), rWindow.m_pDocView); rWindow.m_pProgressBar = gtk_progress_bar_new (); g_signal_connect(rWindow.m_pDocView, "load-changed", G_CALLBACK(loadChanged), rWindow.m_pProgressBar); GtkWidget* pStatusBar = gtk_statusbar_new(); rWindow.m_pStatusBar = pStatusBar; gtk_container_forall(GTK_CONTAINER(pStatusBar), removeChildrenFromStatusbar, pStatusBar); gtk_container_add (GTK_CONTAINER(rWindow.m_pVBox), pStatusBar); gtk_container_add (GTK_CONTAINER(pStatusBar), rWindow.m_pProgressBar); gtk_widget_set_hexpand(rWindow.m_pProgressBar, true); rWindow.m_pStatusbarLabel = gtk_label_new(""); gtk_widget_set_hexpand(rWindow.m_pStatusbarLabel, TRUE); gtk_container_add(GTK_CONTAINER(pStatusBar), rWindow.m_pStatusbarLabel); rWindow.m_pZoomLabel = gtk_label_new("100%"); gtk_container_add(GTK_CONTAINER(pStatusBar), rWindow.m_pZoomLabel); gtk_widget_show_all(pWindow); // Hide the findbar by default. gtk_widget_hide(rWindow.m_pFindbar); // Same for the row/column bar. gtk_widget_hide(rWindow.m_pCornerButton->m_pDrawingArea); gtk_widget_hide(rWindow.m_pRowBar->m_pDrawingArea); gtk_widget_hide(rWindow.m_pColumnBar->m_pDrawingArea); // Hide the non-progressbar children of the status bar by default. gtk_widget_hide(rWindow.m_pStatusbarLabel); gtk_widget_hide(rWindow.m_pZoomLabel); g_aWindows[pWindow] = rWindow; g_signal_connect(rWindow.m_pDocView, "configure-event", G_CALLBACK(TiledRowColumnBar::docConfigureEvent), 0); return pWindow; } /// Common setup for DocView (regardless if it's just a new view or a document to be loaded). static void setupDocView(GtkWidget* pDocView) { #if GLIB_CHECK_VERSION(2,40,0) g_assert_nonnull(pDocView); #endif g_signal_connect(pDocView, "edit-changed", G_CALLBACK(signalEdit), NULL); g_signal_connect(pDocView, "command-changed", G_CALLBACK(signalCommand), NULL); g_signal_connect(pDocView, "command-result", G_CALLBACK(signalCommandResult), NULL); g_signal_connect(pDocView, "search-not-found", G_CALLBACK(signalSearch), NULL); g_signal_connect(pDocView, "search-result-count", G_CALLBACK(signalSearchResultCount), NULL); g_signal_connect(pDocView, "part-changed", G_CALLBACK(signalPart), NULL); g_signal_connect(pDocView, "size-changed", G_CALLBACK(signalSize), NULL); g_signal_connect(pDocView, "hyperlink-clicked", G_CALLBACK(signalHyperlink), NULL); g_signal_connect(pDocView, "cursor-changed", G_CALLBACK(cursorChanged), NULL); } int main( int argc, char* argv[] ) { if( argc < 3 || ( argc > 1 && ( !strcmp( argv[1], "--help" ) || !strcmp( argv[1], "-h" ) ) ) ) return help(); if ( argv[1][0] != '/' ) { fprintf(stderr, "Absolute path required to libreoffice install\n"); return 1; } gtk_init( &argc, &argv ); createModelAndView(argv[1], argv[2]); gtk_main(); return 0; } /* vim:set shiftwidth=4 softtabstop=4 expandtab: */