view.h

Go to the documentation of this file.

/* 
 * Copyright (c) 2008, 2014, Oracle and/or its affiliates. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; version 2 of the
 * License.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301  USA
 */

#ifndef _MFORMS_VIEW_H_
#define _MFORMS_VIEW_H_

#include <boost/signals2.hpp>

#include "mforms/base.h"
#include "mforms/utilities.h"

#include "base/geometry.h"
#include "base/trackable.h"
#include "base/drawing.h"

namespace mforms {

  // Predefined drag formats used during a drag session. Custom definitions are possible too.
  const std::string DragFormatText = "com.mysql.workbench.text"; // UTF-8 encoded text.
  const std::string DragFormatFileName = "com.mysql.workbench.file"; // A plain file name (UTF-8 encoded).

  class View;

  enum Alignment
  {
    NoAlign,
    BottomLeft,
    BottomCenter,
    BottomRight,
    MiddleLeft,
    MiddleCenter,
    MiddleRight,
    TopLeft,
    TopCenter,
    TopRight,
    
    //
    WizardLabelAlignment
  };
  
  struct TextAttributes
  {
#ifndef SWIG
    bool bold;
    bool italic;
    base::Color color;
    TextAttributes() : bold(false), italic(false), color(base::Color::Invalid()) {}
#endif
    TextAttributes(const std::string &c, bool b, bool i) : bold(b), italic(i), color(base::Color::parse(c)) {}
  };

  // Mouse button indicators for mouse handling routines.
  enum MouseButton {
    MouseButtonLeft = 0,
    MouseButtonRight = 1,
    MouseButtonOther = 2,
    
    MouseButtonNone = 0x80, // Sometimes the values for the mouse buttons are hard coded, so better use a high value for this.
                            // TODO: identify hard coded values and replace them.
  };

  enum DragOperation {
    DragOperationNone = 0,
    DragOperationCopy = 1 << 0,
    DragOperationMove = 1 << 1
  };

  struct DragDetails {
    base::Point location; // Position of the mouse in client coordinates.
    DragOperation allowedOperations; // A combination of flags that determine the allowed actions.

    cairo_surface_t *image;          // The drag image to show (owned by the initiator of the operation.
                                     // This must be an image surface in ARGB32 format.
                                     // When doing text dragging this image can be NULL in which case
                                     // the platforms generate a drag image from the given text.
    base::Point hotspot;             // The position of the mouse within the drag image.

    DragDetails()
    {
      location = base::Point();
      allowedOperations = DragOperationNone;
      image = NULL;
      hotspot = base::Point();
    }
  };

#ifndef SWIG

  class MFORMS_EXPORT DropDelegate
  {
  public:
    virtual DragOperation drag_over(View *sender, base::Point p, const std::vector<std::string> &formats) = 0;

    virtual DragOperation files_dropped(View *sender, base::Point p, const std::vector<std::string> &file_names) { return DragOperationNone; };

    virtual DragOperation text_dropped(View *sender, base::Point p, const std::string &text) { return DragOperationNone; };

    virtual DragOperation data_dropped(View *sender, base::Point p, void *data, const std::string &format) { return DragOperationNone; };

  };
#endif

#ifndef DOXYGEN_SHOULD_SKIP_THIS
#ifndef SWIG
  struct ViewImplPtrs
  {
    void (*destroy)(View *self);

    int (*get_width)(View *self);
    int (*get_height)(View *self);
    int (*get_preferred_width)(View *self);
    int (*get_preferred_height)(View *self);
    void (*set_size)(View *self, int, int);
    void (*set_padding)(View *self, int, int, int, int); // left, top, right, bottom

    int (*get_x)(View *self);
    int (*get_y)(View *self);
    void (*set_position)(View *self, int, int);
    std::pair<int, int> (*client_to_screen)(View *self, int, int);
    std::pair<int, int> (*screen_to_client)(View *self, int, int);

    void (*show)(View *self, bool);
    bool (*is_shown)(View *self);
    bool (*is_fully_visible)(View *self);
    
    void (*set_tooltip)(View *self, const std::string&);
    void (*set_name)(View *self, const std::string&);
    void (*set_font)(View *self, const std::string&);
    
    void (*set_enabled)(View *self, bool);
    bool (*is_enabled)(View *self);
    void (*relayout)(View *self);
    void (*set_needs_repaint)(View *self);

