C++ graph_reference类代码示例

 void trigger::_m_draw_box(graph_reference graph)
 {
     rectangle r{ graph.size() };
     graph.gradual_rectangle(r, colors::button_face_shadow_end, colors::button_face_shadow_start, true);
     ::nana::color lt{ colors::gray }, rb{colors::white};
     graph.frame_rectangle(r, lt, lt, rb, rb);
 }

		void drawer::attached(graph_reference graph)
		{
			window wd = widget_->handle();

			editor_ = new text_editor(wd, graph);
			editor_->textbase().bind_ext_evtbase(extra_evtbase);
			editor_->border_renderer(nana::make_fun(*this, &drawer::_m_draw_border));

			_m_text_area(graph.width(), graph.height());

			using namespace API::dev;
			make_drawer_event<events::focus>(wd);
			make_drawer_event<events::key_char>(wd);
			make_drawer_event<events::key_down>(wd);
			make_drawer_event<events::mouse_down>(wd);
			make_drawer_event<events::mouse_up>(wd);
			make_drawer_event<events::mouse_move>(wd);
			make_drawer_event<events::mouse_wheel>(wd);
			make_drawer_event<events::mouse_enter>(wd);
			make_drawer_event<events::mouse_leave>(wd);

			API::tabstop(wd);
			API::eat_tabstop(wd, true);
			API::effects_edge_nimbus(wd, effects::edge_nimbus::active);
			API::effects_edge_nimbus(wd, effects::edge_nimbus::over);
		}

		void solid_triangle(graph_reference graph, int x, int y, nana::color_t color, uint32_t dir)
		{
			x += 3;
			y += 3;
			switch(dir)
			{
			case directions::to_east:
				for(int i = 0; i < 5; ++i)
					graph.line(x + 3 + i, y + 1 + i, x + 3 + i, y + 9 - i, color);
				break;
			case directions::to_southeast:
				for(int i = 0; i < 6; ++i)
					graph.line(x + 2 + i, y + 7 - i, x + 7, y + 7 - i, color);
				break;
			case directions::to_south:
				y += 3;
				for(int i = 0; i < 5; ++i)
					graph.line(x + i, y + i, x + 8 - i, y + i, color);
				break;
			case directions::to_west:
				x += 5;
				y += 1;
				for(int i = 0; i < 5; ++i)
					graph.line(x - i, y + i, x - i, y + 8 - i, color);
				break;
			case directions::to_north:
				y += 7;
				for(int i = 0; i < 5; ++i)
					graph.line(x + i, y - i, x + 8 - i, y - i, color);
				break;
			}		
		}

            void drawer::scroll_delta_pos(graph_reference graph, int mouse_pos)
            {
                if(mouse_pos + metrics_.scroll_mouse_offset == metrics_.scroll_pos) return;

                unsigned scale = vertical_ ? graph.height() : graph.width();

                if(scale > fixedsize * 2)
                {
                    int pos = mouse_pos - metrics_.scroll_mouse_offset;
                    const unsigned scroll_area = static_cast<unsigned>(scale - fixedsize * 2 - metrics_.scroll_length);

                    if(pos < 0)
                        pos = 0;
                    else if(pos > static_cast<int>(scroll_area))
                        pos = static_cast<int>(scroll_area);

                    metrics_.scroll_pos = pos;
                    auto value_max = metrics_.peak - metrics_.range;

                    //Check scroll_area to avoiding division by zero.
                    if (scroll_area)
                        metrics_.value = pos * value_max / scroll_area;

                    if(metrics_.value < value_max)
                    {
                        int selfpos = static_cast<int>(metrics_.value * scroll_area / value_max);
                        int nextpos = static_cast<int>((metrics_.value + 1) * scroll_area / value_max);

                        if(selfpos != nextpos && (pos - selfpos > nextpos - pos))
                            ++metrics_.value;
                    }
                    else
                        metrics_.value = value_max;
                }
            }

            void drawer::_m_adjust_scroll(graph_reference graph)
            {
                if(metrics_.range == 0 || metrics_.peak <= metrics_.range) return;

                unsigned pixels = vertical_ ? graph.height() : graph.width();

                int pos = 0;
                unsigned len = 0;

                if(pixels > fixedsize * 2)
                {
                    pixels -= (fixedsize * 2);
                    len = static_cast<unsigned>(pixels * metrics_.range / metrics_.peak);
                    
                    if(len < fixedsize)
                        len = fixedsize;

                    if(metrics_.value)
                    {
                        pos = static_cast<int>(pixels - len);
                        if(metrics_.value + metrics_.range >= metrics_.peak)
                            metrics_.value = metrics_.peak - metrics_.range;
                        else
                            pos = static_cast<int>((metrics_.value * pos) /(metrics_.peak - metrics_.range));
                    }
                }

                metrics_.scroll_pos = pos;
                metrics_.scroll_length = len;
            }

            buttons drawer::what(graph_reference graph, const point& screen_pos)
            {
                unsigned scale;
                int pos;

                if(vertical_)
                {
                    scale = graph.height();
                    pos = screen_pos.y;
                }
                else
                {
                    scale = graph.width();
                    pos = screen_pos.x;
                }

                const auto bound_pos = static_cast<int>(scale >= fixedsize * 2 ? fixedsize : scale / 2);
                if (pos < bound_pos)
                    return buttons::first;
                if (pos > static_cast<int>(scale) - bound_pos)
                    return buttons::second;

                if(metrics_.scroll_length)
                {
                    if(metrics_.scroll_pos + static_cast<int>(fixedsize) <= pos && pos < metrics_.scroll_pos + static_cast<int>(fixedsize + metrics_.scroll_length))
                        return buttons::scroll;
                }

                if(static_cast<int>(fixedsize) <= pos && pos < metrics_.scroll_pos)
                    return buttons::forward;
                else if(metrics_.scroll_pos + static_cast<int>(metrics_.scroll_length) <= pos && pos < static_cast<int>(scale - fixedsize))
                    return buttons::backward;

                return buttons::none;
            }

            void drawer::_m_button_frame(graph_reference graph, rectangle r, int state)
            {
                if (!state)
                    return;
                
                ::nana::color clr{0x97, 0x97, 0x97}; //highlight
                switch(state)
                {
                case states::actived:
                    clr.from_rgb(0x86, 0xD5, 0xFD); break;
                case states::selected:
                    clr.from_rgb(0x3C, 0x7F, 0xB1); break;
                }
                
                graph.rectangle(r, false, clr);

                clr = clr.blend(colors::white, 0.5);
                graph.palette(false, clr);

                r.pare_off(2);
                if(vertical_)
                {
                    unsigned half = r.width / 2;
                    graph.rectangle({ r.x + static_cast<int>(r.width - half), r.y, half, r.height }, true);
                    r.width -= half;
                }
                else
                {
                    unsigned half = r.height / 2;
                    graph.rectangle({r.x, r.y + static_cast<int>(r.height - half), r.width, half}, true);
                    r.height -= half;
                }
                graph.gradual_rectangle(r, colors::white, clr, !vertical_);
            }

        //private:
            void drawer::_m_background(graph_reference graph)
            {
                graph.rectangle(true, {0xf0, 0xf0, 0xf0});

                if (!metrics_.pressed || !_m_check())
                    return;
                
                nana::rectangle_rotator r(vertical_, ::nana::rectangle{ graph.size() });
                if(metrics_.what == buttons::forward)
                {
                    r.x_ref() = static_cast<int>(fixedsize);
                    r.w_ref() = metrics_.scroll_pos;
                }
                else if(buttons::backward == metrics_.what)
                {
                    r.x_ref() = static_cast<int>(fixedsize + metrics_.scroll_pos + metrics_.scroll_length);
                    r.w_ref() = static_cast<unsigned>((vertical_ ? graph.height() : graph.width()) - (fixedsize * 2 + metrics_.scroll_pos + metrics_.scroll_length));
                }
                else
                    return;

                auto result = r.result();
                if (!result.empty())
                    graph.rectangle(result, true, static_cast<color_rgb>(0xDCDCDC));
            }

			void image_ico::paste(const nana::rectangle& src_r, graph_reference graph, int x, int y) const
			{
				if(ptr_ && (graph.empty() == false))
				{
#if defined(NANA_WINDOWS)
					::DrawIconEx(graph.handle()->context, x, y, *ptr_, src_r.width, src_r.height, 0, 0, DI_NORMAL);
#endif
				}
			}

			void image_ico::stretch(const nana::rectangle&, graph_reference graph, const nana::rectangle& r) const
			{
				if(ptr_ && (graph.empty() == false))
				{
#if defined(NANA_WINDOWS)
					::DrawIconEx(graph.handle()->context, r.x, r.y, *ptr_, r.width, r.height, 0, 0, DI_NORMAL);
#endif
				}
			}

		void drawer::_m_draw_border(graph_reference graph, nana::color_t bgcolor)
		{
			if (!API::widget_borderless(widget_->handle()))
			{
				nana::rectangle r(graph.size());
				graph.rectangle(r, (status_.has_focus ? 0x0595E2 : 0x999A9E), false);
				graph.rectangle(r.pare_off(1), bgcolor, false);
			}
		}

		void drawer::_m_draw_border(graph_reference graph)
		{
			if(status_.border)
			{
				nana::rectangle r(graph.size());
				graph.rectangle(r, (status_.has_focus ? 0x0595E2 : 0x999A9E), false);
				r.pare_off(1);
				graph.rectangle(r, 0xFFFFFF, false);
			}
		}

            void drawer::draw(graph_reference graph, buttons what)
            {
                if(false == metrics_.pressed || metrics_.what != buttons::scroll)
                    _m_adjust_scroll(graph);

                _m_background(graph);

                rectangle_rotator r(vertical_, ::nana::rectangle{ graph.size() });
                r.x_ref() = static_cast<int>(r.w() - fixedsize);
                r.w_ref() = fixedsize;

                int state = ((_m_check() == false || what == buttons::none) ? states::none : states::highlight);
                int moused_state = (_m_check() ? (metrics_.pressed ? states::selected : states::actived) : states::none);

                auto result = r.result();

                //draw first
                _m_draw_button(graph, { 0, 0, result.width, result.height }, buttons::first, (buttons::first == what ? moused_state : state));

                //draw second
                _m_draw_button(graph, result, buttons::second, (buttons::second == what ? moused_state : state));

                //draw scroll
                _m_draw_scroll(graph, (buttons::scroll == what ? moused_state : states::highlight));
                
            }

		void trigger::_m_draw_border(graph_reference graph)
		{
			nana::rectangle r(graph.size());

			::nana::color lt(static_cast<color_rgb>(0x7f7f7f)), rb(static_cast<color_rgb>(0x707070));
			graph.frame_rectangle(r, lt, lt, rb, rb);

			graph.set_color(colors::button_face);
			draw_corner_point(graph, r);

			graph.set_color(static_cast<color_rgb>(0x919191));
			draw_corner_point(graph, r.pare_off(1));

			if (element_state::pressed == attr_.e_state)
				graph.rectangle(r, false, static_cast<color_rgb>(0xc3c3c3));
		}

            void trigger::refresh(graph_reference graph)
            {
                if (false == unknown_)
                    draw_width_ = static_cast<unsigned>((graph.width() - border * 2) * (double(value_) / max_));

                _m_draw_box(graph);
                _m_draw_progress(graph);
            }