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