    void (*suspend_layout)(View *self, bool);
    void (*set_front_color)(View *self, const std::string&);
    std::string (*get_front_color)(View *self);
    void (*set_back_color)(View *self, const std::string&);
    std::string (*get_back_color)(View *self);
    // for containers only
    void (*set_back_image)(View *self, const std::string&, Alignment alignment);

    void (*flush_events)(View *self);
    void (*focus)(View *self);

    void (*register_drop_formats)(View *self, DropDelegate *target, const std::vector<std::string>&);
    DragOperation (*drag_text)(View *self, DragDetails details, const std::string &text);
    DragOperation (*drag_data)(View *self, DragDetails details, void *data,
                                         const std::string &format);
  };
#endif
#endif
  
  class Form;

  class MFORMS_EXPORT View : public Object, public base::trackable
  {
    friend class ControlFactory;
    
  private:
    std::string _name;
    bool _layout_dirty;
    
    boost::signals2::signal<void ()> _signal_resized;

  protected:
    View();

    ViewImplPtrs *_view_impl;
    View *_parent;
    std::vector<std::pair<View*, bool> > _subviews;

    void cache_view(View *sv);
    virtual void remove_from_cache(View *sv);
    int get_subview_index(View *sv);
    View *get_subview_at_index(int index);
    
    // This works only for containers so is made public in the Container subclass
    virtual void set_back_image(const std::string& path, Alignment alignment);
  public:
    virtual ~View();
    
    virtual void set_managed();
    
    View *find_subview(const std::string &name);
    bool contains_subview(View* subview);
    void clear_subviews();
    
    void set_name(const std::string &name);
    void set_tooltip(const std::string &text);
    void set_font(const std::string &fontDescription); // e.g. "Trebuchet MS bold 9"
    std::string get_name();
    void set_parent(View *parent);
    View *get_parent() const;
    Form *get_parent_form() const;
    virtual int get_width();
    virtual int get_height();
    virtual int get_preferred_width();
    virtual int get_preferred_height();
    virtual int get_x();
    virtual int get_y();
    virtual void set_position(int x, int y);
    virtual void set_size(int width, int height);

    std::pair<int, int>client_to_screen(int x, int y);
    std::pair<int, int>screen_to_client(int x, int y);

    void show(bool flag= true);

    bool is_shown();

    bool is_fully_visible();

    void set_enabled(bool flag);

    bool is_enabled();

    void set_needs_repaint();

    virtual void relayout();
    virtual void set_layout_dirty(bool value);
    virtual bool is_layout_dirty();
    
    void suspend_layout();

    void resume_layout();

    void set_front_color(const std::string& color);

    std::string get_front_color();

    void set_back_color(const std::string& color);

    std::string get_back_color();
    

    //Below code is used only for debug purpose.
    //It's using the object::retain_count.
#ifdef _0
    void show_retain_counts(int depth=0);
#endif

    virtual std::string get_string_value() { return ""; }

    virtual int get_int_value() { return 0; }

    virtual bool get_bool_value() { return false; }

    virtual void flush_events();

    virtual void focus();

#ifndef SWIG

    void register_drop_formats(DropDelegate *target, const std::vector<std::string> &drop_formats);
    
    DragOperation do_drag_drop(DragDetails details, const std::string &text);
    DragOperation do_drag_drop(DragDetails details, void *data, const std::string &format);
#endif

#ifndef DOXYGEN_SHOULD_SKIP_THIS
#ifndef SWIG
    // Events called by the platform code. Returns a bool value to indicate if the event was handled.
    // False means the platform should do whatever it needs with that event.
    // Note: these functions are only called if the platform control supports this type of mouse handling.
    //       Examples are: all containers (Panel, ScrollPanel, Box, Table) and DrawBox.
    virtual bool mouse_down(MouseButton button, int x, int y) { return false; }
    virtual bool mouse_up(MouseButton button, int x, int y) { return false; }
    virtual bool mouse_click(MouseButton button, int x, int y) { return false; }
    virtual bool mouse_double_click(MouseButton button, int x, int y) { return false; }
    virtual bool mouse_enter() { return false; }
    virtual bool mouse_leave() { return false; }
    virtual bool mouse_move(MouseButton button, int x, int y) { return false; }
#endif
#endif

    void focus_changed();

    virtual void resize();

    boost::signals2::signal<void ()>* signal_resized() { return &_signal_resized; }
  };
};

#endif