moparisthebest/Yaaic
1
0
Fork 0
mirror of https://github.com/moparisthebest/Yaaic synced 2025-01-08 12:18:07 -05:00
Code Issues Releases Wiki Activity

New stateful ViewPagerIndicator.

Browse Source 
Indicator showing the state of the current pages and off-screen pages by coloring.
This commit is contained in:
Sebastian Kaspari 2012-07-28 11:36:50 +02:00
parent 743eae9b85
commit 9c551d73bf
9 changed files with 1363 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
application/res/layout/conversations.xml
View File

@ -25,7 +25,7 @@ along with Yaaic. If not, see <http://www.gnu.org/licenses/>.
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:background="#ff000000">
<com.viewpagerindicator.TitlePageIndicator
<org.yaaic.indicator.ConversationIndicator
android:id="@+id/titleIndicator"
android:layout_width="fill_parent"
android:layout_height="wrap_content" />

13
application/src/org/yaaic/activity/ConversationActivity.java
View File

@ -29,6 +29,8 @@ import org.yaaic.Yaaic;
import org.yaaic.adapter.ConversationPagerAdapter;
import org.yaaic.adapter.MessageListAdapter;
import org.yaaic.command.CommandParser;
import org.yaaic.indicator.ConversationIndicator;
import org.yaaic.indicator.ConversationTitlePageIndicator.IndicatorStyle;
import org.yaaic.irc.IRCBinder;
import org.yaaic.irc.IRCConnection;
import org.yaaic.irc.IRCService;
@ -80,8 +82,6 @@ import com.actionbarsherlock.app.SherlockActivity;
import com.actionbarsherlock.view.Menu;
import com.actionbarsherlock.view.MenuInflater;
import com.actionbarsherlock.view.MenuItem;
import com.viewpagerindicator.TitlePageIndicator;
import com.viewpagerindicator.TitlePageIndicator.IndicatorStyle;
/**
* The server view with a scrollable list of all channels
@ -104,6 +104,7 @@ public class ConversationActivity extends SherlockActivity implements ServiceCon
private ServerReceiver serverReceiver;
private ViewPager pager;
private ConversationIndicator indicator;
private ConversationPagerAdapter pagerAdapter;
private Scrollback scrollback;
@ -202,12 +203,13 @@ public class ConversationActivity extends SherlockActivity implements ServiceCon
pager = (ViewPager) findViewById(R.id.pager);
pagerAdapter = new ConversationPagerAdapter(server);
pagerAdapter = new ConversationPagerAdapter(this, server);
pager.setAdapter(pagerAdapter);
final float density = getResources().getDisplayMetrics().density;
TitlePageIndicator indicator = (TitlePageIndicator) findViewById(R.id.titleIndicator);
indicator = (ConversationIndicator) findViewById(R.id.titleIndicator);
indicator.setServer(server);
indicator.setTypeface(Typeface.MONOSPACE);
indicator.setViewPager(pager);
@ -215,7 +217,6 @@ public class ConversationActivity extends SherlockActivity implements ServiceCon
indicator.setFooterLineHeight(1 * density);
indicator.setFooterIndicatorHeight(3 * density);
indicator.setFooterIndicatorStyle(IndicatorStyle.Underline);
indicator.setTextColor(0xFFDDDDDD);
indicator.setSelectedColor(0xFFFFFFFF);
indicator.setSelectedBold(true);
indicator.setBackgroundColor(0xFF181818);
@ -528,6 +529,8 @@ public class ConversationActivity extends SherlockActivity implements ServiceCon
conversation.setStatus(status);
}
}
indicator.updateStateColors();
}
/**

75
application/src/org/yaaic/adapter/ConversationPagerAdapter.java
View File

@ -23,11 +23,13 @@ package org.yaaic.adapter;
import java.util.HashMap;
import java.util.LinkedList;
import org.yaaic.indicator.ConversationStateProvider;
import org.yaaic.listener.MessageClickListener;
import org.yaaic.model.Conversation;
import org.yaaic.model.Server;
import org.yaaic.view.MessageListView;
import android.content.Context;
import android.support.v4.view.PagerAdapter;
import android.support.v4.view.ViewPager;
import android.view.View;
@ -39,8 +41,13 @@ import com.viewpagerindicator.TitlePageIndicator;
*
* @author Sebastian Kaspari <sebastian@yaaic.org>
*/
public class ConversationPagerAdapter extends PagerAdapter
public class ConversationPagerAdapter extends PagerAdapter implements ConversationStateProvider
{
public static final int COLOR_NONE = 0x0;
public static final int COLOR_DEFAULT = 0xFFDDDDDD;
public static final int COLOR_MESSAGE = 0xFF31B6E7;
public static final int COLOR_HIGHLIGHT = 0xFFFFBB00;
private final Server server;
private LinkedList<ConversationInfo> conversations;
private final HashMap<Integer, View> views;
@ -63,7 +70,7 @@ public class ConversationPagerAdapter extends PagerAdapter
/**
* Create a new {@link ConversationPagerAdapter} instance.
*/
public ConversationPagerAdapter(Server server) {
public ConversationPagerAdapter(Context context, Server server) {
this.server = server;
conversations = new LinkedList<ConversationInfo>();
@ -276,4 +283,68 @@ public class ConversationPagerAdapter extends PagerAdapter
return conversation.getName();
}
}
@Override
public int getColorAt(int position)
{
Conversation conversation = getItem(position);
switch (conversation.getStatus()) {
case Conversation.STATUS_HIGHLIGHT:
return COLOR_HIGHLIGHT;
case Conversation.STATUS_MESSAGE:
return COLOR_MESSAGE;
default:
return COLOR_DEFAULT;
}
}
/**
* Get the state color for all conversations lower than the given position.
*/
@Override
public int getColorForLowerThan(int position)
{
int color = COLOR_NONE;
for (int i = 0; i < position; i++) {
int currentColor = getColorAt(i);
if (currentColor == COLOR_HIGHLIGHT) {
return COLOR_HIGHLIGHT;
}
if (currentColor == COLOR_MESSAGE) {
color = COLOR_MESSAGE;
}
}
return color;
}
/**
* Get the state color for all conversations greater than the given position.
*/
@Override
public int getColorForGreaterThan(int position)
{
int size = conversations.size();
int color = COLOR_NONE;
for (int i = position + 1; i < size; i++) {
int currentColor = getColorAt(i);
if (currentColor == COLOR_HIGHLIGHT) {
return COLOR_HIGHLIGHT;
}
if (currentColor == COLOR_MESSAGE) {
color = COLOR_MESSAGE;
}
}
return color;
}
}

84
application/src/org/yaaic/adapter/ViewPagerAdapter.java Normal file
View File

@ -0,0 +1,84 @@
/*
* Copyright (C) 2012 Sebastian Kaspari
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.yaaic.adapter;
import android.support.v4.view.PagerAdapter;
import android.support.v4.view.ViewPager;
import android.view.View;
import android.view.ViewGroup;
/**
* Implementation of {@link PagerAdapter} that represents each page as a {@link View}.
*
* @author Sebastian Kaspari <s.kaspari@gmail.com>
*/
public abstract class ViewPagerAdapter extends PagerAdapter
{
/**
* Get a View that displays the data at the specified position in the data set.
*
* @param position The position of the item within the adapter's data set of the item whose view we want.
* @param pager The ViewPager that this view will eventually be attached to.
*
* @return A View corresponding to the data at the specified position.
*/
public abstract View getView(int position, ViewPager pager);
/**
* Determines whether a page View is associated with a specific key object as
* returned by instantiateItem(ViewGroup, int).
*
* @param view Page View to check for association with object
* @param object Object to check for association with view
*
* @return true if view is associated with the key object object.
*/
@Override
public boolean isViewFromObject(View view, Object object) {
return view == object;
}
/**
* Create the page for the given position.
*
* @param container The containing View in which the page will be shown.
* @param position The page position to be instantiated.
*
* @return Returns an Object representing the new page. This does not need
* to be a View, but can be some other container of the page.
*/
@Override
public Object instantiateItem(ViewGroup container, int position) {
ViewPager pager = (ViewPager) container;
View view = getView(position, pager);
pager.addView(view);
return view;
}
/**
* Remove a page for the given position.
*
* @param container The containing View from which the page will be removed.
* @param position The page position to be removed.
* @param view The same object that was returned by instantiateItem(View, int).
*/
@Override
public void destroyItem(ViewGroup container, int position, Object view) {
((ViewPager) container).removeView((View) view);
}
}

301
application/src/org/yaaic/indicator/ConversationIndicator.java Normal file
View File

