libreofficekit/qa/gtktiledviewer/gtv-signal-handlers.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include <gtk/gtk.h>
  11
  12 #include "gtv-application-window.hxx"
  13 #include "gtv-helpers.hxx"
  14 #include "gtv-lokdocview-signal-handlers.hxx"
  15 #include "gtv-lok-dialog.hxx"
  16
  17 #include <sal/types.h>
  18
  19 #include <map>
  20 #include <vector>
  21
  22 #include <boost/property_tree/json_parser.hpp>
  23 #include <boost/optional.hpp>
  24
  25 void btn_clicked(GtkWidget* pButton, gpointer)
  26 {
  27     GtvApplicationWindow* window = GTV_APPLICATION_WINDOW(gtk_widget_get_toplevel(pButton));
  28     GtkToolButton* pItem = GTK_TOOL_BUTTON(pButton);
  29     const gchar* label = gtk_tool_button_get_label(pItem);
  30     if (gtv_application_window_get_toolbar_broadcast(window) && g_str_has_prefix(label, ".uno:"))
  31     {
  32         std::string aArguments;
  33         if (g_strcmp0(label, ".uno:InsertAnnotation") == 0)
  34         {
  35             std::map<std::string, std::string> aEntries;
  36             aEntries["Text"] = "";
  37             GtvHelpers::userPromptDialog(GTK_WINDOW(window), "Insert Comment", aEntries);
  38
  39             boost::property_tree::ptree aTree;
  40             aTree.put(boost::property_tree::ptree::path_type(g_strconcat("Text", "/", "type", nullptr), '/'), "string");
  41             aTree.put(boost::property_tree::ptree::path_type(g_strconcat("Text", "/", "value", nullptr), '/'), aEntries["Text"]);
  42
  43             std::stringstream aStream;
  44             boost::property_tree::write_json(aStream, aTree);
  45             aArguments = aStream.str();
  46         }
  47
  48         bool bNotify = g_strcmp0(label, ".uno:Save") == 0;
  49         if (window->lokdocview)
  50             lok_doc_view_post_command(LOK_DOC_VIEW(window->lokdocview), label, aArguments.c_str(), bNotify);
  51     }
  52 }
  53
  54 void doCopy(GtkWidget* pButton, gpointer /*pItem*/)
  55 {
  56     GtvApplicationWindow* window = GTV_APPLICATION_WINDOW(gtk_widget_get_toplevel(pButton));
  57     char* pUsedFormat = nullptr;
  58     // TODO: Should check `text-selection` signal before trying to copy
  59     char* pSelection = lok_doc_view_copy_selection(LOK_DOC_VIEW(window->lokdocview), "text/html", &pUsedFormat);
  60     if (!pSelection)
  61         return;
  62
  63     GtkClipboard* pClipboard = gtk_clipboard_get_for_display(gtk_widget_get_display(pButton), GDK_SELECTION_CLIPBOARD);
  64     std::string aUsedFormat(pUsedFormat);
  65     if (aUsedFormat == "text/plain;charset=utf-8")
  66         gtk_clipboard_set_text(pClipboard, pSelection, -1);
  67     else
  68         GtvHelpers::clipboardSetHtml(pClipboard, pSelection);
  69
  70     free(pSelection);
  71     free(pUsedFormat);
  72 }
  73
  74 void doPaste(GtkWidget* pButton, gpointer /*pItem*/)
  75 {
  76     GtvApplicationWindow* window = GTV_APPLICATION_WINDOW(gtk_widget_get_toplevel(pButton));
  77     GtkClipboard* pClipboard = gtk_clipboard_get_for_display(gtk_widget_get_display(pButton), GDK_SELECTION_CLIPBOARD);
  78     GdkAtom* pTargets;
  79     gint nTargets;
  80     std::map<std::string, GdkAtom> aTargets;
  81     if (gtk_clipboard_wait_for_targets(pClipboard, &pTargets, &nTargets))
  82     {
  83         for (gint i = 0; i < nTargets; ++i)
  84         {
  85             gchar* pName = gdk_atom_name(pTargets[i]);
  86             aTargets[pName] = pTargets[i];
  87             g_free(pName);
  88         }
  89         g_free(pTargets);
  90     }
  91
  92     boost::optional<GdkAtom> oTarget;
  93     std::string aTargetName;
  94
  95     std::vector<std::string> aPreferredNames =
  96     {
  97         std::string("image/png"),
  98         std::string("text/html")
  99     };
 100     for (const std::string& rName : aPreferredNames)
 101     {
 102         std::map<std::string, GdkAtom>::iterator it = aTargets.find(rName);
 103         if (it != aTargets.end())
 104         {
 105             aTargetName = it->first;
 106             oTarget = it->second;
 107             break;
 108         }
 109     }
 110
 111     if (oTarget)
 112     {
 113         GtkSelectionData* pSelectionData = gtk_clipboard_wait_for_contents(pClipboard, *oTarget);
 114         if (!pSelectionData)
 115         {
 116             return;
 117         }
 118         gint nLength;
 119         const guchar* pData = gtk_selection_data_get_data_with_length(pSelectionData, &nLength);
 120         bool bSuccess = lok_doc_view_paste(LOK_DOC_VIEW(window->lokdocview), aTargetName.c_str(), reinterpret_cast<const char*>(pData), nLength);
 121         gtk_selection_data_free(pSelectionData);
 122         if (bSuccess)
 123             return;
 124     }
 125
 126     gchar* pText = gtk_clipboard_wait_for_text(pClipboard);
 127     if (pText)
 128         lok_doc_view_paste(LOK_DOC_VIEW(window->lokdocview), "text/plain;charset=utf-8", pText, strlen(pText));
 129 }
 130
 131 void createView(GtkWidget* pButton, gpointer /*pItem*/)
 132 {
 133     GtvApplicationWindow* window = GTV_APPLICATION_WINDOW(gtk_widget_get_toplevel(pButton));
 134     gtv_application_window_create_view_from_window(GTV_APPLICATION_WINDOW(window));
 135 }
 136
 137 void getRulerState(GtkWidget* pButton, gpointer /*pItem*/)
 138 {
 139     const std::string type = ".uno:RulerState";
 140     GtvApplicationWindow* window = GTV_APPLICATION_WINDOW(gtk_widget_get_toplevel(pButton));
 141     LibreOfficeKitDocument* pDocument = lok_doc_view_get_document(LOK_DOC_VIEW(window->lokdocview));
 142     pDocument->pClass->getCommandValues(pDocument, type.c_str());
 143 }
 144
 145 static void removeUnoParam(GtkWidget* pWidget, gpointer userdata)
 146 {
 147     GtkWidget* pParamAreaBox = GTK_WIDGET(userdata);
 148     GtkWidget* pParamContainer = gtk_widget_get_parent(pWidget);
 149
 150     gtk_container_remove(GTK_CONTAINER(pParamAreaBox), pParamContainer);
 151 }
 152
 153 static void addMoreUnoParam(GtkWidget* /*pWidget*/, gpointer userdata)
 154 {
 155     GtkWidget* pUnoParamAreaBox = GTK_WIDGET(userdata);
 156
 157     GtkWidget* pParamContainer = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 158     gtk_box_pack_start(GTK_BOX(pUnoParamAreaBox), pParamContainer, TRUE, TRUE, 2);
 159
 160     GtkWidget* pTypeEntry = gtk_entry_new();
 161     gtk_box_pack_start(GTK_BOX(pParamContainer), pTypeEntry, TRUE, TRUE, 2);
 162     gtk_entry_set_placeholder_text(GTK_ENTRY(pTypeEntry), "Param type (Eg. boolean, string etc.)");
 163
 164     GtkWidget* pNameEntry = gtk_entry_new();
 165     gtk_box_pack_start(GTK_BOX(pParamContainer), pNameEntry, TRUE, TRUE, 2);
 166     gtk_entry_set_placeholder_text(GTK_ENTRY(pNameEntry), "Param name");
 167
 168     GtkWidget* pValueEntry = gtk_entry_new();
 169     gtk_box_pack_start(GTK_BOX(pParamContainer), pValueEntry, TRUE, TRUE, 2);
 170     gtk_entry_set_placeholder_text(GTK_ENTRY(pValueEntry), "Param value");
 171
 172     GtkWidget* pRemoveButton = gtk_button_new_from_icon_name("list-remove-symbolic", GTK_ICON_SIZE_BUTTON);
 173     g_signal_connect(pRemoveButton, "clicked", G_CALLBACK(removeUnoParam), pUnoParamAreaBox);
 174     gtk_box_pack_start(GTK_BOX(pParamContainer), pRemoveButton, TRUE, TRUE, 2);
 175
 176     gtk_widget_show_all(pUnoParamAreaBox);
 177 }
 178
 179 static void iterateUnoParams(GtkWidget* pWidget, gpointer userdata)
 180 {
 181     boost::property_tree::ptree *pTree = static_cast<boost::property_tree::ptree*>(userdata);
 182     GtvGtkWrapper<GList> pChildren(gtk_container_get_children(GTK_CONTAINER(pWidget)),
 183                                    [](GList* pList) {
 184                                        g_list_free(pList);
 185                                    });
 186     GList* pIt = nullptr;
 187     guint i = 0;
 188     const gchar* unoParam[3];
 189     for (pIt = pChildren.get(), i = 0; pIt != nullptr && i < 3; pIt = pIt->next, i++)
 190     {
 191         unoParam[i] = gtk_entry_get_text(GTK_ENTRY(pIt->data));
 192     }
 193
 194     pTree->put(boost::property_tree::ptree::path_type(g_strconcat(unoParam[1], "/", "type", nullptr), '/'), unoParam[0]);
 195     pTree->put(boost::property_tree::ptree::path_type(g_strconcat(unoParam[1], "/", "value", nullptr), '/'), unoParam[2]);
 196 }
 197
 198 void recentUnoChanged( GtkWidget* pSelector, gpointer /* pItem */ )
 199 {
 200     GtvApplicationWindow* pWindow = GTV_APPLICATION_WINDOW(gtk_widget_get_toplevel(pSelector));
 201     gchar* pUnoCmd = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(pSelector));
 202
 203     GtvMainToolbar* pToolbar = gtv_application_window_get_main_toolbar(pWindow);
 204     const std::string aUnoArgs = gtv_main_toolbar_get_recent_uno_args(pToolbar, pUnoCmd);
 205     // this will also discard our default placeholder string, "Recent UNO"
 206     if (aUnoArgs.empty())
 207         return;
 208
 209     lok_doc_view_post_command(LOK_DOC_VIEW(pWindow->lokdocview), pUnoCmd, (aUnoArgs.empty() ? nullptr : aUnoArgs.c_str()), false);
 210     g_free(pUnoCmd);
 211 }
 212
 213 static void addToRecentUnoCommands(GtvApplicationWindow* pWindow, const std::string& rUnoCmd, std::string rArgs)
 214 {
 215     GtvMainToolbar* pToolbar = gtv_application_window_get_main_toolbar(pWindow);
 216     rArgs.erase(std::find(rArgs.begin(), rArgs.end(), '\n'));
 217     const std::string rUnoCmdStr = rUnoCmd + " | " + rArgs;
 218
 219
 220     // add to file
 221     std::ofstream outfile("/tmp/gtv-recentunos.txt", std::ios_base::app | std::ios_base::out);
 222     if (outfile.good())
 223         outfile << rUnoCmdStr << '\n';
 224
 225     // add to combo box
 226     gtv_main_toolbar_add_recent_uno(pToolbar, rUnoCmdStr);
 227 }
 228
 229 void unoCommandDebugger(GtkWidget* pButton, gpointer /* pItem */)
 230 {
 231     GtvApplicationWindow* window = GTV_APPLICATION_WINDOW(gtk_widget_get_toplevel(pButton));
 232     GtkWidget* pUnoCmdDialog = gtk_dialog_new_with_buttons ("Execute UNO command",
 233                                                             GTK_WINDOW (window),
 234                                                             GTK_DIALOG_MODAL,
 235                                                             "Execute",
 236                                                             GTK_RESPONSE_OK,
 237                                                             nullptr);
 238     g_object_set(G_OBJECT(pUnoCmdDialog), "resizable", FALSE, nullptr);
 239     GtkWidget* pDialogMessageArea = gtk_dialog_get_content_area (GTK_DIALOG (pUnoCmdDialog));
 240     GtkWidget* pUnoCmdAreaBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 241     gtk_box_pack_start(GTK_BOX(pDialogMessageArea), pUnoCmdAreaBox, TRUE, TRUE, 2);
 242
 243     GtkWidget* pUnoCmdLabel = gtk_label_new("Enter UNO command");
 244     gtk_box_pack_start(GTK_BOX(pUnoCmdAreaBox), pUnoCmdLabel, TRUE, TRUE, 2);
 245
 246     GtkWidget* pUnoCmdEntry = gtk_entry_new ();
 247     gtk_box_pack_start(GTK_BOX(pUnoCmdAreaBox), pUnoCmdEntry, TRUE, TRUE, 2);
 248     gtk_entry_set_placeholder_text(GTK_ENTRY(pUnoCmdEntry), "UNO command (Eg. Bold, Italic etc.)");
 249     GtkWidget* pUnoParamAreaBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 250     gtk_box_pack_start(GTK_BOX(pDialogMessageArea), pUnoParamAreaBox, TRUE, TRUE, 2);
 251
 252     GtkWidget* pAddMoreButton = gtk_button_new_with_label("Add UNO parameter");
 253     gtk_box_pack_start(GTK_BOX(pDialogMessageArea), pAddMoreButton, TRUE, TRUE, 2);
 254     g_signal_connect(G_OBJECT(pAddMoreButton), "clicked", G_CALLBACK(addMoreUnoParam), pUnoParamAreaBox);
 255
 256     gtk_widget_show_all(pUnoCmdDialog);
 257
 258     gint res = gtk_dialog_run (GTK_DIALOG(pUnoCmdDialog));
 259     switch (res)
 260     {
 261     case GTK_RESPONSE_OK:
 262     {
 263         const gchar* sUnoCmd = g_strconcat(".uno:", gtk_entry_get_text(GTK_ENTRY(pUnoCmdEntry)), nullptr);
 264
 265         boost::property_tree::ptree aTree;
 266         gtk_container_foreach(GTK_CONTAINER(pUnoParamAreaBox), iterateUnoParams, &aTree);
 267
 268         std::stringstream aStream;
 269         boost::property_tree::write_json(aStream, aTree, false);
 270         std::string aArguments = aStream.str();
 271
 272         g_info("Generated UNO command: %s %s", sUnoCmd, aArguments.c_str());
 273
 274         lok_doc_view_post_command(LOK_DOC_VIEW(window->lokdocview), sUnoCmd, (aArguments.empty() ? nullptr : aArguments.c_str()), false);
 275         addToRecentUnoCommands(window, sUnoCmd, aArguments);
 276     }
 277         break;
 278     }
 279
 280     gtk_widget_destroy(pUnoCmdDialog);
 281 }
 282
 283 void toggleEditing(GtkWidget* pButton, gpointer /*pItem*/)
 284 {
 285     GtvApplicationWindow* window = GTV_APPLICATION_WINDOW(gtk_widget_get_toplevel(pButton));
 286     bool bActive = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(pButton));
 287     if (bool(lok_doc_view_get_edit(LOK_DOC_VIEW(window->lokdocview))) != bActive)
 288         lok_doc_view_set_edit(LOK_DOC_VIEW(window->lokdocview), bActive);
 289 }
 290
 291 void changePart( GtkWidget* pSelector, gpointer /* pItem */ )
 292 {
 293     int nPart = gtk_combo_box_get_active( GTK_COMBO_BOX(pSelector) );
 294     GtvApplicationWindow* window = GTV_APPLICATION_WINDOW(gtk_widget_get_toplevel(pSelector));
 295
 296     if (gtv_application_window_get_part_broadcast(window) && window->lokdocview)
 297     {
 298         lok_doc_view_set_part( LOK_DOC_VIEW(window->lokdocview), nPart );
 299         lok_doc_view_reset_view(LOK_DOC_VIEW(window->lokdocview));
 300     }
 301 }
 302
 303 void changePartMode( GtkWidget* pSelector, gpointer /* pItem */ )
 304 {
 305     // Just convert directly back to the LibreOfficeKitPartMode enum.
 306     // I.e. the ordering above should match the enum member ordering.
 307     LibreOfficeKitPartMode ePartMode =
 308         LibreOfficeKitPartMode( gtk_combo_box_get_active( GTK_COMBO_BOX(pSelector) ) );
 309     GtvApplicationWindow* window = GTV_APPLICATION_WINDOW(gtk_widget_get_toplevel(pSelector));
 310
 311     if ( window->lokdocview )
 312     {
 313         lok_doc_view_set_partmode( LOK_DOC_VIEW(window->lokdocview), ePartMode );
 314     }
 315 }
 316
 317 void changeZoom( GtkWidget* pButton, gpointer /* pItem */ )
 318 {
 319     static const float fZooms[] = { 0.25, 0.5, 0.75, 1.0, 1.5, 2.0, 3.0, 5.0 };
 320     GtvApplicationWindow* window = GTV_APPLICATION_WINDOW(gtk_widget_get_toplevel(pButton));
 321     const char *sName = gtk_tool_button_get_icon_name( GTK_TOOL_BUTTON(pButton) );
 322
 323     float fZoom = 0;
 324     float fCurrentZoom = 0;
 325
 326     if ( window->lokdocview )
 327     {
 328         fCurrentZoom = lok_doc_view_get_zoom( LOK_DOC_VIEW(window->lokdocview) );
 329     }
 330
 331     if ( strcmp(sName, "zoom-in-symbolic") == 0)
 332     {
 333         for ( size_t i = 0; i < SAL_N_ELEMENTS( fZooms ); i++ )
 334         {
 335             if ( fCurrentZoom < fZooms[i] )
 336             {
 337                 fZoom = fZooms[i];
 338                 break;
 339             }
 340         }
 341     }
 342     else if ( strcmp(sName, "zoom-original-symbolic") == 0)
 343     {
 344         fZoom = 1;
 345     }
 346     else if ( strcmp(sName, "zoom-out-symbolic") == 0)
 347     {
 348         for ( size_t i = 0; i < SAL_N_ELEMENTS( fZooms ); i++ )
 349         {
 350             if ( fCurrentZoom > fZooms[i] )
 351             {
 352                 fZoom = fZooms[i];
 353             }
 354         }
 355     }
 356
 357     if ( fZoom != 0 && window->lokdocview )
 358     {
 359         lok_doc_view_set_zoom( LOK_DOC_VIEW(window->lokdocview), fZoom );
 360         GdkRectangle aVisibleArea;
 361         gtv_application_window_get_visible_area(window, &aVisibleArea);
 362         lok_doc_view_set_visible_area(LOK_DOC_VIEW(window->lokdocview), &aVisibleArea);
 363     }
 364     const std::string aZoom = std::string("Zoom: ") + std::to_string(int(fZoom * 100)) + std::string("%");
 365     gtk_label_set_text(GTK_LABEL(window->zoomlabel), aZoom.c_str());
 366 }
 367
 368 void documentRedline(GtkWidget* pButton, gpointer /*pItem*/)
 369 {
 370     GtvApplicationWindow* window = GTV_APPLICATION_WINDOW(gtk_widget_get_toplevel(pButton));
 371     // Get the data.
 372     LibreOfficeKitDocument* pDocument = lok_doc_view_get_document(LOK_DOC_VIEW(window->lokdocview));
 373     char* pValues = pDocument->pClass->getCommandValues(pDocument, ".uno:AcceptTrackedChanges");
 374     if (!pValues)
 375         return;
 376
 377     std::stringstream aInfo;
 378     aInfo << "lok::Document::getCommandValues('.uno:AcceptTrackedChanges') returned '" << pValues << "'" << std::endl;
 379     g_info("%s", aInfo.str().c_str());
 380     std::stringstream aStream(pValues);
 381     free(pValues);
 382     assert(!aStream.str().empty());
 383     boost::property_tree::ptree aTree;
 384     boost::property_tree::read_json(aStream, aTree);
 385
 386     // Create the dialog.
 387     GtkWidget* pDialog = gtk_dialog_new_with_buttons("Manage Changes",
 388                                                      GTK_WINDOW (window),
 389                                                      GTK_DIALOG_MODAL,
 390                                                      "Accept",
 391                                                      GTK_RESPONSE_YES,
 392                                                      "Reject",
 393                                                      GTK_RESPONSE_NO,
 394                                                      "Jump",
 395                                                      GTK_RESPONSE_APPLY,
 396                                                      nullptr);
 397     gtk_window_set_default_size(GTK_WINDOW(pDialog), 800, 600);
 398     GtkWidget* pContentArea = gtk_dialog_get_content_area(GTK_DIALOG (pDialog));
 399     GtkWidget* pScrolledWindow = gtk_scrolled_window_new(nullptr, nullptr);
 400
 401     // Build the table.
 402     GtkTreeStore* pTreeStore = gtk_tree_store_new(6, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
 403     for (const auto& rValue : aTree.get_child("redlines"))
 404     {
 405         GtkTreeIter aTreeIter;
 406         gtk_tree_store_append(pTreeStore, &aTreeIter, nullptr);
 407         gtk_tree_store_set(pTreeStore, &aTreeIter,
 408                            0, rValue.second.get<int>("index"),
 409                            1, rValue.second.get<std::string>("author").c_str(),
 410                            2, rValue.second.get<std::string>("type").c_str(),
 411                            3, rValue.second.get<std::string>("comment").c_str(),
 412                            4, rValue.second.get<std::string>("description").c_str(),
 413                            5, rValue.second.get<std::string>("dateTime").c_str(),
 414                            -1);
 415     }
 416     GtkWidget* pTreeView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(pTreeStore));
 417     std::vector<std::string> aColumns = {"Index", "Author", "Type", "Comment", "Description", "Timestamp"};
 418     for (size_t nColumn = 0; nColumn < aColumns.size(); ++nColumn)
 419     {
 420         GtkCellRenderer* pRenderer = gtk_cell_renderer_text_new();
 421         GtkTreeViewColumn* pColumn = gtk_tree_view_column_new_with_attributes(aColumns[nColumn].c_str(),
 422                                                                               pRenderer,
 423                                                                               "text", nColumn,
 424                                                                               nullptr);
 425         gtk_tree_view_append_column(GTK_TREE_VIEW(pTreeView), pColumn);
 426     }
 427     gtk_container_add(GTK_CONTAINER(pScrolledWindow), pTreeView);
 428     gtk_box_pack_start(GTK_BOX(pContentArea), pScrolledWindow, TRUE, TRUE, 2);
 429
 430     // Show the dialog.
 431     gtk_widget_show_all(pDialog);
 432     gint res = gtk_dialog_run(GTK_DIALOG(pDialog));
 433
 434     // Dispatch the matching command, if necessary.
 435     if (res == GTK_RESPONSE_YES || res == GTK_RESPONSE_NO || res == GTK_RESPONSE_APPLY)
 436     {
 437         GtkTreeSelection* pSelection = gtk_tree_view_get_selection(GTK_TREE_VIEW(pTreeView));
 438         GtkTreeIter aTreeIter;
 439         GtkTreeModel* pTreeModel;
 440         if (gtk_tree_selection_get_selected(pSelection, &pTreeModel, &aTreeIter))
 441         {
 442             gint nIndex = 0;
 443             // 0: index
 444             gtk_tree_model_get(pTreeModel, &aTreeIter, 0, &nIndex, -1);
 445             std::string aCommand;
 446             if (res == GTK_RESPONSE_YES)
 447                 aCommand = ".uno:AcceptTrackedChange";
 448             else if (res == GTK_RESPONSE_NO)
 449                 aCommand = ".uno:RejectTrackedChange";
 450             else
 451                 // Just select the given redline, don't accept or reject it.
 452                 aCommand = ".uno:NextTrackedChange";
 453             // Without the '.uno:' prefix.
 454             std::string aKey = aCommand.substr(strlen(".uno:"));
 455
 456             // Post the command.
 457             boost::property_tree::ptree aCommandTree;
 458             aCommandTree.put(boost::property_tree::ptree::path_type(aKey + "/type", '/'), "unsigned short");
 459             aCommandTree.put(boost::property_tree::ptree::path_type(aKey + "/value", '/'), nIndex);
 460
 461             aStream.str(std::string());
 462             boost::property_tree::write_json(aStream, aCommandTree);
 463             std::string aArguments = aStream.str();
 464             lok_doc_view_post_command(LOK_DOC_VIEW(window->lokdocview), aCommand.c_str(), aArguments.c_str(), false);
 465         }
 466     }
 467
 468     gtk_widget_destroy(pDialog);
 469 }
 470
 471 void documentRepair(GtkWidget* pButton, gpointer /*pItem*/)
 472 {
 473     GtvApplicationWindow* window = GTV_APPLICATION_WINDOW(gtk_widget_get_toplevel(pButton));
 474     // Get the data.
 475     LibreOfficeKitDocument* pDocument = lok_doc_view_get_document(LOK_DOC_VIEW(window->lokdocview));
 476     // Show it in linear time, so first redo in reverse order, then undo.
 477     std::vector<std::string> aTypes = {".uno:Redo", ".uno:Undo"};
 478     std::vector<boost::property_tree::ptree> aTrees;
 479     for (size_t nType = 0; nType < aTypes.size(); ++nType)
 480     {
 481         const std::string& rType = aTypes[nType];
 482         char* pValues = pDocument->pClass->getCommandValues(pDocument, rType.c_str());
 483         std::stringstream aInfo;
 484         aInfo << "lok::Document::getCommandValues('" << rType << "') returned '" << pValues << "'" << std::endl;
 485         g_info("%s", aInfo.str().c_str());
 486         std::stringstream aStream(pValues);
 487         free(pValues);
 488         assert(!aStream.str().empty());
 489         boost::property_tree::ptree aTree;
 490         boost::property_tree::read_json(aStream, aTree);
 491         aTrees.push_back(aTree);
 492     }
 493
 494     // Create the dialog.
 495     GtkWidget* pDialog = gtk_dialog_new_with_buttons("Repair document",
 496                                                      GTK_WINDOW (window),
 497                                                      GTK_DIALOG_MODAL,
 498                                                      "Jump to state",
 499                                                      GTK_RESPONSE_OK,
 500                                                      nullptr);
 501     gtk_window_set_default_size(GTK_WINDOW(pDialog), 800, 600);
 502     GtkWidget* pContentArea = gtk_dialog_get_content_area(GTK_DIALOG (pDialog));
 503     GtkWidget* pScrolledWindow = gtk_scrolled_window_new(nullptr, nullptr);
 504
 505     // Build the table.
 506     GtkTreeStore* pTreeStore = gtk_tree_store_new(5, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
 507     for (size_t nTree = 0; nTree < aTrees.size(); ++nTree)
 508     {
 509         const auto& rTree = aTrees[nTree];
 510         for (const auto& rValue : rTree.get_child("actions"))
 511         {
 512             GtkTreeIter aTreeIter;
 513             gtk_tree_store_append(pTreeStore, &aTreeIter, nullptr);
 514             gtk_tree_store_set(pTreeStore, &aTreeIter,
 515                                0, aTypes[nTree].c_str(),
 516                                1, rValue.second.get<int>("index"),
 517                                2, rValue.second.get<std::string>("comment").c_str(),
 518                                3, rValue.second.get<std::string>("viewId").c_str(),
 519                                4, rValue.second.get<std::string>("dateTime").c_str(),
 520                                -1);
 521         }
 522     }
 523     GtkWidget* pTreeView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(pTreeStore));
 524     std::vector<std::string> aColumns = {"Type", "Index", "Comment", "View ID", "Timestamp"};
 525     for (size_t nColumn = 0; nColumn < aColumns.size(); ++nColumn)
 526     {
 527         GtkCellRenderer* pRenderer = gtk_cell_renderer_text_new();
 528         GtkTreeViewColumn* pColumn = gtk_tree_view_column_new_with_attributes(aColumns[nColumn].c_str(),
 529                                                                               pRenderer,
 530                                                                               "text", nColumn,
 531                                                                               nullptr);
 532         gtk_tree_view_append_column(GTK_TREE_VIEW(pTreeView), pColumn);
 533     }
 534     gtk_container_add(GTK_CONTAINER(pScrolledWindow), pTreeView);
 535     gtk_box_pack_start(GTK_BOX(pContentArea), pScrolledWindow, TRUE, TRUE, 2);
 536
 537     // Show the dialog.
 538     gtk_widget_show_all(pDialog);
 539     gint res = gtk_dialog_run(GTK_DIALOG(pDialog));
 540
 541     // Dispatch the matching command, if necessary.
 542     if (res == GTK_RESPONSE_OK)
 543     {
 544         GtkTreeSelection* pSelection = gtk_tree_view_get_selection(GTK_TREE_VIEW(pTreeView));
 545         GtkTreeIter aTreeIter;
 546         GtkTreeModel* pTreeModel;
 547         if (gtk_tree_selection_get_selected(pSelection, &pTreeModel, &aTreeIter))
 548         {
 549             gchar* pType = nullptr;
 550             gint nIndex = 0;
 551             // 0: type, 1: index
 552             gtk_tree_model_get(pTreeModel, &aTreeIter, 0, &pType, 1, &nIndex, -1);
 553             // '.uno:Undo' or '.uno:Redo'
 554             const std::string aType(pType);
 555             // Without the '.uno:' prefix.
 556             std::string aKey = aType.substr(strlen(".uno:"));
 557             g_free(pType);
 558
 559             // Post the command.
 560             boost::property_tree::ptree aTree;
 561             aTree.put(boost::property_tree::ptree::path_type(aKey + "/type", '/'), "unsigned short");
 562             aTree.put(boost::property_tree::ptree::path_type(aKey + "/value", '/'), nIndex + 1);
 563
 564             // Without this, we could only undo our own commands.
 565             aTree.put(boost::property_tree::ptree::path_type("Repair/type", '/'), "boolean");
 566             aTree.put(boost::property_tree::ptree::path_type("Repair/value", '/'), true);
 567
 568             std::stringstream aStream;
 569             boost::property_tree::write_json(aStream, aTree);
 570             std::string aArguments = aStream.str();
 571             lok_doc_view_post_command(LOK_DOC_VIEW(window->lokdocview), aType.c_str(), aArguments.c_str(), false);
 572         }
 573     }
 574
 575     gtk_widget_destroy(pDialog);
 576 }
 577
 578 void toggleFindbar(GtkWidget* pButton, gpointer /*pItem*/)
 579 {
 580     GtvApplicationWindow* window = GTV_APPLICATION_WINDOW(gtk_widget_get_toplevel(pButton));
 581     gtv_application_window_toggle_findbar(window);
 582 }
 583
 584 void docAdjustmentChanged(GtkAdjustment*, gpointer pData)
 585 {
 586     GtvApplicationWindow* window = GTV_APPLICATION_WINDOW(pData);
 587     if (window->lokdocview)
 588         LOKDocViewSigHandlers::configureEvent(window->lokdocview, nullptr, nullptr);
 589 }
 590
 591 void signalSearchNext(GtkWidget* pButton, gpointer /*pItem*/)
 592 {
 593     GtvApplicationWindow* window = GTV_APPLICATION_WINDOW(gtk_widget_get_toplevel(pButton));
 594     GtkEntry* pEntry = GTK_ENTRY(window->findbarEntry);
 595     const char* pText = gtk_entry_get_text(pEntry);
 596     bool findAll = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(window->findAll));
 597     lok_doc_view_find_next(LOK_DOC_VIEW(window->lokdocview), pText, findAll);
 598 }
 599
 600 void signalSearchPrev(GtkWidget* pButton, gpointer /*pItem*/)
 601 {
 602     GtvApplicationWindow* window = GTV_APPLICATION_WINDOW(gtk_widget_get_toplevel(pButton));
 603     GtkEntry* pEntry = GTK_ENTRY(window->findbarEntry);
 604     const char* pText = gtk_entry_get_text(pEntry);
 605     bool findAll = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(window->findAll));
 606     lok_doc_view_find_prev(LOK_DOC_VIEW(window->lokdocview), pText, findAll);
 607 }
 608
 609 gboolean signalFindbar(GtkWidget* pWidget, GdkEventKey* pEvent, gpointer /*pData*/)
 610 {
 611     GtvApplicationWindow* window = GTV_APPLICATION_WINDOW(gtk_widget_get_toplevel(pWidget));
 612     gtk_label_set_text(GTK_LABEL(window->findbarlabel), "");
 613     switch(pEvent->keyval)
 614     {
 615         case GDK_KEY_Return:
 616         {
 617             // Search forward.
 618             signalSearchNext(pWidget, nullptr);
 619             return TRUE;
 620         }
 621         case GDK_KEY_Escape:
 622         {
 623             // Hide the findbar.
 624             gtk_widget_hide(GTK_WIDGET(window->findtoolbar));
 625             return TRUE;
 626         }
 627     }
 628     return FALSE;
 629 }
 630
 631 void toggleFindAll(GtkWidget* pButton, gpointer /*pItem*/)
 632 {
 633     GtvApplicationWindow* window = GTV_APPLICATION_WINDOW(gtk_widget_get_toplevel(pButton));
 634     GtkEntry* pEntry = GTK_ENTRY(window->findbarEntry);
 635     const char* pText = gtk_entry_get_text(pEntry);
 636     bool findAll = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(window->findAll));
 637     gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(window->findAll), !findAll);
 638     lok_doc_view_highlight_all(LOK_DOC_VIEW(window->lokdocview), pText);
 639 }
 640
 641 void editButtonClicked(GtkWidget* pWidget, gpointer userdata)
 642 {
 643     GtvApplicationWindow* window = GTV_APPLICATION_WINDOW(gtk_widget_get_toplevel(pWidget));
 644     std::map<std::string, std::string> aEntries;
 645     aEntries["Text"] = "";
 646
 647     GtvHelpers::userPromptDialog(GTK_WINDOW(window), "Edit comment", aEntries);
 648
 649     gchar *commentId = static_cast<gchar*>(g_object_get_data(G_OBJECT(userdata), "id"));
 650
 651     boost::property_tree::ptree aTree;
 652     aTree.put(boost::property_tree::ptree::path_type(g_strconcat("Id", "/", "type", nullptr), '/'), "string");
 653     aTree.put(boost::property_tree::ptree::path_type(g_strconcat("Id", "/", "value", nullptr), '/'), std::string(commentId));
 654
 655     aTree.put(boost::property_tree::ptree::path_type(g_strconcat("Text", "/", "type", nullptr), '/'), "string");
 656     aTree.put(boost::property_tree::ptree::path_type(g_strconcat("Text", "/", "value", nullptr), '/'), aEntries["Text"]);
 657
 658     std::stringstream aStream;
 659     boost::property_tree::write_json(aStream, aTree);
 660     std::string aArguments = aStream.str();
 661
 662     lok_doc_view_post_command(LOK_DOC_VIEW(window->lokdocview), ".uno:EditAnnotation", aArguments.c_str(), false);
 663 }
 664
 665 void replyButtonClicked(GtkWidget* pWidget, gpointer userdata)
 666 {
 667     GtvApplicationWindow* window = GTV_APPLICATION_WINDOW(gtk_widget_get_toplevel(pWidget));
 668     std::map<std::string, std::string> aEntries;
 669     aEntries["Text"] = "";
 670
 671     GtvHelpers::userPromptDialog(GTK_WINDOW(window), "Reply comment", aEntries);
 672
 673     gchar *commentId = static_cast<gchar*>(g_object_get_data(G_OBJECT(userdata), "id"));
 674
 675     boost::property_tree::ptree aTree;
 676     aTree.put(boost::property_tree::ptree::path_type(g_strconcat("Id", "/", "type", nullptr), '/'), "string");
 677     aTree.put(boost::property_tree::ptree::path_type(g_strconcat("Id", "/", "value", nullptr), '/'), std::string(commentId));
 678
 679     aTree.put(boost::property_tree::ptree::path_type(g_strconcat("Text", "/", "type", nullptr), '/'), "string");
 680     aTree.put(boost::property_tree::ptree::path_type(g_strconcat("Text", "/", "value", nullptr), '/'), aEntries["Text"]);
 681
 682     std::stringstream aStream;
 683     boost::property_tree::write_json(aStream, aTree);
 684     std::string aArguments = aStream.str();
 685
 686     // Different reply UNO command for impress
 687     std::string replyCommand = ".uno:ReplyComment";
 688     LibreOfficeKitDocument* pDocument = lok_doc_view_get_document(LOK_DOC_VIEW(window->lokdocview));
 689     if (pDocument && pDocument->pClass->getDocumentType(pDocument) == LOK_DOCTYPE_PRESENTATION)
 690         replyCommand = ".uno:ReplyToAnnotation";
 691     lok_doc_view_post_command(LOK_DOC_VIEW(window->lokdocview), replyCommand.c_str(), aArguments.c_str(), false);
 692 }
 693
 694 void deleteCommentButtonClicked(GtkWidget* pWidget, gpointer userdata)
 695 {
 696     GtvApplicationWindow* window = GTV_APPLICATION_WINDOW(gtk_widget_get_toplevel(pWidget));
 697     gchar *commentid = static_cast<gchar*>(g_object_get_data(G_OBJECT(userdata), "id"));
 698
 699     boost::property_tree::ptree aTree;
 700     aTree.put(boost::property_tree::ptree::path_type(g_strconcat("Id", "/", "type", nullptr), '/'), "string");
 701     aTree.put(boost::property_tree::ptree::path_type(g_strconcat("Id", "/", "value", nullptr), '/'), std::string(commentid));
 702
 703     std::stringstream aStream;
 704     boost::property_tree::write_json(aStream, aTree);
 705     std::string aArguments = aStream.str();
 706
 707     // Different reply UNO command for impress
 708     std::string deleteCommand = ".uno:DeleteComment";
 709     LibreOfficeKitDocument* pDocument = lok_doc_view_get_document(LOK_DOC_VIEW(window->lokdocview));
 710     if (pDocument)
 711     {
 712         if (pDocument->pClass->getDocumentType(pDocument) == LOK_DOCTYPE_PRESENTATION)
 713             deleteCommand = ".uno:DeleteAnnotation";
 714         else if (pDocument->pClass->getDocumentType(pDocument) == LOK_DOCTYPE_SPREADSHEET)
 715             deleteCommand = ".uno:DeleteNote";
 716     }
 717
 718     lok_doc_view_post_command(LOK_DOC_VIEW(window->lokdocview), deleteCommand.c_str(), aArguments.c_str(), false);
 719 }
 720
 721 /// Handles the key-press-event of the address entry widget.
 722 gboolean signalAddressbar(GtkWidget* pWidget, GdkEventKey* pEvent, gpointer /*pData*/)
 723 {
 724     GtvApplicationWindow* window = GTV_APPLICATION_WINDOW(gtk_widget_get_toplevel(pWidget));
 725     switch(pEvent->keyval)
 726     {
 727         case GDK_KEY_Return:
 728         {
 729             GtkEntry* pEntry = GTK_ENTRY(pWidget);
 730             const char* pText = gtk_entry_get_text(pEntry);
 731
 732             boost::property_tree::ptree aTree;
 733             aTree.put(boost::property_tree::ptree::path_type("ToPoint/type", '/'), "string");
 734             aTree.put(boost::property_tree::ptree::path_type("ToPoint/value", '/'), pText);
 735             std::stringstream aStream;
 736             boost::property_tree::write_json(aStream, aTree);
 737             std::string aArguments = aStream.str();
 738
 739             lok_doc_view_post_command(LOK_DOC_VIEW(window->lokdocview), ".uno:GoToCell", aArguments.c_str(), false);
 740             gtk_widget_grab_focus(window->lokdocview);
 741             return TRUE;
 742         }
 743         case GDK_KEY_Escape:
 744         {
 745             std::string aArguments;
 746             lok_doc_view_post_command(LOK_DOC_VIEW(window->lokdocview), ".uno:Cancel", aArguments.c_str(), false);
 747             gtk_widget_grab_focus(window->lokdocview);
 748             return TRUE;
 749         }
 750     }
 751     return FALSE;
 752 }
 753
 754 /// Handles the key-press-event of the formula entry widget.
 755 gboolean signalFormulabar(GtkWidget* /*pWidget*/, GdkEventKey* /*pEvent*/, gpointer /*pData*/)
 756 {
 757     // for now it just displays the callback
 758     // TODO - submit the edited formula
 759     return TRUE;
 760 }
 761
 762 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */