src/session/commands.h

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #ifndef __MAPS_SERVICE_SESSION_COMMANDS_H__
  18 #define __MAPS_SERVICE_SESSION_COMMANDS_H__
  19
  20 #include "command.h"
  21 #include "maps_view.h"
  22
  23 namespace session
  24 {
  25
  26 //LCOV_EXCL_START
  27 /*----------------------------------------------------------------------------*/
  28 /*typedef int (*maps_plugin_geocode_f)(maps_service_h maps,
  29 * const char *address, maps_service_geocode_cb callback,
  30 * void *user_data, int* request_id); */
  31 class command_geocode : public command
  32 {
  33 public:
  34         const string address;
  35         maps_item_hashtable_h preference;
  36         maps_service_geocode_cb callback;
  37         void *user_data;
  38         int error;
  39 public:
  40         command_geocode(maps_service_h ms,
  41                          const string address,
  42                          const maps_item_hashtable_h preference,
  43                          maps_service_geocode_cb callback,
  44                          void *user_data, int *request_id);
  45         virtual ~command_geocode();
  46 private:
  47         command_geocode() : command(NULL)
  48         {
  49         }
  50         command_geocode(const command_geocode &src) : command(NULL)
  51         {
  52         }
  53         command_geocode &operator=(const command_geocode &src)
  54         {
  55                 return *this;
  56         }
  57 private:
  58         virtual int run();
  59 };
  60
  61 class command_geocode_handler : public command_handler
  62 {
  63         maps_service_geocode_cb callback;
  64 public:
  65         command_geocode_handler(plugin::plugin_s *plugin,
  66                                  maps_service_geocode_cb callback,
  67                                  void *user_data,
  68                                  int user_req_id);
  69          virtual ~command_geocode_handler()
  70         {
  71         };
  72 private:
  73         command_geocode_handler() : command_handler(NULL, NULL, 0) {}
  74         command_geocode_handler(const command_geocode_handler &src) :
  75                  command_handler(NULL, NULL, 0)
  76         {
  77         }
  78         command_geocode_handler &operator=(
  79                 const command_geocode_handler &src)
  80         {
  81                 return *this;
  82         }
  83 private:
  84         static bool foreach_geocode_cb(maps_error_e result,
  85                                        int request_id, int index,
  86                                        int total_count,
  87                                        maps_coordinates_h coordinates,
  88                                        void *user_data);
  89         friend class command_geocode;
  90         friend class command_geocode_inside_bounds;
  91         friend class command_geocode_by_structured_address;
  92 };
  93
  94 /*----------------------------------------------------------------------------*/
  95
  96 /* TODO: rename to command_geocode_inside_area */
  97
  98 /*typedef int (*maps_plugin_geocode_inside_area_f)(maps_service_h maps,
  99 * const char *address, maps_area_h bounds,
 100 * maps_service_geocode_cb callback, void *user_data,
 101 * int* request_id); */
 102 class command_geocode_inside_bounds : public command
 103 {
 104 public:
 105         string address;
 106         maps_area_h bounds;
 107         maps_item_hashtable_h preference;
 108         maps_service_geocode_cb callback;
 109         void *user_data;
 110         int error;
 111 public:
 112         command_geocode_inside_bounds(maps_service_h ms,
 113                                        const char *address,
 114                                        const maps_area_h bounds,
 115                                        const maps_item_hashtable_h preference,
 116                                        maps_service_geocode_cb callback,
 117                                        void *user_data,
 118                                        int *request_id);
 119         virtual ~command_geocode_inside_bounds();
 120 private:
 121         command_geocode_inside_bounds() : command(NULL)
 122         {
 123         }
 124         command_geocode_inside_bounds(
 125                 const command_geocode_inside_bounds &src)
 126                  : command(NULL)
 127         {
 128         }
 129         command_geocode_inside_bounds &operator=(
 130                 const command_geocode_inside_bounds &src)
 131         {
 132                 return *this;
 133         }
 134 private:
 135         virtual int run();
 136 };
 137
 138 /*----------------------------------------------------------------------------*/
 139 /*typedef int (*maps_plugin_geocode_by_structured_address_f)(
 140 * maps_service_h maps, maps_address_h address,
 141 * maps_preference_h preference, maps_service_geocode_cb callback,
 142 * void *user_data, int *request_id); */
 143 class command_geocode_by_structured_address : public command
 144 {
 145 public:
 146         maps_address_h address;
 147         maps_item_hashtable_h preference;
 148         maps_service_geocode_cb callback;
 149         void *user_data;
 150         int error;
 151 public:
 152         command_geocode_by_structured_address(maps_service_h ms,
 153                                                const maps_address_h address,
 154                                                const maps_item_hashtable_h preference,
 155                                                maps_service_geocode_cb callback,
 156                                                void *user_data,
 157                                                int *request_id);
 158         virtual ~command_geocode_by_structured_address();
 159 private:
 160         command_geocode_by_structured_address() : command(NULL)
 161         {
 162         }
 163         command_geocode_by_structured_address(
 164                 const command_geocode_by_structured_address &src)
 165                  : command(NULL)
 166         {
 167         }
 168         command_geocode_by_structured_address &operator=(
 169                 const command_geocode_by_structured_address &src)
 170         {
 171                 return *this;
 172         }
 173 private:
 174         virtual int run();
 175 };
 176
 177 /*----------------------------------------------------------------------------*/
 178 /*typedef int (*maps_plugin_reverse_geocode_f)(maps_service_h maps,
 179 * double latitude, double longitude,
 180 * maps_service_reverse_geocode_cb callback, void *user_data,
 181 * int *request_id); */
 182 class command_reverse_geocode : public command
 183 {
 184 public:
 185         const string address;
 186         double latitude;
 187         double longitude;
 188         maps_item_hashtable_h preference;
 189         maps_service_reverse_geocode_cb callback;
 190         void *user_data;
 191         int error;
 192 public:
 193         command_reverse_geocode(maps_service_h ms,
 194                                  double latitude, double longitude,
 195                                  const maps_item_hashtable_h preference,
 196                                  maps_service_reverse_geocode_cb callback,
 197                                  void *user_data, int *request_id);
 198         virtual ~command_reverse_geocode();
 199 private:
 200         command_reverse_geocode() : command(NULL)
 201         {
 202         }
 203         command_reverse_geocode(const command_reverse_geocode &src)
 204                  : command(NULL)
 205         {
 206         }
 207         command_reverse_geocode& operator=(
 208                 const command_reverse_geocode &src)
 209         {
 210                 return *this;
 211         }
 212 private:
 213         virtual int run();
 214 };
 215
 216 class command_reverse_geocode_handler : public command_handler
 217 {
 218         maps_service_reverse_geocode_cb callback;
 219 public:
 220         command_reverse_geocode_handler(plugin::plugin_s *plugin,
 221                                          maps_service_reverse_geocode_cb callback,
 222                                          void *user_data,
 223                                          int user_req_id);
 224         virtual ~command_reverse_geocode_handler()
 225         {
 226         };
 227 private:
 228         command_reverse_geocode_handler()
 229                  : command_handler(NULL, NULL, 0)
 230         {
 231         }
 232         command_reverse_geocode_handler(
 233                 command_reverse_geocode_handler &src)
 234                  : command_handler(NULL, NULL, 0)
 235         {
 236         }
 237         command_reverse_geocode_handler &operator=(
 238                 const command_reverse_geocode_handler &src)
 239         {
 240                 return *this;
 241         }
 242 private:
 243         static void foreach_reverse_geocode_cb(maps_error_e result,
 244                                                int request_id,
 245                                                int index, int total,
 246                                                maps_address_h address,
 247                                                void *user_data);
 248         friend class command_reverse_geocode;
 249 };
 250
 251 /*----------------------------------------------------------------------------*/
 252 /*typedef int (*maps_plugin_multi_reverse_geocode_f)(maps_service_h maps,
 253 * maps_maps_h maps_list, maps_preference_h preference,
 254 * maps_service_multi_reverse_geocode_cb callback, void *user_data, * int *request_id); */
 255 class command_multi_reverse_geocode : public command
 256 {
 257 public:
 258         const string address;
 259         maps_coordinates_list_h maps_list;
 260         maps_item_hashtable_h preference;
 261         maps_service_multi_reverse_geocode_cb callback;
 262         void *user_data;
 263         int error;
 264 public:
 265         command_multi_reverse_geocode(maps_service_h ms,
 266                                  const maps_coordinates_list_h maps_list,
 267                                  const maps_item_hashtable_h preference,
 268                                  maps_service_multi_reverse_geocode_cb callback,
 269                                  void *user_data, int *request_id);
 270         virtual ~command_multi_reverse_geocode();
 271 private:
 272         command_multi_reverse_geocode() : command(NULL)
 273         {
 274         }
 275         command_multi_reverse_geocode(const command_multi_reverse_geocode &src)
 276                  : command(NULL)
 277         {
 278         }
 279         command_multi_reverse_geocode &operator=(
 280                 const command_multi_reverse_geocode &src)
 281         {
 282                 return *this;
 283         }
 284 private:
 285         virtual int run();
 286 };
 287
 288 class command_multi_reverse_geocode_handler : public command_handler
 289 {
 290         maps_service_multi_reverse_geocode_cb callback;
 291 public:
 292         command_multi_reverse_geocode_handler(plugin::plugin_s *plugin,
 293                                          maps_service_multi_reverse_geocode_cb callback,
 294                                          void *user_data,
 295                                          int user_req_id);
 296         virtual ~command_multi_reverse_geocode_handler()
 297         {
 298         };
 299 private:
 300         command_multi_reverse_geocode_handler()
 301                  : command_handler(NULL, NULL, 0)
 302         {
 303         }
 304         command_multi_reverse_geocode_handler(
 305                 command_multi_reverse_geocode_handler &src)
 306                  : command_handler(NULL, NULL, 0)
 307         {
 308         }
 309         command_multi_reverse_geocode_handler &operator=(
 310                 const command_multi_reverse_geocode_handler &src)
 311         {
 312                 return *this;
 313         }
 314 private:
 315         static bool foreach_multi_reverse_geocode_cb(maps_error_e result,
 316                                                int request_id,
 317                                                    int total,
 318                                                    maps_coordinates_list_h address_list,
 319                                                void *user_data);
 320         friend class command_multi_reverse_geocode;
 321 };
 322
 323 /*----------------------------------------------------------------------------*/
 324 /*typedef int (*maps_plugin_search_place_f)(maps_service_h maps,
 325 * maps_coordinates_h position, int distance,
 326 * maps_item_hashtable_h preference, maps_place_filter_h filter,
 327 * maps_service_search_place_cb callback, void *user_data,
 328 * int *request_id); */
 329 class command_search_place : public command
 330 {
 331 public:
 332         maps_coordinates_h position;
 333         int distance;
 334         maps_item_hashtable_h preference;
 335         maps_place_filter_h filter;
 336         maps_service_search_place_cb callback;
 337         void *user_data;
 338
 339         int error;
 340 public:
 341         command_search_place(maps_service_h ms,
 342                               const maps_coordinates_h position,
 343                               int distance,
 344                               const maps_item_hashtable_h preference,
 345                               const maps_place_filter_h filter,
 346                               maps_service_search_place_cb callback,
 347                               void *user_data, int *request_id);
 348         virtual ~command_search_place();
 349 private:
 350         command_search_place() : command(NULL)
 351         {
 352         }
 353         command_search_place(const command_search_place &src)
 354                  : command(NULL)
 355         {
 356         }
 357         command_search_place &operator=(
 358                 const command_search_place &src)
 359         {
 360                 return *this;
 361         }
 362 private:
 363         virtual int run();
 364 };
 365
 366 class command_search_place_handler : public command_handler
 367 {
 368         maps_service_search_place_cb callback;
 369 public:
 370         command_search_place_handler(plugin::plugin_s *plugin,
 371                                       maps_service_search_place_cb
 372                                       callback,
 373                                       void *user_data, int user_req_id);
 374         virtual ~command_search_place_handler()
 375         {
 376         };
 377 private:
 378         command_search_place_handler()
 379                  : command_handler(NULL, NULL, 0)
 380         {
 381         }
 382         command_search_place_handler(
 383                 const command_search_place_handler &src)
 384                  : command_handler(NULL, NULL, 0)
 385         {
 386         }
 387         command_search_place_handler &operator=(
 388                 const command_search_place_handler &src)
 389         { return *this;
 390         }
 391 private:
 392         static bool foreach_place_cb(maps_error_e error, int request_id,
 393                                      int index, int length,
 394                                      maps_place_h place,
 395                                      void *user_data);
 396         friend class command_search_place;
 397         friend class command_search_by_area_place;
 398         friend class command_search_by_address_place;
 399 };
 400
 401 /*----------------------------------------------------------------------------*/
 402 /*typedef int (*maps_plugin_search_place_by_area_f)(maps_service_h maps,
 403 * maps_area_h boundary , maps_item_hashtable_h preference,
 404 * maps_place_filter_h filter, maps_service_search_place_cb callback,
 405 * void *user_data, int *request_id); */
 406 class command_search_by_area_place : public command
 407 {
 408 public:
 409         maps_area_h boundary;
 410         maps_item_hashtable_h preference;
 411         maps_place_filter_h filter;
 412         maps_service_search_place_cb callback;
 413         void *user_data;
 414
 415         int error;
 416 public:
 417         command_search_by_area_place(maps_service_h ms,
 418                                       const maps_area_h boundary,
 419                                       const maps_item_hashtable_h preference,
 420                                       const maps_place_filter_h filter,
 421                                       maps_service_search_place_cb
 422                                       callback,
 423                                       void *user_data, int *request_id);
 424         virtual ~command_search_by_area_place();
 425 private:
 426         command_search_by_area_place() : command(NULL)
 427         {
 428         }
 429         command_search_by_area_place(
 430                 const command_search_by_area_place &src)
 431                  : command(NULL)
 432         {
 433         }
 434         command_search_by_area_place &operator=(
 435                 const command_search_by_area_place &src)
 436         {
 437                 return *this;
 438         }
 439 private:
 440         virtual int run();
 441 };
 442
 443 /*----------------------------------------------------------------------------*/
 444 /*typedef int (*maps_plugin_search_place_by_address_f)(
 445 * maps_service_h maps, const char *address, maps_area_h boundary,
 446 * maps_place_preference_h preference, maps_place_filter_h filter,
 447 * maps_service_search_place_cb callback, void *user_data,
 448 * int *request_id); */
 449 class command_search_by_address_place : public command
 450 {
 451 public:
 452         const string address;
 453         maps_area_h boundary;
 454         maps_item_hashtable_h preference;
 455         maps_place_filter_h filter;
 456         maps_service_search_place_cb callback;
 457         void *user_data;
 458
 459         int error;
 460 public:
 461         command_search_by_address_place(maps_service_h ms,
 462                 const char *address,
 463                 const maps_area_h boundary,
 464                 const maps_item_hashtable_h preference,
 465                 const maps_place_filter_h filter,
 466                 maps_service_search_place_cb callback,
 467                 void *user_data, int *request_id);
 468         virtual ~command_search_by_address_place();
 469 private:
 470         command_search_by_address_place() : command(NULL)
 471         {
 472         }
 473         command_search_by_address_place(
 474                 const command_search_by_address_place &src)
 475                  : command(NULL)
 476         {
 477         }
 478         command_search_by_address_place &operator=(
 479                 const command_search_by_address_place &src)
 480         {
 481                 return *this;
 482         }
 483 private:
 484         virtual int run();
 485 };
 486
 487 /*----------------------------------------------------------------------------*/
 488 /*typedef int (*maps_plugin_search_place_list_f)(maps_service_h maps,
 489 * maps_area_h boundary, maps_item_hashtable_h preference, maps_place_filter_h filter,
 490 * maps_service_search_place_list_cb callback, void *user_data,
 491 * int *request_id); */
 492 class command_search_place_list : public command
 493 {
 494 public:
 495         maps_area_h boundary;
 496         maps_item_hashtable_h preference;
 497         maps_place_filter_h filter;
 498         maps_service_search_place_list_cb callback;
 499         void *user_data;
 500
 501         int error;
 502 public:
 503         command_search_place_list(maps_service_h ms,
 504                                 const maps_area_h boundary,
 505                                 const maps_item_hashtable_h preference,
 506                                 const maps_place_filter_h filter,
 507                                 maps_service_search_place_list_cb callback,
 508                                 void *user_data, int *request_id);
 509         virtual ~command_search_place_list();
 510 private:
 511         command_search_place_list() : command(NULL)
 512         {
 513         }
 514         command_search_place_list(const command_search_place_list &src)
 515                  : command(NULL)
 516         {
 517         }
 518         command_search_place_list &operator=(
 519                 const command_search_place_list &src)
 520         {
 521                 return *this;
 522         }
 523 private:
 524         virtual int run();
 525 };
 526
 527 class command_search_place_list_handler : public command_handler
 528 {
 529         maps_service_search_place_list_cb callback;
 530 public:
 531         command_search_place_list_handler(plugin::plugin_s *plugin,
 532                                         maps_service_search_place_list_cb callback,
 533                                         void *user_data, int user_req_id);
 534         virtual ~command_search_place_list_handler()
 535         {
 536         };
 537 private:
 538         command_search_place_list_handler()
 539                  : command_handler(NULL, NULL, 0)
 540         {
 541         }
 542         command_search_place_list_handler(const command_search_place_list_handler &src)
 543                  : command_handler(NULL, NULL, 0)
 544         {
 545         }
 546         command_search_place_list_handler &operator=(const command_search_place_list_handler &src)
 547         { return *this;
 548         }
 549 private:
 550         static void foreach_place_list_cb(maps_error_e error, int request_id,
 551                                         int total, maps_place_list_h place, void *user_data);
 552         friend class command_search_place_list;
 553 };
 554
 555 /*----------------------------------------------------------------------------*/
 556 /*typedef int (*maps_plugin_get_place_details_f) */
 557 class command_get_place_details : public command
 558 {
 559 public:
 560         const string url;
 561         maps_service_get_place_details_cb callback;
 562         void *user_data;
 563
 564         int error;
 565 public:
 566          command_get_place_details(maps_service_h ms, const char *url,
 567                 maps_service_get_place_details_cb callback, void *user_data, int *request_id);
 568          virtual ~command_get_place_details();
 569 private:
 570         command_get_place_details() : command(NULL)
 571         {
 572         }
 573         command_get_place_details(const command_get_place_details &src)
 574                  : command(NULL)
 575         {
 576         }
 577         command_get_place_details &operator=(const command_get_place_details &src)
 578         {
 579                 return *this;
 580         }
 581 private:
 582         virtual int run();
 583 };
 584
 585 class command_get_place_details_handler : public command_handler
 586 {
 587         maps_service_get_place_details_cb callback;
 588 public:
 589         command_get_place_details_handler(plugin::plugin_s *plugin,
 590                                                 maps_service_get_place_details_cb callback,
 591                                                 void *user_data, int user_req_id);
 592         virtual ~command_get_place_details_handler()
 593         {
 594         };
 595 private:
 596         command_get_place_details_handler()
 597                  : command_handler(NULL, NULL, 0)
 598         {
 599         }
 600         command_get_place_details_handler(const command_get_place_details_handler &src)
 601                  : command_handler(NULL, NULL, 0)
 602         {
 603         }
 604         command_get_place_details_handler &operator=(const command_get_place_details_handler &src)
 605         { return *this;
 606         }
 607 private:
 608         static void foreach_place_details_cb(maps_error_e error, int request_id,
 609                                                 maps_place_h place, void *user_data);
 610         friend class command_get_place_details;
 611 };
 612
 613 /*----------------------------------------------------------------------------*/
 614 /*typedef int (*maps_plugin_search_route_f)(
 615 * maps_service_h maps, maps_item_hashtable_h preference,
 616 * maps_coordinates_h origin, maps_coordinates_h destination,
 617 * maps_service_search_route_cb callback, void *user_data,
 618 * int *request_id); */
 619 class command_search_route_handler : public command_handler
 620 {
 621         maps_service_search_route_cb callback;
 622 public:
 623         command_search_route_handler(plugin::plugin_s *plugin,
 624                                       maps_service_search_route_cb
 625                                       callback,
 626                                       void *user_data, int user_req_id);
 627         virtual ~command_search_route_handler()
 628         {
 629         };
 630 private:
 631         command_search_route_handler()
 632                  : command_handler(NULL, NULL, 0)
 633         {
 634         }
 635         command_search_route_handler(
 636                 const command_search_route_handler &src)
 637                  : command_handler(NULL, NULL, 0)
 638         {
 639         }
 640         command_search_route_handler &operator=(
 641                 const command_search_route_handler &src)
 642         {
 643                 return *this;
 644         }
 645 private:
 646         static bool foreach_route_cb(maps_error_e error, int request_id,
 647                                      int index, int length,
 648                                      maps_route_h route,
 649                                      void *user_data);
 650         friend class command_search_route;
 651         friend class command_search_route_waypoints;
 652 };
 653
 654 class command_search_route : public command
 655 {
 656 public:
 657         maps_item_hashtable_h preference;
 658         maps_coordinates_h origin;
 659         maps_coordinates_h destination;
 660         maps_service_search_route_cb callback;
 661         void *user_data;
 662
 663         int error;
 664 public:
 665         command_search_route(maps_service_h ms,
 666                               const maps_item_hashtable_h preference,
 667                               const maps_coordinates_h origin,
 668                               const maps_coordinates_h destination,
 669                               maps_service_search_route_cb callback,
 670                               void *user_data, int *request_id);
 671         virtual ~command_search_route();
 672 private:
 673         command_search_route() : command(NULL)
 674         {
 675         }
 676         command_search_route(const command_search_route &src)
 677                  : command(NULL)
 678         {
 679         }
 680         command_search_route &operator=(const command_search_route &src)
 681         {
 682                 return *this;
 683         }
 684 private:
 685         virtual int run();
 686 };
 687
 688 /*----------------------------------------------------------------------------*/
 689 /*typedef int (*maps_plugin_search_route_f)(maps_service_h maps,
 690 * maps_item_hashtable_h preference, maps_coordinates_h *waypoint_list,
 691 * int waypoint_num, maps_service_search_route_cb callback,
 692 * void *user_data, int *request_id); */
 693 class command_search_route_waypoints:public command
 694 {
 695 public:
 696         maps_item_hashtable_h preference;
 697         maps_coordinates_h *waypoint_list;
 698         int waypoint_num;
 699         maps_service_search_route_cb callback;
 700         void *user_data;
 701
 702         int error;
 703 public:
 704         command_search_route_waypoints(maps_service_h ms,
 705                                 const maps_item_hashtable_h preference,
 706                                 const maps_coordinates_h *waypoint_list,
 707                                 int waypoint_num,
 708                                 maps_service_search_route_cb callback,
 709                                 void *user_data, int *request_id);
 710         virtual ~command_search_route_waypoints();
 711 private:
 712         command_search_route_waypoints() : command(NULL)
 713         {
 714         }
 715         command_search_route_waypoints(const command_search_route_waypoints &src)
 716                  : command(NULL)
 717         {
 718         }
 719         command_search_route_waypoints &operator=(const command_search_route_waypoints &src)
 720         {
 721                 return *this;
 722         }
 723 private:
 724         virtual int run();
 725 };
 726
 727 /*----------------------------------------------------------------------------*/
 728 /*typedef int (*maps_plugin_cancel_request_f)(maps_service_h maps,
 729 * int request_id); */
 730 class command_cancel_request : public command
 731 {
 732 public:
 733         int request_id;
 734 public:
 735         command_cancel_request(maps_service_h ms, int rid)
 736          : command(ms),
 737                 request_id(rid)
 738         {
 739         }
 740         virtual ~command_cancel_request()
 741         {
 742         };
 743 private:
 744         command_cancel_request() : command(NULL)
 745         {
 746         }
 747         command_cancel_request(const command_cancel_request &src)
 748                 : command(NULL)
 749         {
 750         }
 751         command_cancel_request &operator=(const command_cancel_request &src)
 752         {
 753                 return *this;
 754         }
 755 private:
 756         virtual int run();
 757 };
 758
 759
 760 /*----------------------------------------------------------------------------*/
 761 /*
 762  *              Mapping API commands
 763  */
 764 /*----------------------------------------------------------------------------*/
 765
 766 class command_view_set_center : public command {
 767 private:
 768         maps_view_h v;
 769 public:
 770         maps_coordinates_h c;
 771 public:
 772         command_view_set_center(maps_service_h ms, maps_view_h view,
 773                                 const maps_coordinates_h coords);
 774         virtual ~command_view_set_center();
 775 private:
 776         virtual int run();
 777 private:
 778         virtual command_type_e get_type() const;
 779         virtual int get_priority() const;
 780         virtual void merge(const command *c);
 781 };
 782
 783 class command_view_move_center : public command {
 784 private:
 785         maps_view_h v;
 786 public:
 787         int _delta_x;
 788         int _delta_y;
 789 public:
 790         command_view_move_center(maps_service_h ms, maps_view_h view,
 791                                  const int delta_x, const int delta_y);
 792         virtual ~command_view_move_center();
 793 private:
 794         virtual int run();
 795 private:
 796         virtual command_type_e get_type() const;
 797         virtual int get_priority() const;
 798         virtual void merge(const command *c);
 799 };
 800
 801 class command_view_zoom : public command {
 802 private:
 803         maps_view_h v;
 804 public:
 805         double zoom_factor;
 806 public:
 807         command_view_zoom(maps_service_h ms, maps_view_h view,
 808                           const double  &factor) :
 809                 command(ms), v(view), zoom_factor(factor)
 810         {
 811         }
 812         virtual ~command_view_zoom()
 813         {
 814         }
 815 private:
 816         virtual int run();
 817 private:
 818         virtual command_type_e get_type() const;
 819         virtual int get_priority() const;
 820         virtual void merge(const command *c);
 821 };
 822
 823 class command_view_rotate : public command {
 824 private:
 825         maps_view_h v;
 826 public:
 827         double rotation_angle;
 828 public:
 829         command_view_rotate(maps_service_h ms, maps_view_h view,
 830                             const double  &angle) :
 831                 command(ms), v(view), rotation_angle(angle)
 832         {
 833         }
 834         virtual ~command_view_rotate()
 835         {
 836         }
 837 private:
 838         virtual int run();
 839 private:
 840         virtual command_type_e get_type() const;
 841         virtual int get_priority() const;
 842         virtual void merge(const command *c);
 843 };
 844
 845 class command_view_zoom_rotate : public command {
 846 private:
 847         maps_view_h v;
 848 public:
 849         double zoom_factor;
 850         double rotation_angle;
 851 public:
 852         command_view_zoom_rotate(maps_service_h ms, maps_view_h view,
 853                                  const double  &factor,
 854                                  const double  &angle)
 855                 : command(ms)
 856                   , v(view)
 857                   , zoom_factor(factor)
 858                   , rotation_angle(angle)
 859         {
 860         }
 861         virtual ~command_view_zoom_rotate()
 862         {
 863         }
 864 private:
 865         virtual int run();
 866 private:
 867         virtual command_type_e get_type() const;
 868         virtual int get_priority() const;
 869         virtual void merge(const command *c);
 870 };
 871 //LCOV_EXCL_STOP
 872
 873 }
 874
 875 #endif                          /* __MAPS_SERVICE_SESSION_COMMANDS_H__ */