@ -0,0 +1,301 @@
/*
Yaaic - Yet Another Android IRC Client
Copyright 2009-2012 Sebastian Kaspari
This file is part of Yaaic.
Yaaic is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Yaaic is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Yaaic. If not, see <http://www.gnu.org/licenses/>.
*/
package org.yaaic.indicator;
import org.yaaic.adapter.ConversationPagerAdapter;
import org.yaaic.indicator.ConversationTitlePageIndicator.IndicatorStyle;
import org.yaaic.irc.IRCService;
import org.yaaic.model.Conversation;
import org.yaaic.model.Server;
import org.yaaic.utils.DisplayUtils;
import android.content.Context;
import android.content.Intent;
import android.graphics.Typeface;
import android.support.v4.view.ViewPager;
import android.support.v4.view.ViewPager.OnPageChangeListener;
import android.util.AttributeSet;
import android.view.Gravity;
import android.view.View;
import android.widget.FrameLayout;
/**
* A ConversationIndicator is a group of a ConversationTitlePageIndicator in the
* center and two drawables left and right to indicate the state of the items
* that are not displayed by the ConversationTitlePageIndicator.
*
* @author Sebastian Kaspari <sebastian@yaaic.org>
*/
public class ConversationIndicator extends FrameLayout implements OnPageChangeListener {
private Server server;
private ViewPager pager;
private View leftIndicatorView;
private View rightIndicatorView;
private ConversationTitlePageIndicator titleIndicator;
private ConversationStateProvider stateProvider;
/**
* Create a new {@link ConversationIndicator} instance for the given context.
*
* @param context
*/
public ConversationIndicator(Context context) {
super(context);
init();
}
/**
* Create a new {@link ConversationIndicator} instance for the given context
* and attribute set.
*
* @param context
* @param attrs
*/
public ConversationIndicator(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
/**
* Initialize the indicator view.
*/
public void init() {
titleIndicator = new ConversationTitlePageIndicator(getContext());
titleIndicator.setLayoutParams(
new LayoutParams(
LayoutParams.WRAP_CONTENT,
LayoutParams.WRAP_CONTENT,
Gravity.CENTER
)
);
int indicatorWidth = DisplayUtils.convertToPixels(getContext(), 5);
int indicatorHeight = DisplayUtils.convertToPixels(getContext(), 5);
leftIndicatorView = new View(getContext());
leftIndicatorView.setLayoutParams(
new LayoutParams(
indicatorWidth,
indicatorHeight,
Gravity.LEFT | Gravity.BOTTOM
)
);
leftIndicatorView.setVisibility(View.INVISIBLE);
rightIndicatorView = new View(getContext());
rightIndicatorView.setLayoutParams(
new LayoutParams(
indicatorWidth,
indicatorHeight,
Gravity.RIGHT | Gravity.BOTTOM
)
);
rightIndicatorView.setVisibility(View.INVISIBLE);
addView(leftIndicatorView);
addView(rightIndicatorView);
addView(titleIndicator);
}
/**
* Set the {@link Server} this indicator is used for.
*
* @param server
*/
public void setServer(Server server) {
this.server = server;
}
/**
* Set typeface of title indicator.
*
* @param typeface
*/
public void setTypeface(Typeface typeface)
{
titleIndicator.setTypeface(typeface);
}
/**
* Set the {@link ViewPager} this indicator is used for.
*
* @param pager
*/
public void setViewPager(ViewPager pager)
{
this.pager = pager;
titleIndicator.setViewPager(pager);
titleIndicator.setOnPageChangeListener(this);
stateProvider = (ConversationStateProvider) pager.getAdapter();
}
/**
* Set the color of the footer line.
*
* @param footerColor
*/
public void setFooterColor(int footerColor)
{
titleIndicator.setFooterColor(footerColor);
}
/**
* Set the height of the footer line.
*
* @param footerLineHeight
*/
public void setFooterLineHeight(float footerLineHeight)
{
titleIndicator.setFooterLineHeight(footerLineHeight);
}
/**
* Set the height of the footer indicator.
*
* @param footerTriangleHeight
*/
public void setFooterIndicatorHeight(float footerTriangleHeight)
{
titleIndicator.setFooterIndicatorHeight(footerTriangleHeight);
}
/**
* Set the style of the footer indicator.
*
* @param indicatorStyle
*/
public void setFooterIndicatorStyle(IndicatorStyle indicatorStyle)
{
titleIndicator.setFooterIndicatorStyle(indicatorStyle);
}
/**
* Set wether selected items should be displayed as bold text.
*
* @param selectedBold
*/
public void setSelectedBold(boolean selectedBold)
{
titleIndicator.setSelectedBold(selectedBold);
}
/**
* Set the text color of a selected item.
*
* @param selectedColor
*/
public void setSelectedColor(int selectedColor)
{
titleIndicator.setSelectedColor(selectedColor);
}
/**
* Set the text size for the title indicator.
*
* @param textSize
*/
public void setTextSize(float textSize)
{
titleIndicator.setTextSize(textSize);
}
/**
* On page selected: Update states of the indicators.
*/
@Override
public void onPageSelected(int page)
{
updateStateColors();
}
/**
* Update the colors of the state indicators.
*/
public void updateStateColors() {
int page = pager.getCurrentItem();
ConversationPagerAdapter adapter = (ConversationPagerAdapter) pager.getAdapter();
Conversation conversation = adapter.getItem(page);
Conversation previousConversation = server.getConversation(server.getSelectedConversation());
if (previousConversation != null) {
previousConversation.setStatus(Conversation.STATUS_DEFAULT);
}
if (conversation.getNewMentions() > 0) {
Context context = pager.getContext();
Intent intent = new Intent(context, IRCService.class);
intent.setAction(IRCService.ACTION_ACK_NEW_MENTIONS);
intent.putExtra(IRCService.EXTRA_ACK_SERVERID, server.getId());
intent.putExtra(IRCService.EXTRA_ACK_CONVTITLE, conversation.getName());
context.startService(intent);
}
conversation.setStatus(Conversation.STATUS_SELECTED);
server.setSelectedConversation(conversation.getName());
if (page - 2 >= 0) {
int color = stateProvider.getColorForLowerThan(page - 1);
leftIndicatorView.setBackgroundColor(color);
leftIndicatorView.setVisibility(
color == ConversationPagerAdapter.COLOR_NONE ? View.INVISIBLE : View.VISIBLE
);
} else {
leftIndicatorView.setVisibility(View.INVISIBLE);
}
if (page + 2 < adapter.getCount()) {
int color = stateProvider.getColorForGreaterThan(page + 1);
rightIndicatorView.setBackgroundColor(color);
rightIndicatorView.setVisibility(
color == ConversationPagerAdapter.COLOR_NONE ? View.INVISIBLE : View.VISIBLE
);
} else {
rightIndicatorView.setVisibility(View.INVISIBLE);
}
}
/**
* On scroll state of page changed.
*/
@Override
public void onPageScrollStateChanged(int page)
{
// Not used.
}
/**
* On page scrolled.
*/
@Override
public void onPageScrolled(int arg0, float arg1, int arg2)
{
// Not used.
}
}

52
application/src/org/yaaic/indicator/ConversationStateProvider.java Normal file
View File

@ -0,0 +1,52 @@
/*
Yaaic - Yet Another Android IRC Client
Copyright 2009-2012 Sebastian Kaspari
This file is part of Yaaic.
Yaaic is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Yaaic is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Yaaic. If not, see <http://www.gnu.org/licenses/>.
*/
package org.yaaic.indicator;
/**
* Interface for a {@link ConversationStateProvider} that provides the apropriate
* state color for a position in the pager.
*/
public interface ConversationStateProvider {
/**
* Get the state color for all positions lower than the given position.
*
* @param position
* @return
*/
public int getColorForLowerThan(int position);
/**
* Get the state color for the given position.
*
* @param position
* @return
*/
public int getColorAt(int position);
/**
* Get the state color for all positions greater than the given position.
*
* @param position
* @return
*/
public int getColorForGreaterThan(int position);
}

832
application/src/org/yaaic/indicator/ConversationTitlePageIndicator.java Normal file
View File

@ -0,0 +1,832 @@
/*
* Copyright (C) 2012 Sebastian Kaspari
* Copyright (C) 2011 Jake Wharton
* Copyright (C) 2011 Patrik Akerfeldt
* Copyright (C) 2011 Francisco Figueiredo Jr.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.yaaic.indicator;
import java.util.ArrayList;
import android.content.Context;
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.Rect;
import android.graphics.Typeface;
import android.os.Parcel;
import android.os.Parcelable;
import android.support.v4.view.MotionEventCompat;
import android.support.v4.view.PagerAdapter;
import android.support.v4.view.ViewConfigurationCompat;
import android.support.v4.view.ViewPager;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import com.viewpagerindicator.PageIndicator;
import com.viewpagerindicator.R;
/**
* A TitlePageIndicator is a PageIndicator which displays the title of left view
* (if exist), the title of the current select view (centered) and the title of
* the right view (if exist). When the user scrolls the ViewPager then titles are
* also scrolled.
*
* Modified version to display the titles in different colors according to the
* state of the page.
*/
public class ConversationTitlePageIndicator extends View implements PageIndicator {
/**
* Percentage indicating what percentage of the screen width away from
* center should the underline be fully faded. A value of 0.25 means that
* halfway between the center of the screen and an edge.
*/
private static final float SELECTION_FADE_PERCENTAGE = 0.25f;
/**
* Percentage indicating what percentage of the screen width away from
* center should the selected text bold turn off. A value of 0.05 means
* that 10% between the center and an edge.
*/
private static final float BOLD_FADE_PERCENTAGE = 0.05f;
/**
* Title text used when no title is provided by the adapter.
*/
private static final String EMPTY_TITLE = "";
/**
* Interface for a callback when the center item has been clicked.
*/
public interface OnCenterItemClickListener {
/**
* Callback when the center item has been clicked.
*
* @param position Position of the current center item.
*/
void onCenterItemClick(int position);
}
public enum IndicatorStyle {
None(0), Triangle(1), Underline(2);
public final int value;
private IndicatorStyle(int value) {
this.value = value;
}
public static IndicatorStyle fromValue(int value) {
for (IndicatorStyle style : IndicatorStyle.values()) {
if (style.value == value) {
return style;
}
}
return null;
}
}
private ViewPager mViewPager;
private ViewPager.OnPageChangeListener mListener;
private PagerAdapter mPagerAdapter;
private ConversationStateProvider mStateProvider;
private int mCurrentPage = -1;
private float mPageOffset;
private int mScrollState;
private final Paint mPaintText = new Paint();
private boolean mBoldText;
private int mColorText;
private int mColorSelected;
private final Path mPath = new Path();
private final Rect mBounds = new Rect();
private final Paint mPaintFooterLine = new Paint();
private IndicatorStyle mFooterIndicatorStyle;
private final Paint mPaintFooterIndicator = new Paint();
private float mFooterIndicatorHeight;
private float mFooterIndicatorUnderlinePadding;
private float mFooterPadding;
private float mTitlePadding;
private float mTopPadding;
/** Left and right side padding for not active view titles. */
private float mClipPadding;
private float mFooterLineHeight;
private static final int INVALID_POINTER = -1;
private int mTouchSlop;
private float mLastMotionX = -1;
private int mActivePointerId = INVALID_POINTER;
private boolean mIsDragging;
private OnCenterItemClickListener mCenterItemClickListener;
public ConversationTitlePageIndicator(Context context) {
this(context, null);
}
public ConversationTitlePageIndicator(Context context, AttributeSet attrs) {
this(context, attrs, R.attr.vpiTitlePageIndicatorStyle);
}
public ConversationTitlePageIndicator(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
if (isInEditMode()) {
return;
}
//Load defaults from resources
final Resources res = getResources();
final int defaultFooterColor = res.getColor(R.color.default_title_indicator_footer_color);
final float defaultFooterLineHeight = res.getDimension(R.dimen.default_title_indicator_footer_line_height);
final int defaultFooterIndicatorStyle = res.getInteger(R.integer.default_title_indicator_footer_indicator_style);
final float defaultFooterIndicatorHeight = res.getDimension(R.dimen.default_title_indicator_footer_indicator_height);
final float defaultFooterIndicatorUnderlinePadding = res.getDimension(R.dimen.default_title_indicator_footer_indicator_underline_padding);
final float defaultFooterPadding = res.getDimension(R.dimen.default_title_indicator_footer_padding);
final int defaultSelectedColor = res.getColor(R.color.default_title_indicator_selected_color);
final boolean defaultSelectedBold = res.getBoolean(R.bool.default_title_indicator_selected_bold);
final int defaultTextColor = res.getColor(R.color.default_title_indicator_text_color);
final float defaultTextSize = res.getDimension(R.dimen.default_title_indicator_text_size);
final float defaultTitlePadding = res.getDimension(R.dimen.default_title_indicator_title_padding);
final float defaultClipPadding = res.getDimension(R.dimen.default_title_indicator_clip_padding);
final float defaultTopPadding = res.getDimension(R.dimen.default_title_indicator_top_padding);
//Retrieve styles attributes
TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.TitlePageIndicator, defStyle, 0);
//Retrieve the colors to be used for this view and apply them.
mFooterLineHeight = a.getDimension(R.styleable.TitlePageIndicator_footerLineHeight, defaultFooterLineHeight);
mFooterIndicatorStyle = IndicatorStyle.fromValue(a.getInteger(R.styleable.TitlePageIndicator_footerIndicatorStyle, defaultFooterIndicatorStyle));
mFooterIndicatorHeight = a.getDimension(R.styleable.TitlePageIndicator_footerIndicatorHeight, defaultFooterIndicatorHeight);
mFooterIndicatorUnderlinePadding = a.getDimension(R.styleable.TitlePageIndicator_footerIndicatorUnderlinePadding, defaultFooterIndicatorUnderlinePadding);
mFooterPadding = a.getDimension(R.styleable.TitlePageIndicator_footerPadding, defaultFooterPadding);
mTopPadding = a.getDimension(R.styleable.TitlePageIndicator_topPadding, defaultTopPadding);
mTitlePadding = a.getDimension(R.styleable.TitlePageIndicator_titlePadding, defaultTitlePadding);
mClipPadding = a.getDimension(R.styleable.TitlePageIndicator_clipPadding, defaultClipPadding);
mColorSelected = a.getColor(R.styleable.TitlePageIndicator_selectedColor, defaultSelectedColor);
mColorText = a.getColor(R.styleable.TitlePageIndicator_android_textColor, defaultTextColor);
mBoldText = a.getBoolean(R.styleable.TitlePageIndicator_selectedBold, defaultSelectedBold);
final float textSize = a.getDimension(R.styleable.TitlePageIndicator_android_textSize, defaultTextSize);
final int footerColor = a.getColor(R.styleable.TitlePageIndicator_footerColor, defaultFooterColor);
mPaintText.setTextSize(textSize);
mPaintText.setAntiAlias(true);
mPaintFooterLine.setStyle(Paint.Style.FILL_AND_STROKE);
mPaintFooterLine.setStrokeWidth(mFooterLineHeight);
mPaintFooterLine.setColor(footerColor);
mPaintFooterIndicator.setStyle(Paint.Style.FILL_AND_STROKE);
mPaintFooterIndicator.setColor(footerColor);
a.recycle();
final ViewConfiguration configuration = ViewConfiguration.get(context);
mTouchSlop = ViewConfigurationCompat.getScaledPagingTouchSlop(configuration);
}
public int getFooterColor() {
return mPaintFooterLine.getColor();
}
public void setFooterColor(int footerColor) {
mPaintFooterLine.setColor(footerColor);
mPaintFooterIndicator.setColor(footerColor);
invalidate();
}
public float getFooterLineHeight() {
return mFooterLineHeight;
}
public void setFooterLineHeight(float footerLineHeight) {
mFooterLineHeight = footerLineHeight;
mPaintFooterLine.setStrokeWidth(mFooterLineHeight);
invalidate();
}
public float getFooterIndicatorHeight() {
return mFooterIndicatorHeight;
}
public void setFooterIndicatorHeight(float footerTriangleHeight) {
mFooterIndicatorHeight = footerTriangleHeight;
invalidate();
}
public float getFooterIndicatorPadding() {
return mFooterPadding;
}
public void setFooterIndicatorPadding(float footerIndicatorPadding) {
mFooterPadding = footerIndicatorPadding;
invalidate();
}
public IndicatorStyle getFooterIndicatorStyle() {
return mFooterIndicatorStyle;
}
public void setFooterIndicatorStyle(IndicatorStyle indicatorStyle) {
mFooterIndicatorStyle = indicatorStyle;
invalidate();
}
public int getSelectedColor() {
return mColorSelected;
}
public void setSelectedColor(int selectedColor) {
mColorSelected = selectedColor;
invalidate();
}
public boolean isSelectedBold() {
return mBoldText;
}
public void setSelectedBold(boolean selectedBold) {
mBoldText = selectedBold;
invalidate();
}
public int getTextColor() {
return mColorText;
}
public void setTextColor(int textColor) {
mPaintText.setColor(textColor);
mColorText = textColor;
invalidate();
}
public float getTextSize() {
return mPaintText.getTextSize();
}
public void setTextSize(float textSize) {
mPaintText.setTextSize(textSize);
invalidate();
}
public float getTitlePadding() {
return this.mTitlePadding;
}
public void setTitlePadding(float titlePadding) {
mTitlePadding = titlePadding;
invalidate();
}
public float getTopPadding() {
return this.mTopPadding;
}
public void setTopPadding(float topPadding) {
mTopPadding = topPadding;
invalidate();
}
public float getClipPadding() {
return this.mClipPadding;
}
public void setClipPadding(float clipPadding) {
mClipPadding = clipPadding;
invalidate();
}
public void setTypeface(Typeface typeface) {
mPaintText.setTypeface(typeface);
invalidate();
}
public Typeface getTypeface() {
return mPaintText.getTypeface();
}
/*
* (non-Javadoc)
*
* @see android.view.View#onDraw(android.graphics.Canvas)
*/
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
if (mViewPager == null) {
return;
}
final int count = mViewPager.getAdapter().getCount();
if (count == 0) {
return;
}
// mCurrentPage is -1 on first start and after orientation changed. If so, retrieve the correct index from viewpager.
if(mCurrentPage == -1 && mViewPager != null) {
mCurrentPage = mViewPager.getCurrentItem();
}
//Calculate views bounds
ArrayList<Rect> bounds = calculateAllBounds(mPaintText);
final int boundsSize = bounds.size();
//Make sure we're on a page that still exists
if (mCurrentPage >= boundsSize) {
setCurrentItem(boundsSize - 1);
return;
}
final int countMinusOne = count - 1;
final float halfWidth = getWidth() / 2f;
final int left = getLeft();
final float leftClip = left + mClipPadding;
final int width = getWidth();
final int height = getHeight();
final int right = left + width;
final float rightClip = right - mClipPadding;
int page = mCurrentPage;
float offsetPercent;
if (mPageOffset <= 0.5) {
offsetPercent = mPageOffset;
} else {
page += 1;
offsetPercent = 1 - mPageOffset;
}
final boolean currentSelected = (offsetPercent <= SELECTION_FADE_PERCENTAGE);
final boolean currentBold = (offsetPercent <= BOLD_FADE_PERCENTAGE);
final float selectedPercent = (SELECTION_FADE_PERCENTAGE - offsetPercent) / SELECTION_FADE_PERCENTAGE;
//Verify if the current view must be clipped to the screen
Rect curPageBound = bounds.get(mCurrentPage);
float curPageWidth = curPageBound.right - curPageBound.left;
if (curPageBound.left < leftClip) {
//Try to clip to the screen (left side)
clipViewOnTheLeft(curPageBound, curPageWidth, left);
}
if (curPageBound.right > rightClip) {
//Try to clip to the screen (right side)
clipViewOnTheRight(curPageBound, curPageWidth, right);
}
//Left views starting from the current position
if (mCurrentPage > 0) {
for (int i = mCurrentPage - 1; i >= 0; i--) {
Rect bound = bounds.get(i);
//Is left side is outside the screen
if (bound.left < leftClip) {
int w = bound.right - bound.left;
//Try to clip to the screen (left side)
clipViewOnTheLeft(bound, w, left);
//Except if there's an intersection with the right view
Rect rightBound = bounds.get(i + 1);
//Intersection
if (bound.right + mTitlePadding > rightBound.left) {
bound.left = (int) (rightBound.left - w - mTitlePadding);
bound.right = bound.left + w;
}
}
}
}
//Right views starting from the current position
if (mCurrentPage < countMinusOne) {
for (int i = mCurrentPage + 1 ; i < count; i++) {
Rect bound = bounds.get(i);
//If right side is outside the screen
if (bound.right > rightClip) {
int w = bound.right - bound.left;
//Try to clip to the screen (right side)
clipViewOnTheRight(bound, w, right);
//Except if there's an intersection with the left view
Rect leftBound = bounds.get(i - 1);
//Intersection
if (bound.left - mTitlePadding < leftBound.right) {
bound.left = (int) (leftBound.right + mTitlePadding);
bound.right = bound.left + w;
}
}
}
}
//Now draw views
int colorTextAlpha = mColorText >>> 24;
for (int i = 0; i < count; i++) {
//Get the title
Rect bound = bounds.get(i);
//Only if one side is visible
if ((bound.left > left && bound.left < right) || (bound.right > left && bound.right < right)) {
final boolean currentPage = (i == page);
final CharSequence pageTitle = getTitle(i);
//Only set bold if we are within bounds
mPaintText.setFakeBoldText(currentPage && currentBold && mBoldText);
//Draw text as unselected
mPaintText.setColor(currentPage ? mColorText : mStateProvider.getColorAt(i));
if(currentPage && currentSelected) {
//Fade out/in unselected text as the selected text fades in/out
mPaintText.setAlpha(colorTextAlpha - (int)(colorTextAlpha * selectedPercent));
}
canvas.drawText(pageTitle, 0, pageTitle.length(), bound.left, bound.bottom + mTopPadding, mPaintText);
//If we are within the selected bounds draw the selected text
if (currentPage && currentSelected) {
mPaintText.setColor(mColorSelected);
mPaintText.setAlpha((int)((mColorSelected >>> 24) * selectedPercent));
canvas.drawText(pageTitle, 0, pageTitle.length(), bound.left, bound.bottom + mTopPadding, mPaintText);
}
}
}
//Draw the footer line
mPath.reset();
mPath.moveTo(0, height - mFooterLineHeight / 2f);
mPath.lineTo(width, height - mFooterLineHeight / 2f);
mPath.close();
canvas.drawPath(mPath, mPaintFooterLine);
switch (mFooterIndicatorStyle) {
case Triangle:
mPath.reset();
mPath.moveTo(halfWidth, height - mFooterLineHeight - mFooterIndicatorHeight);
mPath.lineTo(halfWidth + mFooterIndicatorHeight, height - mFooterLineHeight);
mPath.lineTo(halfWidth - mFooterIndicatorHeight, height - mFooterLineHeight);
mPath.close();
canvas.drawPath(mPath, mPaintFooterIndicator);
break;
case Underline:
if (!currentSelected || page >= boundsSize) {
break;
}
Rect underlineBounds = bounds.get(page);
mPath.reset();
mPath.moveTo(underlineBounds.left - mFooterIndicatorUnderlinePadding, height - mFooterLineHeight);
mPath.lineTo(underlineBounds.right + mFooterIndicatorUnderlinePadding, height - mFooterLineHeight);
mPath.lineTo(underlineBounds.right + mFooterIndicatorUnderlinePadding, height - mFooterLineHeight - mFooterIndicatorHeight);
mPath.lineTo(underlineBounds.left - mFooterIndicatorUnderlinePadding, height - mFooterLineHeight - mFooterIndicatorHeight);
mPath.close();
mPaintFooterIndicator.setAlpha((int)(0xFF * selectedPercent));
canvas.drawPath(mPath, mPaintFooterIndicator);
mPaintFooterIndicator.setAlpha(0xFF);
break;
case None:
// Nothing to do here.
break;
}
}
@Override
public boolean onTouchEvent(android.view.MotionEvent ev) {
if (super.onTouchEvent(ev)) {
return true;
}
if ((mViewPager == null) || (mViewPager.getAdapter().getCount() == 0)) {
return false;
}
final int action = ev.getAction();
switch (action & MotionEventCompat.ACTION_MASK) {
case MotionEvent.ACTION_DOWN:
mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
mLastMotionX = ev.getX();
break;
case MotionEvent.ACTION_MOVE: {
final int activePointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
final float x = MotionEventCompat.getX(ev, activePointerIndex);
final float deltaX = x - mLastMotionX;
if (!mIsDragging) {
if (Math.abs(deltaX) > mTouchSlop) {
mIsDragging = true;
}
}
if (mIsDragging) {
mLastMotionX = x;
if (mViewPager.isFakeDragging() || mViewPager.beginFakeDrag()) {
mViewPager.fakeDragBy(deltaX);
}
}
break;
}
case MotionEvent.ACTION_CANCEL:
case MotionEvent.ACTION_UP:
if (!mIsDragging) {
final int count = mViewPager.getAdapter().getCount();
final int width = getWidth();
final float halfWidth = width / 2f;
final float sixthWidth = width / 6f;
final float leftThird = halfWidth - sixthWidth;
final float rightThird = halfWidth + sixthWidth;
final float eventX = ev.getX();
if (eventX < leftThird) {
if (mCurrentPage > 0) {
mViewPager.setCurrentItem(mCurrentPage - 1);
return true;
}
} else if (eventX > rightThird) {
if (mCurrentPage < count - 1) {
mViewPager.setCurrentItem(mCurrentPage + 1);
return true;
}
} else {
//Middle third
if (mCenterItemClickListener != null) {
mCenterItemClickListener.onCenterItemClick(mCurrentPage);
}
}
}
mIsDragging = false;
mActivePointerId = INVALID_POINTER;
if (mViewPager.isFakeDragging()) {
mViewPager.endFakeDrag();
}
break;
case MotionEventCompat.ACTION_POINTER_DOWN: {
final int index = MotionEventCompat.getActionIndex(ev);
final float x = MotionEventCompat.getX(ev, index);
mLastMotionX = x;
mActivePointerId = MotionEventCompat.getPointerId(ev, index);
break;
}
case MotionEventCompat.ACTION_POINTER_UP:
final int pointerIndex = MotionEventCompat.getActionIndex(ev);
final int pointerId = MotionEventCompat.getPointerId(ev, pointerIndex);
if (pointerId == mActivePointerId) {
final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
mActivePointerId = MotionEventCompat.getPointerId(ev, newPointerIndex);
}
mLastMotionX = MotionEventCompat.getX(ev, MotionEventCompat.findPointerIndex(ev, mActivePointerId));
break;
}
return true;
};
/**
* Set bounds for the right textView including clip padding.
*
* @param curViewBound
* current bounds.
* @param curViewWidth
* width of the view.
*/
private void clipViewOnTheRight(Rect curViewBound, float curViewWidth, int right) {
curViewBound.right = (int) (right - mClipPadding);
curViewBound.left = (int) (curViewBound.right - curViewWidth);
}
/**
* Set bounds for the left textView including clip padding.
*
* @param curViewBound
* current bounds.
* @param curViewWidth
* width of the view.
*/
private void clipViewOnTheLeft(Rect curViewBound, float curViewWidth, int left) {
curViewBound.left = (int) (left + mClipPadding);
curViewBound.right = (int) (mClipPadding + curViewWidth);
}
/**
* Calculate views bounds and scroll them according to the current index
*
* @param paint
* @return
*/
private ArrayList<Rect> calculateAllBounds(Paint paint) {
ArrayList<Rect> list = new ArrayList<Rect>();
//For each views (If no values then add a fake one)
final int count = mViewPager.getAdapter().getCount();
final int width = getWidth();
final int halfWidth = width / 2;
for (int i = 0; i < count; i++) {
Rect bounds = calcBounds(i, paint);
int w = bounds.right - bounds.left;
int h = bounds.bottom - bounds.top;
bounds.left = (int)(halfWidth - (w / 2f) + ((i - mCurrentPage - mPageOffset) * width));
bounds.right = bounds.left + w;
bounds.top = 0;
bounds.bottom = h;
list.add(bounds);
}
return list;
}
/**
* Calculate the bounds for a view's title
*
* @param index
* @param paint
* @return
*/
private Rect calcBounds(int index, Paint paint) {
//Calculate the text bounds
Rect bounds = new Rect();
CharSequence title = getTitle(index);
bounds.right = (int) paint.measureText(title, 0, title.length());
bounds.bottom = (int) (paint.descent() - paint.ascent());
return bounds;
}
@Override
public void setViewPager(ViewPager view) {
if (mViewPager == view) {
return;
}
if (mViewPager != null) {
mViewPager.setOnPageChangeListener(null);
}
mPagerAdapter = view.getAdapter();
if (!(mPagerAdapter instanceof ConversationStateProvider)) {
throw new IllegalStateException("Adapter has to implement ConversationStateProvider.");
}
mStateProvider = (ConversationStateProvider) mPagerAdapter;
if (mPagerAdapter == null) {
throw new IllegalStateException("ViewPager does not have adapter instance.");
}
mViewPager = view;
mViewPager.setOnPageChangeListener(this);
invalidate();
}
@Override
public void setViewPager(ViewPager view, int initialPosition) {
setViewPager(view);
setCurrentItem(initialPosition);
}
@Override
public void notifyDataSetChanged() {
invalidate();
}
/**
* Set a callback listener for the center item click.
*
* @param listener Callback instance.
*/
public void setOnCenterItemClickListener(OnCenterItemClickListener listener) {
mCenterItemClickListener = listener;
}
@Override
public void setCurrentItem(int item) {
if (mViewPager == null) {
throw new IllegalStateException("ViewPager has not been bound.");
}
mViewPager.setCurrentItem(item);
mCurrentPage = item;
invalidate();
}
@Override
public void onPageScrollStateChanged(int state) {
mScrollState = state;
if (mListener != null) {
mListener.onPageScrollStateChanged(state);
}
}
@Override
public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
mCurrentPage = position;
mPageOffset = positionOffset;
invalidate();
if (mListener != null) {
mListener.onPageScrolled(position, positionOffset, positionOffsetPixels);
}
}
@Override
public void onPageSelected(int position) {
if (mScrollState == ViewPager.SCROLL_STATE_IDLE) {
mCurrentPage = position;
invalidate();
}
if (mListener != null) {
mListener.onPageSelected(position);
}
}
@Override
public void setOnPageChangeListener(ViewPager.OnPageChangeListener listener) {
mListener = listener;
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
//Measure our width in whatever mode specified
final int measuredWidth = MeasureSpec.getSize(widthMeasureSpec);
//Determine our height
float height = 0;
final int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);
if (heightSpecMode == MeasureSpec.EXACTLY) {
//We were told how big to be
height = MeasureSpec.getSize(heightMeasureSpec);
} else {
//Calculate the text bounds
mBounds.setEmpty();
mBounds.bottom = (int) (mPaintText.descent() - mPaintText.ascent());
height = mBounds.bottom - mBounds.top + mFooterLineHeight + mFooterPadding + mTopPadding;
if (mFooterIndicatorStyle != IndicatorStyle.None) {
height += mFooterIndicatorHeight;
}
}
final int measuredHeight = (int)height;
setMeasuredDimension(measuredWidth, measuredHeight);
}
@Override
public void onRestoreInstanceState(Parcelable state) {
SavedState savedState = (SavedState)state;
super.onRestoreInstanceState(savedState.getSuperState());
mCurrentPage = savedState.currentPage;
requestLayout();
}
@Override
public Parcelable onSaveInstanceState() {
Parcelable superState = super.onSaveInstanceState();
SavedState savedState = new SavedState(superState);
savedState.currentPage = mCurrentPage;
return savedState;
}
static class SavedState extends BaseSavedState {
int currentPage;
public SavedState(Parcelable superState) {
super(superState);
}
private SavedState(Parcel in) {
super(in);
currentPage = in.readInt();
}
@Override
public void writeToParcel(Parcel dest, int flags) {
super.writeToParcel(dest, flags);
dest.writeInt(currentPage);
}
public static final Parcelable.Creator<SavedState> CREATOR = new Parcelable.Creator<SavedState>() {
@Override
public SavedState createFromParcel(Parcel in) {
return new SavedState(in);
}
@Override
public SavedState[] newArray(int size) {
return new SavedState[size];
}
};
}
private CharSequence getTitle(int i) {
CharSequence title = mPagerAdapter.getPageTitle(i);
if (title == null) {
title = EMPTY_TITLE;
}
return title.toString();
}
}

24
application/src/org/yaaic/listener/ConversationSelectedListener.java
View File

@ -21,11 +21,11 @@ along with Yaaic. If not, see <http://www.gnu.org/licenses/>.
package org.yaaic.listener;
import org.yaaic.adapter.ConversationPagerAdapter;
import org.yaaic.indicator.ConversationIndicator;
import org.yaaic.irc.IRCService;
import org.yaaic.model.Channel;
import org.yaaic.model.Conversation;
import org.yaaic.model.Server;
import org.yaaic.view.ConversationSwitcher;
import android.content.Context;
import android.content.Intent;
@ -33,16 +33,16 @@ import android.support.v4.view.ViewPager.OnPageChangeListener;
import android.widget.TextView;
/**
* Listener for conversation selections
* Listener for conversation selections.
*
* @author Sebastian Kaspari <sebastian@yaaic.org>
*/
public class ConversationSelectedListener implements OnPageChangeListener
{
private final Context ctx;
private final Context context;
private final Server server;
private final TextView titleView;
private final ConversationSwitcher switcher;
private final ConversationIndicator indicator;
private final ConversationPagerAdapter adapter;
/**
@ -51,13 +51,13 @@ public class ConversationSelectedListener implements OnPageChangeListener
* @param server
* @param titleView
*/
public ConversationSelectedListener(Context ctx, Server server, TextView titleView, ConversationPagerAdapter adapter, ConversationSwitcher switcher)
public ConversationSelectedListener(Context ctx, Server server, TextView titleView, ConversationPagerAdapter adapter, ConversationIndicator indicator)
{
this.ctx = ctx;
this.server = server;
this.context = ctx;
this.server = server;
this.titleView = titleView;
this.switcher = switcher;
this.adapter = adapter;
this.indicator = indicator;
this.adapter = adapter;
}
/**
@ -88,18 +88,18 @@ public class ConversationSelectedListener implements OnPageChangeListener
}
if (conversation.getNewMentions() > 0) {
Intent i = new Intent(ctx, IRCService.class);
Intent i = new Intent(context, IRCService.class);
i.setAction(IRCService.ACTION_ACK_NEW_MENTIONS);
i.putExtra(IRCService.EXTRA_ACK_SERVERID, server.getId());
i.putExtra(IRCService.EXTRA_ACK_CONVTITLE, conversation.getName());
ctx.startService(i);
context.startService(i);
}
conversation.setStatus(Conversation.STATUS_SELECTED);
server.setSelectedConversation(conversation.getName());
}
switcher.invalidate();
indicator.invalidate();
}
/**

123
application/src/org/yaaic/view/ConversationSwitcher.java
View File

@ -1,123 +0,0 @@
/*
Yaaic - Yet Another Android IRC Client
Copyright 2009-2012 Sebastian Kaspari
This file is part of Yaaic.
Yaaic is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Yaaic is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Yaaic. If not, see <http://www.gnu.org/licenses/>.
*/
package org.yaaic.view;
import java.util.Vector;
import org.yaaic.model.Conversation;
import org.yaaic.model.Server;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.util.AttributeSet;
import android.view.View;
/**
* The ConversationSwitcher - The small funny dots at the bottom ;)
*
* @author Sebastian Kaspari <sebastian@yaaic.org>
*/
public class ConversationSwitcher extends View
{
private Server server;
private final Paint paint;
/**
* Create a new ConversationSwitcher
*
* @param context The Context the view is running in, through which it can access the current theme, resources, etc.
*/
public ConversationSwitcher(Context context, AttributeSet attributes)
{
super(context, attributes);
paint = new Paint();
paint.setStyle(Paint.Style.STROKE);
}
/**
* Set the server whos conversations should be displayed
*
* @param server
*/
public void setServer(Server server)
{
this.server = server;
}
/**
* Measure the size of the view
*
* @param widthMeasureSpec
* @param heightMeasureSpec
*/
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)
{
setMeasuredDimension(MeasureSpec.getSize(widthMeasureSpec), 16);
}
/**
* On draw
*/
@Override
protected void onDraw(Canvas canvas)
{
super.onDraw(canvas);
if (server == null) {
return;
}
Vector<Conversation> conversations = new Vector<Conversation>(server.getConversations());
Conversation conversation;
int width = getWidth();
int height = getHeight();
int circles = conversations.size();
int startX = (width / 2) - (((circles + 1) / 2) * 12);
for (int i = 0; i < circles; i++) {
conversation = conversations.get(i);
switch (conversation.getStatus()) {
case Conversation.STATUS_DEFAULT:
paint.setColor(0xFF888888);
break;
case Conversation.STATUS_HIGHLIGHT:
paint.setColor(0xFF880000);
break;
case Conversation.STATUS_MESSAGE:
paint.setColor(0xFF008800);
break;
case Conversation.STATUS_SELECTED:
paint.setColor(0xFFFFFFFF);
break;
case Conversation.STATUS_MISC:
paint.setColor(0xFF3333AA);
}
canvas.drawCircle(startX + 12 * i, height / 2, 4, paint);
}
}
}