vcl/jsdialog/executor.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
   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 <jsdialog/jsdialogbuilder.hxx>
  11 #include <vcl/weld.hxx>
  12 #include <vcl/jsdialog/executor.hxx>
  13 #include <sal/log.hxx>
  14 #include <rtl/uri.hxx>
  15 #include <boost/property_tree/json_parser.hpp>
  16
  17 namespace jsdialog
  18 {
  19 StringMap jsonToStringMap(const char* pJSON)
  20 {
  21     StringMap aArgs;
  22     if (pJSON && pJSON[0] != '\0')
  23     {
  24         std::stringstream aStream(pJSON);
  25         boost::property_tree::ptree aTree;
  26         boost::property_tree::read_json(aStream, aTree);
  27
  28         for (const auto& rPair : aTree)
  29         {
  30             aArgs[OUString::fromUtf8(rPair.first.c_str())]
  31                 = OUString::fromUtf8(rPair.second.get_value<std::string>(".").c_str());
  32         }
  33     }
  34     return aArgs;
  35 }
  36
  37 void SendFullUpdate(const std::string& nWindowId, const OString& rWidget)
  38 {
  39     weld::Widget* pWidget = JSInstanceBuilder::FindWeldWidgetsMap(nWindowId, rWidget);
  40
  41     if (pWidget != nullptr)
  42     {
  43         auto pJSWidget = dynamic_cast<BaseJSWidget*>(pWidget);
  44         pJSWidget->sendFullUpdate();
  45     }
  46 }
  47
  48 bool ExecuteAction(const std::string& nWindowId, const OString& rWidget, StringMap& rData)
  49 {
  50     weld::Widget* pWidget = JSInstanceBuilder::FindWeldWidgetsMap(nWindowId, rWidget);
  51
  52     OUString sControlType = rData["type"];
  53     OUString sAction = rData["cmd"];
  54
  55     if (sControlType == "responsebutton")
  56     {
  57         if (pWidget == nullptr)
  58         {
  59             // welded wrapper not found - use response code instead
  60             pWidget = JSInstanceBuilder::FindWeldWidgetsMap(nWindowId, "__DIALOG__");
  61             sControlType = "dialog";
  62             sAction = "response";
  63         }
  64         else
  65         {
  66             // welded wrapper for button found - use it
  67             sControlType = "pushbutton";
  68         }
  69     }
  70
  71     if (pWidget != nullptr)
  72     {
  73         if (sControlType == "tabcontrol")
  74         {
  75             auto pNotebook = dynamic_cast<weld::Notebook*>(pWidget);
  76             if (pNotebook)
  77             {
  78                 if (sAction == "selecttab")
  79                 {
  80                     OString pageId = OUStringToOString(rData["data"], RTL_TEXTENCODING_ASCII_US);
  81                     int page = std::atoi(pageId.getStr());
  82
  83                     pNotebook->set_current_page(page);
  84
  85                     return true;
  86                 }
  87             }
  88         }
  89         else if (sControlType == "combobox")
  90         {
  91             auto pCombobox = dynamic_cast<weld::ComboBox*>(pWidget);
  92             if (pCombobox)
  93             {
  94                 if (sAction == "selected")
  95                 {
  96                     int separatorPos = rData["data"].indexOf(';');
  97                     if (separatorPos > 0)
  98                     {
  99                         OUString entryPos = rData["data"].copy(0, separatorPos);
 100                         OString posString = OUStringToOString(entryPos, RTL_TEXTENCODING_ASCII_US);
 101                         int pos = std::atoi(posString.getStr());
 102                         pCombobox->set_active(pos);
 103                         LOKTrigger::trigger_changed(*pCombobox);
 104                         return true;
 105                     }
 106                 }
 107                 else if (sAction == "change")
 108                 {
 109                     pCombobox->set_entry_text(rData["data"]);
 110                     LOKTrigger::trigger_changed(*pCombobox);
 111                     return true;
 112                 }
 113             }
 114         }
 115         else if (sControlType == "pushbutton")
 116         {
 117             auto pButton = dynamic_cast<weld::Button*>(pWidget);
 118             if (pButton)
 119             {
 120                 if (sAction == "click")
 121                 {
 122                     pButton->clicked();
 123                     return true;
 124                 }
 125             }
 126         }
 127         else if (sControlType == "menubutton")
 128         {
 129             auto pButton = dynamic_cast<weld::MenuButton*>(pWidget);
 130             if (pButton)
 131             {
 132                 if (sAction == "toggle")
 133                 {
 134                     if (pButton->get_active())
 135                         pButton->set_active(false);
 136                     else
 137                         pButton->set_active(true);
 138
 139                     BaseJSWidget* pMenuButton = dynamic_cast<BaseJSWidget*>(pButton);
 140                     if (pMenuButton)
 141                         pMenuButton->sendUpdate(true);
 142
 143                     return true;
 144                 }
 145             }
 146         }
 147         else if (sControlType == "checkbox")
 148         {
 149             auto pCheckButton = dynamic_cast<weld::CheckButton*>(pWidget);
 150             if (pCheckButton)
 151             {
 152                 if (sAction == "change")
 153                 {
 154                     bool bChecked = rData["data"] == "true";
 155                     pCheckButton->set_state(bChecked ? TRISTATE_TRUE : TRISTATE_FALSE);
 156                     LOKTrigger::trigger_clicked(*static_cast<weld::Button*>(pCheckButton));
 157                     LOKTrigger::trigger_toggled(*static_cast<weld::ToggleButton*>(pCheckButton));
 158                     return true;
 159                 }
 160             }
 161         }
 162         else if (sControlType == "drawingarea")
 163         {
 164             auto pArea = dynamic_cast<weld::DrawingArea*>(pWidget);
 165             if (pArea)
 166             {
 167                 if (sAction == "click")
 168                 {
 169                     int separatorPos = rData["data"].indexOf(';');
 170                     if (separatorPos > 0)
 171                     {
 172                         // x;y
 173                         OString clickPosX = OUStringToOString(rData["data"].copy(0, separatorPos),
 174                                                               RTL_TEXTENCODING_ASCII_US);
 175                         OString clickPosY = OUStringToOString(rData["data"].copy(separatorPos + 1),
 176                                                               RTL_TEXTENCODING_ASCII_US);
 177                         if (!clickPosX.isEmpty() && !clickPosY.isEmpty())
 178                         {
 179                             double posX = std::atof(clickPosX.getStr());
 180                             double posY = std::atof(clickPosY.getStr());
 181                             OutputDevice& rRefDevice = pArea->get_ref_device();
 182                             // We send OutPutSize for the drawing area bitmap
 183                             // get_size_request is not necessarily updated
 184                             // therefore it may be incorrect.
 185                             Size size = rRefDevice.GetOutputSize();
 186                             posX = posX * size.Width();
 187                             posY = posY * size.Height();
 188                             LOKTrigger::trigger_click(*pArea, Point(posX, posY));
 189                             return true;
 190                         }
 191                     }
 192                     LOKTrigger::trigger_click(*pArea, Point(10, 10));
 193                     return true;
 194                 }
 195             }
 196         }
 197         else if (sControlType == "spinfield")
 198         {
 199             auto pSpinField = dynamic_cast<weld::SpinButton*>(pWidget);
 200             if (pSpinField)
 201             {
 202                 if (sAction == "change" || sAction == "value")
 203                 {
 204                     if (rData["data"] == "undefined")
 205                         return true;
 206
 207                     OString sValue = OUStringToOString(rData["data"], RTL_TEXTENCODING_ASCII_US);
 208                     double nValue = std::atof(sValue.getStr());
 209                     pSpinField->set_value(nValue
 210                                           * weld::SpinButton::Power10(pSpinField->get_digits()));
 211                     LOKTrigger::trigger_value_changed(*pSpinField);
 212                     return true;
 213                 }
 214                 if (sAction == "plus")
 215                 {
 216                     pSpinField->set_value(pSpinField->get_value() + 1);
 217                     LOKTrigger::trigger_value_changed(*pSpinField);
 218                     return true;
 219                 }
 220                 else if (sAction == "minus")
 221                 {
 222                     pSpinField->set_value(pSpinField->get_value() - 1);
 223                     LOKTrigger::trigger_value_changed(*pSpinField);
 224                     return true;
 225                 }
 226             }
 227         }
 228         else if (sControlType == "toolbox")
 229         {
 230             auto pToolbar = dynamic_cast<weld::Toolbar*>(pWidget);
 231             if (pToolbar)
 232             {
 233                 if (sAction == "click")
 234                 {
 235                     LOKTrigger::trigger_clicked(
 236                         *pToolbar, OUStringToOString(rData["data"], RTL_TEXTENCODING_ASCII_US));
 237                     return true;
 238                 }
 239                 else if (sAction == "togglemenu")
 240                 {
 241                     pToolbar->set_menu_item_active(
 242                         OUStringToOString(rData["data"], RTL_TEXTENCODING_ASCII_US), true);
 243                     return true;
 244                 }
 245             }
 246         }
 247         else if (sControlType == "edit")
 248         {
 249             auto pEdit = dynamic_cast<JSEntry*>(pWidget);
 250             if (pEdit)
 251             {
 252                 if (sAction == "change")
 253                 {
 254                     pEdit->set_text_without_notify(rData["data"]);
 255                     LOKTrigger::trigger_changed(*pEdit);
 256                     return true;
 257                 }
 258             }
 259
 260             auto pTextView = dynamic_cast<weld::TextView*>(pWidget);
 261             if (pTextView)
 262             {
 263                 if (sAction == "change")
 264                 {
 265                     pTextView->set_text(rData["data"]);
 266                     LOKTrigger::trigger_changed(*pTextView);
 267                     return true;
 268                 }
 269             }
 270         }
 271         else if (sControlType == "treeview")
 272         {
 273             auto pTreeView = dynamic_cast<JSTreeView*>(pWidget);
 274             if (pTreeView)
 275             {
 276                 if (sAction == "change")
 277                 {
 278                     OUString sDataJSON = rtl::Uri::decode(
 279                         rData["data"], rtl_UriDecodeMechanism::rtl_UriDecodeWithCharset,
 280                         RTL_TEXTENCODING_UTF8);
 281                     StringMap aMap(jsonToStringMap(
 282                         OUStringToOString(sDataJSON, RTL_TEXTENCODING_ASCII_US).getStr()));
 283
 284                     OString nRowString = OUStringToOString(aMap["row"], RTL_TEXTENCODING_ASCII_US);
 285                     int nRow = std::atoi(nRowString.getStr());
 286                     bool bValue = aMap["value"] == "true";
 287
 288                     pTreeView->set_toggle(nRow, bValue ? TRISTATE_TRUE : TRISTATE_FALSE);
 289
 290                     return true;
 291                 }
 292                 else if (sAction == "select")
 293                 {
 294                     OString nRowString
 295                         = OUStringToOString(rData["data"], RTL_TEXTENCODING_ASCII_US);
 296
 297                     pTreeView->unselect_all();
 298
 299                     int nAbsPos = std::atoi(nRowString.getStr());
 300
 301                     std::unique_ptr<weld::TreeIter> itEntry(pTreeView->make_iterator());
 302                     pTreeView->get_iter_abs_pos(*itEntry, nAbsPos);
 303                     pTreeView->select(*itEntry);
 304                     pTreeView->set_cursor(*itEntry);
 305                     LOKTrigger::trigger_changed(*pTreeView);
 306                     return true;
 307                 }
 308                 else if (sAction == "activate")
 309                 {
 310                     OString nRowString
 311                         = OUStringToOString(rData["data"], RTL_TEXTENCODING_ASCII_US);
 312                     int nRow = std::atoi(nRowString.getStr());
 313
 314                     pTreeView->unselect_all();
 315                     pTreeView->select(nRow);
 316                     pTreeView->set_cursor(nRow);
 317                     LOKTrigger::trigger_changed(*pTreeView);
 318                     LOKTrigger::trigger_row_activated(*pTreeView);
 319                     return true;
 320                 }
 321                 else if (sAction == "expand")
 322                 {
 323                     OString nRowString
 324                         = OUStringToOString(rData["data"], RTL_TEXTENCODING_ASCII_US);
 325                     int nAbsPos = std::atoi(nRowString.getStr());
 326                     std::unique_ptr<weld::TreeIter> itEntry(pTreeView->make_iterator());
 327                     pTreeView->get_iter_abs_pos(*itEntry, nAbsPos);
 328                     pTreeView->expand_row(*itEntry);
 329                     return true;
 330                 }
 331                 else if (sAction == "dragstart")
 332                 {
 333                     OString nRowString
 334                         = OUStringToOString(rData["data"], RTL_TEXTENCODING_ASCII_US);
 335                     int nRow = std::atoi(nRowString.getStr());
 336
 337                     pTreeView->select(nRow);
 338                     pTreeView->drag_start();
 339
 340                     return true;
 341                 }
 342                 else if (sAction == "dragend")
 343                 {
 344                     pTreeView->drag_end();
 345                     return true;
 346                 }
 347             }
 348         }
 349         else if (sControlType == "iconview")
 350         {
 351             auto pIconView = dynamic_cast<weld::IconView*>(pWidget);
 352             if (pIconView)
 353             {
 354                 if (sAction == "select")
 355                 {
 356                     OString nPosString
 357                         = OUStringToOString(rData["data"], RTL_TEXTENCODING_ASCII_US);
 358                     int nPos = std::atoi(nPosString.getStr());
 359
 360                     pIconView->select(nPos);
 361                     LOKTrigger::trigger_changed(*pIconView);
 362
 363                     return true;
 364                 }
 365                 else if (sAction == "activate")
 366                 {
 367                     OString nPosString
 368                         = OUStringToOString(rData["data"], RTL_TEXTENCODING_ASCII_US);
 369                     int nPos = std::atoi(nPosString.getStr());
 370
 371                     pIconView->select(nPos);
 372                     LOKTrigger::trigger_changed(*pIconView);
 373                     LOKTrigger::trigger_item_activated(*pIconView);
 374
 375                     return true;
 376                 }
 377             }
 378         }
 379         else if (sControlType == "expander")
 380         {
 381             auto pExpander = dynamic_cast<weld::Expander*>(pWidget);
 382             if (pExpander)
 383             {
 384                 if (sAction == "toggle")
 385                 {
 386                     pExpander->set_expanded(!pExpander->get_expanded());
 387                     return true;
 388                 }
 389             }
 390         }
 391         else if (sControlType == "dialog")
 392         {
 393             auto pDialog = dynamic_cast<weld::Dialog*>(pWidget);
 394             if (pDialog)
 395             {
 396                 if (sAction == "close")
 397                 {
 398                     pDialog->response(RET_CANCEL);
 399                     return true;
 400                 }
 401                 else if (sAction == "response")
 402                 {
 403                     OString nResponseString
 404                         = OUStringToOString(rData["data"], RTL_TEXTENCODING_ASCII_US);
 405                     int nResponse = std::atoi(nResponseString.getStr());
 406                     pDialog->response(nResponse);
 407                     return true;
 408                 }
 409             }
 410         }
 411         else if (sControlType == "popover")
 412         {
 413             auto pPopover = dynamic_cast<weld::Popover*>(pWidget);
 414             if (pPopover)
 415             {
 416                 if (sAction == "close")
 417                 {
 418                     LOKTrigger::trigger_closed(*pPopover);
 419                     return true;
 420                 }
 421             }
 422         }
 423         else if (sControlType == "radiobutton")
 424         {
 425             auto pRadioButton = dynamic_cast<weld::RadioButton*>(pWidget);
 426             if (pRadioButton)
 427             {
 428                 if (sAction == "change")
 429                 {
 430                     bool bChecked = rData["data"] == "true";
 431                     pRadioButton->set_state(bChecked ? TRISTATE_TRUE : TRISTATE_FALSE);
 432                     LOKTrigger::trigger_clicked(*static_cast<weld::Button*>(pRadioButton));
 433                     LOKTrigger::trigger_toggled(*static_cast<weld::ToggleButton*>(pRadioButton));
 434                     return true;
 435                 }
 436             }
 437         }
 438     }
 439
 440     return false;
 441 }
 442 }
 443
 444 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */