/*******************************************************************************
* Copyright (c) Emil Crumhorn - Hexapixel.com - emil.crumhorn@gmail.com
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* emil.crumhorn@gmail.com - initial API and implementation
*******************************************************************************/
package com.hexapixel.widgets.ribbon;
import java.util.List;
import java.util.StringTokenizer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Pattern;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import com.hexapixel.widgets.generic.ColorCache;
/**
* This class deals with all painting of buttons, depending on their size, their state and various decorations - such as
* split-over-two-lines text, arrows in different places (depending on split text and size of buttons - again) and so on.
*
* There are a ton of colors created in this class.
*
* Methods are split up for convenience so that it's possible to draw half a button in one style and the rest in another, which is necessary.
* There are of course convenience methods that call the rest of the methods in order depending on need, such as the drawButton(...) method.
*
* @author Emil
*
*/
public class AbstractButtonPaintManager {
public static final int SPLIT_NOT_SPLIT = 0;
public static final int SPLIT_TOP_ACTIVE = 1;
public static final int SPLIT_TOP_NOT_ACTIVE = 2;
public static final int SPLIT_BOTTOM_ACTIVE = 3;
public static final int SPLIT_BOTTOM_NOT_ACTIVE = 4;
public static final int SPLIT_LEFT_ACTIVE = SPLIT_TOP_ACTIVE;
public static final int SPLIT_LEFT_NOT_ACTIVE = SPLIT_TOP_NOT_ACTIVE;
public static final int SPLIT_RIGHT_ACTIVE = SPLIT_BOTTOM_ACTIVE;
public static final int SPLIT_RIGHT_NOT_ACTIVE = SPLIT_BOTTOM_NOT_ACTIVE;
// corners (not buttons)
public static final int TOP_LEFT = 1;
public static final int TOP_RIGHT = 2;
public static final int BOTTOM_LEFT = 3;
public static final int BOTTOM_RIGHT = 4;
// button type
public static final int TYPE_BUTTON_BIG = 1;
public static final int TYPE_BUTTON_SMALL = 2;
public static final int TYPE_BUTTON_BIG_SPLIT = 3;
public static final int TYPE_BUTTON_SMALL_SPLIT = 4;
// button state
public static final int STATE_NONE = 0;
public static final int STATE_HOVER = 1;
public static final int STATE_SELECTED = 2;
public static final int STATE_HOVER_AND_SELECTED = 3;
// button size
public static final int BUTTON_BIG = 1;
public static final int BUTTON_SMALL = 2;
// OUTER BORDERS HOVER
// top border outer
private Color mButtonOuterTop_Hover = ColorCache.getInstance().getColor(221, 207, 155);
// side borders outer
private Color mButtonOuterSideTopTop_Hover = ColorCache.getInstance().getColor(220, 206, 154);
private Color mButtonOuterSideTopBottom_Hover = ColorCache.getInstance().getColor(197, 174, 125);
private Color mButtonOuterSideBottomTop_Hover = ColorCache.getInstance().getColor(196, 173, 124);
private Color mButtonOuterSideBottomBottom_Hover = ColorCache.getInstance().getColor(211, 206, 185);
// top corner pixel on the inside of the corner
private Color mButtonTopCornerPixel_Hover = ColorCache.getInstance().getColor(233, 223, 159);
// bottom one, same deal
private Color mButtonBottomCornerPixel_Hover = ColorCache.getInstance().getColor(233, 219, 177);
// bottom border outer
private Color mButtonOuterBottomLeft_Hover = ColorCache.getInstance().getColor(209, 202, 173);
private Color mButtonOuterBottomMiddle_Hover = mButtonOuterBottomLeft_Hover;
private Color mButtonOuterBottomRight_Hover = mButtonOuterBottomLeft_Hover;
// OUTER BORDERS HOVER - SMALL
// top border outer
private Color mButtonSmallOuterTop_Hover = ColorCache.getInstance().getColor(219, 206, 153);
// side borders outer
private Color mButtonSmallOuterSideTopTop_Hover = ColorCache.getInstance().getColor(216, 202, 150);
private Color mButtonSmallOuterSideTopBottom_Hover = ColorCache.getInstance().getColor(185, 160, 116);
private Color mButtonSmallOuterSideBottomTop_Hover = ColorCache.getInstance().getColor(183, 158, 115);
private Color mButtonSmallOuterSideBottomBottom_Hover = ColorCache.getInstance().getColor(184, 169, 142);
// top corner pixel on the inside of the corner
private Color mButtonSmallTopCornerPixel_Hover = ColorCache.getInstance().getColor(233, 223, 159);
// bottom one, same deal
private Color mButtonSmallBottomCornerPixel_Hover = ColorCache.getInstance().getColor(233, 219, 177);
// bottom border outer
private Color mButtonSmallOuterBottomLeft_Hover = ColorCache.getInstance().getColor(187, 174, 151);
private Color mButtonSmallOuterBottomMiddle_Hover = ColorCache.getInstance().getColor(203, 195, 170);
private Color mButtonSmallOuterBottomRight_Hover = mButtonSmallOuterBottomLeft_Hover;
// OUTER BORDERS SELECTED
// top border outer
private Color mButtonOuterTop_Selected = ColorCache.getInstance().getColor(142, 129, 101);
// side borders outer
private Color mButtonOuterSideTopTop_Selected = mButtonOuterTop_Selected;
private Color mButtonOuterSideTopBottom_Selected = mButtonOuterTop_Selected;
private Color mButtonOuterSideBottomTop_Selected = mButtonOuterTop_Selected;
private Color mButtonOuterSideBottomBottom_Selected = ColorCache.getInstance().getColor(198, 192, 178);
// top corner pixel on the inside of the corner
private Color mButtonTopCornerPixel_Selected = ColorCache.getInstance().getColor(181, 167, 145);
// bottom one, same deal, 1px further in than hover
private Color mButtonBottomCornerPixel_Selected = ColorCache.getInstance().getColor(254, 216, 93);
// bottom border outer
private Color mButtonOuterBottomLeft_Selected = ColorCache.getInstance().getColor(255, 207, 45);
private Color mButtonOuterBottomMiddle_Selected = ColorCache.getInstance().getColor(255, 233, 160);
private Color mButtonOuterBottomRight_Selected = mButtonOuterBottomLeft_Selected;
// very bottom pixel on outer sides
private Color mButtonOuterBottomPixel_Selected = ColorCache.getInstance().getColor(247, 229, 168);
// OUTER BORDERS SELECTED - SMALL
// top border outer
private Color mButtonSmallOuterTop_Selected = ColorCache.getInstance().getColor(167, 142, 102);
// side borders outer
private Color mButtonSmallOuterSideTopTop_Selected = ColorCache.getInstance().getColor(168, 130, 85);
private Color mButtonSmallOuterSideTopBottom_Selected = mButtonSmallOuterSideTopTop_Selected;
private Color mButtonSmallOuterSideBottomTop_Selected = mButtonSmallOuterSideTopTop_Selected;
private Color mButtonSmallOuterSideBottomBottom_Selected = mButtonSmallOuterSideTopTop_Selected;
// top corner pixel on the inside of the corner
private Color mButtonSmallTopCornerPixel_Selected = ColorCache.getInstance().getColor(178, 154, 120);
// bottom one, same deal
private Color mButtonSmallBottomCornerPixel_Selected = ColorCache.getInstance().getColor(200, 163, 104);
// bottom border outer
private Color mButtonSmallOuterBottomLeft_Selected = ColorCache.getInstance().getColor(187, 174, 151);
private Color mButtonSmallOuterBottomMiddle_Selected = ColorCache.getInstance().getColor(204, 196, 172);
private Color mButtonSmallOuterBottomRight_Selected = mButtonSmallOuterBottomLeft_Selected;
// very bottom pixel on outer sides
private Color mButtonSmallOuterBottomPixel_Selected = mButtonSmallOuterSideTopTop_Selected;
// OUTER BORDERS HOVER + SELECTED
// top border outer
private Color mButtonOuterTop_HoverSelected = ColorCache.getInstance().getColor(142, 129, 101);
// side borders outer
private Color mButtonOuterSideTopTop_HoverSelected = mButtonOuterTop_HoverSelected;
private Color mButtonOuterSideTopBottom_HoverSelected = mButtonOuterTop_HoverSelected;
private Color mButtonOuterSideBottomTop_HoverSelected = mButtonOuterTop_HoverSelected;
private Color mButtonOuterSideBottomBottom_HoverSelected = ColorCache.getInstance().getColor(177, 163, 137);
// top corner pixel on the inside of the corner
private Color mButtonTopCornerPixel_HoverSelected = ColorCache.getInstance().getColor(151, 137, 109);
// bottom one, same deal
private Color mButtonBottomCornerPixel_HoverSelected = ColorCache.getInstance().getColor(225, 194, 113);
// bottom border outer
private Color mButtonOuterBottomLeft_HoverSelected = ColorCache.getInstance().getColor(212, 197, 173);
private Color mButtonOuterBottomMiddle_HoverSelected = mButtonOuterBottomLeft_HoverSelected;
private Color mButtonOuterBottomRight_HoverSelected = mButtonOuterBottomLeft_HoverSelected;
// very bottom pixel on outer sides
private Color mButtonOuterBottomPixel_HoverSelected = ColorCache.getInstance().getColor(204, 190, 165);
// OUTER BORDERS HOVER + SELECTED - SMALL
// top border outer
private Color mButtonSmallOuterTop_HoverSelected = ColorCache.getInstance().getColor(123, 102, 69);
// side borders outer
private Color mButtonSmallOuterSideTopTop_HoverSelected = mButtonSmallOuterTop_HoverSelected;
private Color mButtonSmallOuterSideTopBottom_HoverSelected = mButtonSmallOuterTop_HoverSelected;
private Color mButtonSmallOuterSideBottomTop_HoverSelected = mButtonSmallOuterTop_HoverSelected;
private Color mButtonSmallOuterSideBottomBottom_HoverSelected = mButtonSmallOuterTop_HoverSelected;
// top corner pixel on the inside of the corner
private Color mButtonSmallTopCornerPixel_HoverSelected = ColorCache.getInstance().getColor(139, 111, 77);
// bottom one, same deal
private Color mButtonSmallBottomCornerPixel_HoverSelected = ColorCache.getInstance().getColor(253, 170, 6);
// bottom border outer
private Color mButtonSmallOuterBottomLeft_HoverSelected = ColorCache.getInstance().getColor(253, 173, 3);
private Color mButtonSmallOuterBottomMiddle_HoverSelected = ColorCache.getInstance().getColor(255, 174, 3);
private Color mButtonSmallOuterBottomRight_HoverSelected = mButtonSmallOuterBottomLeft_HoverSelected;
// very bottom pixel on outer sides
private Color mButtonSmallOuterBottomPixel_HoverSelected = ColorCache.getInstance().getColor(169, 135, 73);
// special, bottom left and right corners on a small hover+selected button
private Color mButtonSmallBottomCornerInwards_HoverSelected = ColorCache.getInstance().getColor(249, 157, 25);
// INNER BORDERS HOVER
// top border inner
private Color mButtonInnerTop_Hover = ColorCache.getInstance().getColor(255, 255, 247);
// side borders inner
private Color mButtonInnerSideTopTop_Hover = mButtonInnerTop_Hover;
private Color mButtonInnerSideTopBottom_Hover = ColorCache.getInstance().getColor(255, 248, 223);
private Color mButtonInnerSideBottomTop_Hover = ColorCache.getInstance().getColor(255, 243, 206);
private Color mButtonInnerSideBottomBottom_Hover = ColorCache.getInstance().getColor(255, 243, 93);
// bottom border inner
private Color mButtonInnerBottomLeft_Hover = ColorCache.getInstance().getColor(255, 247, 146);
private Color mButtonInnerBottomMiddle_Hover = ColorCache.getInstance().getColor(255, 254, 247);
private Color mButtonInnerBottomRight_Hover = mButtonInnerBottomLeft_Hover;
// INNER BORDERS HOVER - SMALL
// top border inner
private Color mButtonSmallInnerTop_Hover = ColorCache.getInstance().getColor(255, 255, 251);
// side borders inner
private Color mButtonSmallInnerSideTopTop_Hover = ColorCache.getInstance().getColor(255, 255, 250);
private Color mButtonSmallInnerSideTopBottom_Hover = ColorCache.getInstance().getColor(255, 249, 227);
private Color mButtonSmallInnerSideBottomTop_Hover = ColorCache.getInstance().getColor(255, 242, 201);
private Color mButtonSmallInnerSideBottomBottom_Hover = ColorCache.getInstance().getColor(255, 246, 185);
// bottom border inner
private Color mButtonSmallInnerBottomLeft_Hover = ColorCache.getInstance().getColor(255, 250, 207);
private Color mButtonSmallInnerBottomMiddle_Hover = ColorCache.getInstance().getColor(255, 255, 254);
private Color mButtonSmallInnerBottomRight_Hover = mButtonSmallInnerBottomLeft_Hover;
// INNER BORDERS SELECTED
// top border inner
private Color mButtonInnerTop_Selected = ColorCache.getInstance().getColor(182, 154, 120);
// side borders inner
private Color mButtonInnerSideTopTop_Selected = ColorCache.getInstance().getColor(230, 175, 86);
private Color mButtonInnerSideTopBottom_Selected = ColorCache.getInstance().getColor(250, 195, 93);
private Color mButtonInnerSideBottomTop_Selected = ColorCache.getInstance().getColor(248, 190, 81);
private Color mButtonInnerSideBottomBottom_Selected = ColorCache.getInstance().getColor(255, 207, 45);
// INNER BORDERS SELECTED - SMALL
// top border inner
private Color mButtonSmallInnerTop_Selected = ColorCache.getInstance().getColor(203, 180, 153);
// side borders inner
private Color mButtonSmallInnerSideTopTop_Selected = ColorCache.getInstance().getColor(239, 211, 176);
private Color mButtonSmallInnerSideTopBottom_Selected = ColorCache.getInstance().getColor(241, 178, 90);
private Color mButtonSmallInnerSideBottomTop_Selected = ColorCache.getInstance().getColor(239, 171, 72);
private Color mButtonSmallInnerSideBottomBottom_Selected = ColorCache.getInstance().getColor(251, 186, 67);
// bottom border inner
private Color mButtonSmallInnerBottomLeft_Selected = ColorCache.getInstance().getColor(252, 191, 68);
private Color mButtonSmallInnerBottomMiddle_Selected = ColorCache.getInstance().getColor(253, 227, 173);
private Color mButtonSmallInnerBottomRight_Selected = mButtonSmallInnerBottomLeft_Selected;
// second inside pixel counted from the top inner corner, it's 1 pixel further down on both sides in selected and hover+selected
private Color mButtonSmallExtraTopBottomPixel_Selected = ColorCache.getInstance().getColor(226, 204, 178);
// INNER BORDERS HOVER + SELECTED
// top border inner
private Color mButtonInnerTop_HoverSelected = ColorCache.getInstance().getColor(168, 136, 94);
// side borders inner
private Color mButtonInnerSideTopTop_HoverSelected = ColorCache.getInstance().getColor(225, 153, 47);
private Color mButtonInnerSideTopBottom_HoverSelected = ColorCache.getInstance().getColor(253, 232, 192);
private Color mButtonInnerSideBottomTop_HoverSelected = ColorCache.getInstance().getColor(254, 239, 210);
private Color mButtonInnerSideBottomBottom_HoverSelected = ColorCache.getInstance().getColor(255, 223, 113);
// bottom border inner
private Color mButtonInnerBottomLeft_HoverSelected = ColorCache.getInstance().getColor(255, 207, 44);
private Color mButtonInnerBottomMiddle_HoverSelected = ColorCache.getInstance().getColor(255, 233, 160);
private Color mButtonInnerBottomRight_HoverSelected = mButtonInnerBottomLeft_HoverSelected;
// second inside pixel counted from the top inner corner, it's 1 pixel further down on both sides in selected and hover+selected
private Color mButtonSmallExtraTopBottomPixel_HoverSelected = ColorCache.getInstance().getColor(205, 156, 110);
// INNER BORDERS HOVER + SELECTED - SMALL
// top border inner
private Color mButtonSmallInnerTop_HoverSelected = ColorCache.getInstance().getColor(175, 131, 92);
// side borders inner
private Color mButtonSmallInnerSideTopTop_HoverSelected = ColorCache.getInstance().getColor(229, 172, 118);
private Color mButtonSmallInnerSideTopBottom_HoverSelected = ColorCache.getInstance().getColor(241, 150, 59);
private Color mButtonSmallInnerSideBottomTop_HoverSelected = ColorCache.getInstance().getColor(237, 120, 4);
private Color mButtonSmallInnerSideBottomBottom_HoverSelected = ColorCache.getInstance().getColor(253, 170, 6);
// FILLS HOVER
private Color mButtonFillTopTop_Hover = ColorCache.getInstance().getColor(255, 253, 219);
private Color mButtonFillTopBottom_Hover = ColorCache.getInstance().getColor(255, 231, 144);
private Color mButtonFillBottomTop_Hover = ColorCache.getInstance().getColor(255, 215, 76);
private Color mButtonFillBottomBottom_Hover = ColorCache.getInstance().getColor(255, 231, 150);
// FILLS HOVER - SMALL
private Color mButtonSmallFillTopTop_Hover = ColorCache.getInstance().getColor(255, 253, 236);
private Color mButtonSmallFillTopBottom_Hover = ColorCache.getInstance().getColor(255, 237, 185);
private Color mButtonSmallFillBottomTop_Hover = ColorCache.getInstance().getColor(255, 217, 115);
private Color mButtonSmallFillBottomBottom_Hover = ColorCache.getInstance().getColor(255, 233, 164);
// FILLS SELECTED
private Color mButtonFillTopTop_Selected = ColorCache.getInstance().getColor(253, 212, 168);
private Color mButtonFillTopBottom_Selected = ColorCache.getInstance().getColor(250, 175, 96);
private Color mButtonFillBottomTop_Selected = ColorCache.getInstance().getColor(249, 147, 46);
private Color mButtonFillBottomBottom_Selected = ColorCache.getInstance().getColor(253, 241, 176);
// 1px down
private Color mButtonFillTopInnerLineOne_Selected = ColorCache.getInstance().getColor(224, 182, 136);
// 2px down
private Color mButtonFillTopInnerLineTwo_Selected = ColorCache.getInstance().getColor(245, 201, 154);
// FILLS SELECTED - SMALL
private Color mButtonSmallFillTopTop_Selected = ColorCache.getInstance().getColor(253, 218, 177);
private Color mButtonSmallFillTopBottom_Selected = ColorCache.getInstance().getColor(252, 208, 135);
private Color mButtonSmallFillBottomTop_Selected = ColorCache.getInstance().getColor(251, 188, 87);
private Color mButtonSmallFillBottomBottom_Selected = ColorCache.getInstance().getColor(253, 231, 153);
// 1px down
private Color mButtonSmallFillTopInnerLineOne_Selected = ColorCache.getInstance().getColor(235, 209, 178);
// 2px down
private Color mButtonSmallFillTopInnerLineTwo_Selected = ColorCache.getInstance().getColor(248, 217, 182);
// FILLS SELECTED + HOVER
private Color mButtonFillTopTop_HoverSelected = ColorCache.getInstance().getColor(245, 176, 109);
private Color mButtonFillTopBottom_HoverSelected = ColorCache.getInstance().getColor(232, 147, 82);
private Color mButtonFillBottomTop_HoverSelected = ColorCache.getInstance().getColor(230, 132, 51);
private Color mButtonFillBottomBottom_HoverSelected = ColorCache.getInstance().getColor(253, 209, 101);
// 1px down
private Color mButtonFillTopInnerLineOne_HoverSelected = ColorCache.getInstance().getColor(210, 158, 102);
// 2px down
private Color mButtonFillTopInnerLineTwo_HoverSelected = ColorCache.getInstance().getColor(233, 170, 107);
// FILLS SELECTED + HOVER - SMALL
private Color mButtonSmallFillTopTop_HoverSelected = ColorCache.getInstance().getColor(241, 175, 118);
private Color mButtonSmallFillTopBottom_HoverSelected = ColorCache.getInstance().getColor(243, 144, 65);
private Color mButtonSmallFillBottomTop_HoverSelected = ColorCache.getInstance().getColor(241, 114, 14);
private Color mButtonSmallFillBottomBottom_HoverSelected = ColorCache.getInstance().getColor(252, 155, 72);
// 1px down
private Color mButtonSmallFillTopInnerLineOne_HoverSelected = ColorCache.getInstance().getColor(219, 161, 111);
// 2px down
private Color mButtonSmallFillTopInnerLineTwo_HoverSelected = ColorCache.getInstance().getColor(242, 176, 119);
// SPECIAL FILLS - SPLIT BUTTON
private Color mButtonSplitFillTopTop_NonSelectedHover = ColorCache.getInstance().getColor(255, 254, 242);
private Color mButtonSplitFillTopBottom_NonSelectedHover = ColorCache.getInstance().getColor(255, 247, 217);
private Color mButtonSplitFillBottomTop_NonSelectedHover = ColorCache.getInstance().getColor(255, 241, 194);
private Color mButtonSplitFillBottomBottom_NonSelectedHover = ColorCache.getInstance().getColor(255, 239, 190);
private Color mButtonSplitFillBottomPartTop_NonSelectedHover = ColorCache.getInstance().getColor(255, 240, 194);
private Color mButtonSplitFillBottomPartBottom_NonSelectedHover = ColorCache.getInstance().getColor(255, 248, 224);
private Color mButtonSplitFillBottomPartTop_SelectedHover = ColorCache.getInstance().getColor(253, 201, 104);
private Color mButtonSplitFillBottomPartBottom_SelectedHover = ColorCache.getInstance().getColor(253, 240, 174);
// TEXT
private Color mTextColor = ColorCache.getInstance().getColor(21, 66, 139);
// disabled text
private Color mTextColor_Disabled = ColorCache.getInstance().getColor(165, 141, 159);
private Color mTextFadedRight_Disabled = ColorCache.getInstance().getColor(178, 214, 241);
private Color mTextFadedLeft_Disabled = ColorCache.getInstance().getColor(211, 226, 210);
// ARROW
private Color mArrowColor = ColorCache.getInstance().getColor(86, 125, 177);
private Color mArrowColorShadow = ColorCache.getInstance().getColor(234, 242, 249);
private Color mArrowColorShadow_HoverOrSelected = ColorCache.getInstance().getColor(255, 248, 203);
private Color mArrowColor_Disabled = ColorCache.getInstance().getColor(183, 183, 183);
private Color mArrowColorShadow_Disabled = ColorCache.getInstance().getColor(237, 237, 237);
// SEPARATOR
private Color mSeparatorColor = ColorCache.getInstance().getColor(251, 252, 254);
private Color mSeparatorColorShadow = ColorCache.getInstance().getColor(150, 180, 218);
// SPLIT SPECIALS
private Color mSplitBottomSelectedTopLineLeft_Hover = ColorCache.getInstance().getColor(255, 240, 191);
private Color mSplitBottomSelectedTopLineMid_Hover = ColorCache.getInstance().getColor(255, 244, 215);
private Color mSplitBottomSelectedTopLineLeft_Selected = ColorCache.getInstance().getColor(250, 192, 148);
private Color mSplitBottomSelectedTopLineMid_Selected = ColorCache.getInstance().getColor(255, 213, 167);
private Color mSplitDividerLineLeft_Hover = ColorCache.getInstance().getColor(219, 195, 116);
private Color mSplitDividerLineMid_Hover = ColorCache.getInstance().getColor(205, 189, 136);
private Color mSplitDividerLineLeft_Selected = ColorCache.getInstance().getColor(176, 125, 75);
private Color mSplitDividerLineMid_Selected = ColorCache.getInstance().getColor(149, 123, 82);
private Color mSplitDividerLineTopVertical_Hover = ColorCache.getInstance().getColor(226, 214, 189);
private Color mSplitDividerLineMidVertical_Hover = ColorCache.getInstance().getColor(205, 181, 131);
private Color mSplitDividerLineTopVertical_Selected = ColorCache.getInstance().getColor(184, 145, 101);
private Color mSplitDividerLineMidVertical_Selected = ColorCache.getInstance().getColor(169, 132, 85);
// CHECKBOX
// disabled
private Color mCheckBoxBorderOuterSquareTopLeft_Disabled = ColorCache.getInstance().getColor(224, 226, 229);
private Color mCheckBoxBorderOuterSquareBottomRight_Disabled = ColorCache.getInstance().getColor(242, 243, 243);
private Color mCheckBoxBorderInnerSquareTopLeft_Disabled = ColorCache.getInstance().getColor(238, 240, 242);
private Color mCheckBoxBorderInnerSquareBottomRight_Disabled = ColorCache.getInstance().getColor(251, 251, 251);
// normal
private Color mCheckBoxBorderOuterSquareTopLeft_Normal = ColorCache.getInstance().getColor(162, 172, 185);
private Color mCheckBoxBorderOuterSquareBottomRight_Normal = ColorCache.getInstance().getColor(228, 230, 234);
private Color mCheckBoxBorderInnerSquareTopLeft_Normal = ColorCache.getInstance().getColor(202, 207, 213);
private Color mCheckBoxBorderInnerSquareBottomRight_Normal = ColorCache.getInstance().getColor(246, 246, 246);
// hover
private Color mCheckBoxBorderOuterSquareTopLeft_Hover = ColorCache.getInstance().getColor(250, 213, 122);
private Color mCheckBoxBorderOuterSquareBottomRight_Hover = ColorCache.getInstance().getColor(253, 241, 207);
private Color mCheckBoxBorderInnerSquareTopLeft_Hover = ColorCache.getInstance().getColor(252, 231, 175);
private Color mCheckBoxBorderInnerSquareBottomRight_Hover = ColorCache.getInstance().getColor(254, 248, 231);
// same with borders
private Color mCheckBoxBorderOuter_Disabled = ColorCache.getInstance().getColor(174, 177, 181);
private Color mCheckBoxBorderInner_Disabled = ColorCache.getInstance().getColor(255, 255, 255);
private Color mCheckBoxBorderOuter_Normal = ColorCache.getInstance().getColor(171, 193, 222);
private Color mCheckBoxBorderInner_Normal = ColorCache.getInstance().getColor(244, 244, 244);
private Color mCheckBoxBorderOuter_Hover= ColorCache.getInstance().getColor(85, 119, 163);
private Color mCheckBoxBorderInner_Hover = ColorCache.getInstance().getColor(222, 234, 250);
// actual check mark
private Color mCheckBoxCheckmarkDark = ColorCache.getInstance().getColor(78, 108, 141);
private Color mCheckBoxCheckmarkDark2 = ColorCache.getInstance().getColor(102, 126, 149);
private Color mCheckBoxCheckmarkDark3 = ColorCache.getInstance().getColor(142, 163, 189);
private Color mCheckBoxCheckmarkDark4 = ColorCache.getInstance().getColor(178, 190, 204);
private Color mCheckBoxCheckmarkLight = ColorCache.getInstance().getColor(230, 229, 222);
private Color mCheckBoxCheckmarkLight2 = ColorCache.getInstance().getColor(213, 215, 209);
private Color mCheckBoxCheckmarkLight3 = ColorCache.getInstance().getColor(253, 249, 245);
// boredered toolbars
private Color mOuterToolbarBorderColor = ColorCache.getInstance().getColor(160, 188, 228);
private Color mOuterToolbarBorderMidpointColor = ColorCache.getInstance().getColor(121, 153, 194);
private Color mInnerToolbarBorderColorTop = ColorCache.getInstance().getColor(213, 227, 241);
private Color mInnerToolbarBorderColorBottom = ColorCache.getInstance().getColor(227, 237, 251);
private Color mInnerToolbarBorderCornerColor = ColorCache.getInstance().getColor(180, 202, 227);
private Color mInnerToolbarBorderSideMidpointColor = ColorCache.getInstance().getColor(234, 241, 251);
private Color mInnerToolbarDividerColorLeft = ColorCache.getInstance().getColor(190, 212, 237);
private Color mToolbarFillColorTop = ColorCache.getInstance().getColor(202, 221, 241);
private Color mToolbarFillColorBottomTop = ColorCache.getInstance().getColor(188, 208, 233);
private Color mToolbarFillColorBottomBottom = ColorCache.getInstance().getColor(208, 225, 247);
// buttons with hover
private Color mToolbarFillColorTopTop_Hover = ColorCache.getInstance().getColor(254, 247, 213);
private Color mToolbarFillColorTopBottom_Hover = ColorCache.getInstance().getColor(250, 229, 168);
private Color mToolbarFillColorBottomTop_Hover = ColorCache.getInstance().getColor(255, 208, 72);
private Color mToolbarFillColorBottomBottom_Hover = ColorCache.getInstance().getColor(255, 229, 159);
private Color mToolbarInnerBorderTop_Hover = ColorCache.getInstance().getColor(255, 252, 232);
private Color mToolbarInnerBorderTopBottom_Hover = ColorCache.getInstance().getColor(255, 252, 232);
private Color mToolbarInnerBorderBottomTop_Hover = ColorCache.getInstance().getColor(255, 226, 143);
private Color mToolbarInnerBorderBottomBottom_Hover = ColorCache.getInstance().getColor(255, 249, 204);
private Color mToolbarOuterBorderTop_Selected = ColorCache.getInstance().getColor(203, 180, 153);
private Color mToolbarOuterBorderTopTwo_Selected = ColorCache.getInstance().getColor(235, 209, 180);
private Color mToolbarFillColorTopTop_Selected = ColorCache.getInstance().getColor(251, 219, 181);
private Color mToolbarFillColorTopBottom_Selected = ColorCache.getInstance().getColor(254, 199, 120);
private Color mToolbarFillColorBottomTop_Selected = ColorCache.getInstance().getColor(254, 180, 86);
private Color mToolbarFillColorBottomBottom_Selected = ColorCache.getInstance().getColor(253, 235, 159);
private Color mToolbarInnerBorderBottomBottomLine_Selected = ColorCache.getInstance().getColor(255, 228, 127);
private Color mToolbarOuterBorderTop_HoverSelected = ColorCache.getInstance().getColor(158, 130, 85);
private Color mToolbarOuterBorderTopTwo_HoverSelected = ColorCache.getInstance().getColor(204, 152, 95);
private Color mToolbarOuterBorderTopThree_HoverSelected = ColorCache.getInstance().getColor(232, 174, 113);
private Color mToolbarFillColorTopTop_HoverSelected = ColorCache.getInstance().getColor(248, 186, 121);
private Color mToolbarFillColorTopBottom_HoverSelected = ColorCache.getInstance().getColor(255, 189, 121);
private Color mToolbarFillColorBottomTop_HoverSelected = ColorCache.getInstance().getColor(254, 163, 53);
private Color mToolbarFillColorBottomBottom_HoverSelected = ColorCache.getInstance().getColor(254, 224, 105);
private Color mToolbarInnerBorderBottomBottomLine_HoverSelected = ColorCache.getInstance().getColor(252, 206, 107);
// split toolbar button
private Color mToolbarSplitFillColorTopTop_NonHover = ColorCache.getInstance().getColor(255, 254, 247);
private Color mToolbarSplitFillColorTopBottom_NonHover = ColorCache.getInstance().getColor(255, 247, 223);
private Color mToolbarSplitFillColorBottomTop_NonHover = ColorCache.getInstance().getColor(255, 238, 190);
private Color mToolbarSplitFillColorBottomBottom_NonHover = ColorCache.getInstance().getColor(255, 246, 221);
private Color mToolbarSplitInnerBorderTop_Hover = ColorCache.getInstance().getColor(255, 255, 253);
private Color mToolbarSplitInnerBorderBottom_Hover = ColorCache.getInstance().getColor(255, 238, 187);
public void drawItem(GC gc, AbstractRibbonGroupItem item) {
if (item instanceof RibbonGroupSeparator) {
RibbonGroupSeparator rgs = (RibbonGroupSeparator) item;
Rectangle rgsBounds = rgs.getBounds();
drawSeparator(gc, rgsBounds.x, rgsBounds.y, rgsBounds.height);
return;
}
else if (item instanceof RibbonButton) {
Rectangle buttonBounds = item.getBounds();
int state = getState(item);
if (state != STATE_NONE && item.isEnabled()) {
if (item.isSplit()) {
drawBigSplitButton(gc, state, item);
}
else {
drawButtonOuterBorder(gc, state, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonFills(gc, state, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonInnerBorder(gc, state, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonDecorations(gc, state, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
}
}
drawButtonImage(gc, TYPE_BUTTON_BIG, item);
drawButtonText(gc, state, TYPE_BUTTON_BIG, item);
}
else if (item instanceof RibbonButtonGroup) {
RibbonButtonGroup rbg = (RibbonButtonGroup) item;
List<AbstractRibbonGroupItem> buttons = rbg.getButtons();
for (AbstractRibbonGroupItem button : buttons) {
int state = getState(button);
if (button instanceof RibbonCheckbox) {
drawCheckbox(gc, getState(button), button);
continue;
}
if (button.isSplit()) {
drawSmallSplitButton(gc, state, button);
}
else {
Rectangle buttonBounds = button.getBounds();
if (state != STATE_NONE && button.isEnabled()) {
drawButtonOuterBorder(gc, state, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonFills(gc, state, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonInnerBorder(gc, state, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonDecorations(gc, state, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
}
}
drawButtonImage(gc, TYPE_BUTTON_SMALL, button);
drawButtonText(gc, state, TYPE_BUTTON_SMALL, button);
}
}
else {
System.err.println("Unknown object to draw: " + item.getClass());
}
}
protected void drawToolbar(GC gc, RibbonToolbar tb) {
List<RibbonToolbarGrouping> groupings = tb.getGroupings();
if (tb.getStyle() == RibbonToolbar.STYLE_NO_BORDER) {
for (RibbonToolbarGrouping group : groupings) {
List<RibbonButton> buttons = group.getItems();
for (RibbonButton button : buttons) {
Rectangle buttonBounds = button.getBounds();
int state = getState(button);
if (state != STATE_NONE && button.isEnabled()) {
drawButtonOuterBorder(gc, state, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonFills(gc, state, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonInnerBorder(gc, state, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonDecorations(gc, state, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
}
// drawButtonText draws arrows as well even if we don't have any text
drawButtonText(gc, state, TYPE_BUTTON_SMALL, button);
drawButtonImage(gc, TYPE_BUTTON_SMALL, button);
}
}
}
else {
// on bordered toolbars, basically everything is different
drawBorderedToolbar(gc, tb);
}
}
void drawMenuToolbarButton(GC gc, RibbonButton button) {
int state = getState(button);
Rectangle buttonBounds = button.getBounds();
if (state != STATE_NONE && button.isEnabled()) {
drawButtonOuterBorder(gc, state, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonFills(gc, state, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonInnerBorder(gc, state, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonDecorations(gc, state, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
}
// drawButtonText draws arrows as well even if we don't have any text
drawButtonText(gc, state, TYPE_BUTTON_SMALL, button);
Image toUse = button.isEnabled() ? button.getImage() : button.getDisabledImage();
if (toUse == null)
toUse = button.getImage();
if (toUse == null)
return;
Rectangle imBounds = toUse.getBounds();
int xSpacer = (buttonBounds.width / 2) - (imBounds.width / 2);
int ySpacer = (buttonBounds.height / 2) - (imBounds.height / 2);
gc.drawImage(toUse, buttonBounds.x + xSpacer, buttonBounds.y + ySpacer);
}
private void drawBorderedToolbar(GC gc, RibbonToolbar tb) {
List<RibbonToolbarGrouping> groupings = tb.getGroupings();
for (RibbonToolbarGrouping group : groupings) {
List<RibbonButton> buttons = group.getItems();
// no buttons? no border
if (buttons.size() == 0)
continue;
// first, draw the entire border
gc.setForeground(mOuterToolbarBorderColor);
Rectangle bounds = group.getBounds();
Rectangle box = new Rectangle(bounds.x, bounds.y, bounds.width, bounds.height+1);
// top line, starts 1px in, ends 1px in
gc.drawLine(box.x+1, box.y, box.x+box.width-2, box.y);
// bottom line, same
gc.drawLine(box.x+1, box.y+box.height, box.x+box.width-2, box.y+box.height);
// left side top
gc.setBackground(mOuterToolbarBorderMidpointColor);
gc.fillGradientRectangle(box.x, box.y+1, 1, 1+(box.height/2), true);
// right side top
gc.fillGradientRectangle(box.x+box.width-1, box.y+1, 1, 1+(box.height/2), true);
// left side bottom
gc.setForeground(mOuterToolbarBorderMidpointColor);
gc.setBackground(mOuterToolbarBorderColor);
gc.fillGradientRectangle(box.x, box.y+1+(box.height/2), 1, (box.height/2), true);
// right side bottom
gc.fillGradientRectangle(box.x+box.width-1, box.y+1+(box.height/2), 1, (box.height/2), true);
// ok, the outer border is done, now we draw buttons, inner borders will be decorations
// the button that differs completely here is (thankfully) the non-selected or non-hovered state, so we deal with that first
for (RibbonButton button : buttons) {
int state = getState(button);
if (button.isEnabled()) {
if (button.isSplit() && state != STATE_NONE)
drawSmallSplitToolbarButton(gc, state, button);
else
drawSmallToolbarButton(gc, state, button.getBounds(), button.getToolbarSide(), false);
}
drawButtonImage(gc, STATE_NONE, button);
drawButtonText(gc, state, TYPE_BUTTON_SMALL, button);
}
}
}
// these are a bit of a pain in the neck.. there's little equality to other splits once one looks at the pixel-level
private void drawSmallSplitToolbarButton(GC gc, int state, RibbonButton button) {
boolean skipLeftSideBorders = false;
boolean skipRightSideBorders = false;
boolean skipLeftSideBordersOnRightSide = false;
// if we have a double-sided (so to speak) item, we pretend it's one side first, then we simply draw the missing bits later
// this was much easier than adding even more if-statements to the various draw methods
int tbSide = button.getToolbarSide();
if (tbSide == RibbonButton.TOOLBAR_SIDE_LEFT_AND_RIGHT)
tbSide = RibbonButton.TOOLBAR_SIDE_RIGHT;
if (button.isLeftHovered() || button.isLeftSelected()) {
if (button.isLeftSelected()) {
// draw left in hover_select
drawSmallToolbarButton(gc, state, button.getLeftBounds(), tbSide == RibbonButton.TOOLBAR_SIDE_LEFT ? RibbonButton.TOOLBAR_SIDE_LEFT : RibbonButton.TOOLBAR_SIDE_NOT_LEFT_OR_RIGHT, false);
if (button.isLeftHovered()) {
// draw right in just hover - but the special hover
drawSmallToolbarButton(gc, STATE_HOVER, button.getRightBounds(), tbSide == RibbonButton.TOOLBAR_SIDE_RIGHT ? RibbonButton.TOOLBAR_SIDE_RIGHT : RibbonButton.TOOLBAR_SIDE_NOT_LEFT_OR_RIGHT, true);
}
else if (button.isRightHovered()) {
// draw left in selected state, draw right in hover
drawSmallToolbarButton(gc, STATE_SELECTED, button.getLeftBounds(), tbSide == RibbonButton.TOOLBAR_SIDE_LEFT ? RibbonButton.TOOLBAR_SIDE_LEFT : RibbonButton.TOOLBAR_SIDE_NOT_LEFT_OR_RIGHT, false);
drawSmallToolbarButton(gc, STATE_HOVER, button.getRightBounds(), tbSide == RibbonButton.TOOLBAR_SIDE_RIGHT ? RibbonButton.TOOLBAR_SIDE_RIGHT : RibbonButton.TOOLBAR_SIDE_NOT_LEFT_OR_RIGHT, false);
skipLeftSideBorders = true;
}
else {
// draw right plainly
drawSmallToolbarButton(gc, STATE_NONE, button.getRightBounds(), tbSide == RibbonButton.TOOLBAR_SIDE_RIGHT ? RibbonButton.TOOLBAR_SIDE_RIGHT : RibbonButton.TOOLBAR_SIDE_NOT_LEFT_OR_RIGHT, false);
}
}
else {
// just hovered
drawSmallToolbarButton(gc, state, button.getLeftBounds(), tbSide == RibbonButton.TOOLBAR_SIDE_LEFT ? RibbonButton.TOOLBAR_SIDE_LEFT : RibbonButton.TOOLBAR_SIDE_NOT_LEFT_OR_RIGHT, false);
// draw right in just hover - but the special hover
drawSmallToolbarButton(gc, STATE_HOVER, button.getRightBounds(), tbSide == RibbonButton.TOOLBAR_SIDE_RIGHT ? RibbonButton.TOOLBAR_SIDE_RIGHT : RibbonButton.TOOLBAR_SIDE_NOT_LEFT_OR_RIGHT, true);
}
}
else if (button.isRightHovered() || button.isRightSelected()) {
if (button.isRightSelected()) {
drawSmallToolbarButton(gc, STATE_HOVER, button.getLeftBounds(), tbSide == RibbonButton.TOOLBAR_SIDE_LEFT ? RibbonButton.TOOLBAR_SIDE_LEFT : RibbonButton.TOOLBAR_SIDE_NOT_LEFT_OR_RIGHT, true);
drawSmallToolbarButton(gc, STATE_HOVER_AND_SELECTED, button.getRightBounds(), tbSide == RibbonButton.TOOLBAR_SIDE_RIGHT ? RibbonButton.TOOLBAR_SIDE_RIGHT : RibbonButton.TOOLBAR_SIDE_NOT_LEFT_OR_RIGHT, false);
skipLeftSideBordersOnRightSide = true;
}
else {
drawSmallToolbarButton(gc, state, button.getLeftBounds(), tbSide == RibbonButton.TOOLBAR_SIDE_LEFT ? RibbonButton.TOOLBAR_SIDE_LEFT : RibbonButton.TOOLBAR_SIDE_NOT_LEFT_OR_RIGHT, true);
drawSmallToolbarButton(gc, STATE_HOVER, button.getRightBounds(), tbSide == RibbonButton.TOOLBAR_SIDE_RIGHT ? RibbonButton.TOOLBAR_SIDE_RIGHT : RibbonButton.TOOLBAR_SIDE_NOT_LEFT_OR_RIGHT, false);
}
}
// draw split as it's easier doing here than having some if methods check it inside one of the other methods
gc.setForeground(mSplitDividerLineTopVertical_Hover);
gc.setBackground(mSplitDividerLineMidVertical_Hover);
gc.fillGradientRectangle(button.getRightBounds().x-1, button.getBounds().y, 1, 10, true);
gc.setForeground(mSplitDividerLineMidVertical_Hover);
gc.setBackground(mSplitDividerLineTopVertical_Hover);
gc.fillGradientRectangle(button.getRightBounds().x-1, button.getBounds().y+10, 1, 10, true);
// regardless of side we fill the right side inner border again, as it's mostly "not used"
if (button.isLeftHovered()) {
if (!skipRightSideBorders) {
int x = button.getRightBounds().x + button.getRightBounds().width;
int y = button.getRightBounds().y;
int top = 8;
int bottom = 12;
if (button.getToolbarSide() == RibbonButton.TOOLBAR_SIDE_RIGHT) {
y -= 1;
top = 7;
bottom = 11;
}
else {
x -= 1;
y -= 2;
}
gc.setForeground(mToolbarSplitFillColorTopTop_NonHover);
gc.setBackground(mToolbarSplitFillColorTopBottom_NonHover);
gc.fillGradientRectangle(x, y+2, 1, top, true);
gc.setForeground(mToolbarSplitFillColorBottomTop_NonHover);
gc.setBackground(mToolbarSplitFillColorBottomBottom_NonHover);
gc.fillGradientRectangle(x, y+2+top, 1, bottom, true);
}
}
else if (button.isRightHovered()) {
if (!skipLeftSideBordersOnRightSide) {
// fill right side's left inner border first
gc.setForeground(mToolbarSplitInnerBorderTop_Hover);
gc.setBackground(mToolbarSplitInnerBorderTop_Hover);
gc.fillGradientRectangle(button.getRightBounds().x, button.getRightBounds().y, 1, 8, true);
gc.setBackground(mToolbarSplitInnerBorderBottom_Hover);
gc.fillGradientRectangle(button.getRightBounds().x, button.getRightBounds().y+8, 1, 12, true);
}
if (!skipLeftSideBorders) {
// left side calculations
int x = button.getLeftBounds().x-1; //TODO: why do I need the -1 on this x? weird
int y = button.getLeftBounds().y;
int top = 8;
int bottom = 12;
if (button.getToolbarSide() == RibbonButton.TOOLBAR_SIDE_LEFT) {
y += 1;
top = 7;
bottom = 11;
}
// top part
gc.setForeground(mToolbarSplitFillColorTopTop_NonHover);
gc.setBackground(mToolbarSplitFillColorTopBottom_NonHover);
gc.fillGradientRectangle(x, y, 1, top, true);
// fill right side of left side from top to bottom, it's never shorter
gc.fillGradientRectangle(button.getLeftBounds().x+button.getLeftBounds().width-1, button.getLeftBounds().y, 1, 8, true);
// bottom part
gc.setForeground(mToolbarSplitFillColorBottomTop_NonHover);
gc.setBackground(mToolbarSplitFillColorBottomBottom_NonHover);
gc.fillGradientRectangle(x, y+top, 1, bottom, true);
// fill right side of left side from top to bottom, it's never shorter
gc.fillGradientRectangle(button.getLeftBounds().x+button.getLeftBounds().width-1, button.getLeftBounds().y+8, 1, 12, true);
}
}
// check the buttonstyle again, if it was a double-sided, deal with that
// as we pretended the button was "right sided" we just draw what's missing on the left side
if (button.getToolbarSide() == RibbonButton.TOOLBAR_SIDE_LEFT_AND_RIGHT) {
Rectangle bounds = button.getBounds();
gc.setForeground(mOuterToolbarBorderColor);
// paint the two border corner dots to make the border go around "smoothly"
gc.drawLine(bounds.x-1, bounds.y, bounds.x-1, bounds.y);
gc.drawLine(bounds.x-1, bounds.y+bounds.height-1, bounds.x-1, bounds.y+bounds.height-1);
}
}
private void drawSmallToolbarButton(GC gc, int state, Rectangle bounds, int tbSide, boolean useSplitColors) {
int width = bounds.width;
int height = bounds.height;
if (state == STATE_NONE) {
// start with the fill, inner borders will draw on top
gc.setBackground(mToolbarFillColorTop);
gc.fillRectangle(bounds.x, bounds.y, width, height);
gc.setForeground(mToolbarFillColorBottomTop);
gc.setBackground(mToolbarFillColorBottomBottom);
gc.fillGradientRectangle(bounds.x, bounds.y+8, width, height-9, true);
}
else if (state == STATE_HOVER) {
// fills
if (useSplitColors) {
gc.setForeground(mToolbarSplitFillColorTopTop_NonHover);
gc.setBackground(mToolbarSplitFillColorTopBottom_NonHover);
}
else {
gc.setForeground(mToolbarFillColorTopTop_Hover);
gc.setBackground(mToolbarFillColorTopBottom_Hover);
}
gc.fillGradientRectangle(bounds.x, bounds.y+1, width, 7, true);
if (useSplitColors) {
gc.setForeground(mToolbarSplitFillColorBottomTop_NonHover);
gc.setBackground(mToolbarSplitFillColorBottomBottom_NonHover);
}
else {
gc.setForeground(mToolbarFillColorBottomTop_Hover);
gc.setBackground(mToolbarFillColorBottomBottom_Hover);
}
gc.fillGradientRectangle(bounds.x, bounds.y+1+7, width, 11, true);
}
else if (state == STATE_SELECTED) {
// selected has 2 lines that draw over the border at the top
gc.setForeground(mToolbarOuterBorderTop_Selected);
gc.drawLine(bounds.x-1, bounds.y-1, bounds.x+bounds.width-1, bounds.y-1);
gc.setForeground(mToolbarOuterBorderTopTwo_Selected);
gc.drawLine(bounds.x-1, bounds.y, bounds.x+bounds.width-1, bounds.y);
// now we can fill
gc.setForeground(mToolbarFillColorTopTop_Selected);
gc.setBackground(mToolbarFillColorTopBottom_Selected);
gc.fillGradientRectangle(bounds.x-1, bounds.y+1, bounds.width+1, 5, true);
gc.setForeground(mToolbarFillColorBottomTop_Selected);
gc.setBackground(mToolbarFillColorBottomBottom_Selected);
gc.fillGradientRectangle(bounds.x-1, bounds.y+1+5, bounds.width+1, 13, true);
// bottom line, acts as an inner line
gc.setForeground(mToolbarInnerBorderBottomBottomLine_Selected);
gc.drawLine(bounds.x-1, bounds.y+5+13+1, bounds.x+bounds.width-1, bounds.y+5+13+1);
// bottom left corner has a pixel
if (tbSide == RibbonButton.TOOLBAR_SIDE_LEFT) {
gc.setForeground(mOuterToolbarBorderColor);
gc.drawLine(bounds.x-1, bounds.y+5+13+1, bounds.x-1, bounds.y+5+13+1);
}
}
else if (state == STATE_HOVER_AND_SELECTED) {
int xTra = 0;
if (tbSide == RibbonButton.TOOLBAR_SIDE_RIGHT)
xTra = 1;
// selected has 2 lines that draw over the border at the top
gc.setForeground(mToolbarOuterBorderTop_HoverSelected);
if (tbSide == RibbonButton.TOOLBAR_SIDE_LEFT)
gc.drawLine(bounds.x, bounds.y-1, bounds.x+bounds.width-1+xTra, bounds.y-1);
else
gc.drawLine(bounds.x-1, bounds.y-1, bounds.x+bounds.width-1+xTra, bounds.y-1);
gc.setForeground(mToolbarOuterBorderTopTwo_HoverSelected);
gc.drawLine(bounds.x-1, bounds.y, bounds.x+bounds.width-1+xTra, bounds.y);
gc.setForeground(mToolbarOuterBorderTopThree_HoverSelected);
gc.drawLine(bounds.x-1, bounds.y+1, bounds.x+bounds.width-1+xTra, bounds.y+1);
// now we can fill
gc.setForeground(mToolbarFillColorTopTop_HoverSelected);
gc.setBackground(mToolbarFillColorTopBottom_HoverSelected);
gc.fillGradientRectangle(bounds.x-1, bounds.y+2, bounds.width+1+xTra, 5, true);
gc.setForeground(mToolbarFillColorBottomTop_HoverSelected);
gc.setBackground(mToolbarFillColorBottomBottom_HoverSelected);
gc.fillGradientRectangle(bounds.x-1, bounds.y+2+5, bounds.width+1+xTra, 12, true);
// bottom line, acts as an inner line
gc.setForeground(mToolbarInnerBorderBottomBottomLine_HoverSelected);
gc.drawLine(bounds.x-1, bounds.y+5+13+1, bounds.x+bounds.width-1+xTra, bounds.y+5+13+1);
// bottom left corner has a pixel
if (tbSide == RibbonButton.TOOLBAR_SIDE_LEFT) {
gc.setForeground(mOuterToolbarBorderColor);
gc.drawLine(bounds.x-1, bounds.y+5+13+1, bounds.x-1, bounds.y+5+13+1);
}
else if (tbSide == RibbonButton.TOOLBAR_SIDE_RIGHT) {
gc.setForeground(mOuterToolbarBorderColor);
gc.drawLine(bounds.x-1+bounds.width+1, bounds.y+5+13+1, bounds.x-1+bounds.width+1, bounds.y+5+13+1);
}
}
if (state != STATE_SELECTED && state != STATE_HOVER_AND_SELECTED) {
// ok, lets draw inner borders, the top one is the same on all
if (state == STATE_NONE)
gc.setForeground(mInnerToolbarBorderColorTop);
else if (state == STATE_HOVER)
gc.setForeground(mToolbarInnerBorderTop_Hover);
gc.drawLine(bounds.x, bounds.y, bounds.x+width-1, bounds.y);
// draw bottom inner
if (state == STATE_NONE)
gc.setForeground(mInnerToolbarBorderColorBottom);
else if (state == STATE_HOVER)
gc.setForeground(mToolbarInnerBorderBottomBottom_Hover);
gc.drawLine(bounds.x-1, bounds.y+bounds.height-1, bounds.x+width, bounds.y+bounds.height-1);
}
// draw the left corner pixel if we happen to be the right button
// selected state doesn't have it
if (state != STATE_SELECTED && state != STATE_HOVER_AND_SELECTED) {
if (tbSide == RibbonButton.TOOLBAR_SIDE_LEFT) {
if (state == STATE_NONE)
gc.setForeground(mInnerToolbarBorderCornerColor);
else if (state == STATE_HOVER)
gc.setForeground(mOuterToolbarBorderColor);
gc.drawLine(bounds.x-1, bounds.y, bounds.x-1, bounds.y);
gc.drawLine(bounds.x-1, bounds.y+bounds.height-1, bounds.x-1, bounds.y+bounds.height-1);
}
}
if (tbSide == RibbonButton.TOOLBAR_SIDE_RIGHT) {
if (state == STATE_NONE)
gc.setForeground(mInnerToolbarBorderCornerColor);
else if (state == STATE_HOVER)
gc.setForeground(mOuterToolbarBorderColor);
// selected state doesn't have it
if (state != STATE_SELECTED && state != STATE_HOVER_AND_SELECTED) {
gc.drawLine(bounds.x+width, bounds.y, bounds.x+width, bounds.y);
gc.drawLine(bounds.x+width, bounds.y+bounds.height-1, bounds.x+width, bounds.y+bounds.height-1);
}
}
if (state == STATE_NONE) {
// draw all dividers
if (tbSide == RibbonButton.TOOLBAR_SIDE_NOT_LEFT_OR_RIGHT || tbSide == RibbonButton.TOOLBAR_SIDE_LEFT) {
gc.setForeground(mInnerToolbarDividerColorLeft);
gc.drawLine(bounds.x+bounds.width, bounds.y, bounds.x+bounds.width, bounds.y+bounds.height-1);
}
if (tbSide == RibbonButton.TOOLBAR_SIDE_NOT_LEFT_OR_RIGHT || tbSide == RibbonButton.TOOLBAR_SIDE_RIGHT) {
gc.setForeground(mInnerToolbarBorderColorBottom);
gc.drawLine(bounds.x-1, bounds.y, bounds.x-1, bounds.y+bounds.height-1);
}
}
else if (state == STATE_HOVER || state == STATE_SELECTED || state == STATE_HOVER_AND_SELECTED) {
// draw all dividers
if (tbSide == RibbonButton.TOOLBAR_SIDE_NOT_LEFT_OR_RIGHT || tbSide == RibbonButton.TOOLBAR_SIDE_LEFT) {
// hover gives the right bar a different color
gc.setForeground(mOuterToolbarBorderColor);
gc.drawLine(bounds.x+bounds.width, bounds.y, bounds.x+bounds.width, bounds.y+bounds.height-1);
}
}
// ok, all that's left is the left side and right side inner borders, which are gradients
if (state != STATE_SELECTED && state != STATE_HOVER_AND_SELECTED) {
if (tbSide == RibbonButton.TOOLBAR_SIDE_LEFT
|| tbSide == RibbonButton.TOOLBAR_SIDE_RIGHT
|| (tbSide == RibbonButton.TOOLBAR_SIDE_NOT_LEFT_OR_RIGHT && state == STATE_HOVER)) {
if (state == STATE_NONE) {
gc.setForeground(mInnerToolbarBorderColorTop);
gc.setBackground(mInnerToolbarBorderSideMidpointColor);
}
else if (state == STATE_HOVER) {
gc.setForeground(mToolbarInnerBorderTop_Hover);
gc.setBackground(mToolbarInnerBorderTopBottom_Hover);
}
if (tbSide == RibbonButton.TOOLBAR_SIDE_LEFT) {
gc.fillGradientRectangle(bounds.x-1, bounds.y+1, 1, 7, true);
if (state == STATE_HOVER)
gc.fillGradientRectangle(bounds.x+bounds.width-1, bounds.y+1, 1, 7, true);
}
else {
if (tbSide == RibbonButton.TOOLBAR_SIDE_NOT_LEFT_OR_RIGHT)
gc.fillGradientRectangle(bounds.x+bounds.width-1, bounds.y+1, 1, 7, true);
else
gc.fillGradientRectangle(bounds.x+bounds.width, bounds.y+1, 1, 7, true);
if (state == STATE_HOVER) {
if (tbSide == RibbonButton.TOOLBAR_SIDE_RIGHT || tbSide == RibbonButton.TOOLBAR_SIDE_NOT_LEFT_OR_RIGHT)
gc.fillGradientRectangle(bounds.x-1, bounds.y, 1, 8, true);
else
gc.fillGradientRectangle(bounds.x-1, bounds.y+1, 1, 7, true);
}
}
if (state == STATE_NONE) {
gc.setForeground(mInnerToolbarBorderSideMidpointColor);
gc.setBackground(mInnerToolbarBorderColorBottom);
}
else if (state == STATE_HOVER) {
gc.setForeground(mToolbarInnerBorderBottomTop_Hover);
gc.setBackground(mToolbarInnerBorderBottomBottom_Hover);
}
if (tbSide == RibbonButton.TOOLBAR_SIDE_LEFT) {
gc.fillGradientRectangle(bounds.x-1, bounds.y+1+7, 1, 11, true);
if (state == STATE_HOVER)
gc.fillGradientRectangle(bounds.x+bounds.width-1, bounds.y+1+7, 1, 11, true);
}
else {
if (tbSide == RibbonButton.TOOLBAR_SIDE_NOT_LEFT_OR_RIGHT)
gc.fillGradientRectangle(bounds.x+bounds.width-1, bounds.y+1+7, 1, 11, true);
else
gc.fillGradientRectangle(bounds.x+bounds.width, bounds.y+1+7, 1, 11, true);
if (state == STATE_HOVER)
gc.fillGradientRectangle(bounds.x-1, bounds.y+1+7, 1, 11, true);
}
}
// hover bonus, draws one pixel further in at the top left and bottom left on the left side
if (state == STATE_HOVER) {
if (tbSide == RibbonButton.TOOLBAR_SIDE_LEFT) {
gc.setForeground(mToolbarInnerBorderTop_Hover);
gc.drawLine(bounds.x, bounds.y+1, bounds.x, bounds.y+1);
gc.setForeground(mToolbarInnerBorderBottomBottom_Hover);
gc.drawLine(bounds.x, bounds.y+bounds.height-2, bounds.x, bounds.y+bounds.height-2);
}
}
}
}
private void drawSmallSplitButton(GC gc, int state, AbstractRibbonGroupItem item) {
Rectangle leftBounds = item.getLeftBounds();
Rectangle rightBounds = item.getRightBounds();
Rectangle buttonBounds = item.getBounds();
if (item.isLeftHovered() || item.isLeftSelected()) {
if (item.isLeftHovered() && !item.isLeftSelected()) {
drawButtonOuterBorder(gc, state, SPLIT_LEFT_ACTIVE, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height, true, true, true, true);
drawButtonFills(gc, state, SPLIT_LEFT_ACTIVE, TYPE_BUTTON_SMALL, leftBounds.x+3, leftBounds.y, leftBounds.width-3, leftBounds.height);
drawButtonFills(gc, state, SPLIT_RIGHT_NOT_ACTIVE, TYPE_BUTTON_SMALL, rightBounds.x, rightBounds.y, rightBounds.width, rightBounds.height);
drawButtonInnerBorder(gc, state, SPLIT_LEFT_ACTIVE, TYPE_BUTTON_SMALL, leftBounds.x, leftBounds.y, leftBounds.width, leftBounds.height, true, true, false, true);
drawButtonDecorations(gc, state, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawSplitButtonExtras(gc, STATE_HOVER, SPLIT_LEFT_ACTIVE, TYPE_BUTTON_SMALL, rightBounds.x, rightBounds.y, rightBounds.width, rightBounds.height);
}
else {
// left is selected
if ((item.getStyle() & AbstractRibbonGroupItem.STYLE_TOGGLE) != 0) {
if (item.isLeftSelected() && item.isRightHovered()) {
drawButtonOuterBorder(gc, STATE_HOVER_AND_SELECTED, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width-2, buttonBounds.height, true, true, true, true);
drawButtonFills(gc, STATE_HOVER_AND_SELECTED, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonInnerBorder(gc, STATE_SELECTED, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height, true, true, true, false);
drawButtonOuterBorder(gc, STATE_HOVER, SPLIT_RIGHT_ACTIVE, TYPE_BUTTON_SMALL, rightBounds.x-1, rightBounds.y, rightBounds.width+1, rightBounds.height, false, true, true, true);
drawButtonFills(gc, STATE_HOVER, SPLIT_RIGHT_ACTIVE, TYPE_BUTTON_SMALL, rightBounds.x, rightBounds.y, rightBounds.width, rightBounds.height);
}
else {
if (state == STATE_HOVER_AND_SELECTED) {
drawButtonOuterBorder(gc, STATE_HOVER_AND_SELECTED, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width-2, buttonBounds.height, true, true, true, true);
drawButtonFills(gc, STATE_HOVER_AND_SELECTED, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonInnerBorder(gc, STATE_SELECTED, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height, true, true, true, false);
drawButtonOuterBorder(gc, STATE_HOVER, SPLIT_LEFT_ACTIVE, TYPE_BUTTON_SMALL, rightBounds.x-1, rightBounds.y, rightBounds.width+1, rightBounds.height, false, true, true, true);
drawButtonFills(gc, STATE_HOVER, SPLIT_RIGHT_NOT_ACTIVE, TYPE_BUTTON_SMALL, rightBounds.x, rightBounds.y, rightBounds.width, rightBounds.height);
}
else if (state == STATE_SELECTED) {
drawButtonOuterBorder(gc, STATE_SELECTED, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width-2, buttonBounds.height, true, true, true, true);
drawButtonFills(gc, STATE_SELECTED, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonInnerBorder(gc, STATE_SELECTED, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height, true, true, true, false);
drawButtonOuterBorder(gc, STATE_SELECTED, SPLIT_LEFT_ACTIVE, TYPE_BUTTON_SMALL, rightBounds.x-1, rightBounds.y, rightBounds.width+1, rightBounds.height, false, true, true, true);
drawButtonFills(gc, STATE_SELECTED, SPLIT_RIGHT_NOT_ACTIVE, TYPE_BUTTON_SMALL, rightBounds.x, rightBounds.y, rightBounds.width, rightBounds.height);
}
drawButtonDecorations(gc, state, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height, true, false, true, false, true, false);
drawButtonDecorations(gc, STATE_HOVER, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height, false, true, false, true, false, false);
}
}
else {
drawButtonOuterBorder(gc, STATE_HOVER_AND_SELECTED, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width-2, buttonBounds.height, true, true, true, true);
drawButtonFills(gc, STATE_HOVER_AND_SELECTED, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonInnerBorder(gc, STATE_SELECTED, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height, true, true, true, false);
drawButtonOuterBorder(gc, STATE_HOVER, SPLIT_LEFT_ACTIVE, TYPE_BUTTON_SMALL, rightBounds.x-1, rightBounds.y, rightBounds.width+1, rightBounds.height, false, true, true, true);
drawButtonFills(gc, STATE_HOVER, SPLIT_RIGHT_NOT_ACTIVE, TYPE_BUTTON_SMALL, rightBounds.x, rightBounds.y, rightBounds.width, rightBounds.height);
drawButtonDecorations(gc, state, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height, true, false, true, false, true, false);
drawButtonDecorations(gc, STATE_HOVER, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height, false, true, false, true, false, false);
}
drawSplitButtonExtras(gc, STATE_HOVER_AND_SELECTED, SPLIT_LEFT_ACTIVE, TYPE_BUTTON_SMALL, rightBounds.x, rightBounds.y, rightBounds.width, rightBounds.height);
}
}
else if (item.isRightHovered() || item.isRightSelected()) {
if (item.isRightHovered() && !item.isRightSelected()) {
drawButtonOuterBorder(gc, state, SPLIT_LEFT_ACTIVE, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height, true, true, true, true);
drawButtonFills(gc, state, SPLIT_RIGHT_ACTIVE, TYPE_BUTTON_SMALL, rightBounds.x, rightBounds.y, rightBounds.width, rightBounds.height);
drawButtonFills(gc, state, SPLIT_LEFT_NOT_ACTIVE, TYPE_BUTTON_SMALL, leftBounds.x+3, leftBounds.y, leftBounds.width-3, leftBounds.height);
drawButtonInnerBorder(gc, state, SPLIT_RIGHT_ACTIVE, TYPE_BUTTON_SMALL, leftBounds.x, leftBounds.y, leftBounds.width-1, leftBounds.height, true, true, true, true);
drawButtonInnerBorder(gc, state, SPLIT_RIGHT_ACTIVE, TYPE_BUTTON_SMALL, rightBounds.x-2, rightBounds.y, rightBounds.width+2, rightBounds.height, false, true, true, true);
drawButtonDecorations(gc, state, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawSplitButtonExtras(gc, STATE_HOVER, SPLIT_LEFT_ACTIVE, TYPE_BUTTON_SMALL, rightBounds.x, rightBounds.y, rightBounds.width, rightBounds.height);
}
else {
// right is selected, draw selected button first
drawButtonOuterBorder(gc, STATE_HOVER, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonFills(gc, STATE_HOVER, SPLIT_LEFT_NOT_ACTIVE, TYPE_BUTTON_SMALL, leftBounds.x+3, leftBounds.y, leftBounds.width-3, leftBounds.height);
drawButtonInnerBorder(gc, STATE_HOVER, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonOuterBorder(gc, STATE_SELECTED, SPLIT_LEFT_ACTIVE, TYPE_BUTTON_SMALL, rightBounds.x-2, rightBounds.y, rightBounds.width+2, rightBounds.height, false, true, true, true);
drawButtonOuterBorder(gc, STATE_HOVER_AND_SELECTED, SPLIT_LEFT_ACTIVE, TYPE_BUTTON_SMALL, rightBounds.x-1, rightBounds.y, rightBounds.width+1, rightBounds.height, false, false, false, true);
drawButtonFills(gc, STATE_SELECTED, SPLIT_LEFT_NOT_ACTIVE, TYPE_BUTTON_SMALL, rightBounds.x, rightBounds.y, rightBounds.width, rightBounds.height);
drawButtonInnerBorder(gc, STATE_SELECTED, TYPE_BUTTON_SMALL, rightBounds.x-2, rightBounds.y, rightBounds.width+2, rightBounds.height, false, true, true, false);
drawButtonDecorations(gc, STATE_HOVER, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height, true, false, true, false, false, false);
drawButtonDecorations(gc, STATE_SELECTED, TYPE_BUTTON_SMALL, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height, false, true, false, false, false, true);
drawSplitButtonExtras(gc, STATE_HOVER, SPLIT_LEFT_ACTIVE, TYPE_BUTTON_SMALL, rightBounds.x, rightBounds.y, rightBounds.width, rightBounds.height);
}
}
}
private void drawBigSplitButton(GC gc, int state, AbstractRibbonGroupItem item) {
Rectangle topBounds = item.getTopBounds();
Rectangle bottomBounds = item.getBottomBounds();
Rectangle buttonBounds = item.getBounds();
//System.err.println(state + " " + item + " " + item.isTopHovered() + " " + item.isTopSelected() + " " + item.isBottomHovered() + " " + item.isBottomSelected());
// the following is an obvious no-no on a split button. You can't hover over a top while the bottom is selected (as there are no permanent selections on split buttons)
// so how do we get to this combo of selection and hover?
// this happens when a menu popped up and the user decides to click the top part of the split button instead of elsewhere (which closes the menu).
// the bottom stays pressed while the menu is open and the button isn't quite registering what the user does while it is
// so the various listeners are a little confused at this point, and therefore we need to help it by telling the button what the proper state should be
if (item.isTopHovered() && item.isBottomSelected()) {
item.setBottomSelected(false);
item.setBottomHovered(false);
item.setTopHovered(true);
item.setTopSelected(true);
}
if (item.isTopHovered() || item.isTopSelected()) {
if (item.isTopHovered() && !item.isTopSelected()) {
drawButtonOuterBorder(gc, state, SPLIT_TOP_ACTIVE, TYPE_BUTTON_BIG, topBounds.x, topBounds.y, topBounds.width, topBounds.height-1, true, true, true, true);
drawButtonOuterBorder(gc, state, SPLIT_BOTTOM_NOT_ACTIVE, TYPE_BUTTON_BIG, bottomBounds.x, bottomBounds.y+1, bottomBounds.width, bottomBounds.height-1, true, true, true, true);
drawButtonFills(gc, state, SPLIT_TOP_ACTIVE, TYPE_BUTTON_BIG, topBounds.x, topBounds.y, topBounds.width, topBounds.height-1);
drawButtonFills(gc, state, SPLIT_BOTTOM_NOT_ACTIVE, TYPE_BUTTON_BIG, bottomBounds.x, bottomBounds.y+1, bottomBounds.width, bottomBounds.height-1);
drawButtonInnerBorder(gc, state, SPLIT_TOP_ACTIVE, TYPE_BUTTON_BIG, topBounds.x, topBounds.y, topBounds.width, topBounds.height-1, true, true, true, true);
drawButtonInnerBorder(gc, state, SPLIT_BOTTOM_NOT_ACTIVE, TYPE_BUTTON_BIG, bottomBounds.x, bottomBounds.y+1, bottomBounds.width, bottomBounds.height-1, true, true, true, true);
drawButtonDecorations(gc, state, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawSplitButtonExtras(gc, STATE_HOVER, SPLIT_TOP_ACTIVE, TYPE_BUTTON_BIG, bottomBounds.x, bottomBounds.y, bottomBounds.width, bottomBounds.height);
}
else {
// top is selected
if ((item.getStyle() & AbstractRibbonGroupItem.STYLE_TOGGLE) != 0) {
if (item.isTopSelected() && item.isBottomHovered()) {
drawButtonOuterBorder(gc, STATE_HOVER_AND_SELECTED, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonFills(gc, STATE_HOVER_AND_SELECTED, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonInnerBorder(gc, STATE_HOVER_AND_SELECTED, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonOuterBorder(gc, STATE_HOVER, SPLIT_BOTTOM_ACTIVE, TYPE_BUTTON_BIG, bottomBounds.x, bottomBounds.y+1, bottomBounds.width, bottomBounds.height-1, true, true, true, true);
drawButtonFills(gc, STATE_HOVER, SPLIT_BOTTOM_ACTIVE, TYPE_BUTTON_BIG, bottomBounds.x, bottomBounds.y+1, bottomBounds.width, bottomBounds.height-1);
drawButtonInnerBorder(gc, STATE_HOVER, SPLIT_BOTTOM_ACTIVE, TYPE_BUTTON_BIG, bottomBounds.x, bottomBounds.y+1, bottomBounds.width, bottomBounds.height-1, true, true, true, true);
drawButtonDecorations(gc, STATE_HOVER_AND_SELECTED, SPLIT_TOP_ACTIVE, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height, true, true, true, true, true, true);
drawSplitButtonExtras(gc, STATE_HOVER_AND_SELECTED, SPLIT_TOP_ACTIVE, TYPE_BUTTON_BIG, bottomBounds.x, bottomBounds.y, bottomBounds.width, bottomBounds.height);
}
else {
if (state == STATE_HOVER_AND_SELECTED) {
// top is selected
drawButtonOuterBorder(gc, STATE_HOVER_AND_SELECTED, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonFills(gc, STATE_HOVER_AND_SELECTED, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonInnerBorder(gc, STATE_HOVER_AND_SELECTED, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonOuterBorder(gc, STATE_HOVER, SPLIT_BOTTOM_NOT_ACTIVE, TYPE_BUTTON_BIG, bottomBounds.x, bottomBounds.y+1, bottomBounds.width, bottomBounds.height-1, true, true, true, true);
drawButtonFills(gc, STATE_HOVER, SPLIT_BOTTOM_NOT_ACTIVE, TYPE_BUTTON_BIG, bottomBounds.x, bottomBounds.y+1, bottomBounds.width, bottomBounds.height-1);
drawButtonInnerBorder(gc, STATE_HOVER, SPLIT_BOTTOM_NOT_ACTIVE, TYPE_BUTTON_BIG, bottomBounds.x, bottomBounds.y+1, bottomBounds.width, bottomBounds.height-1, true, true, true, true);
drawButtonDecorations(gc, STATE_HOVER_AND_SELECTED, SPLIT_TOP_ACTIVE, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height, true, true, true, true, true, true);
drawSplitButtonExtras(gc, STATE_HOVER_AND_SELECTED, SPLIT_TOP_ACTIVE, TYPE_BUTTON_BIG, bottomBounds.x, bottomBounds.y, bottomBounds.width, bottomBounds.height);
}
else if (state == STATE_SELECTED) {
drawButtonOuterBorder(gc, STATE_SELECTED, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonFills(gc, STATE_SELECTED, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonInnerBorder(gc, STATE_SELECTED, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonDecorations(gc, STATE_SELECTED, SPLIT_TOP_ACTIVE, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height, true, true, true, true, true, true);
drawSplitButtonExtras(gc, STATE_HOVER_AND_SELECTED, SPLIT_TOP_ACTIVE, TYPE_BUTTON_BIG, bottomBounds.x, bottomBounds.y, bottomBounds.width, bottomBounds.height);
}
}
}
else {
// top is selected
drawButtonOuterBorder(gc, STATE_HOVER_AND_SELECTED, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonFills(gc, STATE_HOVER_AND_SELECTED, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonInnerBorder(gc, STATE_SELECTED, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonOuterBorder(gc, STATE_HOVER, SPLIT_BOTTOM_NOT_ACTIVE, TYPE_BUTTON_BIG, bottomBounds.x, bottomBounds.y+1, bottomBounds.width, bottomBounds.height-1, true, true, true, true);
drawButtonFills(gc, STATE_HOVER, SPLIT_BOTTOM_NOT_ACTIVE, TYPE_BUTTON_BIG, bottomBounds.x, bottomBounds.y+1, bottomBounds.width, bottomBounds.height-1);
drawButtonInnerBorder(gc, STATE_HOVER, SPLIT_BOTTOM_NOT_ACTIVE, TYPE_BUTTON_BIG, bottomBounds.x, bottomBounds.y+1, bottomBounds.width, bottomBounds.height-1, true, true, true, true);
drawButtonDecorations(gc, STATE_HOVER_AND_SELECTED, SPLIT_TOP_ACTIVE, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height, true, true, true, true, true, true);
drawSplitButtonExtras(gc, STATE_HOVER_AND_SELECTED, SPLIT_TOP_ACTIVE, TYPE_BUTTON_BIG, bottomBounds.x, bottomBounds.y, bottomBounds.width, bottomBounds.height);
}
}
}
else if (item.isBottomHovered() || item.isBottomSelected()) {
if (item.isBottomHovered() && !item.isBottomSelected()) {
drawButtonOuterBorder(gc, state, SPLIT_TOP_NOT_ACTIVE, TYPE_BUTTON_BIG, topBounds.x, topBounds.y, topBounds.width, topBounds.height-1, true, true, true, true);
drawButtonOuterBorder(gc, state, SPLIT_BOTTOM_NOT_ACTIVE, TYPE_BUTTON_BIG, bottomBounds.x, bottomBounds.y+1, bottomBounds.width, bottomBounds.height-1, true, true, true, true);
drawButtonFills(gc, state, SPLIT_TOP_NOT_ACTIVE, TYPE_BUTTON_BIG, topBounds.x, topBounds.y, topBounds.width, topBounds.height-1);
drawButtonFills(gc, state, SPLIT_BOTTOM_ACTIVE, TYPE_BUTTON_BIG, bottomBounds.x, bottomBounds.y+1, bottomBounds.width, bottomBounds.height-1);
drawButtonInnerBorder(gc, state, SPLIT_TOP_NOT_ACTIVE, TYPE_BUTTON_BIG, topBounds.x, topBounds.y, topBounds.width, topBounds.height-1, true, true, true, true);
drawButtonInnerBorder(gc, state, SPLIT_BOTTOM_ACTIVE, TYPE_BUTTON_BIG, bottomBounds.x, bottomBounds.y+1, bottomBounds.width, bottomBounds.height-1, true, true, true, true);
drawButtonDecorations(gc, state, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawSplitButtonExtras(gc, STATE_HOVER, SPLIT_BOTTOM_ACTIVE, TYPE_BUTTON_BIG, bottomBounds.x, bottomBounds.y, bottomBounds.width, bottomBounds.height);
}
else {
// bottom is selected, draw selected button first
drawButtonOuterBorder(gc, STATE_SELECTED, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonFills(gc, STATE_HOVER_AND_SELECTED, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
drawButtonInnerBorder(gc, STATE_SELECTED, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height);
// override by drawing the top
drawButtonOuterBorder(gc, STATE_HOVER, SPLIT_TOP_ACTIVE, TYPE_BUTTON_BIG, topBounds.x, topBounds.y, topBounds.width, topBounds.height-1, true, true, true, true);
drawButtonFills(gc, STATE_HOVER, SPLIT_TOP_NOT_ACTIVE, TYPE_BUTTON_BIG, topBounds.x, topBounds.y, topBounds.width, topBounds.height-1);
// fill bottom
drawButtonFills(gc, STATE_HOVER_AND_SELECTED, SPLIT_BOTTOM_ACTIVE, TYPE_BUTTON_BIG, bottomBounds.x, bottomBounds.y, bottomBounds.width, bottomBounds.height);
drawButtonInnerBorder(gc, STATE_HOVER, SPLIT_TOP_NOT_ACTIVE, TYPE_BUTTON_BIG, topBounds.x, topBounds.y, topBounds.width, topBounds.height-1, true, true, true, true);
drawButtonDecorations(gc, STATE_HOVER_AND_SELECTED, SPLIT_BOTTOM_ACTIVE, TYPE_BUTTON_BIG, buttonBounds.x, buttonBounds.y, buttonBounds.width, buttonBounds.height, true, true, true, true, true, true);
drawSplitButtonExtras(gc, STATE_HOVER_AND_SELECTED, SPLIT_BOTTOM_ACTIVE, TYPE_BUTTON_BIG, bottomBounds.x, bottomBounds.y, bottomBounds.width, bottomBounds.height);
}
}
}
private int getState(AbstractRibbonGroupItem item) {
int state = STATE_NONE;
if (item.isHoverButton() && !item.isSelected())
state = STATE_HOVER;
else if (item.isSelected() && !item.isHoverButton())
state = STATE_SELECTED;
else if (item.isSelected() && item.isHoverButton())
state = STATE_HOVER_AND_SELECTED;
return state;
}
public void drawButtonImage(GC gc, int buttonSize, AbstractRibbonGroupItem item) {
Image toUse = item.getImage();
if (!item.isEnabled())
toUse = item.getDisabledImage() == null ? toUse : item.getDisabledImage();
if (toUse == null)
return;
Rectangle imBounds = toUse.getBounds();
Rectangle itemBounds = item.getBounds();
int border = 2*2; // -4 as border is 2 * 2 and we don't let any image take up border property
if (buttonSize == BUTTON_BIG) {
int maxSpace = itemBounds.width - border;
int diff = Math.abs(maxSpace - imBounds.width);
int spacer = diff/2;
int extra = (diff % 2 != 0) ? 1 : 0;
gc.drawImage(toUse, itemBounds.x+2+spacer+extra, itemBounds.y+3);
}
else {
int spacer = 0;
int space = 22;
space -= 4; // border
int leftOver = space - imBounds.height;
// vertical image alignment
switch (item.getImageVerticalAlignment()) {
default:
case SWT.NONE:
case SWT.CENTER:
spacer = leftOver/2;
break;
case SWT.TOP:
spacer = 1;
break;
case SWT.BOTTOM:
spacer = (itemBounds.height - 4 - 1 - imBounds.height);
break;
}
int offsetX = 0;
int offsetY = 0;
if (item.isToolbarButton()) {
offsetX = -1;
offsetY = -1;
}
gc.drawImage(toUse, itemBounds.x+4+offsetX, itemBounds.y+2+spacer+offsetY);
}
}
public void drawButtonText(GC gc, int state, int buttonSize, AbstractRibbonGroupItem item) {
String toDraw = item.getName();
int maxSpace = item.getBounds().width - 4; // -4 as border is 2 * 2 and we don't let any image take up border property
int spacer = 0;
int extra = 0;
boolean anyText = false;
if (toDraw != null && toDraw.length() != 0) {
anyText = true;
Point strExtent = gc.stringExtent(toDraw);
int diff = Math.abs(maxSpace - strExtent.x);
spacer = diff/2;
extra = (diff % 2 != 0) ? 1 : 0;
}
int yStart = item.getBounds().y+38;
if (buttonSize == BUTTON_SMALL)
yStart = item.getBounds().y+4;
Image toUse = item.getImage();
if (!item.isEnabled())
toUse = item.getDisabledImage() == null ? toUse : item.getDisabledImage();
Rectangle imBounds = (toUse == null ? new Rectangle(0, 0, 0, 0) : toUse.getBounds());
boolean drawArrow = (item.isArrow() || item.isSplit());
int xStart = item.getBounds().x+3+spacer+extra;
if (buttonSize == BUTTON_SMALL)
xStart = item.getBounds().x+3+imBounds.width+4;
if (buttonSize == BUTTON_BIG && item.isTwoLineText() && anyText) {
StringTokenizer st = new StringTokenizer(toDraw, "\n");
int curY = yStart;
int count = 0;
while (st.hasMoreTokens()) {
String token = st.nextToken();
Point tokenStrExtent = gc.stringExtent(token);
int tokenDiff = Math.abs(maxSpace - tokenStrExtent.x);
int tokenSpacer = tokenDiff/2;
int tokenExtra = (tokenDiff % 2 != 0) ? 1 : 0;
xStart = item.getBounds().x+3+tokenSpacer+tokenExtra;
if (count == 1)
xStart -= 5; // -5 = arrow width
if (!item.isEnabled()) {
gc.setForeground(mTextFadedRight_Disabled);
gc.drawText(token, xStart, curY, true);
gc.setForeground(mTextFadedLeft_Disabled);
gc.drawText(token, xStart, curY, true);
gc.setForeground(mTextColor_Disabled);
gc.drawText(token, xStart, curY, true);
}
else {
gc.setForeground(mTextColor);
gc.drawText(token, xStart, curY, true);
}
if (count == 1 && drawArrow) {
drawArrow(gc, xStart + tokenStrExtent.x + 3, curY+5, state, item.isEnabled());
}
curY += gc.stringExtent(token).y;
count++;
}
}
else {
xStart++;
// draw text
if (anyText) {
if (item.getName() != null) {
if (!item.isEnabled()) {
gc.setForeground(mTextFadedRight_Disabled);
gc.drawText(toDraw, xStart, yStart, true);
gc.setForeground(mTextFadedLeft_Disabled);
gc.drawText(toDraw, xStart, yStart, true);
gc.setForeground(mTextColor_Disabled);
gc.drawText(toDraw, xStart, yStart, true);
}
else {
gc.setForeground(mTextColor);
gc.drawText(toDraw, xStart, yStart, true);
}
}
}
if (drawArrow) {
if (buttonSize == BUTTON_BIG) {
//System.err.println(token +"" + tokenStrExtent.x);
drawArrow(gc, xStart + (item.getBounds().width/2)-10, 58, state, item.isEnabled());
}
else {
xStart = item.getBounds().x+item.getBounds().width-4-5+1;
drawArrow(gc, xStart, yStart+5, state, item.isEnabled());
}
}
}
}
public void drawSplitButtonExtras(GC gc, int state, int split, int buttonSize, int x, int y, int width, int height) {
// figure out the middle point
int middleWidth = (width/2);
int extra = 0;
if (width % 2 != 0)
extra = 1;
// line just below the split, usually the top inner border, but it's different on a split button
if (buttonSize == BUTTON_BIG) {
if (state == STATE_HOVER_AND_SELECTED) {
if (split == SPLIT_BOTTOM_ACTIVE) {
gc.setForeground(mSplitBottomSelectedTopLineLeft_Hover);
gc.setBackground(mSplitBottomSelectedTopLineMid_Hover);
gc.fillGradientRectangle(x+1, y+2, middleWidth-1, 1, false);
gc.setForeground(mSplitBottomSelectedTopLineMid_Hover);
gc.setBackground(mSplitBottomSelectedTopLineLeft_Hover);
gc.fillGradientRectangle(x+middleWidth-1, y+2, middleWidth+extra+1, 1, false);
}
else if (split == SPLIT_TOP_ACTIVE) {
gc.setForeground(mSplitBottomSelectedTopLineLeft_Selected);
gc.setBackground(mSplitBottomSelectedTopLineMid_Selected);
gc.fillGradientRectangle(x+1, y+2, middleWidth-1, 1, false);
gc.setForeground(mSplitBottomSelectedTopLineMid_Selected);
gc.setBackground(mSplitBottomSelectedTopLineLeft_Selected);
gc.fillGradientRectangle(x+middleWidth-1, y+2, middleWidth+extra+1, 1, false);
}
}
else if (state == STATE_HOVER) {
// missing corner pixels of top inner corner of bottom split section
gc.setForeground(mButtonInnerSideBottomTop_Hover);
gc.drawLine(x+1, y+2, x+1, y+2);
gc.drawLine(x+width-1, y+2, x+width-1, y+2);
}
// draw center split
if (state == STATE_HOVER_AND_SELECTED && split == SPLIT_TOP_ACTIVE) {
gc.setForeground(mSplitDividerLineLeft_Selected);
gc.setBackground(mSplitDividerLineMid_Selected);
}
else {
gc.setForeground(mSplitDividerLineLeft_Hover);
gc.setBackground(mSplitDividerLineMid_Hover);
}
gc.fillGradientRectangle(x+1, y+1, middleWidth-1, 1, false);
if (state == STATE_HOVER_AND_SELECTED && split == SPLIT_TOP_ACTIVE) {
gc.setForeground(mSplitDividerLineMid_Selected);
gc.setBackground(mSplitDividerLineLeft_Selected);
}
else {
gc.setForeground(mSplitDividerLineMid_Hover);
gc.setBackground(mSplitDividerLineLeft_Hover);
}
gc.fillGradientRectangle(x+middleWidth-1, y+1, middleWidth+extra+1, 1, false);
if (state == STATE_HOVER_AND_SELECTED) {
if (split == SPLIT_TOP_ACTIVE) {
gc.setForeground(mButtonOuterSideBottomTop_Selected);
gc.drawLine(x, y+2, x, y+2);
gc.drawLine(x+width, y+2, x+width, y+2);
}
else {
gc.setForeground(mButtonOuterSideBottomTop_Hover);
gc.drawLine(x, y+2, x, y+2);
gc.drawLine(x+width, y+2, x+width, y+2);
}
}
}
else if (buttonSize == BUTTON_SMALL) {
// draw center split
if (state == STATE_HOVER_AND_SELECTED && split == SPLIT_TOP_ACTIVE) {
gc.setForeground(mSplitDividerLineTopVertical_Selected);
gc.setBackground(mSplitDividerLineMidVertical_Selected);
}
else {
gc.setForeground(mSplitDividerLineTopVertical_Hover);
gc.setBackground(mSplitDividerLineMidVertical_Hover);
}
gc.fillGradientRectangle(x+width-12, y+1, 1, 10, true);
if (state == STATE_HOVER_AND_SELECTED && split == SPLIT_TOP_ACTIVE) {
gc.setForeground(mSplitDividerLineMidVertical_Selected);
gc.setBackground(mSplitDividerLineTopVertical_Selected);
}
else {
gc.setForeground(mSplitDividerLineMidVertical_Hover);
gc.setBackground(mSplitDividerLineTopVertical_Hover);
}
gc.fillGradientRectangle(x+width-12, y+1+10, 1, 10, true);
}
}
public void drawButtonDecorations(GC gc, int state, int buttonSize, int x, int y, int width, int height, boolean topLeftCorner, boolean topRightCorner, boolean bottomLeftCorner, boolean bottomRightCorner, boolean bottomLeftSpecial, boolean bottomRightSpecial) {
drawButtonDecorations(gc, state, SPLIT_NOT_SPLIT, buttonSize, x, y, width, height, topLeftCorner, topRightCorner, bottomLeftCorner, bottomRightCorner, bottomLeftSpecial, bottomRightSpecial);
}
public void drawButtonDecorations(GC gc, int state, int buttonSize, int x, int y, int width, int height) {
drawButtonDecorations(gc, state, SPLIT_NOT_SPLIT, buttonSize, x, y, width, height, true, true, true, true, true, true);
}
public void drawButtonDecorations(GC gc, int state, int split, int buttonSize, int x, int y, int width, int height, boolean topLeftCorner, boolean topRightCorner, boolean bottomLeftCorner, boolean bottomRightCorner, boolean bottomLeftSpecial, boolean bottomRightSpecial) {
// CORNER PIXELS
if (state == STATE_HOVER) {
if (buttonSize == BUTTON_BIG)
gc.setForeground(mButtonTopCornerPixel_Hover);
else
gc.setForeground(mButtonSmallTopCornerPixel_Hover);
}
else if (state == STATE_SELECTED) {
if (buttonSize == BUTTON_BIG)
gc.setForeground(mButtonTopCornerPixel_Selected);
else
gc.setForeground(mButtonSmallTopCornerPixel_Selected);
}
else if (state == STATE_HOVER_AND_SELECTED) {
if (buttonSize == BUTTON_BIG) {
if (split == SPLIT_BOTTOM_ACTIVE) {
gc.setForeground(mButtonTopCornerPixel_Hover);
}
else
gc.setForeground(mButtonTopCornerPixel_HoverSelected);
}
else
gc.setForeground(mButtonSmallTopCornerPixel_HoverSelected);
}
// top left corner
if (topLeftCorner)
gc.drawLine(x+1, y+1, x+1, y+1);
// top right corner
if (topRightCorner)
gc.drawLine(x+width-1, y+1, x+width-1, y+1);
// small buttons have a further down pixel just below the above in selected and hover+selected modes
if (buttonSize == BUTTON_SMALL && (state == STATE_SELECTED || state == STATE_HOVER_AND_SELECTED)) {
if (state == STATE_SELECTED)
gc.setForeground(mButtonSmallExtraTopBottomPixel_Selected);
else if (state == STATE_HOVER_AND_SELECTED)
gc.setForeground(mButtonSmallExtraTopBottomPixel_HoverSelected);
// top left corner #2
if (topLeftCorner)
gc.drawLine(x+1, y+2, x+1, y+2);
// top right corner #2
if (topRightCorner)
gc.drawLine(x+width-1, y+2, x+width-1, y+2);
}
if (state == STATE_HOVER || state == STATE_HOVER_AND_SELECTED || buttonSize == BUTTON_SMALL) {
if (state == STATE_HOVER) {
if (buttonSize == BUTTON_BIG)
gc.setForeground(mButtonBottomCornerPixel_Hover);
else
gc.setForeground(mButtonSmallBottomCornerPixel_Hover);
}
else if (state == STATE_SELECTED)
gc.setForeground(mButtonSmallBottomCornerPixel_Selected);
else if (state == STATE_HOVER_AND_SELECTED) {
if (buttonSize == BUTTON_BIG) {
if (split == SPLIT_TOP_ACTIVE)
gc.setForeground(mButtonBottomCornerPixel_Hover);
else
gc.setForeground(mButtonBottomCornerPixel_HoverSelected);
}
else
gc.setForeground(mButtonSmallBottomCornerPixel_HoverSelected);
}
if (state == STATE_HOVER_AND_SELECTED && split == SPLIT_BOTTOM_ACTIVE) {
gc.setForeground(mButtonBottomCornerPixel_Selected);
// also on split button
// top bottom corner
if (bottomLeftCorner)
gc.drawLine(x+2, y+height-2, x+2, y+height-2);
// top bottom corner
if (bottomRightCorner)
gc.drawLine(x+width-2, y+height-2, x+width-2, y+height-2);
}
// top bottom corner
if (bottomLeftCorner)
gc.drawLine(x+1, y+height-2, x+1, y+height-2);
// top bottom corner
if (bottomRightCorner)
gc.drawLine(x+width-1, y+height-2, x+width-1, y+height-2);
}
else {
gc.setForeground(mButtonBottomCornerPixel_Selected);
// top bottom corner
if (bottomLeftCorner)
gc.drawLine(x+2, y+height-2, x+2, y+height-2);
// top bottom corner
if (bottomRightCorner)
gc.drawLine(x+width-2, y+height-2, x+width-2, y+height-2);
}
// hover+selected small button has some extra colors drawn inwards a few pixels in the bottom left and right corners, 1px up from the very bottom
// it's 5px wide,
if (state == STATE_HOVER_AND_SELECTED && buttonSize == BUTTON_SMALL && width > (5*2+(2*2))) {
gc.setForeground(mButtonSmallBottomCornerInwards_HoverSelected);
// left
if (bottomLeftSpecial)
gc.drawLine(x+2, y+height-2, x+2+5, y+height-2);
// right
if (bottomRightSpecial)
gc.drawLine(x+width-2, y+height-2, x+width-2-5, y+height-2);
}
}
public void drawButtonFills(GC gc, int state, int buttonSize, int x, int y, int width, int height) {
drawButtonFills(gc, state, SPLIT_NOT_SPLIT, buttonSize, x, y, width, height);
}
public void drawButtonFills(GC gc, int state, int split, int buttonSize, int x, int y, int width, int height) {
int topPart = 0;
int bottomPart = 0;
int yStart = 0;
int xStart = 0;
int xWidth = 0;
// selected and hover+selected are slightly slightly different in gradient sizes as well as where we start
if (buttonSize == BUTTON_BIG) {
if (state == STATE_SELECTED || state == STATE_HOVER_AND_SELECTED) {
yStart = y+4;
xStart = x+2;
xWidth = width-3;
topPart = 22;
bottomPart = 39;
if (state == STATE_HOVER_AND_SELECTED && split == SPLIT_BOTTOM_ACTIVE) {
yStart--;
}
}
else {
yStart = y+2;
xStart = x+2;
xWidth = width-3;
topPart = 23;
bottomPart = 39;
}
}
else if (buttonSize == BUTTON_SMALL) {
if (state == STATE_SELECTED || state == STATE_HOVER_AND_SELECTED) {
yStart = y+4;
xStart = x+2;
xWidth = width-3;
topPart = 9;
bottomPart = 8;
}
else if (state == STATE_HOVER) {
yStart = y+2;
xStart = x+2;
xWidth = width-3;
topPart = 9;
bottomPart = 9;
}
if (split != SPLIT_NOT_SPLIT) {
yStart = y+1;
xWidth = width+1;
xStart = x-1;
topPart = 10;
bottomPart = 10;
}
}
if (split != SPLIT_NOT_SPLIT) {
if (buttonSize == BUTTON_BIG) {
if (split == SPLIT_TOP_ACTIVE) {
topPart = 22;
bottomPart = 12;
}
else if (split == SPLIT_BOTTOM_NOT_ACTIVE) {
topPart = 0;
bottomPart = 26;
}
else if (split == SPLIT_BOTTOM_ACTIVE) {
topPart = 0;
bottomPart = 26;
if (state == STATE_HOVER_AND_SELECTED && split == SPLIT_BOTTOM_ACTIVE) {
bottomPart++;
}
}
else if (split == SPLIT_TOP_NOT_ACTIVE) {
topPart = 22;
bottomPart = 12;
}
}
}
// special at the top of selected and hover+selected buttons, just the first two lines at the very top
if (split == SPLIT_NOT_SPLIT) {
if (state == STATE_SELECTED || state == STATE_HOVER_AND_SELECTED) {
if (state == STATE_SELECTED) {
if (buttonSize == BUTTON_BIG)
gc.setForeground(mButtonFillTopInnerLineOne_Selected);
else
gc.setForeground(mButtonSmallFillTopInnerLineOne_Selected);
}
else if (state == STATE_HOVER_AND_SELECTED) {
if (buttonSize == BUTTON_BIG)
gc.setForeground(mButtonFillTopInnerLineOne_HoverSelected);
else
gc.setForeground(mButtonSmallFillTopInnerLineOne_HoverSelected);
}
gc.drawLine(xStart, yStart-2, xStart+xWidth, yStart-2);
if (state == STATE_SELECTED) {
if (buttonSize == BUTTON_BIG)
gc.setForeground(mButtonFillTopInnerLineTwo_Selected);
else
gc.setForeground(mButtonSmallFillTopInnerLineTwo_Selected);
}
else if (state == STATE_HOVER_AND_SELECTED) {
if (buttonSize == BUTTON_BIG)
gc.setForeground(mButtonFillTopInnerLineTwo_HoverSelected);
else
gc.setForeground(mButtonSmallFillTopInnerLineTwo_HoverSelected);
}
gc.drawLine(xStart, yStart-1, xStart+xWidth, yStart-1);
}
}
// top or left part
if (state == STATE_HOVER) {
if (buttonSize == BUTTON_BIG) {
if (split == SPLIT_TOP_NOT_ACTIVE) {
gc.setForeground(mButtonSplitFillTopTop_NonSelectedHover);
gc.setBackground(mButtonSplitFillTopBottom_NonSelectedHover);
}
else {
gc.setForeground(mButtonFillTopTop_Hover);
gc.setBackground(mButtonFillTopBottom_Hover);
}
}
else {
if (split == SPLIT_RIGHT_NOT_ACTIVE || split == SPLIT_LEFT_NOT_ACTIVE) {
gc.setForeground(mButtonSplitFillTopTop_NonSelectedHover);
gc.setBackground(mButtonSplitFillTopBottom_NonSelectedHover);
}
else {
gc.setForeground(mButtonSmallFillTopTop_Hover);
gc.setBackground(mButtonSmallFillTopBottom_Hover);
}
}
}
else if (state == STATE_SELECTED) {
if (buttonSize == BUTTON_BIG) {
if (split == SPLIT_TOP_NOT_ACTIVE) {
gc.setForeground(mButtonSplitFillBottomPartTop_NonSelectedHover);
gc.setBackground(mButtonSplitFillBottomPartBottom_NonSelectedHover);
}
else {
gc.setForeground(mButtonFillTopTop_Selected);
gc.setBackground(mButtonFillTopBottom_Selected);
}
}
else {
gc.setForeground(mButtonSmallFillTopTop_Selected);
gc.setBackground(mButtonSmallFillTopBottom_Selected);
}
}
else if (state == STATE_HOVER_AND_SELECTED) {
if (buttonSize == BUTTON_BIG) {
if (split == SPLIT_TOP_NOT_ACTIVE) {
gc.setForeground(mButtonSplitFillBottomPartTop_NonSelectedHover);
gc.setBackground(mButtonSplitFillBottomPartBottom_NonSelectedHover);
}
else {
gc.setForeground(mButtonFillTopTop_HoverSelected);
gc.setBackground(mButtonFillTopBottom_HoverSelected);
}
}
else {
gc.setForeground(mButtonSmallFillTopTop_HoverSelected);
gc.setBackground(mButtonSmallFillTopBottom_HoverSelected);
}
}
gc.fillGradientRectangle(xStart, yStart, xWidth, topPart, true);
// bottom part
if (state == STATE_HOVER) {
if (buttonSize == BUTTON_BIG) {
if (split == SPLIT_BOTTOM_NOT_ACTIVE) {
gc.setForeground(mButtonSplitFillBottomPartTop_NonSelectedHover);
gc.setBackground(mButtonSplitFillBottomPartBottom_NonSelectedHover);
}
else if (split == SPLIT_TOP_NOT_ACTIVE) {
gc.setForeground(mButtonSplitFillBottomTop_NonSelectedHover);
gc.setBackground(mButtonSplitFillBottomBottom_NonSelectedHover);
}
else {
gc.setForeground(mButtonFillBottomTop_Hover);
gc.setBackground(mButtonFillBottomBottom_Hover);
}
}
else {
if (split == SPLIT_RIGHT_NOT_ACTIVE || split == SPLIT_LEFT_NOT_ACTIVE) {
gc.setForeground(mButtonSplitFillBottomTop_NonSelectedHover);
gc.setBackground(mButtonSplitFillBottomBottom_NonSelectedHover);
}
else {
gc.setForeground(mButtonSmallFillBottomTop_Hover);
gc.setBackground(mButtonSmallFillBottomBottom_Hover);
}
}
}
else if (state == STATE_SELECTED) {
if (buttonSize == BUTTON_BIG) {
if (split == SPLIT_TOP_NOT_ACTIVE) {
gc.setForeground(mButtonSplitFillBottomPartTop_NonSelectedHover);
gc.setBackground(mButtonSplitFillBottomPartBottom_NonSelectedHover);
}
else {
gc.setForeground(mButtonFillBottomTop_Selected);
gc.setBackground(mButtonFillBottomBottom_Selected);
}
}
else {
gc.setForeground(mButtonSmallFillBottomTop_Selected);
gc.setBackground(mButtonSmallFillBottomBottom_Selected);
}
}
else if (state == STATE_HOVER_AND_SELECTED) {
if (buttonSize == BUTTON_BIG) {
if (split == SPLIT_TOP_NOT_ACTIVE) {
gc.setForeground(mButtonSplitFillBottomPartTop_NonSelectedHover);
gc.setBackground(mButtonSplitFillBottomPartBottom_NonSelectedHover);
}
else if (split == SPLIT_BOTTOM_ACTIVE) {
gc.setForeground(mButtonSplitFillBottomPartTop_SelectedHover);
gc.setBackground(mButtonSplitFillBottomPartBottom_SelectedHover);
}
else {
gc.setForeground(mButtonFillBottomTop_HoverSelected);
gc.setBackground(mButtonFillBottomBottom_HoverSelected);
}
}
else {
gc.setForeground(mButtonSmallFillBottomTop_HoverSelected);
gc.setBackground(mButtonSmallFillBottomBottom_HoverSelected);
}
}
gc.fillGradientRectangle(xStart, yStart+topPart, xWidth, bottomPart, true);
}
public void drawButtonInnerBorder(GC gc, int state, int buttonSize, int x, int y, int width, int height, boolean drawLeft, boolean drawTop, boolean drawRight, boolean drawBottom) {
drawButtonInnerBorder(gc, state, SPLIT_NOT_SPLIT, buttonSize, x, y, width, height, drawLeft, drawTop, drawRight, drawBottom);
}
public void drawButtonInnerBorder(GC gc, int state, int buttonSize, int x, int y, int width, int height) {
drawButtonInnerBorder(gc, state, SPLIT_NOT_SPLIT, buttonSize, x, y, width, height, true, true, true, true);
}
public void drawButtonInnerBorder(GC gc, int state, int split, int buttonSize, int x, int y, int width, int height, boolean drawLeft, boolean drawTop, boolean drawRight, boolean drawBottom) {
// figure out the middle point
int middleWidth = (width/2);
int extra = 0;
if (width % 2 != 0)
extra = 1;
int topPart = 0;
int bottomPart = 0;
int yStartSide = 0;
// selected and hover+selected are slightly slightly different in gradient sizes as well as where we start
if (buttonSize == BUTTON_BIG) {
if (state == STATE_SELECTED || state == STATE_HOVER_AND_SELECTED) {
yStartSide = y+2;
topPart = 22;
bottomPart = 41;
}
else {
yStartSide = y+2;
topPart = 23;
bottomPart = 39;
}
}
else if (buttonSize == BUTTON_SMALL) {
if (state == STATE_SELECTED || state == STATE_HOVER_AND_SELECTED) {
yStartSide = y+3;
topPart = 10;
bottomPart = 7;
}
else {
yStartSide = y+2;
topPart = 9;
bottomPart = 9;
}
}
// split buttons need to adhere strongly to bounds numbers
if (split != SPLIT_NOT_SPLIT) {
if (buttonSize == BUTTON_BIG) {
if (split == SPLIT_TOP_ACTIVE) {
topPart = 22;
bottomPart = 12;
}
else if (split == SPLIT_BOTTOM_NOT_ACTIVE) {
yStartSide = y+1;
topPart = 0;
bottomPart = 28;
}
else if (split == SPLIT_TOP_NOT_ACTIVE) {
topPart = 22;
bottomPart = 12;
}
else if (split == SPLIT_BOTTOM_ACTIVE) {
topPart = 0;
bottomPart = 26;
}
}
else {
}
}
// top border
if (state == STATE_HOVER) {
if (buttonSize == BUTTON_BIG) {
if (split == SPLIT_BOTTOM_NOT_ACTIVE)
gc.setForeground(mButtonSplitFillBottomPartTop_NonSelectedHover); // TODO: this part should be gradient, even though it's barely noticeable to the eye
else if (split == SPLIT_BOTTOM_ACTIVE)
gc.setForeground(mButtonInnerSideBottomTop_Hover);
else
gc.setForeground(mButtonInnerTop_Hover);
}
else
gc.setForeground(mButtonSmallInnerTop_Hover);
}
else if (state == STATE_SELECTED) {
if (buttonSize == BUTTON_BIG)
gc.setForeground(mButtonInnerTop_Selected);
else
gc.setForeground(mButtonSmallInnerTop_Selected);
}
else if (state == STATE_HOVER_AND_SELECTED) {
if (buttonSize == BUTTON_BIG)
gc.setForeground(mButtonInnerTop_HoverSelected);
else
gc.setForeground(mButtonSmallInnerTop_HoverSelected);
}
// inner top line
if (drawTop) {
if (buttonSize == BUTTON_SMALL && split != SPLIT_NOT_SPLIT)
gc.drawLine(x+2, y+1, x+width-1, y+1);
else
gc.drawLine(x+2, y+1, x+width-2, y+1);
}
// side borders
// inner left side
if (state == STATE_HOVER) {
if (buttonSize == BUTTON_BIG) {
if (split == SPLIT_TOP_ACTIVE) {
gc.setForeground(mButtonSplitFillTopTop_NonSelectedHover);
gc.setBackground(mButtonSplitFillTopBottom_NonSelectedHover);
}
else {
gc.setForeground(mButtonInnerSideTopTop_Hover);
gc.setBackground(mButtonInnerSideTopBottom_Hover);
}
}
else {
gc.setForeground(mButtonSmallInnerSideTopTop_Hover);
gc.setBackground(mButtonSmallInnerSideTopBottom_Hover);
}
}
else if (state == STATE_SELECTED) {
if (buttonSize == BUTTON_BIG) {
gc.setForeground(mButtonInnerSideTopTop_Selected);
gc.setBackground(mButtonInnerSideTopBottom_Selected);
}
else {
gc.setForeground(mButtonSmallInnerSideTopTop_Selected);
gc.setBackground(mButtonSmallInnerSideTopBottom_Selected);
}
}
else if (state == STATE_HOVER_AND_SELECTED) {
if (buttonSize == BUTTON_BIG) {
gc.setForeground(mButtonInnerSideTopTop_HoverSelected);
gc.setBackground(mButtonInnerSideTopBottom_HoverSelected);
}
else {
gc.setForeground(mButtonSmallInnerSideTopTop_HoverSelected);
gc.setBackground(mButtonSmallInnerSideTopBottom_HoverSelected);
}
}
// left side top
if (drawLeft)
gc.fillGradientRectangle(x+1, yStartSide, 1, topPart, true);
// right side top, small split button doesn't have one
if (drawRight) {
//if (buttonSize != BUTTON_SMALL_NORMAL || split == SPLIT_NOT_SPLIT)
gc.fillGradientRectangle(x+width-1, yStartSide, 1, topPart, true);
}
if (state == STATE_HOVER) {
if (buttonSize == BUTTON_BIG) {
if (split == SPLIT_TOP_ACTIVE) {
gc.setForeground(mButtonSplitFillBottomTop_NonSelectedHover);
gc.setBackground(mButtonSplitFillBottomBottom_NonSelectedHover);
}
else if (split == SPLIT_TOP_NOT_ACTIVE) {
gc.setForeground(mButtonSplitFillBottomPartTop_NonSelectedHover);
gc.setBackground(mButtonSplitFillBottomPartTop_NonSelectedHover);
}
else {
gc.setForeground(mButtonInnerSideBottomTop_Hover);
gc.setBackground(mButtonInnerSideBottomBottom_Hover);
}
}
else {
gc.setForeground(mButtonSmallInnerSideBottomTop_Hover);
gc.setBackground(mButtonSmallInnerSideBottomBottom_Hover);
}
}
else if (state == STATE_SELECTED) {
if (buttonSize == BUTTON_BIG) {
gc.setForeground(mButtonInnerSideBottomTop_Selected);
gc.setBackground(mButtonInnerSideBottomBottom_Selected);
}
else {
gc.setForeground(mButtonSmallInnerSideBottomTop_Selected);
gc.setBackground(mButtonSmallInnerSideBottomBottom_Selected);
}
}
else if (state == STATE_HOVER_AND_SELECTED) {
if (buttonSize == BUTTON_BIG) {
gc.setForeground(mButtonInnerSideBottomTop_HoverSelected);
gc.setBackground(mButtonInnerSideBottomBottom_HoverSelected);
}
else {
gc.setForeground(mButtonSmallInnerSideBottomTop_HoverSelected);
gc.setBackground(mButtonSmallInnerSideBottomBottom_HoverSelected);
}
}
// left side bottom
if (drawLeft)
gc.fillGradientRectangle(x+1, yStartSide+topPart, 1, bottomPart, true);
// right side bottom
if (drawRight) {
//if (buttonSize != BUTTON_SMALL_NORMAL || split == SPLIT_NOT_SPLIT)
gc.fillGradientRectangle(x+width-1, yStartSide+topPart, 1, bottomPart, true);
}
if (drawBottom) {
if (split == SPLIT_BOTTOM_NOT_ACTIVE || split == SPLIT_BOTTOM_ACTIVE || split == SPLIT_NOT_SPLIT || buttonSize == BUTTON_SMALL) {
// bottom border
if (state == STATE_HOVER || (buttonSize == BUTTON_BIG && state == STATE_HOVER_AND_SELECTED) || (state == STATE_SELECTED && buttonSize == BUTTON_SMALL)) {
if (state == STATE_HOVER) {
if (buttonSize == BUTTON_BIG) {
gc.setForeground(mButtonInnerBottomLeft_Hover);
gc.setBackground(mButtonInnerBottomMiddle_Hover);
}
else {
gc.setForeground(mButtonSmallInnerBottomLeft_Hover);
gc.setBackground(mButtonSmallInnerBottomMiddle_Hover);
}
}
else if (state == STATE_SELECTED) {
if (buttonSize == BUTTON_SMALL) {
gc.setForeground(mButtonSmallInnerBottomLeft_Selected);
gc.setBackground(mButtonSmallInnerBottomMiddle_Selected);
}
}
else if (state == STATE_HOVER_AND_SELECTED){
gc.setForeground(mButtonInnerBottomLeft_HoverSelected);
gc.setBackground(mButtonInnerBottomMiddle_HoverSelected);
}
// left part
gc.fillGradientRectangle(x+2, y+height-2, middleWidth-1, 1, false);
if (state == STATE_HOVER) {
if (buttonSize == BUTTON_BIG) {
gc.setForeground(mButtonInnerBottomMiddle_Hover);
gc.setBackground(mButtonInnerBottomRight_Hover);
}
else {
gc.setForeground(mButtonSmallInnerBottomMiddle_Hover);
gc.setBackground(mButtonSmallInnerBottomRight_Hover);
}
}
else if (state == STATE_SELECTED) {
if (buttonSize == BUTTON_SMALL) {
gc.setForeground(mButtonSmallInnerBottomMiddle_Selected);
gc.setBackground(mButtonSmallInnerBottomRight_Selected);
}
}
else if (state == STATE_HOVER_AND_SELECTED){
gc.setForeground(mButtonInnerBottomMiddle_HoverSelected);
gc.setBackground(mButtonInnerBottomRight_HoverSelected);
}
// inner top line
if (buttonSize == BUTTON_SMALL && split != SPLIT_NOT_SPLIT)
extra++;
// draw right part
gc.fillGradientRectangle(x+middleWidth-1, y+height-2, middleWidth+extra, 1, false);
}
}
}
}
public void drawButtonOuterBorder(GC gc, int state, int buttonSize, int x, int y, int width, int height, boolean drawLeft, boolean drawTop, boolean drawRight, boolean drawBottom) {
drawButtonOuterBorder(gc, state, SPLIT_NOT_SPLIT, buttonSize, x, y, width, height, drawLeft, drawTop, drawRight, drawBottom);
}
public void drawButtonOuterBorder(GC gc, int state, int buttonSize, int x, int y, int width, int height) {
drawButtonOuterBorder(gc, state, SPLIT_NOT_SPLIT, buttonSize, x, y, width, height, true, true, true, true);
}
public void drawButtonOuterBorder(GC gc, int state, int split, int buttonSize, int x, int y, int width, int height, boolean drawLeft, boolean drawTop, boolean drawRight, boolean drawBottom) {
// figure out the middle point
int middleWidth = (width/2);
int extra = 0;
if (width % 2 != 0)
extra = 1;
// ----------------
// OUTER TOP BORDER
// ----------------
if (state == STATE_HOVER) {
if (buttonSize == BUTTON_BIG)
gc.setForeground(mButtonOuterTop_Hover);
else
gc.setForeground(mButtonSmallOuterTop_Hover);
}
else if (state == STATE_SELECTED) {
if (buttonSize == BUTTON_BIG)
gc.setForeground(mButtonOuterTop_Selected);
else
gc.setForeground(mButtonSmallOuterTop_Selected);
}
else if (state == STATE_HOVER_AND_SELECTED) {
if (buttonSize == BUTTON_BIG) {
if (split == SPLIT_TOP_NOT_ACTIVE)
gc.setForeground(mButtonOuterTop_Hover);
else
gc.setForeground(mButtonOuterTop_HoverSelected);
}
else
gc.setForeground(mButtonSmallOuterTop_HoverSelected);
}
// draw outer top border, 1 line
// the line starts 1 pixel in to the right from where the given x is, and ends 1 pixel in too (unless it's small and split)
if (drawTop) {
if (buttonSize == BUTTON_SMALL && split != SPLIT_NOT_SPLIT && split != SPLIT_LEFT_ACTIVE)
gc.drawLine(x+1, y, x+width, y);
else
gc.drawLine(x+1, y, x+width-1, y);
}
// OUTER SIDE BORDERS
if (state == STATE_HOVER) {
if (buttonSize == BUTTON_BIG) {
gc.setForeground(mButtonOuterSideTopTop_Hover);
gc.setBackground(mButtonOuterSideTopBottom_Hover);
}
else {
gc.setForeground(mButtonSmallOuterSideTopTop_Hover);
gc.setBackground(mButtonSmallOuterSideTopBottom_Hover);
}
}
else if (state == STATE_SELECTED) {
if (buttonSize == BUTTON_BIG) {
gc.setForeground(mButtonOuterSideTopTop_Selected);
gc.setBackground(mButtonOuterSideTopBottom_Selected);
}
else {
gc.setForeground(mButtonSmallOuterSideTopTop_Selected);
gc.setBackground(mButtonSmallOuterSideTopBottom_Selected);
}
}
else if (state == STATE_HOVER_AND_SELECTED) {
if (buttonSize == BUTTON_BIG) {
gc.setForeground(mButtonOuterSideTopTop_HoverSelected);
gc.setBackground(mButtonOuterSideTopBottom_HoverSelected);
}
else {
gc.setForeground(mButtonSmallOuterSideTopTop_HoverSelected);
gc.setBackground(mButtonSmallOuterSideTopBottom_HoverSelected);
}
}
int topOuterPart = 37;
int bottomOuterPart = 27;
if (buttonSize == BUTTON_SMALL) {
topOuterPart = 10;
bottomOuterPart = 10;
}
if (state == STATE_SELECTED || state == STATE_HOVER_AND_SELECTED) {
if (buttonSize == BUTTON_SMALL) {
bottomOuterPart = 9;
}
else {
bottomOuterPart = 26;
}
}
int yStart = y+1;
// split buttons need to adhere strongly to bounds numbers
if (split != SPLIT_NOT_SPLIT) {
if (buttonSize == BUTTON_BIG) {
if (state == STATE_HOVER) {
if (split == SPLIT_TOP_ACTIVE) {
topOuterPart = 36;
bottomOuterPart = 0;
}
else if (split == SPLIT_BOTTOM_NOT_ACTIVE) {
topOuterPart = 0;
bottomOuterPart = 28;
}
}
if (state == STATE_HOVER_AND_SELECTED) {
if (split == SPLIT_TOP_NOT_ACTIVE) {
topOuterPart = 39;
bottomOuterPart = 24;
}
else if (split == SPLIT_BOTTOM_ACTIVE) {
yStart = 38;
topOuterPart = 0;
bottomOuterPart = 27;
}
else if (split == SPLIT_TOP_ACTIVE) {
topOuterPart = 39;
bottomOuterPart = 24;
}
}
}
}
// left, same pixel story
// top part
// left
if (drawLeft)
gc.fillGradientRectangle(x, yStart, 1, topOuterPart, true);
// right
if (drawRight)
gc.fillGradientRectangle(x+width, yStart, 1, topOuterPart, true);
// bottom part
if (state == STATE_HOVER) {
if (buttonSize == BUTTON_BIG) {
gc.setForeground(mButtonOuterSideBottomTop_Hover);
gc.setBackground(mButtonOuterSideBottomBottom_Hover);
}
else {
gc.setForeground(mButtonSmallOuterSideBottomTop_Hover);
gc.setBackground(mButtonSmallOuterSideBottomBottom_Hover);
}
}
else if (state == STATE_SELECTED) {
if (buttonSize == BUTTON_BIG) {
gc.setForeground(mButtonOuterSideBottomTop_Selected);
gc.setBackground(mButtonOuterSideBottomBottom_Selected);
}
else {
gc.setForeground(mButtonSmallOuterSideBottomTop_Selected);
gc.setBackground(mButtonSmallOuterSideBottomBottom_Selected);
}
}
else if (state == STATE_HOVER_AND_SELECTED) {
if (buttonSize == BUTTON_BIG) {
gc.setForeground(mButtonOuterSideBottomTop_HoverSelected);
gc.setBackground(mButtonOuterSideBottomBottom_HoverSelected);
}
else {
gc.setForeground(mButtonSmallOuterSideBottomTop_HoverSelected);
gc.setBackground(mButtonSmallOuterSideBottomBottom_HoverSelected);
}
}
// left
if (drawLeft)
gc.fillGradientRectangle(x, yStart+topOuterPart, 1, bottomOuterPart, true);
// right
if (drawRight)
gc.fillGradientRectangle(x+width, yStart+topOuterPart, 1, bottomOuterPart, true);
// bottom border
if (drawBottom) {
if (state == STATE_HOVER_AND_SELECTED && (split == SPLIT_BOTTOM_ACTIVE || split == SPLIT_TOP_ACTIVE) && buttonSize == BUTTON_BIG) {
// do nada for now
}
else {
if (state == STATE_HOVER) {
if (buttonSize == BUTTON_BIG) {
gc.setForeground(mButtonOuterBottomLeft_Hover);
gc.setBackground(mButtonOuterBottomMiddle_Hover);
}
else {
gc.setForeground(mButtonSmallOuterBottomLeft_Hover);
gc.setBackground(mButtonSmallOuterBottomMiddle_Hover);
}
}
else if (state == STATE_SELECTED) {
if (buttonSize == BUTTON_BIG) {
gc.setForeground(mButtonOuterBottomLeft_Selected);
gc.setBackground(mButtonOuterBottomMiddle_Selected);
}
else {
gc.setForeground(mButtonSmallOuterBottomLeft_Selected);
gc.setBackground(mButtonSmallOuterBottomMiddle_Selected);
}
}
else if (state == STATE_HOVER_AND_SELECTED) {
if (buttonSize == BUTTON_BIG) {
gc.setForeground(mButtonOuterBottomLeft_HoverSelected);
gc.setBackground(mButtonOuterBottomMiddle_HoverSelected);
}
else {
gc.setForeground(mButtonSmallOuterBottomLeft_HoverSelected);
gc.setBackground(mButtonSmallOuterBottomMiddle_HoverSelected);
}
}
// draw left part
gc.fillGradientRectangle(x+1, y+height-1, middleWidth, 1, false);
if (state == STATE_HOVER) {
if (buttonSize == BUTTON_BIG) {
gc.setForeground(mButtonOuterBottomMiddle_Hover);
gc.setBackground(mButtonOuterBottomRight_Hover);
}
else {
gc.setForeground(mButtonSmallOuterBottomMiddle_Hover);
gc.setBackground(mButtonSmallOuterBottomRight_Hover);
}
}
else if (state == STATE_SELECTED) {
if (buttonSize == BUTTON_BIG) {
gc.setForeground(mButtonOuterBottomMiddle_Selected);
gc.setBackground(mButtonOuterBottomRight_Selected);
}
else {
gc.setForeground(mButtonSmallOuterBottomMiddle_Selected);
gc.setBackground(mButtonSmallOuterBottomRight_Selected);
}
}
else if (state == STATE_HOVER_AND_SELECTED) {
if (buttonSize == BUTTON_BIG) {
gc.setForeground(mButtonOuterBottomMiddle_HoverSelected);
gc.setBackground(mButtonOuterBottomRight_HoverSelected);
}
else {
gc.setForeground(mButtonSmallOuterBottomMiddle_HoverSelected);
gc.setBackground(mButtonSmallOuterBottomRight_HoverSelected);
}
}
// draw right part
if (buttonSize == BUTTON_SMALL && split != SPLIT_NOT_SPLIT && split != SPLIT_LEFT_ACTIVE)
extra += 1;
gc.fillGradientRectangle(x+middleWidth, y+height-1, middleWidth+extra, 1, false);
}
}
// special for selected, 1px extra
if (state == STATE_SELECTED || state == STATE_HOVER_AND_SELECTED) {
if (state == STATE_SELECTED) {
if (buttonSize == BUTTON_BIG)
gc.setForeground(mButtonOuterBottomPixel_Selected);
else
gc.setForeground(mButtonSmallOuterBottomPixel_Selected);
}
else if (state == STATE_HOVER_AND_SELECTED) {
if (buttonSize == BUTTON_BIG) {
if (split == SPLIT_TOP_NOT_ACTIVE)
gc.setForeground(mButtonOuterBottomPixel_Selected);
else
gc.setForeground(mButtonOuterBottomPixel_HoverSelected);
}
else
gc.setForeground(mButtonSmallOuterBottomPixel_HoverSelected);
}
if ((buttonSize == BUTTON_BIG && (state == STATE_HOVER_AND_SELECTED || state == STATE_SELECTED)) || (state != STATE_HOVER_AND_SELECTED && split != SPLIT_BOTTOM_ACTIVE) || buttonSize == BUTTON_SMALL) {
// left
if (buttonSize != BUTTON_SMALL || split == SPLIT_NOT_SPLIT)
gc.drawLine(x, y+1+topOuterPart+bottomOuterPart, x, y+1+topOuterPart+bottomOuterPart);
// right
gc.drawLine(x+width, y+1+topOuterPart+bottomOuterPart, x+width, y+1+topOuterPart+bottomOuterPart);
}
}
}
public void drawArrow(GC gc, int x, int y, int state, boolean enabled) {
if (enabled)
gc.setForeground(mArrowColor);
else
gc.setForeground(mArrowColor_Disabled);
gc.drawLine(x, y, x+4, y);
gc.drawLine(x+1, y+1, x+3, y+1);
gc.drawLine(x+2, y+2, x+1, y+2);
if (enabled) {
if (state == STATE_NONE)
gc.setForeground(mArrowColorShadow);
else
gc.setForeground(mArrowColorShadow_HoverOrSelected);
}
else
gc.setForeground(mArrowColorShadow_Disabled);
gc.drawLine(x, y+1, x, y+1);
gc.drawLine(x+1, y+2, x+1, y+2);
gc.drawLine(x+2, y+3, x+2, y+3);
gc.drawLine(x+3, y+2, x+3, y+2);
gc.drawLine(x+4, y+1, x+4, y+1);
}
public void drawSeparator(GC gc, int x, int y, int height) {
gc.setForeground(mSeparatorColor);
gc.drawLine(x, y, x, y+height);
gc.setForeground(mSeparatorColorShadow);
gc.drawLine(x+1, y, x+1, y+height);
}
public void drawCheckbox(GC gc, int state, AbstractRibbonGroupItem item) {
Rectangle bounds = item.getBounds();
int x = bounds.x;
int y = bounds.y;
int cbWidth = 12;
int cbHeight = 12;
if (state == STATE_NONE || state == STATE_SELECTED)
gc.setForeground(mCheckBoxBorderOuter_Normal);
else if (state == STATE_HOVER || state == STATE_HOVER_AND_SELECTED)
gc.setForeground(mCheckBoxBorderOuter_Hover);
if (!item.isEnabled())
gc.setForeground(mCheckBoxBorderOuter_Disabled);
gc.drawRectangle(x, y, cbWidth, cbHeight);
if (state == STATE_NONE || state == STATE_SELECTED)
gc.setForeground(mCheckBoxBorderInner_Normal);
else if (state == STATE_HOVER || state == STATE_HOVER_AND_SELECTED)
gc.setForeground(mCheckBoxBorderInner_Hover);
if (!item.isEnabled())
gc.setForeground(mCheckBoxBorderInner_Disabled);
gc.drawRectangle(x+1, y+1, cbWidth-2, cbHeight-2);
Color outerTopLeft = null;
Color outerBottomRight = null;
Color innerTopLeft = null;
Color innerBottomRight = null;
switch (state) {
case STATE_NONE:
case STATE_SELECTED:
outerTopLeft = mCheckBoxBorderOuterSquareTopLeft_Normal;
outerBottomRight = mCheckBoxBorderOuterSquareBottomRight_Normal;
innerTopLeft = mCheckBoxBorderInnerSquareTopLeft_Normal;
innerBottomRight = mCheckBoxBorderInnerSquareBottomRight_Normal;
break;
case STATE_HOVER:
case STATE_HOVER_AND_SELECTED:
outerTopLeft = mCheckBoxBorderOuterSquareTopLeft_Hover;
outerBottomRight = mCheckBoxBorderOuterSquareBottomRight_Hover;
innerTopLeft = mCheckBoxBorderInnerSquareTopLeft_Hover;
innerBottomRight = mCheckBoxBorderInnerSquareBottomRight_Hover;
break;
}
if (!item.isEnabled()) {
outerTopLeft = mCheckBoxBorderOuterSquareTopLeft_Disabled;
outerBottomRight = mCheckBoxBorderOuterSquareBottomRight_Disabled;
innerTopLeft = mCheckBoxBorderInnerSquareTopLeft_Disabled;
innerBottomRight = mCheckBoxBorderInnerSquareBottomRight_Disabled;
}
Pattern p = new Pattern(gc.getDevice(), bounds.x+2, bounds.y+2, bounds.x+2+9, bounds.y+2+9, outerTopLeft, outerBottomRight);
gc.setForegroundPattern(p);
gc.setBackgroundPattern(p);
gc.fillRectangle(new Rectangle(bounds.x+2, bounds.y+2, 9, 9));
Pattern p2 = new Pattern(gc.getDevice(), bounds.x+3, bounds.y+3, bounds.x+3+7, bounds.y+3+7, innerTopLeft, innerBottomRight);
gc.setForegroundPattern(p2);
gc.setBackgroundPattern(p2);
gc.fillRectangle(new Rectangle(bounds.x+3, bounds.y+3, 7, 7));
gc.setForeground(mTextColor);
if (!item.isEnabled())
gc.setForeground(mTextColor_Disabled);
if (item.getName() != null)
gc.drawString(item.getName(), x+13+6, y, true);
p.dispose();
p2.dispose();
gc.setForegroundPattern(null);
gc.setBackgroundPattern(null);
// force GC back to normal! 1x1 px drawing does not work otherwise (see bug #199658 I filed against this problem)
gc.setAdvanced(false);
// draw check mark
if (item.isSelected()) {
// center bottom 4px square
gc.setForeground(mCheckBoxCheckmarkDark);
gc.setBackground(mCheckBoxCheckmarkDark);
gc.fillRectangle(x+5, y+8, 2, 2);
// dark color on left of square, 2 pixels up
gc.drawLine(x+4, y+7, x+4, y+7+1);
// other side, similar but not-connected to square, corner to corner only
gc.drawLine(x+7, y+6, x+7, y+6+1);
// same deal again, top right of the above
gc.drawLine(x+8, y+4, x+8, y+4+1);
// and again, just 1px
gc.drawLine(x+9, y+3, x+9, y+3);
// bottom uses slightly lighter colors
gc.setForeground(mCheckBoxCheckmarkDark3);
// very bottom left
gc.drawLine(x+4, y+9, x+4, y+9);
// bottom bottom, 2px wide
gc.drawLine(x+5, y+10, x+6, y+10);
// top
gc.drawLine(x+4, y+6, x+4, y+6);
// next darkness level, slightly lighter
gc.setForeground(mCheckBoxCheckmarkDark2);
gc.drawLine(x+9, y+2, x+9, y+2);
// lets start from the top and go down
// left of the last 1px pixel
gc.drawLine(x+8, y+3, x+8, y+3);
// and below that same px
gc.drawLine(x+9, y+4, x+9, y+4);
// similar pattern a bit down
gc.drawLine(x+7, y+5, x+7, y+5);
gc.drawLine(x+8, y+6, x+8, y+6);
// and again
gc.drawLine(x+6, y+7, x+6, y+7);
gc.drawLine(x+7, y+8, x+7, y+8);
// and one on the left side
gc.drawLine(x+3, y+7, x+3, y+7);
// and lighter still
gc.setForeground(mCheckBoxCheckmarkDark4);
// start at top again
// top right
gc.drawLine(x+10, y+3, x+10, y+3);
// left and down 1
gc.drawLine(x+7, y+4, x+7, y+4);
// right and down 1
gc.drawLine(x+9, y+5, x+9, y+5);
// left and down 1
gc.drawLine(x+6, y+6, x+6, y+6);
// right and down 1
gc.drawLine(x+8, y+7, x+8, y+7);
// and farthest down
gc.drawLine(x+7, y+9, x+7, y+9);
// lighter colors
gc.setForeground(mCheckBoxCheckmarkLight);
// left side
gc.drawLine(x+3, y+8, x+3, y+8);
// bit further right
gc.drawLine(x+5, y+7, x+5, y+7);
// lighter yet, outer corner of the v-part
gc.setForeground(mCheckBoxCheckmarkLight2);
gc.drawLine(x+3, y+6, x+3, y+6);
// TODO: fill in more colors? it's hardly visible to the eye the difference at this point
// white colors, make it stand out
gc.setForeground(mCheckBoxCheckmarkLight3);
gc.drawLine(x+8, y+8, x+8, y+8);
// need to use alpha if we want these
/*gc.drawLine(x+2, y+7, x+2, y+7);
gc.drawLine(x+2, y+6, x+2, y+6);
gc.drawLine(x+2, y+8, x+2, y+8);*/
}
}
}